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.CoordTransRuntimeException;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.gdal.gdal.gdal;

import org.gdal.osr.CoordinateTransformation;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.crs.proj.CrsProj;

import org.gvsig.crs.proj.OperationCrsException;

/**

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

    private CoordinateTransformation coordinateTransformation = 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();

        int errno = 0;

        String msg = "";

        int errtype = 0;

        double[] transformed = { 0, 0, 0 };

        initializeCoordinateTransformation();

        gdal.PushErrorHandler( "CPLQuietErrorHandler" );

        gdal.ErrorReset();

        if (coordinateTransformation != null) { // && inverseCoordinateTransformation != null) {

            coordinateTransformation.TransformPoint(transformed, x, y, 0);

        }

        gdal.PopErrorHandler();

        errno = gdal.GetLastErrorNo();

        msg = gdal.GetLastErrorMsg();

        errtype = gdal.GetLastErrorType();

        Point2D.Double result = null;

        if (errno != 0 || errtype != 0 || !msg.isEmpty()) {

            // FIXME:

            // gdal no devuelve m?s de 20 errores por transformaci?n,

            // si queremos de los devuelva todos tenemos que anular la

            // transformaci?n cada vez que se produce un error

            if (msg

                .equalsIgnoreCase("Reprojection failed, err = -14, further errors will be supressed on the transform object.")) {

                resetCoordinateTransformation();

            }

            throw new CoordTransRuntimeException(sourceCrs, targetCrs, x, y);

        }

        result = new Point2D.Double(transformed[0], transformed[1]);

        return result;

    }

    private void initializeCoordinateTransformation() {

        if (coordinateTransformation == null) {

            int errno = 0;

            String msg = "";

            int errtype = 0;

            gdal.ErrorReset();

            gdal.PushErrorHandler( "CPLQuietErrorHandler" );

            coordinateTransformation =

                CoordinateTransformation.CreateCoordinateTransformation(source.getSpatialReference(),

                    target.getSpatialReference());

            gdal.PopErrorHandler();

            errno = gdal.GetLastErrorNo();

            msg = gdal.GetLastErrorMsg();

            errtype = gdal.GetLastErrorType();

            if (errno != 0 || errtype != 0 || !msg.isEmpty()) {

                logger.warn("Can't initialize coordinate transformation from "+sourceCrs.getAbrev()+" to "+targetCrs.getAbrev()+" "+errno + " "+errtype+" "+msg+".");

            }

        }

    }

    private void resetCoordinateTransformation() {

        coordinateTransformation = null;

        initializeCoordinateTransformation();

    }

    public IProjection getPOrig() {

        return (IProjection) sourceCrs;

    }

    public IProjection getPDest() {

        return (IProjection) targetCrs;

    }

    public Point2D convert(Point2D ptOrig, Point2D ptDest) throws CoordTransRuntimeException {

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

        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; }

     */

}