gvSIG data provider for OpenStreetMap (raster)

/* OSM layers for gvSIG. 

 * Geographic Information System of the Valencian Government

*

* Copyright (C) 2012 Nacho Brodin

* 

* 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.osm.cachestruct;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.List;

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

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

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;

/**

 * Implementation for a structure of a cache

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

 */

public class OSMCacheStruct implements CacheStruct {

    private TileMatrixSet                 tileMatrixSet  = null;

    private ArrayList<TileMatrixLimits>   limits         = null;

    private String                        layerName      = null;

        private Rectangle2D                   worldExtent    = null;

        private String                        fileSuffix     = null;

        private String                        epsg           = null;

        private long                          fileSize       = 0;

        private double                        realPixelSize  = 0;

    public OSMCacheStruct(int levels, 

                    int tilePxWidth,

                    int tilePxHeight,

                    String layerName,

                    String baseDir,

                    String fileSuffix,

                    long size) {

            this.layerName = layerName;

            this.fileSuffix = fileSuffix;

            this.fileSize = size;

            this.epsg = "EPSG:3857"; //WGS87 Pseudomercator

            //Coordenadas del mundo en geogr?ficas y planas

            //worldExtent = new Rectangle2D.Double(-180, -85.0511, 360, 170.1022); // arctan(sin(PI)) = 85.0511

            //worldExtent = new Rectangle2D.Double(-180, -180, 360, 360);

            worldExtent = new Rectangle2D.Double(-20037508, -20037508, 40075016, 40075016);

            double[][] pixelSizeList = buildWorldMatrix(levels, tilePxWidth, tilePxHeight, worldExtent);

        buildLayerMatrix(levels, tilePxWidth, tilePxHeight, worldExtent, pixelSizeList);

    }

    private void buildLayerMatrix(int levels, 

                    int tilePxWidth, 

                    int tilePxHeight,

                    Rectangle2D worldExtent,

                    double[][] pixelSizeList) {

            limits = new ArrayList<TileMatrixLimits>();

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

                    //Calculo de tiles para ese nivel en la capa actual

                    int minTileCol = 0;

                    int minTileRow = 0;

                    int maxTileCol = (i == 0) ? 0 : (int)Math.pow(2, i) - 1;

                    int maxTileRow = (i == 0) ? 0 : (int)Math.pow(2, i) - 1;

                    TileMatrixLimits limit = new TileMatrixLimits();

                    limit.setMinTileRow(minTileRow);

                    limit.setMinTileCol(minTileCol);

                    limit.setMaxTileRow(maxTileRow);

                    limit.setMaxTileCol(maxTileCol);

                    //Calcula las coordenadas de la esquina superior izquierda del TileMatrixLimits

                    double ulx = worldExtent.getMinX() + (minTileCol * tilePxWidth * pixelSizeList[0][i]);

                    double uly = worldExtent.getMaxY() - (minTileRow * tilePxHeight * pixelSizeList[1][i]);

                    limit.getTileMatrix().setTopLeftCorner(new double[]{ulx, uly});

                    limit.getTileMatrix().setScaleXDenominator(pixelSizeList[0][i]);

                    limit.getTileMatrix().setScaleYDenominator(pixelSizeList[1][i]);

                    limit.getTileMatrix().setTileWidth(tilePxWidth);

                    limit.getTileMatrix().setTileHeight(tilePxHeight);

                    limits.add(limit);

            }

    }

    private double[][] buildWorldMatrix(int levels, 

                    int tilePxWidth, 

                    int tilePxHeight,

                    Rectangle2D worldExtent) {

            double[] pixelSizeXList = new double[levels];

            double[] pixelSizeYList = new double[levels];

            limits = new ArrayList<TileMatrixLimits>();

            tileMatrixSet = new TileMatrixSet();

            tileMatrixSet.setBbox(worldExtent);

            int nTilesWidth = 0;

            int nTilesHeight = 0;

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

                    TileMatrix tm = new TileMatrix();

                    tm.setTileWidth(tilePxWidth);

                    tm.setTileHeight(tilePxHeight);

                    nTilesWidth = (i == 0) ? 1 : nTilesWidth * 2;

                    nTilesHeight = (i == 0) ? 1 : nTilesHeight * 2;

                    tm.setMatrixWidth(nTilesWidth);

                    tm.setMatrixHeight(nTilesHeight);

                    if((tilePxWidth * nTilesWidth) != 0)

                            pixelSizeXList[i] = worldExtent.getWidth() / ((long)tilePxWidth * (long)nTilesWidth);

                    else

                            pixelSizeXList[i] = 0;

                    if((tilePxHeight * nTilesHeight) != 0)

                            pixelSizeYList[i] = worldExtent.getHeight() / ((long)tilePxHeight * (long)nTilesHeight);

                    else

                            pixelSizeYList[i] = 0;

                    //System.out.println("-Level:" + i + " " + nTilesWidth + " " + nTilesHeight + " " + pixelSizeList[i]);

                    tm.setScaleXDenominator(pixelSizeXList[i]);

                    tm.setScaleYDenominator(pixelSizeYList[i]);

                    tileMatrixSet.getTileMatrix().add(tm);

            }

            double[][] r = new double [2][];

            r[0] = pixelSizeXList;

            r[1] = pixelSizeYList;

            return r;

    }

    public Extent getWorldExtent() {

            return RasterLocator.getManager().getDataStructFactory().createExtent(worldExtent);

    }

        public int getNumberOfLevels() {

                return tileMatrixSet.getTileMatrix().size();

        }

        public String getLayerName() {

                return layerName;

        }

        public String getServerURL() {

                return layerName;

        }

        public String getFileSuffix() {

                return fileSuffix;

        }

        public int[] getTileSizeByLevel(int level) {

                return new int[] {

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

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

                };

        }

        public double[] getTileSizeInRealCoordsByLevel(int level) {

                return new double[] {

                                tileMatrixSet.getTileMatrix().get(level).getScaleXDenominator() * tileMatrixSet.getTileMatrix().get(level).getTileWidth(),

                                tileMatrixSet.getTileMatrix().get(level).getScaleYDenominator() *  tileMatrixSet.getTileMatrix().get(level).getTileHeight()

                        };

        }

        public int getLayerWidthOfTileMatrixByLevel(int level) {

                TileMatrixLimits l = limits.get(level);

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

        }

        public int getLayerHeightOfTileMatrixByLevel(int level) {

                TileMatrixLimits l = limits.get(level);

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

        }

        public int getLayerInitXTilePositionByLevel(int level) {

                TileMatrixLimits l = limits.get(level);

                return l.getMinTileCol();

        }

        public int getLayerInitYTilePositionByLevel(int level) {

                TileMatrixLimits l = limits.get(level);

                return l.getMinTileRow();

        }

        public long getWorldHeightOfTileMatrixByLevel(int level) {

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

        }

        public long getWorldWidthOfTileMatrixByLevel(int level) {

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

        }

        public double getPixelSizeByLevel(int level) {

                if(level < 0)

                        return realPixelSize;

                return tileMatrixSet.getTileMatrix().get(level).getScaleXDenominator();

        }

        public Point2D[] getTileExtent(Tile tile) {

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

        }

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

                return limits.get(level).getTileExtent(row, col);

        }

        public List<Tile> getTileList(Rectangle2D r) {

                //No se necesita el nivel de resoluci?n real ya que es solo para dibujado

                return null;

        }

        public List<Tile> getTileList(Point2D ul, Point2D lr, double mtsPixelXRequest) {

                //Selecci?n de nivel de resoluci?n

                int tilePxWidth = 0;

                int tilePxHeight = 0;

                double tileWCWidth = 0;

                double tileWCHeight = 0;

                int level = 0;

                double mtsPixelXLevel = 0;

                double mtsPixelYLevel = 0;

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

                        mtsPixelXLevel = tileMatrixSet.getTileMatrix().get(i).getScaleXDenominator();

                        mtsPixelYLevel = tileMatrixSet.getTileMatrix().get(i).getScaleYDenominator();

                        if(clipDecimals(mtsPixelXRequest, 6) >= clipDecimals(mtsPixelXLevel, 6) 

                                || i == (tileMatrixSet.getTileMatrix().size() - 1)) {

                                level = Math.max(i, 0);

                                //Se ajusta al m?ximo nivel disponible para esa capa

                                if(level > (limits.size() - 1)) {

                                        level = limits.size() - 1;

                                        mtsPixelXLevel = tileMatrixSet.getTileMatrix().get(level).getScaleXDenominator();

                                        mtsPixelYLevel = tileMatrixSet.getTileMatrix().get(level).getScaleYDenominator();

                                }

                                tilePxWidth = tileMatrixSet.getTileMatrix().get(level).getTileWidth();

                                tilePxHeight = tileMatrixSet.getTileMatrix().get(level).getTileHeight();

                                //mtsPixelLevel = tileMatrixSet.getTileMatrix().get(i - 1).getScaleDenominator();

                                tileWCWidth = tilePxWidth * mtsPixelXLevel;

                                tileWCHeight = tilePxHeight * mtsPixelYLevel;

                                break;

                        }

                }

                //Calculo del rectangulo de tiles

                int minTileCol = (int)((Math.abs(ul.getX() - worldExtent.getMinX()) / mtsPixelXLevel) / tilePxWidth);

                int minTileRow = (int)((Math.abs(ul.getY() - worldExtent.getMaxY()) / mtsPixelYLevel) / tilePxHeight);

                double maxTC = ((Math.abs(lr.getX() - worldExtent.getMinX()) / mtsPixelXLevel) / tilePxWidth);

                double maxTR = ((Math.abs(lr.getY() - worldExtent.getMaxY()) / mtsPixelYLevel) / tilePxHeight);

                int maxTileCol = ((maxTC - ((int)maxTC)) == 0) ? (int)(maxTC - 1) : (int)maxTC;

                int maxTileRow = ((maxTR - ((int)maxTR)) == 0) ? (int)(maxTR - 1) : (int)maxTR;

                //Calculo de tiles con sus coordenadas

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

                for (int i = minTileRow; i <= maxTileRow; i++) {

                        for (int j = minTileCol; j <= maxTileCol; j++) {

                                Point2D ulTile = new Point2D.Double(

                                                worldExtent.getMinX() + (tileWCWidth * j),

                                                worldExtent.getMaxY() - (tileWCHeight * i));

                                Point2D lrTile = new Point2D.Double(ulTile.getX() + tileWCWidth, ulTile.getY() - tileWCHeight);

                                Tile t = TileCacheLocator.getManager().createTile(tilePxWidth, tilePxHeight, i, j, ulTile, lrTile);

                                t.setLevel(level);

                                tileList.add(t);

                        }

                }

                return tileList;

        }

        public boolean compare(CacheStruct struct) {

                //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) &&

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

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

                                        return true;

                                }

                        }

                }

                return false;

        }

        public String getEPSG() {

                return epsg;

        }

        public String getFileSize() {

                return fileSize + "";

        }

        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 double clipDecimals(double num, int n) {

                long m = (long) Math.pow(10, n);

                long aux = Math.round(num * m);

                return (double) aux / (double) m;

        }

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

                return tile;

        }

}