Application: gvSIG desktop » gvSIG raster

package org.gvsig.wmts.provider;

import java.awt.image.BufferedImage;

import java.io.File;

import java.io.IOException;

import java.net.ConnectException;

import java.net.URL;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import javax.imageio.ImageIO;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.compat.CompatLocator;

import org.gvsig.compat.net.Downloader;

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.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.BufferManager;

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

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

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

import org.gvsig.raster.wmts.ogc.WMTSStatus;

import org.gvsig.raster.wmts.ogc.struct.WMTSTileMatrix;

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 WMTSImage extends AbstractDisposable {

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

    private static final int MAX_RECENT_ACCEDED_TILES_NUMBER = 25;

    private TileStruct tileStruct;

    private WMTSRasterProvider provider;

    private DownloadedTile tile;

    private Map<Integer, WMTSTileMatrix> tileMatrixPerZoomLevel = null;

    protected Map<String, DownloadedTile> recentAccededWMTSTiles;

    private IProjection projection;

    /**

     * @param provider

     * @param query

     * @param tileStruct

     * @param tileMatrixPerZoomLevel

     */

    public WMTSImage(TileStruct tileStruct, Map<Integer, WMTSTileMatrix> tileMatrixPerZoomLevel, WMTSRasterProvider provider) {

        this.tileStruct = tileStruct;

        DisposeUtils.bind((Disposable) this.tileStruct);

        this.provider = provider;

        this.projection = provider.getProjection();

        this.tile = null;

        this.tileMatrixPerZoomLevel = tileMatrixPerZoomLevel;

        this.recentAccededWMTSTiles = new HashMap<String, DownloadedTile>();

    }

    /**

     * @param bandNumber

     * @param zoomLevel

     * @param structRow

     * @param structCol

     * @return Band

     * @throws CreateEnvelopeException

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     * @throws IOException

     * @throws ConnectException

     */

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

        ValidateDataParametersException, CloneNotSupportedException, ConnectException, IOException {

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

        Buffer buffer = null;

        if (this.tile != null && this.tile.getKey().equalsIgnoreCase(keyTile)) {

            // Devolver la banda del buffer del tile

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

            buffer = tile.getBuffer();

            Band band = buffer.getBand(bandNumber);

            return band;

        } else {

            if(this.tile != null) {

                DisposeUtils.dispose(this.tile);

            }

            this.tile = null;

            // Cargar un tile nuevo

            Band band = null;

            try {

                while (this.tile == null) {

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

                }

                buffer = tile.getBuffer();

                band = buffer.getBand(bandNumber);

                return band;

            } catch (DataException | BufferException | CreateGeometryException | BandException 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, ConnectException, IOException, BandException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        BufferManager bufferManager = BufferLocator.getBufferManager();

        // C?lculo del envelope del tile que queremos construir

        Envelope envelope = createRequestTileEnvelope(zoomLevel, structRow, structCol, geomManager);

        int[] bandDataTypes =

            { BufferManager.TYPE_BYTE, BufferManager.TYPE_BYTE, BufferManager.TYPE_BYTE, BufferManager.TYPE_BYTE };

        WMTSTileMatrix tileMatrix = tileMatrixPerZoomLevel.get(zoomLevel);

        WMTSStatus status = provider.getWMTSStatus();

        String tileMatrixIdentifier = tileMatrix.getIdentifier();

        status.setTileMatrix(tileMatrixIdentifier);

        Envelope affectedEnvelope = null;

        int firstAffectedRow = getTileMatrixRow(zoomLevel, tileMatrix, envelope.getMaximum(DIMENSIONS.Y));

        int firstAffectedColumn = getTileMatrixColumn(zoomLevel, tileMatrix, envelope.getMinimum(DIMENSIONS.X));

        int lastAffectedRow = getTileMatrixRow(zoomLevel, tileMatrix, envelope.getMinimum(DIMENSIONS.Y));

        int lastAffectedColumn = getTileMatrixColumn(zoomLevel, tileMatrix, envelope.getMaximum(DIMENSIONS.X));

        for (int row=firstAffectedRow; row<=lastAffectedRow; row++) {

            for (int column = firstAffectedColumn; column <= lastAffectedColumn; column++) {

                Envelope tileEnvelope = getTileEnvelope(zoomLevel, tileMatrix, row, column);

                if (affectedEnvelope == null) {

                    affectedEnvelope = tileEnvelope;

                } else {

                    affectedEnvelope.add(tileEnvelope);

                }

            }

        }

        Buffer affectedBuffer = null;

        try {

            affectedBuffer =

                bufferManager.createBuffer((lastAffectedRow - firstAffectedRow + 1) * tileMatrix.getTileHeight(),

                    (lastAffectedColumn - firstAffectedColumn + 1) * tileMatrix.getTileWidth(), bandDataTypes, null,

                    this.projection, affectedEnvelope);

            int targetTileRow = 0;

            int sourceRow = 0;

            for (int row = firstAffectedRow; row <= lastAffectedRow; row++) {

                int targetTileColumn = 0;

                int sourceColumn = 0;

                sourceRow = targetTileRow * tileMatrix.getTileHeight();

                for (int column = firstAffectedColumn; column <= lastAffectedColumn; column++) {

                    sourceColumn = targetTileColumn * tileMatrix.getTileWidth();

                    String keyTile = composeKeyForRecentTiles(tileMatrixIdentifier, zoomLevel, row, column);

                    DownloadedTile tile = recentAccededWMTSTiles.get(keyTile);

                    Buffer sourceTileBuffer = null;

                    if (tile == null) {

                        status.setTileCol(column);

                        status.setTileRow(row);

                        Envelope tileEnvelope = getTileEnvelope(zoomLevel, tileMatrix, row, column);

                        URL url = provider.getWMTSClient().getTileURL(status);

                        Downloader downloader = CompatLocator.getDownloader();

                        BufferedImage img;

                        try {

                            logger.info("URL: " + url.toString());

                            File file = downloader.downloadFile(url, "WMTS_tile", null);

                            img = ImageIO.read(file);

                        } catch (Exception e) {

                            continue;

                            // throw new BufferException(e);

                        }

                        sourceTileBuffer = bufferManager.createRGBABuffer(img, projection, tileEnvelope);

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

                            removeOlderTile();

                        }

                        DownloadedTile downloadedTile = new DownloadedTile(sourceTileBuffer, keyTile);

                        recentAccededWMTSTiles.put(keyTile, downloadedTile);

                        DisposeUtils.dispose(sourceTileBuffer);

                    } else {

                        sourceTileBuffer = tile.getBuffer();

                    }

                    for (int iband = 0; iband < affectedBuffer.getBandCount(); iband++) {

                        Band affectedBand = affectedBuffer.getBand(iband);

                        affectedBand.copyFrom(sourceTileBuffer.getBand(iband), sourceRow, sourceColumn);

                    }

                    targetTileColumn++;

                }

                targetTileRow++;

            }

            Buffer clipped = null;

            try {

                clipped = affectedBuffer.clip(envelope);

                DownloadedTile downloadedTile = new DownloadedTile(clipped, key);

                return downloadedTile;

            } finally {

                DisposeUtils.disposeQuietly(clipped);

            }

        } finally {

            DisposeUtils.disposeQuietly(affectedBuffer);

        }

    }

    private int getTileMatrixRow(int zoomLevel, WMTSTileMatrix tileMatrix, double y) {

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

        double heightWCTile = tileMatrix.getTileHeight() * pixelSize;

        double[] topLeftCorner = tileMatrix.getTopLeftCorner();

        double top;

            top = topLeftCorner[1];

        double row = (top-y)/heightWCTile;

        return (int)row;

    }

    private int getTileMatrixColumn(int zoomLevel, WMTSTileMatrix tileMatrix, double x) {

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

        double widthWCTile = tileMatrix.getTileWidth() * pixelSize;

        double[] topLeftCorner = tileMatrix.getTopLeftCorner();

        double left;

        left = topLeftCorner[0];

        double row = (x - left) / widthWCTile;

        return (int) row;

    }

    private String composeKeyForRecentTiles(String tileMatrixIdentifier, int zoomLevel, int row, int col) {

        StringBuilder builder = new StringBuilder();

        builder.append(tileMatrixIdentifier);

        builder.append(":");

        builder.append(zoomLevel);

        builder.append(":");

        builder.append(col);

        builder.append(":");

        builder.append(row);

        return builder.toString();

    }

    /**

     * C?lculo del envelope del tile que queremos construir

     *

     * @param zoomLevel

     * @param structRow

     * @param structCol

     * @param geomManager

     * @return

     * @throws CreateEnvelopeException

     */

    private Envelope createRequestTileEnvelope(int zoomLevel, int structRow, int structCol, GeometryManager geomManager)

        throws CreateEnvelopeException {

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

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

        return envelope;

    }

    private Envelope getTileEnvelope(int zoomLevel, WMTSTileMatrix tileMatrix, int row, int column)

        throws LocatorException, CreateEnvelopeException {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        // PRUEBA V?LIDA: tileMatrix.getWidthWCTile y tileMatrix.getHeightWCTile

        // no devuelven lo que esperamos aqu?

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

        double widthWCTile = tileMatrix.getTileWidth() * pixelSize;

        double heightWCTile = tileMatrix.getTileHeight() * pixelSize;

        double[] topLeftCorner = tileMatrix.getTopLeftCorner();

        double tileMinX;

        double tileMaxY;

        tileMinX = topLeftCorner[0] + (column * widthWCTile);

        tileMaxY = topLeftCorner[1] - (row * heightWCTile);

        double tileMaxX = tileMinX + widthWCTile;

        double tileMinY = tileMaxY - heightWCTile;

        Envelope envelope = geomManager.createEnvelope(tileMinX, tileMinY, tileMaxX, tileMaxY, SUBTYPES.GEOM2D);

        return envelope;

    }

    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 class DownloadedTile extends AbstractDisposable {

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

        long lastAccess;

        String key;

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

//            logger

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

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

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

        }

        @Override

        protected void doDispose() throws BaseException {

            DisposeUtils.dispose(buffer);

            buffer = null;

        }

    }

    @Override

    protected void doDispose() throws BaseException {

        if(this.tile != null) {

            DisposeUtils.dispose(this.tile);

        }

        DisposeUtils.dispose((Disposable) tileStruct);

        tileStruct = null;

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

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

            DisposeUtils.dispose(tile);

            iterator.remove();

        }

        recentAccededWMTSTiles = null;

    }

    protected void removeOlderTile() {

        DownloadedTile olderTile = null;

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

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

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

                olderTile = tile;

            }

        }

        if (olderTile != null) {

            recentAccededWMTSTiles.remove(olderTile.getKey());

            DisposeUtils.dispose(olderTile);

        }

    }

}