AffineTransformOp speed/memory question

Question

I have asked this question before, but I wanted to rephrase/clarify some points and expand upon it. I have a piece of code which transforms a BufferedImage using an AffineTransform.

op = new AffineTransformOp(atx, interactive ? interpolationInteractive : interpolationNormal);
displayImage = op.filter(displayImage, null);

This code works fine, however it causes a memory accumulation. Specifically, every time this piece of code is called more memory is stored up. I have tried the other form of filter as well.

op = new AffineTransformOp(atx, interactive ? interpolationInteractive : interpolationNormal);
displayImage2 = op.createCompatibleDestImage(displayImage, displayImage.getColorModel());
op.filter(displayImage, displayImage2);

However, this is much much slower than the first version. I want the speed of the first version with the memory usage of the second.

1. How can I clean up after the first version? Specifically, where are the intermediate BufferedImages stored, and how can I delete them?
2. Why is the second version slower than the first? What can I do to speed it up?

Thanks for your help!!!

Answer 1

I agree with the comment that unless you're getting OutOfMemoryErrors, then this is a normal thing and the GC will collect the images whenever it sees fit. Here's a silly test I did sometimes when I had a concern: put that into loop in a main function and watch the memory usage in a profiler (it should make a zig-zag-like pattern or something) but not always be able to complete successfully.

Answer 2

How are you getting displayImage and what ColorModel is it using?

If it is an IndexColorModel, that may explain a lot.

The first code fragment will return a BufferedImage using a DirectColorModel. That will require 4 bytes per pixel vs typically 1-byte per pixel for an indexed image. That 1:4 expansion could be causing your out of memory condition.

The second code fragment makes a BufferedImage with the same model as the source. When that is an IndexColorModel and the interpolation is not NEAREST_NEIGHBOR, the filter() call will create a temporary BufferedImage with a DirectColorModel. It will use that as the destination of the filter operation, then requantize the temporary buffer and draw it into your displayImage2. So, twice as many bitblits.

If you're only doing a single transform, I'd say go with the second form.

If you're doing multiple operations, allocate a pair of BufferedImages with a DirectColorModel. large enough to hold your biggest image. Draw you source image into one of them and perform your filters back and forth between them. Then when you're finished, use a ColorConvertOp to requantize back to an indexed image. That way you only need to color convert once instead of on each filter call.