How do you efficiently scale a JFrame's content Java?

Question

I'm searching for a method to properly scale (almost) all of a JFrame's content. All the solutions I have tried so far had a huge lack in rendering speed. What I am looking for is a speed similar to what you have when scaling content on your smartphone.

The JFrame's content should be rescalable quickly and stay scaled even if you overdraw the JFrame with new content. It should also be flexible enough so it let's you choose which BufferedImage's (which is essentially the only type I'm drawing, I don't draw any other "shapes") to redraw. I'm drawing using an ordinary Graphics, resp. Graphics2D object.

What I've tried before is the Graphic2D's scale-method and using an AffineTransformat object to scale each BufferedImage individually:

    g.scale(scalingFactorX, scalingFactorY);

or alternatively:

    BufferedImage img = someImageToScale();
    AffineTransform scaleTransform = AffineTransform.getScaleInstance(scalingFactorX, scalingFactorY);
    AffineTransformOp bilinearScaleOp = new AffineTransformOp(scaleTransform,
            AffineTransformOp.TYPE_NEAREST_NEIGHBOR);

    return bilinearScaleOp.filter(img, new BufferedImage(targetWidth, targetHeight,
            BufferedImage.TYPE_INT_ARGB));

where scalingFactorX/Y are the factors the content should be scaled by and targetWidth, resp. targetHeight denote the resulting (scaled) dimensions of the BufferedImage.

Both approaches are rather slow which seems to be because in both cases, each frame, the scaled version of the contents have to be recalculated. I feel like I'm missing something very obvious here.

Answer 1

While drawImage() can resample an image, it must must do so each time paintComponent() is called. As suggested here, AffineTransformOp lets you choose the interpolation type; use the fastest one that meets your image quality requirements. Once you've satisfactorily resampled an image, ensure that you do not inadvertently resample the image a second time when rendering in a particular Graphics context. Override getPreferredSize() to make the destination component the same size as the resampled image, as shown in these examples.

My images are only 32x32, but there are a large amount of them (~500).

Consider using the flyweight pattern to render only visible images. JTable and JList are examples, as outlined here.

Are there performance benefits or other advantages to using separate components?

You may need to prototype and profile to be sure, perhaps by comparing representative examples:

• Typical component-based examples include the button-based game cited here, or the chess games examined here, here and here.

• The tile-based game cited here illustrates a single tile panel and multiple accessory panels that all listen to a common game model.