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.ref.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 CoordinateOperation operation;

        protected MathTransform mathTransform = null;

        protected DefaultCRS source = null;

        protected DefaultCRS target = null;

        final protected boolean inverse;

        final protected TransformationDefinition definition;

        public DefaultTransformation(CoordinateOperation operation, TransformationDefinition definition) {

                this.operation = operation;

                this.definition = definition;

                this.inverse = false;

        }

        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;

        }

        public boolean isInverse() {

                return inverse;

        }

        @Override

        public CoordinateReferenceSystem getSourceCRS() {

                // FIXME: concurrency

                if (source==null) {

                        if (inverse) {

                                source = new DefaultCRS(operation.getTargetCRS(), getDefinition().getSourceDefinition());

                        }

                        else {

                                source = new DefaultCRS(operation.getSourceCRS(), getDefinition().getSourceDefinition());                                

                        }

                }

                return source;

        }

        @Override

        public CoordinateReferenceSystem getTargetCRS() {

                // FIXME: concurrency

                if (target==null) {

                        if (inverse) {

                                target = new DefaultCRS(operation.getSourceCRS(), getDefinition().getTargetDefinition());        

                        }

                        else {

                                target = new DefaultCRS(operation.getTargetCRS(), getDefinition().getTargetDefinition());

                        }

                }

                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 {

                try {

                        if (mathTransform==null) {

                                if (inverse) {

                                        mathTransform = operation.getMathTransform().inverse();

                                }

                                else {

                                        mathTransform = operation.getMathTransform();

                                }

                        }

                } catch (TransformException e) {

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

                }

                return mathTransform;

        }

        @Override

        public CoordinateTransformation getInverse() throws NoninvertibleTransformException {

                if (inverse) {

                        return new DefaultTransformation(this.operation, this.definition, false);        

                }

                return new DefaultTransformation(this.operation, this.definition, true);

        }

        @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.operation, this.definition, this.inverse);

        }

}