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.ogc.impl.struct;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

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.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 * Description of a tile matrix

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

 */

public abstract class WMTSTileMatrixImpl extends WMTSBaseStruct implements WMTSTileMatrix {

    private double                  scaleDenominator             = 0;

    private Rectangle2D             bboxTileMatrixSet            = null;

    private double[]                topLeftCorner                = null;

    private int                     tileWidth                    = 0;

    private int                     tileHeight                   = 0;

    private long                    matrixWidth                  = 0;

    private long                    matrixHeight                 = 0;

    private static final double     MTS_X_GRADO                  = 111319.490793274;

    protected boolean               forceChangeAxisOrder         = false;

    private double                  epsilon                      = 1e-6;

    private String                  tileMatrixSetSupportedCRS    = null;

        /**

         * Force to change the axis order read from the capabilities

         * @param force

         */

        public void setForceChangeAxisOrder(boolean force) {

                this.forceChangeAxisOrder = force;

        }

        /**

         * Sets the CRS supported by the parent

         * @param parentSupportedCRS

         */

        public void setSupportedCRS(String parentSupportedCRS) {

                this.tileMatrixSetSupportedCRS = parentSupportedCRS;

        }

        /**

         * Gets the CRS supported by the parent

         * @return

         */

        public String getSupportedCRS() {

                return this.tileMatrixSetSupportedCRS;

        }

        public void checkChangeAxis() {

                if(forceChangeAxisOrder) {

                        double aux = topLeftCorner[0];

                        topLeftCorner[0] = topLeftCorner[1];

                        topLeftCorner[1] = aux;

                        return;

                }

            if(tileMatrixSetSupportedCRS.contains("CRS:84") || tileMatrixSetSupportedCRS.contains("CRS84"))

                    return;

                //Para CRS no proyectados menos CRS:84 hay que cambiar de orden los ejes

                String epsgNumber = tileMatrixSetSupportedCRS.substring(tileMatrixSetSupportedCRS.lastIndexOf(":") + 1);

                try {

                        Integer.parseInt(epsgNumber);

                        IProjection projSrc = CRSFactory.getCRS("EPSG:" + epsgNumber);

                        if(projSrc != null && !projSrc.isProjected()) {

                                double aux = topLeftCorner[0];

                                topLeftCorner[0] = topLeftCorner[1];

                                topLeftCorner[1] = aux;

                        }

                } catch (NumberFormatException e) {

                        //No se invierte el orden de los ejes

                } catch (Exception e) {

                }

        }

        public void setBBoxTileMatrixSet(Rectangle2D bbox) {

                if(bboxTileMatrixSet == null)

                        this.bboxTileMatrixSet = bbox;

        }

        public Rectangle2D getBBoxTileMatrixSet() {

                return bboxTileMatrixSet;

        }

    /*public class InternalTileImpl implements WMTSTile {

            public int       wPx, hPx;

            public int       row, col;

            public double    ulx, uly, lrx, lry;

            public File      file;

            public InternalTileImpl(int wPx, int hPx, int row, int col, double ulx, double uly, double lrx, double lry) {

                    this.row = row;

                    this.col = col;

                    this.ulx = ulx;

                    this.uly = uly;

                    this.lrx = lrx;

                    this.lry = lry;

                    this.wPx = wPx;

                    this.hPx = hPx;

            }

            public double getULX() {

                    return ulx;

            }

            public double getULY() {

                    return uly;        

            }

            public double getLRX() {

                    return lrx;

            }

            public double getLRY() {

                    return lry;

            }

            public int getWidthPx() {

                    return wPx;

            }

            public int getHeightPx() {

                    return hPx;

            }

            public int getRow() {

                    return row;

            }

            public int getCol() {

                    return col;

            }

            public void setFile(File file) {

                    this.file = file;

            }

            public File getFile() {

                    return file;

            }

            public Point2D worldToRaster(Point2D pt) {

                    Point2D p = new Point2D.Double();

                    double psX = (lrx - ulx) / tileWidth;

                    double psY = (lry - uly) / tileHeight;

                    AffineTransform t = new AffineTransform(psX, 0, 0, psY, ulx - (psX / 2), uly + (psY / 2));

                    try {

                            t.inverseTransform(pt, p);

                    } catch (NoninvertibleTransformException e) {

                            return pt;

                    }

                    return p;

            }

            public WMTSTile cloneTile() {

                    InternalTileImpl status = new InternalTileImpl(wPx, hPx, row, col, ulx, uly, lrx, lry);

                    status.file = file;

                    return status;

            }

    }*/

    /**

     * Parses this service

     * @param parser

     * @param content

     * @throws IOException

     * @throws XmlPullParserException

     */

        public abstract void parse(KXmlParser parser, List<WMTSTileMatrix> list) throws IOException, XmlPullParserException; 

        public double getScaleDenominator() {

                return scaleDenominator;

        }

        public void setScaleDenominator(double scaleDenominator) {

                this.scaleDenominator = scaleDenominator;

        }

        public int getTileWidth() {

                return tileWidth;

        }

        public void setTileWidth(int tileWidth) {

                this.tileWidth = tileWidth;

        }

        public int getTileHeight() {

                return tileHeight;

        }

        public void setTileHeight(int tileHeight) {

                this.tileHeight = tileHeight;

        }

        public long getMatrixWidth() {

                return matrixWidth;

        }

        public void setMatrixWidth(long matrixWidth) {

                this.matrixWidth = matrixWidth;

        }

        public long getMatrixHeight() {

                return matrixHeight;

        }

        public void setMatrixHeight(long matrixHeight) {

                this.matrixHeight = matrixHeight;

        }

        public double[] getTopLeftCorner() {

                if(topLeftCorner == null)

                        topLeftCorner = new double[2];

                return topLeftCorner;

        }

    public void parse(KXmlParser parser) throws IOException, XmlPullParserException {

    }

    /**

     * Gets the width in world coordinates of a tile

     * @return

     */

    public double getWidthWCTile(boolean projected) {

            double pixelSpan = 0;

            if(!projected) {

                    /*if(getBBoxTileMatrixSet() != null)

                            return getBBoxTileMatrixSet().getWidth() / matrixWidth;

                    else {*/

                            pixelSpan = (scaleDenominator * 0.00028) / MTS_X_GRADO;

                    //}

            } else {

                    pixelSpan = (scaleDenominator * 0.00028);

            }

            double w = pixelSpan * tileWidth;

                if(((w - ((int)w)) > (1 - epsilon) || (w - ((int)w)) < epsilon))

                        return Math.round(w);

                return w;

    }

    /**

     * Gets the height in world coordinates of a tile

     * @return

     */

    public double getHeightWCTile(boolean projected) {

            double pixelSpan = 0;

            if(!projected) {

                    /*if(getBBoxTileMatrixSet() != null)

                            return getBBoxTileMatrixSet().getHeight() / matrixHeight;

                    else {*/

                            pixelSpan = (scaleDenominator * 0.00028) / MTS_X_GRADO;

                    //}

            } else {

                    pixelSpan = (scaleDenominator * 0.00028);

            }

            double h = pixelSpan * tileHeight;

                if(((h - ((int)h)) > (1 - epsilon) || (h - ((int)h)) < epsilon))

                        return Math.round(h);

                return h;

    }

    /**

     * This function will check if the request coordinates intersects with the tiles in the matrix. If a tile

     * intersects then this will be added to the list.

     * @deprecated this method was for grid subsets.   

     */

        public List<WMTSTile> intersects(boolean projected, WMTSTileMatrixLimits tileMatrixLimits, Rectangle2D request, Rectangle2D extentLayer) {

            double widthMtsTile = getWidthWCTile(projected);

            double heightMtsTile = getHeightWCTile(projected);

                double ulx, uly, lrx, lry;

            List<WMTSTile> list = new ArrayList<WMTSTile>();

            Rectangle2D r = new Rectangle2D.Double(0, 0, 0, 0);

            //Recorre la matriz de tiles calculando las coordenadas de cada tile

            //Para cada tile comprueba si intersecta con el ?rea seleccionada si es as?

            //mete el tile en la lista para devolverlo como resultado

            //cambiar esto por un conversor entre coordenadas pixel y reales

            int i = 0, j = 0;

            double initX = topLeftCorner[1] + (widthMtsTile * tileMatrixLimits.getMinTileCol());

            double initY = topLeftCorner[0] - (heightMtsTile * (tileMatrixLimits.getMinTileRow()));

            for (int row = tileMatrixLimits.getMinTileRow(); row <= tileMatrixLimits.getMaxTileRow(); row++) {

                    uly = initY - (heightMtsTile * i);

                        lry = uly - heightMtsTile;

                        j = 0;

                        for (int col = tileMatrixLimits.getMinTileCol(); col <= tileMatrixLimits.getMaxTileCol(); col++) {

                                ulx = initX + (widthMtsTile * j);

                                lrx = ulx + widthMtsTile;

                                r.setRect(Math.min(ulx, lrx), Math.min(uly, lry), Math.abs(ulx - lrx), Math.abs(uly - lry));

                                if(request.intersects(r) && r.intersects(extentLayer)) {

                                        list.add(new WMTSTileImpl(tileWidth, tileHeight, row, col, ulx, uly, lrx, lry));

                                }

                                j ++;

                        }

                        i ++;

                }

            return list;

    }

    /**

     * This function will check if the request coordinates intersects with the tiles in the matrix. If a tile

     * intersects then this will be added to the list.  

     */

        public List<WMTSTile> intersects(boolean projected, Rectangle2D request, Rectangle2D extentLayer) {

            double widthWorldCoordTile = getWidthWCTile(projected);

            double heightWorldCoordTile = getHeightWCTile(projected); 

                double ulx, uly, lrx, lry;

                List<WMTSTile> list = new ArrayList<WMTSTile>();

            Rectangle2D r = new Rectangle2D.Double(0, 0, 0, 0);

            //Recorre la matriz de tiles calculando las coordenadas de cada tile

            //Para cada tile comprueba si intersecta con el ?rea seleccionada si es as?

            //mete el tile en la lista para devolverlo como resultado

            double initX = topLeftCorner[0];

            double initY = topLeftCorner[1];

            int tileInitX = 0;

            int tileInitY = 0;

            int tileEndX = (int)(matrixWidth - 1);

            int tileEndY = (int)(matrixHeight - 1);

            if(request.getMinX() >= initX)

                    tileInitX = (int)((request.getMinX() - initX) / widthWorldCoordTile);

            if(request.getMaxY() <= initY)

                    tileInitY = (int)(Math.abs(request.getMaxY() - initY) / heightWorldCoordTile);

            if(request.getMaxX() <= (widthWorldCoordTile * matrixWidth))

                    tileEndX = (int)((request.getMaxX() - initX) / widthWorldCoordTile);

            if(request.getMinY() >= (heightWorldCoordTile * matrixHeight))

                    tileEndY = (int)(Math.abs(request.getMinY() - initY) / heightWorldCoordTile);

            for (int row = tileInitY; row <= tileEndY; row++) {

                    uly = initY - (heightWorldCoordTile * row);

                        lry = uly - heightWorldCoordTile;

                        for (int col = tileInitX; col <= tileEndX; col++) {

                                ulx = initX + (widthWorldCoordTile * col);

                                lrx = ulx + widthWorldCoordTile;

                                r.setRect(Math.min(ulx, lrx), Math.min(uly, lry), Math.abs(ulx - lrx), Math.abs(uly - lry));

                                //El segundo intersects es necesario porque el extent de la capa puede variar por cada nivel de 

                                //resoluci?n en caso de que haya una lista de TileMatrix en el capabilities

                                if(row < matrixHeight && col < matrixWidth) {

                                        if(request.intersects(r) && r.intersects(extentLayer)) { 

                                                list.add(new WMTSTileImpl(tileWidth, tileHeight, row, col, ulx, uly, lrx, lry));

                                        }

                                }

                        }

                }

//            int i = 0, j = 0;

//            for (int row = 0; row < matrixHeight; row++) {

//                    uly = initY - (heightMtsTile * i);

//                        lry = uly - heightMtsTile;

//                        j = 0;

//                        for (int col = 0; col < matrixWidth; col++) {

//                                ulx = initX + (widthMtsTile * j);

//                                lrx = ulx + widthMtsTile;

//                                r.setRect(Math.min(ulx, lrx), Math.min(uly, lry), Math.abs(ulx - lrx), Math.abs(uly - lry));

//                                if(request.intersects(r)) {

//                                        list.add(new Tile(tileWidth, tileHeight, row, col, ulx, uly, lrx, lry));

//                                }

//                                j ++;

//                        }

//                        i ++;

//                }

            return list;

    }

    /**

     * This function will check if the request coordinates intersects with the tiles in the matrix. If a tile

     * intersects then this will be added to the list.  

     */

        public List<WMTSTile> contains(boolean projected, Point2D point, Rectangle2D extentLayer) {

                double widthMtsTile = getWidthWCTile(projected); //getWidthMtsTile(projected);

            double heightMtsTile = getHeightWCTile(projected); //getHeightMtsTile(projected);

                double ulx, uly, lrx, lry;

                List<WMTSTile> list = new ArrayList<WMTSTile>();

            Rectangle2D r = new Rectangle2D.Double(0, 0, 0, 0);

            //Recorre la matriz de tiles calculando las coordenadas de cada tile

            //Para cada tile comprueba si intersecta con el ?rea seleccionada si es as?

            //mete el tile en la lista para devolverlo como resultado

            int i = 0, j = 0;

            double initX = topLeftCorner[1];

            double initY = topLeftCorner[0];

            //cambiar esto por un conversor entre coordenadas pixel y reales

            for (int row = 0; row < matrixHeight; row++) {

                    uly = initY - (heightMtsTile * i);

                        lry = uly - heightMtsTile;

                        j = 0;

                        for (int col = 0; col < matrixWidth; col++) {

                                ulx = initX + (widthMtsTile * j);

                                lrx = ulx + widthMtsTile;

                                r.setRect(Math.min(ulx, lrx), Math.min(uly, lry), Math.abs(ulx - lrx), Math.abs(uly - lry));

                                if(r.contains(point)) {

                                        list.add(new WMTSTileImpl(tileWidth, tileHeight, row, col, ulx, uly, lrx, lry));

                                }

                                j ++;

                        }

                        i ++;

                }

            return list;

    }

    /**

     * This function will check if the request coordinates intersects with the tiles in the matrix. If a tile

     * intersects then this will be added to the list.  

     */

        public List<WMTSTile> contains(boolean projected, WMTSTileMatrixLimits tileMatrixLimits, Point2D point, Rectangle2D extentLayer) {

                double widthMtsTile = getWidthWCTile(projected);

            double heightMtsTile = getHeightWCTile(projected);

                double ulx, uly, lrx, lry;

                List<WMTSTile> list = new ArrayList<WMTSTile>();

            Rectangle2D r = new Rectangle2D.Double(0, 0, 0, 0);

            //Recorre la matriz de tiles calculando las coordenadas de cada tile

            //Para cada tile comprueba si intersecta con el ?rea seleccionada si es as?

            //mete el tile en la lista para devolverlo como resultado

            //cambiar esto por un conversor entre coordenadas pixel y reales

            int i = 0, j = 0;

            double initX = topLeftCorner[1] + (widthMtsTile * tileMatrixLimits.getMinTileCol());

            double initY = topLeftCorner[0] - (heightMtsTile * (tileMatrixLimits.getMinTileRow()));

            for (int row = tileMatrixLimits.getMinTileRow(); row <= tileMatrixLimits.getMaxTileRow(); row++) {

                    uly = initY - (heightMtsTile * i);

                        lry = uly - heightMtsTile;

                        j = 0;

                        for (int col = tileMatrixLimits.getMinTileCol(); col <= tileMatrixLimits.getMaxTileCol(); col++) {

                                ulx = initX + (widthMtsTile * j);

                                lrx = ulx + widthMtsTile;

                                r.setRect(Math.min(ulx, lrx), Math.min(uly, lry), Math.abs(ulx - lrx), Math.abs(uly - lry));

                                if(r.contains(point)) {

                                        list.add(new WMTSTileImpl(tileWidth, tileHeight, row, col, ulx, uly, lrx, lry));

                                }

                                j ++;

                        }

                        i ++;

                }

            return list;

    }

        public void print() {

                System.out.println("   *****WMTSTileMatrix******");

                System.out.println("   scaleDenominator:" + getScaleDenominator());

                if(topLeftCorner != null)

                        System.out.println("   topLeftCorner:" + topLeftCorner[0] + ", " + topLeftCorner[1]);

                System.out.println("   tileWidth:" + getTileWidth());

                System.out.println("   tileHeight:" + getTileHeight());

                System.out.println("   matrixWidth:" + getMatrixWidth());

                System.out.println("   matrixHeight:" + getMatrixHeight());

        }

}