ImageCache.java

package edu.stanford.hci.r3.util.graphics;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.lang.ref.SoftReference;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.WeakHashMap;

import javax.imageio.ImageIO;
import javax.media.jai.JAI;
import javax.media.jai.PlanarImage;

public class ImageCache {

        public class ImageObject {
                private SoftReference<BufferedImage> bImgSoft;

                private SoftReference<PlanarImage> pImgSoft;

                public ImageObject() {
                }

                public BufferedImage getBufferedImage(File imagePath) {
                        if (bImgSoft != null) {
                                final BufferedImage cachedImg = bImgSoft.get();
                                if (cachedImg != null) {
                                        // System.out.println("Cache Hit!");
                                        return cachedImg;
                                }
                        }

                        // System.out.println("Cache Miss =(");
                        // released by the Garbage Collector
                        // OR, never loaded
                        try {
                                bImgSoft = new SoftReference<BufferedImage>(ImageIO.read(imagePath));
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                        return bImgSoft.get();
                }

                public PlanarImage getPlanarImage(File imagePath) {
                        if (pImgSoft != null) {
                                final PlanarImage cachedImg = pImgSoft.get();
                                if (cachedImg != null) {
                                        // not yet released by the Garbage Collector
                                        // System.out.println("Image Cache Hit for Planar Image");
                                        return cachedImg;
                                } else {
                                        System.out.println("Image Cache MISS for Planar Image");
                                }
                        }
                        pImgSoft = new SoftReference<PlanarImage>(JAI.create("fileload", imagePath
                                        .getAbsolutePath()));
                        return pImgSoft.get();
                }

                public void setBufferedImage(BufferedImage bImg) {
                        bImgSoft = new SoftReference<BufferedImage>(bImg);
                }
        }

        private static ImageCache instance = new ImageCache();

        public static ImageCache getInstance() {
                return instance;
        }

        public static BufferedImage loadBufferedImage(File path) {
                return getInstance().getBufferedImage(path);
        }

        public static BufferedImage loadBufferedImage(URL resource) {
                try {
                        return getInstance().getBufferedImage(new File(resource.toURI()));
                } catch (URISyntaxException e) {
                        e.printStackTrace();
                }
                return null;
        }

        public static PlanarImage loadPlanarImage(File path) {
                return getInstance().getPlanarImage(path);
        }

        // cache for images
        private WeakHashMap<File, ImageObject> cache = new WeakHashMap<File, ImageObject>();

        private ImageCache() {
                // nothing
        }

        public void addBufferedImageToCache(final File pathToImage, BufferedImage bImg) {
                // System.out.println("Adding...");
                ImageObject image = cache.get(pathToImage);
                if (image == null) { // evicted, or never loaded
                        image = new ImageObject();
                        cache.put(pathToImage, image);
                }
                image.setBufferedImage(bImg);
        }

        private ImageObject get(final File pathToImage) {
                ImageObject image = cache.get(pathToImage);
                if (image == null) { // evicted, or never loaded
                        image = new ImageObject();
                        cache.put(pathToImage, image);
                }
                return image;
        }

        public BufferedImage getBufferedImage(File pathToImage) {
                return get(pathToImage).getBufferedImage(pathToImage);
        }

        public PlanarImage getPlanarImage(File pathToImage) {
                if (pathToImage == null) {
                        return null;
                }
                return get(pathToImage).getPlanarImage(pathToImage);
        }
}

---