Performance issues with Java 2D when drawing bufferedimages

Question

Hi,

I'm designing a Canvas object which is been used to draw a BufferedImage of size 228x262 pixels.

That image is been drawn using Graphics2D.drawImage(...) method. I'm doing a pixel basis color manipulation within given offset ranges. A sample of the code below:

for( int i = frameOffset; i < colorClock; i++ ) {  
    rgb[i] = new Color(this.colorBK).getRGB();  
    }

Where rbg is set to that bufferedimage I'm changing in.
The problem is that code is painting slow.

I'm creating the image using GraphicsConfiguration.createCompatibleImage, and I'm using double buffering via Buffer Strategy.

Any lights please?

Thanks on adv.

Answer 1

Don't create a new Color just to extract an RGB integer for every pixel in your image. The only single parameter constructor I can find for Color is one that takes an int RGB - can you not just use colorBK directly?

Also, if you are doing this conversion on every paint that will be slow; you should only need to do the conversion once.

Answer 2

If you run the loop every time you draw the image, the loop might be the bottleneck. There is an completely unnecessary object allocation which will make the garbage collector to run quite often.

I'm assuming that colorBK is int. If this is the case, you just create and initialize a Color object and ask it to return a rgb value that is assigned to rgb array. What actually happens is that you assign the value of colorBK in the rgb array. So, equivalent and more efficient implementation would be rgb[i] = colorBK.

To optimize this even more, you could assign the value of colorBK to a final local variable. This would avoid fetching the value of the field over and over again. So the loop could look like this:

final int color = colorBK;
for( int i = frameOffset; i < colorClock; i++ ) {
    rgb[i] = color;
}

To get even more performance gain, you should think that if there is completely different ways of doing this. As the above example just changes some pixels to certain color, I could assume that this could be done with an image and a couple of fillRects.

So you would fill a rect behind the image with the color you want (in this case colorBK). If the image has transparent pixels in those areas the above loop changes they remain unchanged in the canvas and the same effect is gained. This might be more efficient as the graphics methods are better optimized and does not involve heavy array usage.