Application: gvSIG desktop » gvSIG projections

package org.gvsig.geotools.proj.lib;

import java.text.ParseException;

import java.util.HashSet;

import java.util.Set;

import org.geotools.referencing.wkt.Parser;

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

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

import org.gvsig.proj.CoordinateReferenceSystem;

import org.gvsig.proj.CoordinateReferenceSystemLocator;

import org.gvsig.proj.CoordinateTransformation;

import org.gvsig.proj.catalog.CRSDefinition;

import org.gvsig.proj.catalog.TextSerialization.Format;

import org.gvsig.proj.catalog.TextSerialization.WKTConvention;

import org.gvsig.proj.catalog.TransformationDefinition;

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

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

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

import org.gvsig.proj.catalog.extent.Extent;

import org.opengis.referencing.ReferenceIdentifier;

import org.opengis.referencing.operation.CoordinateOperation;

import org.opengis.referencing.operation.MathTransform;

import org.opengis.referencing.operation.TransformException;

import org.opengis.referencing.operation.Transformation;

public class DefaultTransformation implements 

                CoordinateTransformation {

        final protected MathTransform mathTransform ;

        final protected DefaultCRS source;

        final protected DefaultCRS target;

        final protected TransformationDefinition definition;

        public DefaultTransformation(MathTransform transform,

                        TransformationDefinition definition,

                        DefaultCRS source,

                        DefaultCRS target) {

                this.mathTransform = transform;

                this.definition = definition;

                this.source = source;

                this.target = target;

        }

        /*

        public DefaultTransformation(DefaultTransformationDefinition definition)

                        throws UnsupportedOperationException, ParseException {

                this.definition = definition;

                this.operation = definition.getInternalOperation();

                this.inverse = false;

        }*/

        /*

        public DefaultTransformation(CoordinateOperation operation, TransformationDefinition definition, boolean inverse) {

                this.operation = operation;

                this.definition = definition;

                this.inverse = inverse;

        }*/

        @Override

        public DefaultCRS getSourceCRS() {

                return source;

        }

        @Override

        public DefaultCRS getTargetCRS() {

                return target;

        }

        @Override

        public void apply(double[] point) throws TransformationException {

                try {

                        getMathTransform().transform(point, 0, point, 0, 1);

                } catch (TransformException e) {

                        throw new TransformationException(getDefinition().getIdentifier(), e);

                }

        }

        @Override

        public void apply(double[] srcPoint, double[] dstPoint) throws TransformationException {

                try {

                        getMathTransform().transform(srcPoint, 0, dstPoint, 0, 1);

                } catch (TransformException e) {

                        throw new TransformationException(getDefinition().getIdentifier(), e);

                }

        }

        @Override

        public void apply(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) throws TransformationException {

                try {

                        getMathTransform().transform(srcPts, srcOff, dstPts, dstOff, numPts);

                } catch (TransformException e) {

                        throw new TransformationException(getDefinition().getIdentifier(), e);

                }

        }

        protected MathTransform getMathTransform() throws TransformationException {

                return mathTransform;

        }

        @Override

        public CoordinateTransformation getInverse() throws NoninvertibleTransformException {

                try {

                        return new DefaultTransformation(this.mathTransform.inverse(), this.definition, this.target, this.source);

                } catch (org.opengis.referencing.operation.NoninvertibleTransformException e) {

                        throw new NoninvertibleTransformException(e);

                }

        }

        @Override

        public TransformationDefinition getDefinition() {

                return definition;

        }

        @Override

        public boolean isIdentity() throws TransformationException {

                return getMathTransform().isIdentity();

        }

        @Override

        protected DefaultTransformation clone() throws CloneNotSupportedException {

                return new DefaultTransformation(this.mathTransform, this.definition, this.source, this.target);

        }

}