Application: gvSIG desktop

/* 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.Rectangle2D;

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;

    public class Tile {

            public int       wPx, hPx;

            public int       row, col;

            public double    ulx, uly, lrx, lry;

            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;

            }

    }

    /**

     * Parses this service

     * @param parser

     * @param content

     * @throws IOException

     * @throws XmlPullParserException

     */

    @SuppressWarnings("unchecked")

        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 {

    }

    /**

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

     */

    @SuppressWarnings("unchecked")

        public ArrayList intersects(boolean projected, WMTSTileMatrixLimits tileMatrixLimits, Rectangle2D request, Rectangle2D extentLayer) {

            double widthMtsTile = 0;

            double heightMtsTile = 0;

            if(!projected) {

                    widthMtsTile = (scaleDenominator * tileWidth * 0.28) / (MTS_X_GRADO * 1000);

                    heightMtsTile = (scaleDenominator * tileHeight * 0.28) / (MTS_X_GRADO * 1000);

            } else {

                    widthMtsTile = (scaleDenominator * tileWidth * 0.28) / 1000;

                    heightMtsTile = (scaleDenominator * tileHeight * 0.28) / 1000;

            }

                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)) {

                                        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.  

     */

    @SuppressWarnings("unchecked")

        public ArrayList intersects(boolean projected, Rectangle2D request, Rectangle2D extentLayer) {

            double widthMtsTile = 0;

            double heightMtsTile = 0;

            if(!projected) {

                    widthMtsTile = (scaleDenominator * tileWidth * 0.28) / (MTS_X_GRADO * 1000);

                    heightMtsTile = (scaleDenominator * tileHeight * 0.28) / (MTS_X_GRADO * 1000);

            } else {

                    widthMtsTile = (scaleDenominator * tileWidth * 0.28) / 1000;

                    heightMtsTile = (scaleDenominator * tileHeight * 0.28) / 1000;

            }

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

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

        }

}