Application: gvSIG desktop » gvSIG projections

package org.gvsig.geotools.proj.lib;

import javax.measure.Unit;

import javax.measure.quantity.Length;

import org.cresques.cts.CRSAdapter;

import org.cresques.cts.IProjection;

import org.gvsig.geotools.proj.catalog.DefaultCRSDefinition;

import org.gvsig.geotools.proj.catalog.DefaultTransformationDefinition;

import org.gvsig.geotools.proj.catalog.utils.DistanceCalculator;

import org.gvsig.proj.catalog.CRSDefinition;

import org.gvsig.proj.catalog.exception.CoordinateReferenceSystemException;

import org.gvsig.proj.catalog.exception.TransformationException;

import org.opengis.referencing.crs.CoordinateReferenceSystem;

import org.opengis.referencing.crs.GeneralDerivedCRS;

import org.opengis.referencing.crs.GeographicCRS;

import org.opengis.referencing.crs.ProjectedCRS;

import org.opengis.referencing.operation.CoordinateOperation;

public class DefaultCRS implements org.gvsig.proj.CoordinateReferenceSystem {

        final private CoordinateReferenceSystem crs;

        final private CRSDefinition definition;

        public DefaultCRS(DefaultCRSDefinition definition) {

                this.definition = definition;

                this.crs = definition.getInternalCRS();

        }

        /*

        public DefaultCRS(CoordinateReferenceSystem crs) 

                        throws UnsupportedCoordinateReferenceSystemException {

                this.crs = crs;

                GtCoordinateReferenceSystemManager manager = (GtCoordinateReferenceSystemManager) CoordinateReferenceSystemLocator.getManager();

                try {

                        // FIXME: crs.toString? crs.toWKT?

                        this.definition = manager.getCatalogManager().parseCRSDefinition(crs.toString());

                } catch (ParseException e) {

                        throw new UnsupportedCoordinateReferenceSystemException(e);

                }

        }*/

        DefaultCRS(CoordinateReferenceSystem crs, CRSDefinition definition) {

                this.crs = crs;

                this.definition = definition;

        }

        CoordinateReferenceSystem getInternalCRS() {

                return crs;

        }

        @Override

        public boolean isProjected() {

                return (crs instanceof ProjectedCRS

                                || (crs instanceof GeneralDerivedCRS &&

                                                ((GeneralDerivedCRS)crs).getBaseCRS() instanceof ProjectedCRS));

        }

        @Override

        public boolean isGeographic() {

                return (crs instanceof GeographicCRS

                                || (crs instanceof GeneralDerivedCRS &&

                                                ((GeneralDerivedCRS)crs).getBaseCRS() instanceof GeographicCRS));

        }

        @Override

        public double[] toGeo(double[] point) throws TransformationException {

                if (isProjected()) {

                        double[] transformedPoint = new double[point.length];

                        // FIXME: cache toGeoTransform?

                        CoordinateOperation toGeo = ((GeneralDerivedCRS)crs).getConversionFromBase();

                        DefaultTransformationDefinition toGeoTransform = new DefaultTransformationDefinition(toGeo, true);

                        toGeoTransform.apply(point, transformedPoint);

                        return point;

                }

                if (isGeographic()) {

                        return point;

                }

                throw new TransformationException();

        }

        @Override

        public double getDistance(double[] point1, double[] point2, Unit<Length> targetUnit) throws CoordinateReferenceSystemException {

                return DistanceCalculator.getDistance(this.crs, point1, point2, true, targetUnit);

        }        

        @Override

        public double getDistance(double[] point1, double[] point2, boolean useBaseCRS, Unit<Length> targetUnit) throws CoordinateReferenceSystemException {

                return DistanceCalculator.getDistance(this.crs, point1, point2, useBaseCRS, targetUnit);

        }

        @Override

        public CRSDefinition getDefinition() {

                return definition;

        }

        @Override

        public DefaultCRS clone() throws CloneNotSupportedException {

                return new DefaultCRS(this.crs, this.definition);

        }

        @Override

        public IProjection getIProjection() {

                return new CRSAdapter(this);

        }

}