org.jxmapviewer.viewer.TileCache Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jxmapviewer2 Show documentation
A MapViewer based on the JXMapViewer component of SwingX-WS.
There is a newer version: 2.8
/*
 * TileCache.java
 *
 * Created on January 2, 2007, 7:17 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package org.jxmapviewer.viewer;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.net.URI;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;

import javax.imageio.ImageIO;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * An implementation only class for now. For internal use only.
 * @author [email protected]
 */
public class TileCache
{
    private static final Log log = LogFactory.getLog(TileCache.class);
    
    private Map imgmap = new HashMap();
    private LinkedList imgmapAccessQueue = new LinkedList();
    private int imagesize = 0;
    private Map bytemap = new HashMap();
    private LinkedList bytemapAccessQueue = new LinkedList();
    private int bytesize = 0;

    /**
     * Default constructor - Empty
     */
    public TileCache()
    {
    }

    /**
     * Put a tile image into the cache. This puts both a buffered image and array of bytes that make up the compressed
     * image.
     * @param uri URI of image that is being stored in the cache
     * @param bimg bytes of the compressed image, ie: the image file that was loaded over the network
     * @param img image to store in the cache
     */
    public void put(URI uri, byte[] bimg, BufferedImage img)
    {
        synchronized (bytemap)
        {
            while (bytesize > 1000 * 1000 * 50)
            {
                URI olduri = bytemapAccessQueue.removeFirst();
                byte[] oldbimg = bytemap.remove(olduri);
                bytesize -= oldbimg.length;
                log("removed 1 img from byte cache");
            }

            bytemap.put(uri, bimg);
            bytesize += bimg.length;
            bytemapAccessQueue.addLast(uri);
        }
        addToImageCache(uri, img);
    }

    /**
     * Returns a buffered image for the requested URI from the cache. This method must return null if the image is not
     * in the cache. If the image is unavailable but it's compressed version *is* available, then the compressed version
     * will be expanded and returned.
     * @param uri URI of the image previously put in the cache
     * @return the image matching the requested URI, or null if not available
     * @throws IOException if retrieval fails 
     */
    public BufferedImage get(URI uri) throws IOException
    {
        synchronized (imgmap)
        {
            if (imgmap.containsKey(uri))
            {
                imgmapAccessQueue.remove(uri);
                imgmapAccessQueue.addLast(uri);
                return imgmap.get(uri);
            }
        }
        synchronized (bytemap)
        {
            if (bytemap.containsKey(uri))
            {
                log("retrieving from bytes");
                bytemapAccessQueue.remove(uri);
                bytemapAccessQueue.addLast(uri);
                BufferedImage img = ImageIO.read(new ByteArrayInputStream(bytemap.get(uri)));
                addToImageCache(uri, img);
                return img;
            }
        }
        return null;
    }

    /**
     * Request that the cache free up some memory. How this happens or how much memory is freed is up to the TileCache
     * implementation. Subclasses can implement their own strategy. The default strategy is to clear out all buffered
     * images but retain the compressed versions.
     */
    public void needMoreMemory()
    {
        imgmap.clear();
        log("HACK! need more memory: freeing up memory");
    }

    private void addToImageCache(final URI uri, final BufferedImage img)
    {
        synchronized (imgmap)
        {
            try {
                            while (imagesize > 1000 * 1000 * 50)
                            {
                                    URI olduri = imgmapAccessQueue.removeFirst();
                                    BufferedImage oldimg = imgmap.remove(olduri);
                                    imagesize -= oldimg.getWidth() * oldimg.getHeight() * 4;
                                    log("removed 1 img from image cache");
                            }
                            imgmap.put(uri, img);
                            imagesize += img.getWidth() * img.getHeight() * 4;
                            imgmapAccessQueue.addLast(uri);
                        } catch (Exception ex) {
                            log("Failed to load tile at URL. Tile is null");
                        }
        }
        log("added to cache: " + " uncompressed = " + imgmap.keySet().size() + " / " + imagesize / 1000 + "k"
                + " compressed = " + bytemap.keySet().size() + " / " + bytesize / 1000 + "k");
    }

    private void log(String string)
    {
        log.debug(string);
    }

}