Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.googlemaps.provider;

import java.awt.image.BufferedImage;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.geom.Geometry.DIMENSIONS;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.googlemaps.lib.api.GoogleMapsLocator;

import org.gvsig.googlemaps.lib.api.GoogleMapsManager;

import org.gvsig.googlemaps.lib.api.GoogleMapsRequest;

import org.gvsig.googlemaps.lib.api.GoogleMapsRequestParams;

import org.gvsig.googlemaps.lib.api.exceptions.DownloadingException;

import org.gvsig.googlemaps.lib.api.exceptions.URLFormatException;

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.TileStruct;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

/**

 * @author fdiaz

 *

 */

public class GoogleMapsImage extends AbstractDisposable {

    private static final Logger logger = LoggerFactory.getLogger(GoogleMapsImage.class);

    private static final int MAX_RECENT_ACCEDED_TILES_NUMBER = 50;

    private Map<String, DownloadedTile> recentAccededTiles;

    private TileStruct tileStruct;

    private GoogleMapsRasterProvider provider;

    /**

     * @param provider

     * @param query

     * @param tileStruct

     */

    public GoogleMapsImage(TileStruct tileStruct, GoogleMapsRasterProvider provider) {

        this.tileStruct = tileStruct;

        this.provider = provider;

        recentAccededTiles = new HashMap<String, DownloadedTile>();

    }

    /**

     * @param bandNumber

     * @param zoomLevel

     * @param structRow

     * @param structCol

     * @return Band

     * @throws CreateEnvelopeException

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     */

    public Band fetchTile(int bandNumber, int zoomLevel, int structRow, int structCol) throws CreateEnvelopeException,

        ValidateDataParametersException, CloneNotSupportedException {

//        BufferManager bufferManager = BufferLocator.getBufferManager();

        String keyTile = composeKeyForRecentTiles(zoomLevel, structRow, structCol);

        DownloadedTile tile = recentAccededTiles.get(keyTile);

        Buffer buffer = null;

        if (tile != null && tile.isDownloaded()) {

            // Devolver la banda del buffer del tile

            logger.info("Devolviendo la banda "+bandNumber+" del buffer del tile "+tile.getKey());

            try {

                buffer = tile.getBuffer();

                Band band = buffer.getBand(bandNumber);

                ToolsLocator.getDisposableManager().bind(band);

                return band;

            } catch (InterruptedException e) {

                logger.warn("Can't fetch tile: zoomLevel = " + zoomLevel + ", tileRow = " + structRow

                    + ", tileColumn = " + structCol + ", band = " + bandNumber + ".", e);

                return null;

            }

        } else {

            // Cargar un tile nuevo

            Band band = null;

            try {

                while(tile==null || !tile.isDownloaded()) {

                    tile = requestTile(zoomLevel, structRow, structCol, keyTile);

                }

                buffer = tile.getBuffer();

                if (recentAccededTiles.size() >= MAX_RECENT_ACCEDED_TILES_NUMBER) {

                    removeOlderTile();

                }

                recentAccededTiles.put(keyTile, tile);

                band = buffer.getBand(bandNumber);

                ToolsLocator.getDisposableManager().bind(band);

                return band;

            } catch (DataException | BufferException | CreateGeometryException | InterruptedException | URLFormatException | DownloadingException e) {

                logger.warn("Can't fetch tile: zoomLevel = " + zoomLevel + ", tileRow = " + structRow

                    + ", tileColumn = " + structCol + ", band = " + bandNumber + ".", e);

                return null;

            }

        }

    }

    private DownloadedTile requestTile(int zoomLevel, int structRow, int structCol, String key) throws CreateEnvelopeException,

        CloneNotSupportedException, BufferException, ValidateDataParametersException, DataException, CreateGeometryException, URLFormatException, DownloadingException {

        Double pixelSize = this.tileStruct.getPixelSizePerZoomLevel().get(zoomLevel);

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Envelope structExtent = this.tileStruct.getEnvelope();

        int rowsPerTile = this.tileStruct.getRowsPerTile();

        int columnsPerTile = this.tileStruct.getColumnsPerTile();

        double minX = Math.max(structExtent.getMinimum(DIMENSIONS.X) + (structCol * (pixelSize * columnsPerTile)),structExtent.getMinimum(DIMENSIONS.X));

        double minY = Math.max(structExtent.getMaximum(DIMENSIONS.Y) - ((structRow + 1) * (pixelSize * rowsPerTile)),structExtent.getMinimum(DIMENSIONS.Y));

        double maxX = Math.min(structExtent.getMinimum(DIMENSIONS.X) + ((structCol + 1) * (pixelSize * columnsPerTile)),structExtent.getMaximum(DIMENSIONS.X));

        double maxY = Math.min(structExtent.getMaximum(DIMENSIONS.Y) - (structRow * (pixelSize * rowsPerTile)),structExtent.getMaximum(DIMENSIONS.Y));

        Envelope envelope = geomManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D);

        Point center;

        center = geomManager.createPoint(envelope.getCenter(DIMENSIONS.X), envelope.getCenter(DIMENSIONS.Y), SUBTYPES.GEOM2D);

        GoogleMapsManager googleMapsManager = GoogleMapsLocator.getManager();

        GoogleMapsRequestParams requestParams = googleMapsManager.createRequestParams();

        DataStoreParameters storeParameters = provider.getParameters();

        requestParams.setHasApiKey((Boolean) storeParameters.getDynValue("hasApiKey"));

        requestParams.setApiKey((String) storeParameters.getDynValue("apiKey"));

        requestParams.setLanguage((String) storeParameters.getDynValue("language"));

        requestParams.setRegion((String) storeParameters.getDynValue("region"));

        requestParams.setURL("http://maps.google.com/maps/api/staticmap?");

        requestParams.setMapType((String) storeParameters.getDynValue("mapType"));

        requestParams.setFormat((String) storeParameters.getDynValue("format"));

        GoogleMapsRequest googleRequest=googleMapsManager.createRequest(requestParams);

        DownloadedTile downloadedTile = new DownloadedTile(key, envelope);

        downloadedTile.setImage(googleRequest.getTile(center, zoomLevel, (int)Math.round(envelope.getLength(DIMENSIONS.X)/pixelSize), (int)Math.round(envelope.getLength(DIMENSIONS.Y)/pixelSize)));

        return downloadedTile;

    }

    private String composeKeyForRecentTiles(int zoomLevel, int structRow, int structCol) {

        StringBuilder builder = new StringBuilder();

        builder.append(zoomLevel);

        builder.append(":");

        builder.append(structCol);

        builder.append(":");

        builder.append(structRow);

        return builder.toString();

    }

    private void removeOlderTile() {

        DownloadedTile olderTile = null;

        for (Iterator<DownloadedTile> iterator = recentAccededTiles.values().iterator(); iterator.hasNext();) {

            DownloadedTile tile = (DownloadedTile) iterator.next();

            if (olderTile == null || tile.getLastAccess() < olderTile.getLastAccess()) {

                olderTile = tile;

            }

        }

        if (olderTile != null) {

            recentAccededTiles.remove(olderTile.getKey());

            DisposeUtils.dispose(olderTile);

        }

    }

    private class DownloadedTile extends AbstractDisposable { //implements GoogleMapsRequestListener {

        private org.gvsig.raster.lib.buffer.api.Buffer buffer;

        long lastAccess;

        private String key;

        private Envelope envelope;

        private boolean downloaded;

        public DownloadedTile(String key, Envelope envelope) {

            logger

                .info("CONSTRUCTOR hashCode = " + this.hashCode() + " className = " + this.getClass().getSimpleName());

            this.key = key;

            this.envelope = envelope;

            lastAccess = System.currentTimeMillis();

            this.downloaded = false;

        }

        public String getKey() {

            return key;

        }

        public synchronized org.gvsig.raster.lib.buffer.api.Buffer getBuffer() throws InterruptedException {

            lastAccess = System.currentTimeMillis();

            while(!isDownloaded()){

                logger.info("Esperando al tile: "+this.key);

                this.wait();

            }

            logger.info("Sirviendo el tile: "+this.key);

            return buffer;

        }

        public long getLastAccess() {

            return lastAccess;

        }

        @Override

        protected void finalize() throws Throwable {

            super.finalize();

            logger.info("CLEANED key " + this.key + " hashCode = " + this.hashCode());

        }

        public synchronized void setImage(BufferedImage img) {

            downloaded = false;

            try {

                this.buffer =

                    BufferLocator.getBufferManager().createBuffer(img, GoogleMapsRasterProvider.GOOGLE_MAPS_PROJECTION,

                        this.envelope);

            } catch (LocatorException | BufferException e) {

                logger.warn("Can't create buffer to load downloaded image.", e);

            }

            this.downloaded = true;

            logger.info("Tile listo       : " + this.key);

            this.notify();

        }

        @Override

        protected void doDispose() throws BaseException {

            logger.info("DO DISPOSE key " + this.key + " hashCode = " + this.hashCode());

            DisposeUtils.dispose(buffer);

            buffer = null;

        }

        public boolean isDownloaded(){

            return this.downloaded;

        }

    }

    @Override

    protected void doDispose() throws BaseException {

        if (recentAccededTiles != null) {

            Set<Entry<String, DownloadedTile>> entrySet = recentAccededTiles.entrySet();

            for (Iterator<Entry<String, DownloadedTile>> iterator = entrySet.iterator(); iterator.hasNext();) {

                Entry<String, DownloadedTile> entry = (Entry<String, DownloadedTile>) iterator.next();

                DisposeUtils.dispose(entry.getValue());

            }

            recentAccededTiles.clear();

        }

        DisposeUtils.dispose((Disposable) tileStruct);

        tileStruct = null;

    }

}