Application: gvSIG desktop » gvSIG raster

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.raster.tilecache.provider;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map.Entry;

import java.util.Set;

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.api.RasterQuery;

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

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

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.primitive.Envelope;

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

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

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.exception.BaseException;

/**

 * Represents a tiled image

 *

 * @author dmartinezizquierdo

 *

 */

public class MemoryTileStructImage extends AbstractTileCacheStructImage {

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

    private static final int MAX_RECENT_ACCEDED_TILES_NUMBER = 50;

    /**

     * @param innerProvider

     * @param query

     */

    public MemoryTileStructImage(RasterStoreProvider innerProvider, RasterQuery query) {

        super(innerProvider, query);

        tileStruct = getTileStruct();

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

    }

    /**

     * @param buffer

     * @param bandNumber

     * @param zoomLevel

     * @param tileRow

     * @param tileCol

     * @return Band

     * @throws CreateEnvelopeException

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     */

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

        ValidateDataParametersException, CloneNotSupportedException {

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

        Tile tile = recentAccededTiles.get(keyTile);

        if (tile != null) {

            // Devolver la banda del buffer del tile

            return tile.getBuffer().getBand(bandNumber);

        } else {

            // Cargar un tile nuevo

            Buffer buffer = null;

            try {

                buffer = requestTile(zoomLevel, structRow, structCol);

                ToolsLocator.getDisposableManager().bind(buffer);

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

                    removeOlderTile();

                }

                recentAccededTiles.put(keyTile, new Tile(buffer, keyTile));

                Band band = buffer.getBand(bandNumber);

                ToolsLocator.getDisposableManager().bind(band);

                return band;

            } catch (DataException | BufferException e) {

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

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

                return null;

            } finally {

                DisposeUtils.dispose(buffer);

                buffer = null;

            }

        }

    }

    private Buffer requestTile(int zoomLevel, int structRow, int structCol) throws CreateEnvelopeException,

        CloneNotSupportedException, BufferException, ValidateDataParametersException, DataException {

        RasterQuery rasterQuery = (RasterQuery) this.query.clone();

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

        rasterQuery.setPixelSize(pixelSize);

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        Envelope structExtent = this.tileStruct.getEnvelope();

        int rowsPerTile = this.tileStruct.getRowsPerTile();

        int columnsPerTile = this.tileStruct.getColumnsPerTile();

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

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

        double maxX = minX + pixelSize * columnsPerTile;

        double maxY = minY + pixelSize * rowsPerTile;

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

        Buffer buffer = null;

        Buffer clippedBuffer = null;

        Buffer interpolatedBuffer = null;

        try {

            buffer = innerProvider.createBuffer(rasterQuery);

            clippedBuffer = buffer.clip(envelope);

            interpolatedBuffer =

                clippedBuffer.createInterpolated(

                    (int) (Math.round(clippedBuffer.getPixelSizeY() * clippedBuffer.getRows() / pixelSize)),

                    (int) (Math.round(clippedBuffer.getPixelSizeX() * clippedBuffer.getColumns() / pixelSize)),

                    Buffer.INTERPOLATION_NearestNeighbour, null);

            return interpolatedBuffer;

        } finally {

            DisposeUtils.dispose(buffer);

            DisposeUtils.dispose(clippedBuffer);

//            DisposeUtils.dispose(interpolatedBuffer);

        }

    }

    @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;

    }

    public TileStruct getTileStruct() {

        if(this.tileStruct==null){

            if (innerProvider != null && innerProvider instanceof TiledRasterStoreProvider) {

                this.tileStruct = ((TiledRasterStoreProvider) innerProvider).getTileStruct();

            } else {

                throw new UnsupportedOperationException("Can't be applied the memory tile cache to the provider "+innerProvider.getFullName());

            }

        }

        return this.tileStruct;

    }

}