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.io.File;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import java.util.SortedMap;

import java.util.TreeMap;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

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

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

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

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

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

import org.gvsig.fmap.dal.raster.api.RasterSet;

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

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

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

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerManager;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderFactory;

import org.gvsig.fmap.dal.spi.DALSPILocator;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.extensionpoint.ExtensionPoint.Extension;

/**

 * Represents a tiled image

 *

 * @author dmartinezizquierdo

 *

 */

public class TileStructImage extends AbstractDisposable {

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

    private static final int MAX_RECENT_ACCEDED_TILES_NUMBER = 50;

    private int rowsPerTile;

    private int columnsPerTile;

    private FilesystemServerExplorerProviderFactory factory;

    private String providerName;

    private String extension;

    private SortedMap<Integer, Double> pixelSizePerZoomLevel;

    // private SortedMap<Integer,Envelope> envelopePerZoomLevel;

    private File tilesFolder;

    private Map<String, Tile> recentAccededTiles;

    private Integer bandNumber = null;

    private int[] dataTypes;

    private IProjection crs;

    private Envelope structExtent;

    private Object colorInterpretation;

    private Object legend;

    private Object colorTable;

    private RasterStoreProvider innerProvider;

    private RasterQuery query;

    /**

     * @param folder

     * @param crs

     * @param innerProvider

     * @param innerStore

     */

    public TileStructImage(File folder, IProjection crs, RasterStoreProvider innerProvider, RasterQuery query) {

        this.crs = crs;

        this.innerProvider = innerProvider;

        this.query = query;

        GeometryManager geoManager = GeometryLocator.getGeometryManager();

        // envelopePerZoomLevel = new TreeMap<Integer, Envelope>();

        pixelSizePerZoomLevel = new TreeMap<Integer, Double>();

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

        // FIXME

        File tilePropertiesFile = new File(folder, "tileCacheStruct.xml");

        tilesFolder = new File(folder, "V" + File.separatorChar + "Z" + File.separatorChar + "T");

        if (!tilesFolder.exists()) {

            tilesFolder.mkdirs();

        }

        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();

        DocumentBuilder dBuilder;

        try {

            dBuilder = dbFactory.newDocumentBuilder();

            Document doc = dBuilder.parse(tilePropertiesFile);

            doc.getDocumentElement().normalize();

            NodeList nList = doc.getElementsByTagName("TileCacheStruct");

            for (int temp = 0; temp < nList.getLength(); temp++) {

                Node nNode = nList.item(temp);

                if (nNode.getNodeType() == Node.ELEMENT_NODE) {

                    Element eElement = (Element) nNode;

                    NamedNodeMap tileSizeAttributes = eElement.getElementsByTagName("tileSize").item(0).getAttributes();

                    rowsPerTile = Integer.valueOf(tileSizeAttributes.getNamedItem("rows").getNodeValue());

                    columnsPerTile = Integer.valueOf(tileSizeAttributes.getNamedItem("columns").getNodeValue());

                    NodeList elementsByTagName = eElement.getElementsByTagName("format");

                    providerName = elementsByTagName.item(0).getTextContent();

                    NodeList structExtentList = eElement.getElementsByTagName("structExtent");

                    if (structExtentList.getLength() > 0) {

                        Element structExtentNode = (Element) structExtentList.item(0);

                        if (structExtentNode != null) {

                            Double minX =

                                Double.valueOf(structExtentNode.getElementsByTagName("minX").item(0).getTextContent());

                            Double minY =

                                Double.valueOf(structExtentNode.getElementsByTagName("minY").item(0).getTextContent());

                            Double maxX =

                                Double.valueOf(structExtentNode.getElementsByTagName("maxX").item(0).getTextContent());

                            Double maxY =

                                Double.valueOf(structExtentNode.getElementsByTagName("maxY").item(0).getTextContent());

                            structExtent = geoManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D);

                        }

                    }

                    FilesystemServerExplorerManager explorerManager =

                        DALFileLocator.getFilesystemServerExplorerManager();

                    @SuppressWarnings("unchecked")

                    Iterator<Extension> it = explorerManager.getRegisteredProviders();

                    while (it.hasNext()) {

                        Extension ext = it.next();

                        FilesystemServerExplorerProviderFactory providerFactory;

                        try {

                            providerFactory = (FilesystemServerExplorerProviderFactory) ext.create();

                            if (providerFactory.getName().equalsIgnoreCase(providerName)) {

                                this.factory = providerFactory;

                                break;

                            }

                        } catch (Exception e) {

                            throw new RuntimeException(e);// FIXME !!!

                        }

                    }

                    NodeList levelsTag = eElement.getElementsByTagName("levels");

                    Element levels = (Element) levelsTag.item(0);

                    NodeList levelList = levels.getElementsByTagName("level");

                    for (int i = 0; i < levelList.getLength(); i++) {

                        Element level = (Element) levelList.item(i);

                        NamedNodeMap levelAttributes = level.getAttributes();

                        int zoomLevel = Integer.valueOf(levelAttributes.getNamedItem("index").getNodeValue());

                        double pixelSize = Double.valueOf(levelAttributes.getNamedItem("pixelSize").getNodeValue());

                        pixelSizePerZoomLevel.put(zoomLevel, pixelSize);

                    }

                }

            }

        } catch (Exception e) {

            throw new RuntimeException();

        }

    }

    /**

     * @param pixelSize

     * @return The appropiate zoom level for the pizelSize

     */

    public int getZoomLvlForPixelSize(double pixelSize) {

        int zoom = 0;

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

            zoom = i;

            double levelPixelSize = pixelSizePerZoomLevel.get(zoom);

            if (pixelSize >= levelPixelSize) {

                return zoom;

            }

        }

        return zoom;

    }

    /**

     * @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 {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        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 rasterSet = null;

            RasterStore tileStore = null;

            RasterSet tileStoreRasterSet = null;

            try {

                tileStore = createTileStore(zoomLevel, structRow, structCol);

                tileStoreRasterSet = tileStore.getRasterSet();

                rasterSet = bufferManager.createBuffer(tileStoreRasterSet, false);

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

                    removeOlderTile();

                }

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

                Band band = rasterSet.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 {

                if (tileStore != null) {

                    DisposeUtils.dispose(tileStore);

                    tileStore = null;

                }

                if (tileStoreRasterSet != null) {

                    DisposeUtils.dispose(tileStoreRasterSet);

                    tileStoreRasterSet = null;

                }

                if (rasterSet != null) {

                    DisposeUtils.dispose(rasterSet);

                    rasterSet = null;

                }

            }

        }

    }

    private RasterStore createTileStore(int zoomLevel, int structRow, int structCol)

        throws ValidateDataParametersException, CreateEnvelopeException, BufferException, DataException,

        CloneNotSupportedException {

        File tileFile = null;

        File zoomFolder = new File(tilesFolder, String.valueOf(zoomLevel));

        if (!zoomFolder.exists()) {

            zoomFolder.mkdirs();

        }

        File firstColumnFolder = new File(zoomFolder, String.valueOf(structCol));

        if (!firstColumnFolder.exists()) {

            tileFile = requestTileFile(zoomLevel, structRow, structCol);

            this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath());

        }

        String rowBaseName = String.valueOf(structRow);

        if (this.extension == null) {

            File[] providerAcceptedFiles = firstColumnFolder.listFiles(factory);

            for (int i = 0; i < providerAcceptedFiles.length; i++) {

                File providerAcceptedFile = providerAcceptedFiles[i];

                if (FilenameUtils.getBaseName(providerAcceptedFile.getAbsolutePath()).equalsIgnoreCase(rowBaseName)) {

                    tileFile = providerAcceptedFile;

                }

            }

            if (tileFile == null || !tileFile.exists()) {

                tileFile = requestTileFile(zoomLevel, structRow, structCol);

            }

            this.extension = FilenameUtils.getExtension(tileFile.getAbsolutePath());

        } else {

            if (tileFile == null) {

                tileFile =

                    new File(firstColumnFolder.getAbsolutePath() + File.separatorChar + rowBaseName + "."

                        + this.extension);

            }

        }

        if (!tileFile.exists()) {

            tileFile = requestTileFile(zoomLevel, structRow, structCol);

        }

        RasterStore tileStore = null;

        DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices();

        DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(providerName);

        DynObject params = providerFactory.createParameters();

        if (params.getDynClass().getDynField("file") != null) {

            params.setDynValue("file", tileFile);

        }

        if (params.getDynClass().getDynField("crs") != null) {

            params.setDynValue("crs", this.crs);

        }

        tileStore = (RasterStore) manager.openStore(providerName, params);

        return tileStore;

    }

    private File requestTileFile(int zoomLevel, int structRow, int structCol) throws CreateEnvelopeException, CloneNotSupportedException, BufferException, ValidateDataParametersException, DataException {

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

        Double pixelSize = this.pixelSizePerZoomLevel.get(zoomLevel);

        rasterQuery.setPixelSize(pixelSize);

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        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;

        File destFile = 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);

            String providerName = "GTiff";

            String extension = "tif";

            DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices();

            DataServerExplorerParameters eparams;

            eparams = manager.createServerExplorerParameters("FilesystemExplorer");

            StringBuilder builder = new StringBuilder();

            builder.append(tilesFolder);

            builder.append(File.separator);

            builder.append(zoomLevel);

            builder.append(File.separator);

            builder.append(structCol);

            builder.append(File.separator);

            builder.append(structRow);

            builder.append(".");

            builder.append(extension);

            String path = builder.toString();

            destFile = new File(path);

            File parent = destFile.getParentFile();

            if (!parent.exists()) {

                parent.mkdirs();

            }

            eparams.setDynValue("initialpath", path);

            DataServerExplorer serverExplorer = manager.createServerExplorer(eparams);

            NewRasterStoreParameters params = (NewRasterStoreParameters) serverExplorer.getAddParameters(providerName);

            params.setDynValue("file", destFile);

            params.setDynValue("compress", "NONE");

            params.setDynValue("tfw", false);

            //FIXME: Ver de coger estos dos valores del inner provider para que los tiles sean homog?neos con el raster original

            params.setDynValue("photometric", "RGB");

            params.setDynValue("alpha", "NON-PREMULTIPLIED");

            params.setBuffer(interpolatedBuffer);

            serverExplorer.add(providerName, params, true);

        } finally {

            if (buffer!=null){

                DisposeUtils.dispose(buffer);

            }

            if (clippedBuffer!=null){

                DisposeUtils.dispose(clippedBuffer);

            }

            if (interpolatedBuffer!=null){

                DisposeUtils.dispose(interpolatedBuffer);

            }

        }

        return destFile;

    }

    /**

     * @return the band number

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     * @throws DataException

     * @throws BufferException

     * @throws CreateEnvelopeException

     * @throws DynMethodException

     */

    public int getBandNumber() throws ValidateDataParametersException, CreateEnvelopeException, BufferException,

        DataException, CloneNotSupportedException {

        if (this.bandNumber == null) {

            fillStoreInfo();

        }

        return this.bandNumber;

    }

    /**

     * @return the data types

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     * @throws DataException

     * @throws BufferException

     * @throws CreateEnvelopeException

     * @throws DynMethodException

     */

    public int[] getDataTypes() throws ValidateDataParametersException, CreateEnvelopeException, BufferException,

        DataException, CloneNotSupportedException {

        if (this.dataTypes == null) {

            fillStoreInfo();

        }

        return this.dataTypes;

    }

    /**

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     * @throws DynMethodException

     * @throws DataException

     * @throws BufferException

     * @throws CreateEnvelopeException

     *

     */

    private void fillStoreInfo() throws ValidateDataParametersException, CreateEnvelopeException, BufferException,

        DataException, CloneNotSupportedException {

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

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

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

            dataTypes[i] = this.innerProvider.getBandInfo(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.");

        }

    }

    /**

     * @param zoomLevel

     * @return rows per zoom level

     */

    public int getRows(int zoomLevel) {

        return (int) (Math.round(getEnvelope().getLength(DIMENSIONS.Y) / pixelSizePerZoomLevel.get(zoomLevel)));

    }

    /**

     * @param zoomLevel

     * @return columns per zoom level

     */

    public int getColumns(int zoomLevel) {

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

    }

    /**

     * @return envelope per zoom level

     */

    public Envelope getEnvelope() {

        return structExtent;

    }

    /**

     * @return the rows number per tile

     */

    public int getRowsPerTile() {

        return rowsPerTile;

    }

    /**

     * @return the columns number per tile

     */

    public int getColumnsPerTile() {

        return columnsPerTile;

    }

    /**

     * @return the provider name

     */

    public String getProviderName() {

        return providerName;

    }

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

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

        }

    }

    /**

     * @return the color interpretation

     * @throws DynMethodException

     * @throws CloneNotSupportedException

     * @throws ValidateDataParametersException

     * @throws DataException

     * @throws BufferException

     * @throws CreateEnvelopeException

     */

    public Object getColorInterpretation() throws DynMethodException, ValidateDataParametersException,

        CreateEnvelopeException, BufferException, DataException, CloneNotSupportedException {

        if (this.colorInterpretation == null) {

            fillStoreInfo();

        }

        return this.colorInterpretation;

    }

    /**

     * @return the color table

     * @throws ValidateDataParametersException

     * @throws DynMethodException

     * @throws CloneNotSupportedException

     * @throws DataException

     * @throws BufferException

     * @throws CreateEnvelopeException

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     */

    public Object getColorTable() throws DynMethodException, ValidateDataParametersException, CreateEnvelopeException,

        BufferException, DataException, CloneNotSupportedException {

        if (this.colorTable == null) {

            fillStoreInfo();

        }

        return this.colorTable;

    }

    /**

     * @return the legend

     * @throws ValidateDataParametersException

     * @throws DynMethodException

     * @throws CloneNotSupportedException

     * @throws DataException

     * @throws BufferException

     * @throws CreateEnvelopeException

     * @throws InitializeException

     * @throws ProviderNotRegisteredException

     */

    public Object getLegend() throws DynMethodException, ValidateDataParametersException, CreateEnvelopeException,

        BufferException, DataException, CloneNotSupportedException {

        if (this.legend == null) {

            fillStoreInfo();

        }

        return this.legend;

    }

    private 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) {

            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(recentAccededTiles!=null){

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

            for (Iterator iterator = entrySet.iterator(); iterator.hasNext();) {

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

                DisposeUtils.dispose(entry.getValue());

            }

            recentAccededTiles.clear();

        }

        if(innerProvider!=null){

            DisposeUtils.dispose(innerProvider);

            innerProvider=null;

        }

        query=null;

        factory=null;

        crs=null;

        structExtent=null;

        colorInterpretation=null;

        legend=null;

        colorTable=null;

    }

}