Re: graphics.drawImage(Image, int, int, ImageObserver) implementation
On Feb 9, 11:05 pm, Knute Johnson <nos...@rabbitbrush.frazmtn.com>
wrote:
On 2/9/2010 6:24 PM, Vuntic wrote:
In short, with simplification:
I have a class Gwi extends JPanel with a method of public void
paintComponent(Graphics graphics) and a constructor. The constructor
schedules a TimerTask with a Timer. That TimerTask calls the
instance's repaint() method once every 30ms or so.
paintComponent has a lot of code, so I summarized in full the middle
part:
paintComponent(Graphics graphics)
{
super.paintComponent(graphics);
/*constructs a BufferedImage screen
this operation is extremely efficient: I read from arrays and
write directly to the array underlying screen, since I know
before-hand what its format will invariably be*/
graphics.drawImage(screen, 0, 0, this);
}
It used to be that this was extremely inefficient, since I was
getRGBing and setRGBing on BufferedImages. To remedy this, I searched
through the relevant classes in the jdk for the underlying array to a
BufferedImage. Now, the paintComponent method takes up about half of a
processor on my computer when run at a mid-low fps of ~33. Almost all
of this is spent in graphics.drawImage(...). When searching through
the JDK for the implementation of drawImage(Image, int, int,
ImageObserver) seemed to tell me that there was no implementation in
Graphics or Graphics2D, I spent several hours searching the internet
for an answer, with no luck. That was a few weeks ago, and I haven't
run across any answer since then, so I'm finally asking here.
Anyone know how I can draw an image to the screen efficiently 60 times
per second after constructing it pixel-by-pixel each frame?
Don't do anything in paintComponent() except draw. Do all the
construction in another thread somewhere and call repaint(). Still
60fps if the image is large could be very difficult without a very fast
computer and even faster video. See the example below for one way to d=
o
it. I get about 500fps on my Windows box (Windows will pretty much
always be the fastest) with the code below.
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.lang.reflect.*;
import javax.swing.*;
public class test3 extends JPanel implements Runnable {
volatile BufferedImage bi;
volatile long then;
long now,time;
Thread thread;
double angle;
int n;
double rate;
public test3() {
super(false);
setPreferredSize(new Dimension(400,300));
addComponentListener(new ComponentAdapter() {
public void componentResized(ComponentEvent ce=
) {
GraphicsConfiguration gc = getGraphi=
csConfiguration();
bi = gc.createCompatibleImage(getWid=
th(),getHeight());
}
});
}
public void start() {
then = System.nanoTime();
thread = new Thread(this);
thread.start();
}
public void stop() {
thread.interrupt();
}
public void run() {
try {
long now = 0;
long then = System.nanoTime();
while (true) {
render();
try {
EventQueue.invokeAndWait(new R=
unnable() {
public void run() {
paintImmediate=
ly(getBounds());
}
});
} catch (InvocationTargetException ite=
) {
System.out.println(ite);
}
/*
while (now < then + 10000000)
now = System.nanoTime();
then = now;
*/
}
} catch (InterruptedException ie) {
System.out.println(ie);
}
}
public void render() {
int w = getWidth();
int h = getHeight();
Graphics2D g = bi.createGraphics();
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g.setColor(Color.WHITE);
g.fillRect(0,0,w,h);
g.setColor(Color.RED);
g.drawString(String.format("%5.1f",rate),10,12);
angle += 0.001;
g.rotate(angle,w/2,h/2);
g.setColor(Color.BLUE);
g.fillRect(w/2 - 100,h/2 - 100,200,200);
if (++n % 100 == 0) {
now = System.nanoTime();
time = now - then;
then = now;
rate = 100000000000.0 / time;
}
g.dispose();
}
public void paintComponent(Graphics g) {
g.drawImage(bi,0,0,null);
}
public static void main(String[] args) {
final test3 t3 = new test3();
final JFrame f = new JFrame();
f.addWindowListener(new WindowAdapter() {
public void windowOpened(WindowEvent we) {
t3.start();
}
public void windowClosing(WindowEvent we) {
t3.stop();
f.dispose();
}
});
f.add(t3,BorderLayout.CENTER);
f.pack();
f.setVisible(true);
}
}
--
Knute Johnson
email s/nospam/knute2010/
Thank you greatly for taking the time to compose that example... but
it doesn't fix my problem. Although using its ideas will speed up my
output by about a factor of 2x, I ought to be able to do what I want
~30x faster.
I'm sorry; I didn't give enough information in my original post.
"screen," the BufferedImage I'm drawing to the screen, is 640x480 in
the current version of my project, but I'll need to be able to have it
fullscreen at really any screen size, up to oh eventually 2560x1920.
At my own monitor's res, 1280x1024, test3 uses up an entire processor
to manage ~26fps, sadly.
Also, I think that it's worth mentioning again, with better specifics,
that at 60fps the construction of screen takes up only 1.2% of one of
my processors (calculated based on the figure at 1000fps) and that
even at 1280x1024 that's only up to 5%.
Oh and I get ~320fps vs your 500 on that same code. Thought I should
mention that.
Oh! I don't really see where to flowingly insert this into what I
previously wrote, so here:
Like I mentioned earlier, I made my code acceptably efficient in the
short-term by delving into BufferedImage and replacing setRGB(...)
with the code of the setRGB method in the jdk and then replacing the
methods called in that code with the code found in those methods, etc,
till I finally got access to the array that underlies the
BufferedImage and just wrote directly to that. I was wondering if
there was any way to do this with graphics.drawImage(Image, int, int,
ImageObserver) as well.
--Vuntic