Re: graphics.drawImage(Image, int, int, ImageObserver) implementation

From:

Knute Johnson <nospam@rabbitbrush.frazmtn.com>

Newsgroups:

comp.lang.java.gui

Date:

Tue, 09 Feb 2010 21:05:47 -0800

Message-ID:

<L8rcn.5005$YR1.3276@newsfe17.iad>

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 do
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 = getGraphicsConfiguration();
                 bi = gc.createCompatibleImage(getWidth(),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 Runnable() {
                         public void run() {
                             paintImmediately(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/