Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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.

 *

 */

package org.gvsig.raster.wmts.io.downloader;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.net.URL;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.util.MathUtils;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.TileCacheLocator;

import org.gvsig.raster.cache.tile.exception.TileBuildException;

import org.gvsig.raster.cache.tile.provider.CacheStruct;

import org.gvsig.raster.wmts.io.WMTSDataParameters;

import org.gvsig.raster.wmts.io.WMTSProvider;

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

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

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

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

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

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

/**

 * Implementation for a structure of a cache

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class WMTSCacheStruct implements CacheStruct {

    private String                        layerName           = null;

        private String                        serverURL           = null;

        private WMTSTileMatrixSet             tileMatrixSet       = null;

        private List<WMTSTileMatrixLimits>    tileMatrixSetLimits = null;

        private double[]                      pixelSize           = null;

    private RasterDataStore               store               = null;

    public WMTSCacheStruct(RasterDataStore store, WMTSTileMatrixSetLink tileMatrixSetLink) {

            this.store = store;

            this.tileMatrixSet = tileMatrixSetLink.getTileMatrixSet();

                this.tileMatrixSetLimits = tileMatrixSetLink.getTileMatrixLimits();

                pixelSize = ((WMTSProvider)store.getProvider()).getPixelSizeByLevel();

                serverURL = ((WMTSProvider)store.getProvider()).getURIOfFirstProvider().getPath();

                layerName = ((WMTSDataParameters)store.getParameters()).getLayer().getTitle();

    }

        public int getNumberOfLevels() {

                return tileMatrixSet.getTileMatrix().size();

        }

        public String getLayerName() {

                return layerName;

        }

        public String getServerURL() {

                return serverURL + getDimension();

        }

        public int[] getTileSizeByLevel(int level) {

                return new int[] {

                        ((WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level)).getTileWidth(),

                        ((WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level)).getTileHeight()

                };

        }

        public int getLayerWidthOfTileMatrixByLevel(int level) {

                if(tileMatrixSetLimits != null && tileMatrixSetLimits.size() > level) {

                        WMTSTileMatrixLimits l = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(level);

                        return l.getMaxTileRow() - l.getMinTileRow();

                } else {

                        WMTSTileMatrix tm = (WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level);

                        return (int)tm.getMatrixWidth();

                }

        }

        public int getLayerHeightOfTileMatrixByLevel(int level) {

                if(tileMatrixSetLimits != null && tileMatrixSetLimits.size() > level) {

                        WMTSTileMatrixLimits l = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(level);

                        return l.getMaxTileCol() - l.getMinTileCol();

                } else {

                        WMTSTileMatrix tm = (WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level);

                        return (int)tm.getMatrixHeight();

                }

        }

        public int getLayerInitXTilePositionByLevel(int level) {

                if(tileMatrixSetLimits != null && tileMatrixSetLimits.size() > level) {

                        WMTSTileMatrixLimits l = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(level);

                        return l.getMinTileCol();

                } else

                        return 0;

        }

        public int getLayerInitYTilePositionByLevel(int level) {

                if(tileMatrixSetLimits != null && tileMatrixSetLimits.size() > level) {

                        WMTSTileMatrixLimits l = (WMTSTileMatrixLimits)tileMatrixSetLimits.get(level);

                        return l.getMinTileRow();

                } else

                        return 0;

        }

        public long getWorldHeightOfTileMatrixByLevel(int level) {

                return ((WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level)).getMatrixWidth();

        }

        public long getWorldWidthOfTileMatrixByLevel(int level) {

                return ((WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level)).getMatrixHeight();

        }

        public double getPixelSizeByLevel(int level) {

                if(level < pixelSize.length)

                        return pixelSize[level];

                else

                        return pixelSize[pixelSize.length - 1];

        }

        public Point2D[] getTileExtent(Tile tile) {

                return getTileExtent(tile.getLevel(), tile.getCol(), tile.getRow());

        }

        public Point2D[] getTileExtent(int level, int col, int row) {

                double[] ul = tileMatrixSet.getBoundingBox().getUpperCorner();

                long tileWidth = ((WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level)).getTileWidth();

                long tileHeight = ((WMTSTileMatrix)tileMatrixSet.getTileMatrix().get(level)).getTileHeight();

                double mtsWidthTile = tileWidth * pixelSize[level];

                double mtsHeightTile = tileHeight * pixelSize[level];

                double ulx = ul[0] + (col * mtsWidthTile);

                double uly = ulx + mtsWidthTile;

                double lrx = ul[1] - (row * mtsHeightTile);

                double lry = lrx - mtsHeightTile;

                return new Point2D[]{new Point2D.Double(ulx, uly), new Point2D.Double(lrx, lry)};

        }

        public Tile getTileStructure(int level, int tileCol, int tileRow, Point2D ul, Point2D lr) throws TileBuildException  {

                int[] size = getTileSizeByLevel(level);

                Tile tile = TileCacheLocator.getManager().createTile(level, tileRow, tileCol);

                tile.setUl(ul);

                tile.setLr(lr);

                tile.setWidthPx(size[0]);

                tile.setHeightPx(size[1]);

                Rectangle2D r = new Rectangle2D.Double(Math.min(ul.getX(), lr.getX()),

                                Math.min(ul.getY(), lr.getY()),

                                Math.abs(ul.getX() - lr.getX()),

                                Math.abs(ul.getY() - lr.getY()));

                int bufWidth = (int)(r.getWidth() / getPixelSizeByLevel(level));

                int bufHeight = (int)(r.getHeight() / getPixelSizeByLevel(level));

                try {

                        WMTSStatus status = ((WMTSProvider)store.getProvider()).buildWMTSStatus(r, bufWidth, bufHeight);

                        tile.setDownloaderParams("WMTSStatus", status);

                } catch (RasterDriverException e) {

                        throw new TileBuildException(e);

                }

                return tile;

        }

        public List<Tile> getTileList(Point2D ul, Point2D lr, double mtsPixelRequest) throws TileBuildException {

                Rectangle2D r = new Rectangle2D.Double(Math.min(ul.getX(), lr.getX()),

                                Math.min(ul.getY(), lr.getY()),

                                Math.abs(ul.getX() - lr.getX()),

                                Math.abs(ul.getY() - lr.getY()));

                int bufWidth = (int)(r.getWidth() / mtsPixelRequest);

                int bufHeight = (int)(r.getHeight() / mtsPixelRequest);

                try {

                        WMTSStatus status = ((WMTSProvider)store.getProvider()).buildWMTSStatus(r, bufWidth, bufHeight);

                        //Conversi?n a tiles de la librer?a

                        List<WMTSTile> tiles = status.getTileList();

                        List<Tile> tileList = new ArrayList<Tile>();

                        for (int i = 0; i < tiles.size(); i++) {

                                WMTSTile tOrigin = (WMTSTile) tiles.get(i);

                                Tile t = TileCacheLocator.getManager().createTile(status.getLevel(), tOrigin.getCol(), tOrigin.getRow());

                                t.setUl(new Point2D.Double(tOrigin.getULX(), tOrigin.getULY()));

                                t.setLr(new Point2D.Double(tOrigin.getLRX(), tOrigin.getLRY()));

                                t.setWidthPx(tOrigin.getWidthPx());

                                t.setHeightPx(tOrigin.getHeightPx());

                                t.setDownloaderParams("WMTSStatus", status.cloneStatus());

                                tileList.add(t);

                        }

                        return tileList;

                } catch (RasterDriverException e) {

                        throw new TileBuildException(e);

                }

        }

        public double[] getTileSizeInRealCoordsByLevel(int level) {

                return new double[] {

                                getPixelSizeByLevel(level) * getTileSizeByLevel(level)[0],

                                getPixelSizeByLevel(level) *  getTileSizeByLevel(level)[1]

                        };

        }

        public String getFileSuffix() {

                return ((WMTSProvider)store.getProvider()).getFileSuffix();

        }

        public boolean compare(CacheStruct struct) {

                MathUtils mu = RasterLocator.getManager().getMathUtils();

                //Compara: n?mero de niveles, tama?o de tile,

                //anchoXalto de la matriz, tama?o de pixel por nivel,

                //coordenadas de al menos un tile de la matriz

                if(struct.getNumberOfLevels() == getNumberOfLevels()) {

                        for (int i = 0; i < getNumberOfLevels(); i++) {

                                if(        struct.getTileSizeByLevel(i)[0] == getTileSizeByLevel(i)[0] &&

                                        struct.getTileSizeByLevel(i)[1] == getTileSizeByLevel(i)[1] &&

                                        struct.getWorldHeightOfTileMatrixByLevel(i) == getWorldHeightOfTileMatrixByLevel(i) &&

                                        struct.getWorldWidthOfTileMatrixByLevel(i) == getWorldWidthOfTileMatrixByLevel(i) &&

                                        mu.clipDecimals(struct.getPixelSizeByLevel(i), 2) == mu.clipDecimals(getPixelSizeByLevel(i), 2) &&

                                        compareExtents(struct.getTileExtent(i, 0, 0), getTileExtent(i, 0, 0))) {

                                        return true;

                                }

                        }

                }

                return false;

        }

        private boolean compareExtents(Point2D[] p, Point2D[] p1) {

                return (p[0].getX() == p1[0].getX() && p[0].getY() == p1[0].getY() &&

                                p[1].getX() == p1[1].getX() && p[1].getY() == p1[1].getY());

        }

        public String getEPSG() {

                /*IProjection proj = provider.getProjection();

                if(proj != null)

                        return proj.getAbrev();

                return null;*/

                return ((WMTSProvider)store.getProvider()).getSRSCode();

        }

        private String getDimension() {

                WMTSDataParameters p = (WMTSDataParameters)(((WMTSProvider)store.getProvider()).getDataParameters());

                String dimension = p.getDimension();

                String dimensionValue = p.getDimensionSelectedValue();

                if(dimension != null && dimensionValue != null)

                        return dimension + "_" + dimensionValue;

                return "";

        }

        public String getFileSize() {

                return "0";

        }

        public List<Tile> getTileList(int x, int y, int w, int h) {

                return null;

        }

        public ArrayList<Tile> getTileList(Rectangle2D r) {

                return null;

        }

}