Application: gvSIG desktop » gvSIG projections

package org.gvsig.geotools.proj.catalog;

import java.text.ParseException;

import java.util.HashSet;

import java.util.Set;

import org.geotools.referencing.wkt.Parser;

import org.gvsig.proj.CoordinateReferenceSystem;

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.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 DefaultTransformationDefinition implements TransformationDefinition,

                CoordinateTransformation {

        final private CoordinateOperation operation;

        private String wkt = null;

        private MathTransform mathTransform = null;

        private DefaultCRSDefinition source = null;

        private DefaultCRSDefinition target = null;

        // FIXME: do we need the inverse concept in the definition??

        boolean inverse = false;

        public DefaultTransformationDefinition(CoordinateOperation operation) {

                this.operation = operation;

        }

        public DefaultTransformationDefinition(CoordinateOperation operation, boolean inverse) throws NoninvertibleTransformException {

                this.operation = operation;

                try {

                        operation.getMathTransform().inverse();

                }

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

                        throw new NoninvertibleTransformException(operation.getName().getCode());

                }

                this.inverse = inverse;

        }

        public DefaultTransformationDefinition(String wkt) throws ParseException {

                this.wkt = wkt;

                Parser parser = new Parser();

                Object obj = parser.parseObject(wkt);

                this.operation = (CoordinateOperation) obj;

        }

        public CoordinateOperation getInternalOperation() {

                return operation;

        }

        @Override

        public CRSDefinition getSourceDefinition() {

                // FIXME: concurrency

                if (source==null) {

                        if (inverse) {

                                source = new DefaultCRSDefinition(operation.getTargetCRS());

                        }

                        else {

                                source = new DefaultCRSDefinition(operation.getSourceCRS());                                

                        }

                }

                return source;

        }

        @Override

        public CRSDefinition getTargetDefinition() {

                // FIXME: concurrency

                if (target==null) {

                        if (inverse) {

                                target = new DefaultCRSDefinition(operation.getSourceCRS());        

                        }

                        else {

                                target = new DefaultCRSDefinition(operation.getTargetCRS());

                        }

                }

                return target;

        }

        @Override

        public String getName() {

                // FIXME: compare with identifier

                return operation.getName().toString();

        }

        @Override

        public String getIdentifier() {

                // FIXME: compare with name

                Set<ReferenceIdentifier> ids = operation.getIdentifiers();

                for (ReferenceIdentifier id: ids) {

                        String fullCode = id.toString();

                        String code = id.getCode();

                }

                return operation.getName().toString();

        }

        @Override

        public Set<String> getIdentifiers() {

                HashSet<String> ids = new HashSet<String>();

                for (ReferenceIdentifier id: operation.getIdentifiers()) {

                        ids.add(id.toString());

                }

                return ids;

        }

        @Override

        public String getAuthorityName() {

                return operation.getName().getAuthority().getTitle().toString();

        }

        @Override

        public String getOperationVersion() {

                return operation.getOperationVersion();

        }

        @Override

        public Extent getDomainOfValidity() {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String getDescription() {

                return operation.getScope() + "\nRemarks: " + operation.getRemarks();

        }

        @Override

        public boolean isTransformation() {

                return (operation instanceof Transformation);

        }

        @Override

        public TransformationDefinition getInverseDefinition() throws NoninvertibleTransformException {

                return new DefaultTransformationDefinition(this.operation, true);

        }

        @Override

        public String toWKT() throws UnsupportedOperationException {

                // TODO Auto-generated method stub

                // FIXME: review inverse transformation to be correctly stored as wkt

                // FIXME: think if we should convert to WKT the operation or the mathTransform

                // MathTransforms seem to be the only option that ensures the transformation can be recreated

                // But... source and target crs will be lost!!

                if (wkt!=null) {

                        return wkt;

                }

                return operation.toWKT();

        }

        @Override

        public String toString(Format format, WKTConvention convention) throws UnsupportedOperationException {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String toString(Format format, WKTConvention convention, int indentation)

                        throws UnsupportedOperationException {

                // TODO Auto-generated method stub

                return null;

        }

        public boolean isInverse() {

                return inverse;

        }

        @Override

        public CoordinateReferenceSystem getSourceCRS() {

                return (CoordinateReferenceSystem) getSourceDefinition();

        }

        @Override

        public CoordinateReferenceSystem getTargetCRS() {

                return (CoordinateReferenceSystem) getTargetDefinition();

        }

        @Override

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

                try {

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

                } catch (TransformException e) {

                        throw new TransformationException(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(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(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(getIdentifier(), e);

                }

                return mathTransform;

        }

        @Override

        public CoordinateTransformation getInverse() throws NoninvertibleTransformException {

                if (inverse) {

                        return new DefaultTransformationDefinition(this.operation);        

                }

                return new DefaultTransformationDefinition(this.operation, true);

        }

        @Override

        public TransformationDefinition getDefinition() {

                return this;

        }

        @Override

        public boolean isIdentity() throws TransformationException {

                return getMathTransform().isIdentity();

        }

}