Application: gvSIG desktop » gvSIG projections

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Instituto de Desarrollo Regional and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   Instituto de Desarrollo Regional (Universidad de Castilla La-Mancha)

 *   Campus Universitario s/n

 *   02071 Alabacete

 *   Spain

 *

 *   +34 967 599 200

 */

package org.gvsig.crs;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gvsig.crs.proj.CrsProj;

import org.gvsig.crs.proj.JNIBaseCrs;

import org.gvsig.crs.proj.OperationCrsException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase que implementa las operaciones de tranformacion de coordenadas entre

 * dos CRSs.

 *

 * @author Miguel Garc?a Jim?nez (garciajimenez.miguel@gmail.com)

 * @author Diego Guerrero Sevilla (diego.guerrero@uclm.es)

 *

 */

// public class COperation implements ICOperation {

public class COperation implements ICoordTrans {

        private static final Logger logger = LoggerFactory

                        .getLogger(COperation.class);

        /**

         * CRS Fuente

         */

        private ICrs sourceCrs;

        /**

         * CRS Destino

         */

        private ICrs targetCrs;

        /**

         * CRS con los par?metros de transformaci?n (puede representar el CRS fuente

         * o destino, dependiendo de <code>paramsInTarget</code>).

         */

        private CrsProj paramsCrsProj = null;

        /**

         * Indica si los par?metros de transformaci?n van asociados al CRS fuente (

         * <code>false</code>) o al destino (<code>true</code>)

         */

        private boolean paramsInTarget;

        /**

         * par?metros de transformaci?n para el CRS fuente en el formato proj4

         */

        private String sourceParams = null;

        /**

         * par?metros de transformaci?n para el CRS destino en el formato proj4

         */

        private String targetParams = null;

        private CrsProj source = null;

        private CrsProj target = null;

        /**

         * Constructor.

         *

         * @param from

         *            CRS fuente.

         * @param to

         *            CRS destino.

         * @throws CrsException

         */

        public COperation(ICrs from, ICrs to) throws CrsException {

                sourceCrs = from;

                targetCrs = to;

                source = sourceCrs.getCrsProj();

                target = targetCrs.getCrsProj();

        }

        /**

         * Construcctor.

         *

         * @param sourceCrs

         *            CRS fuente.

         * @param targetCrs

         *            CRS destino.

         * @param sourceParams

         *            Par?metros de transformaci?n para la fuente (en formato

         *            proj4).

         * @param targetParams

         *            Par?metros de transformaci?n para el destino (en formato

         *            proj4).

         * @throws CrsException

         */

        public COperation(ICrs sourceCrs, ICrs targetCrs, String sourceParams,

                        String targetParams) throws CrsException {

                this.sourceCrs = sourceCrs;

                this.targetCrs = targetCrs;

                this.sourceParams = sourceParams;

                this.targetParams = targetParams;

                if (sourceParams != null)

                        source = new CrsProj(sourceCrs.getProj4String() + sourceParams);

                else

                        source = sourceCrs.getCrsProj();

                if (targetParams != null)

                        target = new CrsProj(targetCrs.getProj4String() + targetParams);

                else

                        target = targetCrs.getCrsProj();

        }

        /**

         * Realiza la operaci?n de transformaci?n sobre un punto. Si exiten

         * par?metros de transformaci?n (<code>paramsCrsProj</code>) se utilizan en

         * lugar del CRS fuente o destino, seg?n indique <code>paramsInTarget</code>

         * .

         *

         * @throws OperationCrsException

         *

         */

        private Point2D operate(Point2D pt) throws CrsException,

                        OperationCrsException {

                double x[] = { pt.getX() };

                double y[] = { pt.getY() };

                double z[] = { 0D };

                int errno = 0;

                try {

                        errno = JNIBaseCrs.operate(x, y, z, source, target);

                } catch (OperationCrsException e) {

                        // Parche para arreglar posible error al transformar de latlong a proyectadas cuando la y es +/- 90

                        if (e.getErrno() == -20) {

                                source.reloadCrs();

                                target.reloadCrs();

                                if (!sourceCrs.isProjected() && targetCrs.isProjected()) {

                                        if (Math.abs((pt.getY() - 90.0)) < 0.000000001) {

                                                x[0] = pt.getX();

                                                y[0] = 89.99999999;

                                                z[0] = 0D;

                                                errno = JNIBaseCrs.operate(x, y, z, source, target);

                                        } else if (Math.abs(pt.getY() + 90.0) < 0.000000001) {

                                                x[0] = pt.getX();

                                                y[0] = -89.99999999;

                                                z[0] = 0D;

                                                errno = JNIBaseCrs.operate(x, y, z, source, target);

                                        }

                                }

                        }

                }

                if (errno != -38) // "failed to load NAD27-83 correction file"

                                                        // (pj_strerrno.c)

                        return new Point2D.Double(x[0], y[0]);

                else {

                        x[0] = pt.getX();

                        y[0] = pt.getY();

                        z[0] = 0D;

                        try {

                                errno = JNIBaseCrs.operate(x, y, z, sourceCrs.getCrsProj(),

                                                targetCrs.getCrsProj());

                        } catch (OperationCrsException e) {

                                if (e.getErrno() == -20) {

                                        if (!sourceCrs.isProjected() && targetCrs.isProjected()) {

                                                if (Math.abs((pt.getY() - 90.0)) < 0.000000001) {

                                                        x[0] = pt.getX();

                                                        y[0] = 89.99999999;

                                                        z[0] = 0D;

                                                        errno = JNIBaseCrs.operate(x, y, z,

                                                                        sourceCrs.getCrsProj(),

                                                                        targetCrs.getCrsProj());

                                                } else if (Math.abs(pt.getY() + 90.0) < 0.000000001) {

                                                        x[0] = pt.getX();

                                                        y[0] = -89.99999999;

                                                        z[0] = 0D;

                                                        errno = JNIBaseCrs.operate(x, y, z,

                                                                        sourceCrs.getCrsProj(),

                                                                        targetCrs.getCrsProj());

                                                }

                                        }

                                }

                        }

                        return new Point2D.Double(x[0], y[0]);

                }

                /*

                 * if (paramsCrsProj != null){ if (paramsInTarget) errno =

                 * JNIBaseCrs.operate( x , y, z,sourceCrs.getCrsProj(), paramsCrsProj);

                 * else errno = JNIBaseCrs.operate( x , y,

                 * z,paramsCrsProj,targetCrs.getCrsProj()); if (errno != -38) //

                 * "failed to load NAD27-83 correction file" (pj_strerrno.c) return new

                 * Point2D.Double(x[0],y[0]); }

                 *

                 * // Si el punto estaba fuera del ?mbito del nadgrid operamos sin

                 * nadgrid (convertimos) x[0] = pt.getX(); y[0] = pt.getY(); z[0] = 0D;

                 * JNIBaseCrs.operate( x , y, z,sourceCrs.getCrsProj(),

                 * targetCrs.getCrsProj()); return new Point2D.Double(x[0],y[0]);

                 */

                // System.out.println("x="+x[0]+"y="+y[0]);

                // if(!targetCrs.isProjected())

                // return new Point2D.Double(x[0]*((180)/Math.PI),y[0]*((180)/Math.PI));

                // else

        }

        /**

         * Realiza la operaci?n de transformaci?n sobre un punto. Si exiten

         * par?metros de transformaci?n (<code>paramsCrsProj</code>) se utilizan en

         * lugar del CRS fuente o destino, seg?n indique <code>paramsInTarget</code>

         * .

         *

         * @throws CrsException

         *

         */

        // TODO Eliminar este m?todo. Me vale con el operate(Point2D).

        private double[] operate(double[] ptOrig) throws OperationCrsException,

                        CrsException {

                double x[] = { ptOrig[0] };

                double y[] = { ptOrig[1] };

                double z[] = { ptOrig[2] };

                int errno = 0;

                CrsProj source;

                CrsProj target;

                if (sourceParams != null)

                        source = new CrsProj(sourceCrs.getProj4String() + sourceParams);

                else

                        source = sourceCrs.getCrsProj();

                if (targetParams != null)

                        target = new CrsProj(targetCrs.getProj4String() + targetParams);

                else

                        target = targetCrs.getCrsProj();

                errno = JNIBaseCrs.operate(x, y, z, source, target);

                if (errno != -38) { // "failed to load NAD27-83 correction file"

                                                        // (pj_strerrno.c)

                        double ptDest[] = { x[0], y[0], z[0] };

                        return ptDest;

                }

                /*

                 * if (paramsCrsProj != null){ if (paramsInTarget) errno =

                 * JNIBaseCrs.operate( x , y, z,sourceCrs.getCrsProj(), paramsCrsProj);

                 * else errno = JNIBaseCrs.operate( x , y,

                 * z,paramsCrsProj,targetCrs.getCrsProj()); if (errno != -38){ //

                 * "failed to load NAD27-83 correction file" (pj_strerrno.c) double

                 * ptDest[] = {x[0], y[0], z[0]}; return ptDest; } }

                 */

                // Si el punto estaba fuera del ?mbito del nadgrid operamos sin nadgrid

                // (convertimos)

                x[0] = ptOrig[0];

                y[0] = ptOrig[1];

                z[0] = ptOrig[2];

                JNIBaseCrs.operate(x, y, z, sourceCrs.getCrsProj(),

                                targetCrs.getCrsProj());

                double ptDest[] = { x[0], y[0], z[0] };

                return ptDest;

        }

        public IProjection getPOrig() {

                return (IProjection) sourceCrs;

        }

        public IProjection getPDest() {

                return (IProjection) targetCrs;

        }

        public Point2D convert(Point2D ptOrig, Point2D ptDest) {

                try {

                        ptDest = operate(ptOrig);

                } catch (CrsException e) {

                        logger.error("Can't operate over point orig (" + ptOrig.toString()

                                        + ").", e);

                        throw new IllegalStateException(e.getMessage());

                } catch (OperationCrsException e) {

                        logger.error("Can't operate over point orig (" + ptOrig.toString()

                                        + ").", e);

                        throw new IllegalStateException(e.getMessage());

                }

                return ptDest;

        }

        public Rectangle2D convert(Rectangle2D rect) {

                Point2D pt1 = new Point2D.Double(rect.getMinX(), rect.getMinY());

                Point2D pt2 = new Point2D.Double(rect.getMaxX(), rect.getMaxY());

                Point2D pt3 = new Point2D.Double(rect.getMinX(), rect.getMaxY());

                Point2D pt4 = new Point2D.Double(rect.getMaxX(), rect.getMinY());

                try {

                        pt1 = operate(pt1);

                        pt2 = operate(pt2);

                        pt3 = operate(pt3);

                        pt4 = operate(pt4);

                } catch (CrsException e) {

                        logger.error("Can't operate over rect (" + rect.toString() + ").",

                                        e);

                        throw new IllegalStateException(e.getMessage());

                } catch (OperationCrsException e) {

                        logger.error("Can't operate over rect (" + rect.toString() + ").",

                                        e);

                        throw new IllegalStateException(e.getMessage());

                }

                double min_x = Math.min(Math.min(pt1.getX(), pt2.getX()),

                                Math.min(pt3.getX(), pt4.getX()));

                double min_y = Math.min(Math.min(pt1.getY(), pt2.getY()),

                                Math.min(pt3.getY(), pt4.getY()));

                double max_x = Math.max(Math.max(pt1.getX(), pt2.getX()),

                                Math.max(pt3.getX(), pt4.getX()));

                double max_y = Math.max(Math.max(pt1.getY(), pt2.getY()),

                                Math.max(pt3.getY(), pt4.getY()));

                return new Rectangle2D.Double(min_x, min_y, max_x - min_x, max_y

                                - min_y);

        }

        public ICoordTrans getInverted() {

                COperation operation;

                try {

                        operation = new COperation(targetCrs, sourceCrs, targetParams,

                                        sourceParams);

                        return operation;

                } catch (CrsException e) {

                        logger.error("Can't get operation.", e);

                        return null;

                }

        }

        /*

         * public void setParamsCrsProj(CrsProj paramsCrs, boolean inTarget){

         * this.paramsInTarget = inTarget; this.paramsCrsProj = paramsCrs; }

         */

}