Application: gvSIG desktop

package org.gvsig.raster.tilecache.provider;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import java.util.Map.Entry;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

import org.gvsig.fmap.dal.raster.RasterQuery;

import org.gvsig.fmap.dal.raster.RasterStore;

import org.gvsig.fmap.dal.raster.spi.RasterStoreProvider;

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

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

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

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.dynobject.exception.DynMethodException;

import org.gvsig.tools.exception.BaseException;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractTileCacheStructImage extends AbstractDisposable implements TileCacheStructImage {

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

    protected RasterStoreProvider innerProvider;

    protected RasterQuery query;

    protected TileStruct tileStruct;

    protected Object colorInterpretation;

    protected Object legend;

    protected Object colorTable;

    protected Map<String, Tile> recentAccededTiles;

    protected Integer bandNumber = null;

    protected int[] dataTypes;

    /**

     * @param innerProvider

     * @param query

     */

    public AbstractTileCacheStructImage(RasterStoreProvider innerProvider, RasterQuery query) {

        super();

        this.innerProvider = innerProvider;

        this.query = query;

    }

    /**

     * @param pixelSize

     * @return The appropriate zoom level for the pizelSize

     */

    @Override

    public int getZoomLvlForPixelSize(double pixelSize) {

        //FIXME: Elegir el c?digo id?neo

        // Este trozo de c?digo selecciona un zoom superior con lo que,

        // al hacer la interpolaci?n se generar?n p?xeles m?s grandes

        // (y l?neas m?s gruesas)

//        int zoom = 0;

//        Map<Integer, Double> pixelSizePerZoomLevel = tileStruct.getPixelSizePerZoomLevel();

//

//        SortedSet<Integer> keySet = new TreeSet<>(Collections.reverseOrder());

//        keySet.addAll(pixelSizePerZoomLevel.keySet());

//        Iterator<Integer> iterator = keySet.iterator();

//        while(iterator.hasNext()){

//            zoom = iterator.next();

//            double levelPixelSize = pixelSizePerZoomLevel.get(zoom);

//            if (pixelSize <= levelPixelSize) {

//                return zoom;

//            }

//        }

//

//        return zoom;

        // Este trozo de c?digo selecciona un zoom inferior con lo que,

        // al hacer la interpolaci?n se perder?n p?xeles

        // repercutiendo en la legibilidad de las leyendas si no se usa una adecuada interpolaci?n

        // (y las l?neas se podr?n ver entrecortadas)

        int zoom = 0;

        Map<Integer, Double> pixelSizePerZoomLevel = getTileStruct().getPixelSizePerZoomLevel();

        for (int i : pixelSizePerZoomLevel.keySet()) {

            zoom = i;

            double levelPixelSize = pixelSizePerZoomLevel.get(zoom);

            if (pixelSize >= levelPixelSize) {

                return zoom;

            }

        }

        return zoom;

    }

    /**

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     * @throws DynMethodException

     * @throws DataException

     * @throws BufferException

     * @throws CreateEnvelopeException

     *

     */

    protected void fillStoreInfo() {

        this.bandNumber = this.innerProvider.getBands();

        this.dataTypes = new int[this.bandNumber];

        for (int i = 0; i < this.bandNumber; i++) {

            dataTypes[i] = this.innerProvider.getBandDescriptor(i).getDataType();

        }

        try {

            this.colorInterpretation =

                this.innerProvider.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORINTERPRETATION_NAME, null);

            this.colorTable = this.innerProvider.invokeDynMethod(RasterStore.DYNMETHOD_GETCOLORTABLE_NAME, null);

            this.legend = this.innerProvider.invokeDynMethod(RasterStore.DYNMETHOD_GETLEGEND_NAME, null);

        } catch (DynMethodException e) {

            logger.warn("Can't fill legend info from store.");

        }

    }

    @Override

    public int getBandNumber() {

        if (this.bandNumber == null) {

            fillStoreInfo();

        }

        return this.bandNumber;

    }

    @Override

    public int[] getDataTypes() {

        if (this.dataTypes == null) {

            fillStoreInfo();

        }

        return this.dataTypes;

    }

    @Override

    public int getRows(int zoomLevel) {

        return (int) (Math.round(getEnvelope().getLength(DIMENSIONS.Y) / this.tileStruct.getPixelSizePerZoomLevel().get(zoomLevel)));

    }

    @Override

    public int getColumns(int zoomLevel) {

        return (int) (Math.round(this.getEnvelope().getLength(DIMENSIONS.X) / this.tileStruct.getPixelSizePerZoomLevel().get(zoomLevel)));

    }

    @Override

    public Envelope getEnvelope() {

        return this.tileStruct.getEnvelope();

    }

    @Override

    public int getRowsPerTile() {

        return this.tileStruct.getRowsPerTile();

    }

    @Override

    public int getColumnsPerTile() {

        return this.tileStruct.getColumnsPerTile();

    }

    @Override

    public String getProviderName() {

        return this.tileStruct.getProviderName();

    }

    protected 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();

    }

    protected void removeOlderTile() {

        Tile olderTile = null;

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

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

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

                olderTile = tile;

            }

        }

        if (olderTile != null) {

            recentAccededTiles.remove(olderTile.getKey());

            DisposeUtils.dispose(olderTile);

        }

    }

    @Override

    public Object getColorInterpretation() {

        if (this.colorInterpretation == null) {

            fillStoreInfo();

        }

        return this.colorInterpretation;

    }

    @Override

    public Object getColorTable() {

        if (this.colorTable == null) {

            fillStoreInfo();

        }

        return this.colorTable;

    }

    @Override

    public Object getLegend() {

        if (this.legend == null) {

            fillStoreInfo();

        }

        return this.legend;

    }

    /**

     *

     */

    @Override

    public void forgetCache(){

        this.recentAccededTiles.clear();

    }

    @Override

    protected void doDispose() throws BaseException {

        if (recentAccededTiles != null) {

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

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

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

                DisposeUtils.dispose(entry.getValue());

            }

            recentAccededTiles.clear();

        }

        DisposeUtils.dispose(innerProvider);

        innerProvider = null;

        DisposeUtils.dispose((Disposable) tileStruct);

        tileStruct = null;

        query = null;

        colorInterpretation = null;

        legend = null;

        colorTable = null;

    }

    protected class Tile extends AbstractDisposable {

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

        long lastAccess;

        String key;

        public Tile(org.gvsig.raster.lib.buffer.api.Buffer buffer, String key) {

            ToolsLocator.getDisposableManager().bind(buffer);

            this.buffer = buffer;

            this.key = key;

            lastAccess = System.currentTimeMillis();

        }

        public String getKey() {

            return key;

        }

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

            lastAccess = System.currentTimeMillis();

            return buffer;

        }

        public long getLastAccess() {

            return lastAccess;

        }

        @Override

        protected void finalize() throws Throwable {

            super.finalize();

        }

        @Override

        public void doDispose() throws BaseException {

            DisposeUtils.dispose(buffer);

            buffer = null;

        }

    }

}