Application: gvSIG desktop » gvSIG raster

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

/**

 * @author fdiaz

 *

 */

@Deprecated

    @Override

    public TileStruct getTileStruct() {

        // TODO Auto-generated method stub

        return null;

    }

/* 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.lib.buffer.api;

import java.util.Map;

import java.util.SortedMap;

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

/**

 * @author fdiaz

 *

 */

public interface TileStruct {

    /**

     * @return the rowsPerTile

     */

    public int getRowsPerTile();

    /**

     * @param rowsPerTile

     *            the rowsPerTile to set

     */

    public void setRowsPerTile(int rowsPerTile);

    /**

     * @return the columnsPerTile

     */

    public int getColumnsPerTile();

    /**

     * @param columnsPerTile

     *            the columnsPerTile to set

     */

    public void setColumnsPerTile(int columnsPerTile);

    /**

     * @return the providerName

     */

    public String getProviderName();

    /**

     * @param providerName

     *            the providerName to set

     */

    public void setProviderName(String providerName);

    /**

     * @return the pixelSizePerZoomLevel

     */

    public Map<Integer, Double> getPixelSizePerZoomLevel();

    /**

     * @param pixelSizePerZoomLevel

     *            the pixelSizePerZoomLevel to set

     */

    public void setPixelSizePerZoomLevel(SortedMap<Integer, Double> pixelSizePerZoomLevel);

    /**

     * @return the envelope

     */

    public Envelope getEnvelope();

    /**

     * @param envelope

     *            the envelope to set

     */

    public void setEnvelope(Envelope envelope);

}

    public TileStruct getTileStruct();

/* 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.lib.buffer.spi;

import java.util.Iterator;

import java.util.Set;

import java.util.SortedMap;

import java.util.Map.Entry;

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

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

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;

/**

 * @author fdiaz

 *

 */

public class DefaultTileStruct extends AbstractDisposable implements TileStruct{

    private int rowsPerTile;

    private int columnsPerTile;

    private String providerName;

    private SortedMap<Integer, Double> pixelSizePerZoomLevel;

    private Envelope envelope;

    public int getRowsPerTile() {

        return rowsPerTile;

    }

    public void setRowsPerTile(int rowsPerTile) {

        this.rowsPerTile = rowsPerTile;

    }

    public int getColumnsPerTile() {

        return columnsPerTile;

    }

    public void setColumnsPerTile(int columnsPerTile) {

        this.columnsPerTile = columnsPerTile;

    }

    public String getProviderName() {

        return providerName;

    }

    public void setProviderName(String providerName) {

        this.providerName = providerName;

    }

    public SortedMap<Integer, Double> getPixelSizePerZoomLevel() {

        return pixelSizePerZoomLevel;

    }

    public void setPixelSizePerZoomLevel(SortedMap<Integer, Double> pixelSizePerZoomLevel) {

        this.pixelSizePerZoomLevel = pixelSizePerZoomLevel;

    }

    public Envelope getEnvelope() {

        return envelope;

    }

    public void setEnvelope(Envelope envelope) {

        this.envelope = envelope;

    }

    @Override

    protected void doDispose() throws BaseException {

        if (pixelSizePerZoomLevel != null) {

            pixelSizePerZoomLevel.clear();

        }

        pixelSizePerZoomLevel = null;

        envelope = null;

    }

}

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

@Deprecated

    @Override

    public TileStruct getTileStruct() {

        // TODO Auto-generated method stub

        return null;

    }

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Attr;

import org.gvsig.fmap.dal.DataStore;

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

import org.gvsig.raster.lib.buffer.spi.DefaultTileStruct;

import org.gvsig.tools.dispose.Disposable;

    private TileStruct tileStruct;

        tileStruct = new DefaultTileStruct();

        // FIXME

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

        if (!tilePropertiesFile.exists()) {

            createTileCacheStructXMLFile(folder);

        }

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

                    tileStruct.setRowsPerTile(Integer.valueOf(tileSizeAttributes.getNamedItem("rows").getNodeValue()));

                    tileStruct.setColumnsPerTile(Integer.valueOf(tileSizeAttributes.getNamedItem("columns").getNodeValue()));

                    tileStruct.setProviderName(elementsByTagName.item(0).getTextContent());

                            tileStruct.setEnvelope(geoManager.createEnvelope(minX, minY, maxX, maxY, SUBTYPES.GEOM2D));                        }

                            if (providerFactory.getName().equalsIgnoreCase(tileStruct.getProviderName())) {

                    this.tileStruct.setPixelSizePerZoomLevel(pixelSizePerZoomLevel);

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

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

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

                DisposeUtils.dispose(tileStore);

                tileStore = null;

                DisposeUtils.dispose(tileStoreRasterSet);

                tileStoreRasterSet = null;

                DisposeUtils.dispose(rasterSet);

                rasterSet = null;

        DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory(this.tileStruct.getProviderName());

        tileStore = (RasterStore) manager.openStore(this.tileStruct.getProviderName(), params);

    private File requestTileFile(int zoomLevel, int structRow, int structCol) throws CreateEnvelopeException,

        CloneNotSupportedException, BufferException, ValidateDataParametersException, DataException {

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

        Envelope structExtent = this.tileStruct.getEnvelope();

        int rowsPerTile = this.tileStruct.getRowsPerTile();

        int columnsPerTile = this.tileStruct.getColumnsPerTile();

            // FIXME: Ver de coger estos dos valores del inner provider para que

            // los tiles sean homog?neos con el raster original

            int bands = innerProvider.getBands();

            switch (bands) {

            case 3:

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

                break;

            case 4:

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

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

                break;

            default:

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

                break;

            }

            DisposeUtils.dispose(buffer);

            DisposeUtils.dispose(clippedBuffer);

            DisposeUtils.dispose(interpolatedBuffer);

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

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

        return this.tileStruct.getEnvelope();

        return this.tileStruct.getRowsPerTile();

        return this.tileStruct.getColumnsPerTile();

        return this.tileStruct.getProviderName();

            logger

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

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

        if (recentAccededTiles != null) {

        DisposeUtils.dispose(innerProvider);

        innerProvider = null;

        DisposeUtils.dispose((Disposable) tileStruct);

        tileStruct = null;

        query = null;

        factory = null;

        crs = null;

        colorInterpretation = null;

        legend = null;

        colorTable = null;

    }

    private void createTileCacheStructXMLFile(File folder) {

        // FIXME: ?Coger estos valores de alguna constante o de una preferencia?

        int tileSizeX = 256;

        int tileSizeY = 256;

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

        if (!file.exists()) {

            Buffer auxBuffer = null;

            try {

                DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();

                DocumentBuilder docBuilder = docFactory.newDocumentBuilder();

                // root elements

                Document doc = (Document) docBuilder.newDocument();

                Element rootElement = doc.createElement("TileCacheStruct");

                doc.appendChild(rootElement);

                // tileSize

                Element tileSize = doc.createElement("tileSize");

                rootElement.appendChild(tileSize);

                // tileSize Rows

                Attr rows = doc.createAttribute("rows");

                rows.setValue(String.valueOf(tileSizeY));

                tileSize.setAttributeNode(rows);

                // tileSize Columns

                Attr columns = doc.createAttribute("columns");

                columns.setValue(String.valueOf(tileSizeX));

                tileSize.setAttributeNode(columns);

                // format

                Element format = doc.createElement("format");

                format.setTextContent("GTiff");

                rootElement.appendChild(format);

                // structExtent

                Element structExtent = doc.createElement("structExtent");

                rootElement.appendChild(structExtent);

                Envelope envelope = (Envelope) innerProvider.getDynValue(DataStore.METADATA_ENVELOPE);

                // structExtent minX

                Element minX = doc.createElement("minX");

                minX.setTextContent(String.valueOf(envelope.getMinimum(DIMENSIONS.X)));

                structExtent.appendChild(minX);

                // structExtent minY

                Element minY = doc.createElement("minY");

                minY.setTextContent(String.valueOf(envelope.getMinimum(DIMENSIONS.Y)));

                structExtent.appendChild(minY);

                // structExtent maxX

                Element maxX = doc.createElement("maxX");

                maxX.setTextContent(String.valueOf(envelope.getMaximum(DIMENSIONS.X)));

                structExtent.appendChild(maxX);

                // structExtent maxY

                Element maxY = doc.createElement("maxY");

                maxY.setTextContent(String.valueOf(envelope.getMaximum(DIMENSIONS.Y)));

                structExtent.appendChild(maxY);

                Element levels = doc.createElement("levels");

                rootElement.appendChild(levels);

                // FIXME: ?alguna otra forma de obtener el pixelSize del store

                // completo?

                auxBuffer = innerProvider.createBuffer(null);

                int completeRows = auxBuffer.getRows();

                int completeColumns = auxBuffer.getColumns();

                double completePixelSizeX = auxBuffer.getPixelSizeX();

                double completePixelSizeY = auxBuffer.getPixelSizeY();

                int maximumLength = completeColumns;

                int tileMaximumLength = tileSizeX;

                double maximumPixelSize = completePixelSizeX;

                if (completeRows * tileSizeY > completeColumns * tileSizeX) {

                    maximumLength = completeRows;

                    tileMaximumLength = tileSizeY;

                    maximumPixelSize = completePixelSizeY;

                }

                List<Double> pixelSizes = new ArrayList<Double>();

                Map<Integer, Double> zoomLevels = new HashMap<Integer, Double>();

                double pixelSize = maximumPixelSize;

                while (maximumLength * maximumPixelSize / pixelSize > tileMaximumLength) {

                    pixelSizes.add(pixelSize);

                    pixelSize = pixelSize * 2;

                }

                pixelSizes.add(pixelSize);

                int i = 0;

                for (int zoomLevel = pixelSizes.size() - 1; zoomLevel >= 0; zoomLevel--) {

                    zoomLevels.put(i, pixelSizes.get(zoomLevel));

                    appendZoomLevel(doc, levels, i, pixelSizes.get(zoomLevel));

                    i++;

                }

                // write the content into xml file

                DOMSource source = new DOMSource(doc);

                File parent = file.getParentFile();

                if (!parent.exists()) {

                    parent.mkdirs();

                }

                file.createNewFile();

                StreamResult result = new StreamResult(file.toURI().getPath());

                TransformerFactory transformerFactory = TransformerFactory.newInstance();

                Transformer transformer = transformerFactory.newTransformer();

                transformer.setOutputProperty(OutputKeys.INDENT, "yes");

                transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");

                transformer.transform(source, result);

            } catch (ParserConfigurationException | TransformerException | IOException | BufferException e) {

                logger.warn("Can't create tileCacheStruct.xml file", e);

            } finally {

                DisposeUtils.dispose(auxBuffer);

                auxBuffer = null;

            }

    /**

     * @param doc

     * @param rootElement

     * @param levels

     * @param zoomLevel

     * @param pixelSize

     */

    private void appendZoomLevel(Document doc, Element levels, int zoomLevel, double pixelSize) {

        Element level = doc.createElement("level");

        levels.appendChild(level);

        // level zoomLevel

        Attr index = doc.createAttribute("index");

        index.setValue(String.valueOf(zoomLevel));

        level.setAttributeNode(index);

        // level pixelSize

        Attr pxSize = doc.createAttribute("pixelSize");

        pxSize.setValue(String.valueOf(pixelSize));

        level.setAttributeNode(pxSize);

    }

    public TileStruct getTileStruct() {

        if(this.tileStruct==null){

            this.tileStruct = new DefaultTileStruct();

        }

        return this.tileStruct;

    }

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

    @Override

    public TileStruct getTileStruct() {

        return tileStructImage.getTileStruct();

    }

  <dependency>

    <groupId>org.gvsig</groupId>

    <artifactId>org.gvsig.raster.lib.buffer.spi</artifactId>

  </dependency>

        dataStore = openFileCached(new File("/home/paco/data/cartography/raster/ecw/valencia_1980_tif.tif"));

//        dataStore = openFileCached(new File("/home/paco/data/Testdata/raster/JPG/relieve_andalucia.png"));

        DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory("GTiff");

//        DataStoreProviderFactory providerFactory = manager.getStoreProviderFactory("PNG");

            store = (RasterStore) manager.openStore("GTiff", params);

//            store = (RasterStore) manager.openStore("PNG", params);