Application: gvSIG desktop » gvSIG projections

package org.gvsig.geotools.proj.catalog;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import org.geotools.metadata.iso.citation.Citations;

import org.geotools.referencing.operation.transform.ConcatenatedTransform;

import org.geotools.referencing.wkt.Formatter;

import org.geotools.referencing.wkt.Symbols;

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

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

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

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

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

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

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

import org.opengis.referencing.ReferenceIdentifier;

import org.opengis.referencing.operation.ConcatenatedOperation;

import org.opengis.referencing.operation.CoordinateOperation;

import org.opengis.referencing.operation.MathTransform;

import org.opengis.referencing.operation.PassThroughOperation;

import org.opengis.referencing.operation.SingleOperation;

import org.opengis.referencing.operation.Transformation;

public class DefaultTransformationDefinition implements TransformationDefinition {

        final private CoordinateOperation operation;

        final private MathTransform mathTransform;

        final private DefaultCRSDefinition source;

        final private DefaultCRSDefinition target;

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

        final private boolean inverse;

        /**

         * Creates a DefaultTransformationDefinition object

         * 

         * @param operation

         * @param source

         * @param target 

         * @throws UnsupportedTransformationException 

         */

        public DefaultTransformationDefinition(CoordinateOperation operation,

                        DefaultCRSDefinition source, DefaultCRSDefinition target)

                                        throws UnsupportedTransformationException {

                if (source.getInternalCRS().equals(operation.getSourceCRS())

                                && target.getInternalCRS().equals(operation.getTargetCRS())) {

                        this.inverse = false;

                }

                else if (source.getInternalCRS().equals(operation.getTargetCRS())

                                && target.getInternalCRS().equals(operation.getSourceCRS())) {

                        this.inverse = true;

                }

                else {

                        throw new UnsupportedTransformationException(

                                        "The provided source and target do not match any of the sources and targets of the provided operation");

                }

                if (inverse) {

                        try {

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

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

                                throw new UnsupportedTransformationException(e);

                        }

                }

                else {

                        this.mathTransform = operation.getMathTransform();

                }

                this.operation = operation;

                this.source = source;

                this.target = target;

        }

        /**

         * Creates a DefaultTransformationDefinition object

         * 

         * @param mathTransform

         * @param source

         * @param target

         * @throws UnsupportedTransformationException 

         */

        public DefaultTransformationDefinition(MathTransform mathTransform,

                        DefaultCRSDefinition source, DefaultCRSDefinition target) throws CoordinateReferenceSystemException {

                this.mathTransform = mathTransform;

                this.inverse = false;

                this.operation = null;

                this.source = source;

                this.target = target;

        }

        public CoordinateOperation getInternalOperation() {

                return operation;

        }

        @Override

        public DefaultCRSDefinition getSourceDefinition() {

                return source;

        }

        @Override

        public DefaultCRSDefinition getTargetDefinition() {

                return target;

        }

        @Override

        public String getName() {

                // FIXME: define in API whether null or blank ""  is allowed

                if (operation != null) {

                        return nameFromOperation(operation);

                }

                return nameFromMathTransform();

        }

        protected String nameFromMathTransform() {

                StringBuilder meaningfulName = new StringBuilder();

                appendSourceTargetToName(meaningfulName);

                meaningfulName.append(" using ");

                meaningfulName.append(mathTransform.getClass().getSimpleName());

                return meaningfulName.toString();

        }

        protected void appendSourceTargetToName(StringBuilder builder) {

                builder.append(source.getName());

                builder.append(" to ");

                builder.append(target.getName());

        }

        protected String nameFromOperation(CoordinateOperation op) {

                if (op instanceof ConcatenatedOperation) {

                        StringBuilder meaningfulName = new StringBuilder();

                        List<SingleOperation> opList = ((ConcatenatedOperation) op).getOperations();

                        for (SingleOperation singleOp: opList) {

                                if (singleOp instanceof Transformation) {

                                        meaningfulName.append("Concat operation using ");

                                        if (singleOp.getName() != null) {

                                                meaningfulName.append(singleOp.getName());

                                        }

                                        String id = IdentifiedObjectUtils.getIdentifier(singleOp);

                                        if (id!=null) {

                                                meaningfulName.append("[").append(id).append("]");

                                        }

                                }

                        }

                        if (op.getName() != null) {

                                if (meaningfulName.length()>0) {

                                        meaningfulName.append(" transforming ");

                                }

                                meaningfulName.append(op.getName().toString().replace("\u21e8", "=>"));        

                        }

                        if (meaningfulName.length()>0) {

                                return meaningfulName.toString();

                        }

                }

                else if (op instanceof PassThroughOperation) {

                        return nameFromOperation(((PassThroughOperation)op).getOperation());

                }

                if (op.getName() !=null) {

                        return op.getName().toString().replace("\u21e8", "=>");

                }

                return nameFromMathTransform();

        }

        @Override

        public String getIdentifier() {

                if (operation==null) {

                        return null;

                }

                return IdentifiedObjectUtils.getIdentifier(operation);

        }

        @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() {

                if (operation==null ||

                                operation.getName()==null ||

                                                operation.getName().getAuthority()==null) {

                        return null;

                }

                return IdentifiedObjectUtils.getIdentifier(operation.getName().getAuthority().getIdentifiers());

        }

        @Override

        public String getOperationVersion() {

                if (operation==null) {

                        return null;

                }

                return operation.getOperationVersion();

        }

        @Override

        public Extent getDomainOfValidity() {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String getDescription() {

                if (operation==null) {

                        return null;

                }

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

        }

        @Override

        public TransformationDefinition getInverseDefinition()

                        throws NoninvertibleTransformException, UnsupportedTransformationException {

                if (this.operation==null) {

                        try {

                                return new DefaultTransformationDefinition(mathTransform.inverse(), target, source);

                        } catch (CoordinateReferenceSystemException

                                        | org.opengis.referencing.operation.NoninvertibleTransformException e) {

                                throw new NoninvertibleTransformException(e);

                        }        

                }

                return new DefaultTransformationDefinition(this.operation, target, source);

        }

        @Override

        public String toWKT() throws UnsupportedOperationException {

                return mathTransform.toWKT();

        }

        @Override

        public String toString(Format format) throws UnsupportedFormatException {

                if (format==Format.WKT1) {

                        return toWKT();

                }

                throw new UnsupportedFormatException(format);

        }

        @Override

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

                if (format==Format.WKT1) {

                        Formatter formatter = new Formatter(Symbols.DEFAULT, indentation);

                        if (convention==WKTConvention.EPSG) {

                                formatter.setAuthority(Citations.EPSG);

                        }

                        else if (convention==WKTConvention.ESRI) {

                                formatter.setAuthority(Citations.ESRI);

                        }

                        formatter.append(mathTransform);

                        return formatter.toString();

                }

                throw new UnsupportedFormatException(format);

        }

        public MathTransform getMathTransform() {

                return mathTransform;

        }

        /*

        @Override

        public boolean isIdentity() throws TransformationException {

                return mathTransform.isIdentity();

        }*/

        @Override

        public boolean equals(Object obj) {

                // TODO Auto-generated method stub

                return super.equals(obj);

        }

}