Question

I am implementing a board game where each player has several units and each unit is shown to a user using a common image which I read from a file using the following method. I read this image at application startup and going to use it later.

    private static BufferedImage readBufferedImage (String imagePath) {
        try {
            InputStream is = IconManager.class.getClassLoader().getResourceAsStream(imagePath);
            BufferedImage bimage = ImageIO.read(is);
            is.close();
            return bimage;
        } catch (Exception e) {
            return null;
        }
    }

Units differ with various colorful tokens located on the top of that common image.

Before I just add several commonImages to JPanel and tokens were implemented using JLabels which were floating on the top of commonImage

    //at startup
    ImageIcon commonImage = new ImageIcon(readBufferedImage("image.png"));
    ...
    JPanel panel = new JPanel();
    panel.add(commonImage);
    panel.add(commonImage);

    //located JLabels with token on the top of each commonImage        

However, now I want to use JScrollPane instead of JPanel, so I think it is a better approach to drawString() and drawImage() to each commonImage before I show it to a user.

I estimate roughly a number of units as 20. So now every turn for every unit I would need to generate on-the-fly separate BufferedImage with various tokens configuration.

The question is whether I should cache already generated BufferedImages depending on token configuration to extract from cache if the image has been generated before with same configuration?

Answer 1

The question you ask depends on a few factors:

1. How long it takes to generate the image from scratch
2. How long it takes to check if the image was generated before
3. How large each image will be
4. The probability of the image being reused

So without having a good knowledge of your application, no one is going to be able to give you an answer accurate for every situation.

In general, if you’re only moving tokens around, it should be quick to implement an update and the paintComponent method of the panel your drawing. If you save your base image, token image and the current resulting image (basically what you proposed), I wouldn’t anticipate a performance problem. The key is to do your updating of the image in your custom update method, and always draw the current resulting image in the paintComponent method.

Update

For example, you can cache the current display using code similar to this:

private BufferedImage cachedImage;
...

@Override
public void paintComponent(Graphics g){
    //If the image needs to be refreshed draw it to the cache first
    if(cachedImage == null){
        cachedImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_4BYTE_ABGR);
        super.paintComponent(cachedImage.getGraphics());
    }

    //Draw the image from cache
    g.drawImage(cachedImage, 0, 0, this);
}

When you want to clear the cache, in your method that does the update, you’d set cachedImage = null;

But in your situation,

• Any performance problems at the scale of 200×200 you experience would have to do with the number of drawings you’re doing. Since I’m guessing you’re not concerned about a frames/second rate, I doubt you’ll have performance problems (you can collect timings to see exactly how long it takes to draw – I’d guess well under 100 ms)
• The easiest thing to do would be cache the images of the tokens and their strings (I’m assuming they rarely change), but still dynamically create the layout of the tokens. (Any other performance gains in your situation aren’t going to be so easy).
• Caching previous rendering of the screen will essentially break the swing display model (not much point in using it – just do the layout yourself). This actually applies to pretty much any caching of a container.