| gvSIG desktop 1

/* 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.remoteclient.wmts.struct;

import java.awt.geom.AffineTransform;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import org.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 * Description of a tile matrix

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

 */

public abstract class WMTSTileMatrix extends WMTSBaseStruct {

    private double                  scaleDenominator             = 0;

    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               forceLongitudeFirstAxisOrder = false;

        /**

         * Sets longitude first in the axis order read from the capabilities file

         * @param force

         */

        public void setForceLongitudeFirstAxisOrder(boolean force) {

                this.forceLongitudeFirstAxisOrder = force;

        }

    public class Tile {

            public int       wPx, hPx;

            public int       row, col;

            public double    ulx, uly, lrx, lry;

            public File      file;

            public Tile(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;

            }

            /**

             * Convierte un punto desde del mundo a coordenadas pixel.

             * @param pt Punto a transformar

             * @return punto transformado en coordenadas pixel

             */

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

                    Tile status = new Tile(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, ArrayList 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 meters of a tile

     * @param projected

     * @return

     */

    public double getWidthMtsTile(boolean projected) {

            if(!projected) {

                    return (scaleDenominator * tileWidth * 0.28) / (MTS_X_GRADO * 1000);

            } else {

                    return (scaleDenominator * tileWidth * 0.28) / 1000;

            }

    }

    /**

     * Gets the height in meters of a tile

     * @param projected

     * @return

     */

    public double getHeightMtsTile(boolean projected) {

            if(!projected) {

                    double coord = (scaleDenominator * tileHeight * 0.28) / (MTS_X_GRADO * 1000);

                    if(coord > 0.99 || coord < 0.005)

                            return Math.round(coord);

                    return coord;

            } else {

                    return (scaleDenominator * tileHeight * 0.28) / 1000;

            }

    }

    /**

     * 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 ArrayList intersects(boolean projected, WMTSTileMatrixLimits tileMatrixLimits, Rectangle2D request, Rectangle2D extentLayer) {

            double widthMtsTile = getWidthMtsTile(projected);

            double heightMtsTile = getHeightMtsTile(projected);

                double ulx, uly, lrx, lry;

            ArrayList list = new ArrayList();

            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 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 ArrayList intersects(boolean projected, Rectangle2D request, Rectangle2D extentLayer) {

            double widthMtsTile = getWidthMtsTile(projected);

            double heightMtsTile = getHeightMtsTile(projected);

                double ulx, uly, lrx, lry;

            ArrayList list = new ArrayList();

            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[1];

            double initY = topLeftCorner[0];

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

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

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

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

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

                    uly = initY - (heightMtsTile * row);

                        lry = uly - heightMtsTile;

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

                                ulx = initX + (widthMtsTile * col);

                                lrx = ulx + widthMtsTile;

                                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(request.intersects(r) && r.intersects(extentLayer)) {

                                        list.add(new Tile(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 ArrayList contains(boolean projected, Point2D point, Rectangle2D extentLayer) {

                double widthMtsTile = getWidthMtsTile(projected);

            double heightMtsTile = getHeightMtsTile(projected);

                double ulx, uly, lrx, lry;

            ArrayList list = new ArrayList();

            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 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 ArrayList contains(boolean projected, WMTSTileMatrixLimits tileMatrixLimits, Point2D point, Rectangle2D extentLayer) {

                double widthMtsTile = getWidthMtsTile(projected);

            double heightMtsTile = getHeightMtsTile(projected);

                double ulx, uly, lrx, lry;

            ArrayList list = new ArrayList();

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

        }

}