Java，如何绘制不断变化的图形
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/3742731/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Java, how to draw constantly changing graphics
提问by Margus
Have not done this before, so obviously I suck at it. Here 64 pixels around current mouse position get drawn little bigger on a form. Problem is, that it's 'kind of' to slow, and I have no idea where to start fixing.
以前没有这样做过，所以显然我很讨厌它。这里围绕当前鼠标位置的 64 像素在窗体上绘制得更大一些。问题是，它“有点”变慢，我不知道从哪里开始修复。
Besides that, I made a thread, that constantly calls update graphics when it's finished and a little fps like text, to show really how fast things are drawn.
除此之外，我创建了一个线程，它在完成时不断调用更新图形和像文本一样的小 fps，以真正显示绘制事物的速度。
Image example: (Image is from letter 'a' in Eclipse)
图像示例：（图像来自 Eclipse 中的字母“a”）
Code example :
代码示例：
@SuppressWarnings("serial")
public static class AwtZoom extends Frame {
private BufferedImage image;
private long timeRef = new Date().getTime();
Robot robot = null;
public AwtZoom() {
super("Image zoom");
setLocation(new Point(640, 0));
setSize(400, 400);
setVisible(true);
final Ticker t = new Ticker();
this.image = (BufferedImage) (this.createImage(320, 330));
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent we) {
t.done();
dispose();
}
});
try {
robot = new Robot();
} catch (AWTException e) {
e.printStackTrace();
}
t.start();
}
private class Ticker extends Thread {
public boolean update = true;
public void done() {
update = false;
}
public void run() {
try {
while (update == true) {
update(getGraphics());
// try {
// Thread.sleep(200);
// } catch (InterruptedException e) {
// e.printStackTrace();
// return;
// }
}
} catch (Exception e) {
update=false;
}
}
}
public void update(Graphics g) {
paint(g);
}
boolean isdone = true;
public void paint(Graphics g) {
if (isdone) {
isdone=false;
int step = 40;
Point p = MouseInfo.getPointerInfo().getLocation();
Graphics2D gc = this.image.createGraphics();
try {
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
gc.setColor(robot.getPixelColor(p.x - 4 + x, p.y
- 4 + y));
gc.fillOval(x * step, y * step, step - 3, step - 3);
gc.setColor(Color.GRAY);
gc.drawOval(x * step, y * step, step - 3, step - 3);
}
}
} catch (Exception e) {
e.printStackTrace();
}
gc.dispose();
isdone = true;
iter++;
}
g.drawImage(image, 40, 45, this);
g.setColor(Color.black);
StringBuilder sb = new StringBuilder();
sb.append(iter)
.append(" frames in ")
.append((double) (new Date().getTime() - this.timeRef) / 1000)
.append("s.");
g.drawString(sb.toString(), 50, 375);
}
int iter = 0;
}
Changes made:
* added "gc.dispose();"
* added "isdone", so redraw could not be called faster, then it should.
* added this linkto thrashgod source rewrite
* added this linkto thrashgod source rewrite 2
所做的更改：
* 添加了“gc.dispose();”
* 添加了“isdone”，因此无法更快地调用重绘，那么它应该调用。
*将此链接添加到 thrashgod 源代码重写
*将此链接添加到 thrashgod 源代码重写 2
采纳答案by Steve McLeod
Here's my major rewrite with the following noteworthy changes:
这是我的主要重写，有以下值得注意的变化：
- I've separated the task of detecting pixel colours from the task of drawing
- I've replaced robot.getPixelColor(...) with robot.createScreenCapture(...) to fetch all 64 pixels at once, rather than one at a time
- I've introduced smart clipping - only what needs to be redrawn is redrawn.
- I've fixed up threading so all updates to the model and view happen on the Event Dispatch Thread
- 我已经将检测像素颜色的任务与绘图任务分开了
- 我已将 robots.getPixelColor(...) 替换为 robots.createScreenCapture(...) 以一次获取所有 64 个像素，而不是一次获取一个
- 我已经引入了智能裁剪——只有需要重绘的才会被重绘。
- 我已经修复了线程，所以模型和视图的所有更新都发生在事件调度线程上
The ticker runs constantly. When it detects a change in pixel colour (either due to the mouse moving to a different region or the pixels under the mouse changing) it detects exactly what changed, updates the model, then requests the view to repaint. This approach updates instantly to the human eye. 289 screen updates took cumulatively 1 second.
自动收报机不断运行。当它检测到像素颜色的变化（由于鼠标移动到不同的区域或鼠标下的像素发生变化）时，它会准确地检测到发生了什么变化，更新模型，然后请求视图重新绘制。这种方法会立即更新到人眼中。289 次屏幕更新累计耗时 1 秒。
It was an enjoyable challenge for a quiet Saturday evening.
对于一个安静的周六晚上来说，这是一个令人愉快的挑战。
import javax.swing.*;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.geom.Ellipse2D;
import java.awt.image.BufferedImage;
public class ZoomPanel extends JPanel {
private static final int STEP = 40;
private int iter = 0;
private long cumulativeTimeTaken = 0;
public static void main(String[] args) {
final JFrame frame = new JFrame("Image zoom");
final ZoomPanel zoomPanel = new ZoomPanel();
frame.getContentPane().add(zoomPanel);
final Ticker t = new Ticker(zoomPanel);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent we) {
t.done();
frame.dispose();
}
});
t.start();
frame.setLocation(new Point(640, 0));
frame.pack();
frame.setVisible(true);
}
private final Color[][] model = new Color[8][8];
public ZoomPanel() {
setSize(new Dimension(400, 400));
setMinimumSize(new Dimension(400, 400));
setPreferredSize(new Dimension(400, 400));
setOpaque(true);
}
private void setColorAt(int x, int y, Color pixelColor) {
model[x][y] = pixelColor;
repaint(40 + x * STEP, 45 + y * STEP, 40 + (x * STEP) - 3, 45 + (y * STEP) - 3);
}
private Color getColorAt(int x, int y) {
return model[x][y];
}
public void paintComponent(Graphics g) {
long start = System.currentTimeMillis();
if (!SwingUtilities.isEventDispatchThread()) {
throw new RuntimeException("Repaint attempt is not on event dispatch thread");
}
final Graphics2D g2 = (Graphics2D) g;
g2.setColor(getBackground());
try {
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
g2.setColor(model[x][y]);
Ellipse2D e = new Ellipse2D.Double(40 + x * STEP, 45 + y * STEP, STEP - 3, STEP - 3);
g2.fill(e);
g2.setColor(Color.GRAY);
g2.draw(e);
}
}
} catch (Exception e) {
e.printStackTrace();
}
iter++;
g2.setColor(Color.black);
long stop = System.currentTimeMillis();
cumulativeTimeTaken += stop - start;
StringBuilder sb = new StringBuilder();
sb.append(iter)
.append(" frames in ")
.append((double) (cumulativeTimeTaken) / 1000)
.append("s.");
System.out.println(sb);
}
private static class Ticker extends Thread {
private final Robot robot;
public boolean update = true;
private final ZoomPanel view;
public Ticker(ZoomPanel zoomPanel) {
view = zoomPanel;
try {
robot = new Robot();
} catch (AWTException e) {
throw new RuntimeException(e);
}
}
public void done() {
update = false;
}
public void run() {
int runCount = 0;
while (update) {
runCount++;
if (runCount % 100 == 0) {
System.out.println("Ran ticker " + runCount + " times");
}
final Point p = MouseInfo.getPointerInfo().getLocation();
Rectangle rect = new Rectangle(p.x - 4, p.y - 4, 8, 8);
final BufferedImage capture = robot.createScreenCapture(rect);
for (int x = 0; x < 8; x++) {
for (int y = 0; y < 8; y++) {
final Color pixelColor = new Color(capture.getRGB(x, y));
if (!pixelColor.equals(view.getColorAt(x, y))) {
final int finalX = x;
final int finalY = y;
SwingUtilities.invokeLater(new Runnable() {
public void run() {
view.setColorAt(finalX, finalY, pixelColor);
}
});
}
}
}
}
}
}
}
回答by trashgod
If you don't mind using Swing, this exampleshows how to quickly zoom in on a BufferedImageobtained from an Icon. In your case, you'd want an 8x8 BufferedImagethat gets filled in mouseMoved()with the pixels seen by the robot.
如果您不介意使用 Swing，这个例子展示了如何快速放大BufferedImage从Icon. 在您的情况下，您需要一个 8x8BufferedImage来填充mouseMoved()机器人看到的像素。
Addendum: Here's a snapshot of the top, left corner of your example.
附录：这是示例左上角的快照。
Addendum:
附录：
Zooming itself is not important...
缩放本身并不重要...
The slow part is getting pixels from the desktop; scaling is minor. If you just want to see a variety of animation techniques, have a look at this example.
缓慢的部分是从桌面获取像素；缩放是次要的。如果你只是想看看各种动画技术，看看这个例子。
Addendum: As getting individual pixels is slow and the createScreenCapture()method suggested by @Steve McLeod is fast, here's the idea I was driving at. You can see it also updates much more smoothly. Note that releasing the mouse button allows one to see the captured colors.
附录：由于获取单个像素很慢，而createScreenCapture()@Steve McLeod 建议的方法很快，这就是我的想法。您可以看到它的更新也更加顺畅。请注意，释放鼠标按钮可以看到捕获的颜色。
import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Robot;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
import javax.swing.JPanel;
/** @see https://stackoverflow.com/questions/3742731 */
public class Zoom extends JPanel implements MouseMotionListener {
private static final int SIZE = 16;
private static final int S2 = SIZE / 2;
private static final int SCALE = 48;
private BufferedImage img;
private Robot robot;
public Zoom() {
super(true);
this.setPreferredSize(new Dimension(SIZE * SCALE, SIZE * SCALE));
img = new BufferedImage(SIZE, SIZE, BufferedImage.TYPE_INT_RGB);
try {
robot = new Robot();
} catch (AWTException e) {
e.printStackTrace(System.err);
}
}
@Override
protected void paintComponent(Graphics g) {
g.drawImage(img, 0, 0, getWidth(), getHeight(), null);
}
@Override
public void mouseMoved(MouseEvent e) {
Point p = e.getPoint();
int x = p.x * SIZE / getWidth();
int y = p.y * SIZE / getHeight();
int c = img.getRGB(x, y);
this.setToolTipText(x + "," + y + ": "
+ String.format("%08X", c));
}
@Override
public void mouseDragged(MouseEvent e) {
int x = e.getXOnScreen();
int y = e.getYOnScreen();
Rectangle rect = new Rectangle(x - S2, y - S2, SIZE, SIZE);
img = robot.createScreenCapture(rect);
repaint();
}
private static void create() {
JFrame f = new JFrame("Click & drag to zoom.");
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Zoom zoom = new Zoom();
f.add(zoom);
f.pack();
f.setVisible(true);
zoom.addMouseMotionListener(zoom);
}
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
@Override
public void run() {
create();
}
});
}
}
回答by Blue Okiris
Add this method to the Paint method:
将此方法添加到 Paint 方法中：
public void clear(Graphics g, Color currentColor) {
g.setColor(backgroundColor);
g.fillRect(0, 0, width, height);
g.setColor(currentColor);
int delay = 5; //milliseconds
ActionListener taskPerformer = new ActionListener() {
public void actionPerformed(ActionEvent evt) { } };
new Timer(delay, taskPerformer).start();
} //run this right before you draw something
Okay so use timer to slow down delay, not a threading, that's bad.
好的，所以使用计时器来减慢延迟，而不是线程，这很糟糕。
回答by Ritik
Simply use a time delay loop.You can then fine tune the delay by adjusting the limits of i.It also gives you the control to adjust transition speeds by some hit and trials.
只需使用时间延迟循环。然后您可以通过调整 i 的限制来微调延迟。它还使您可以通过一些命中和试验来控制调整过渡速度。
for(long i=0;i<=100000000000;i++);
for(long i=0;i<=100000000000;i++);
canvas.repaint();
canvas.repaint();
It works very fine with me and also no need to use buffered images.
它对我来说很好用，也不需要使用缓冲图像。
