Application: gvSIG desktop » gvSIG projections

package org.gvsig.geotools.proj.lib;

import java.text.ParseException;

import org.geotools.referencing.CRS;

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

import org.gvsig.proj.CoordinateTransformation;

import org.gvsig.proj.catalog.CRSCatalogLocator;

import org.gvsig.proj.catalog.CRSCatalogManager;

import org.gvsig.proj.catalog.CRSDefinition;

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

import org.gvsig.proj.catalog.TransformationDefinition;

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

import org.opengis.referencing.FactoryException;

import org.opengis.referencing.operation.CoordinateOperation;

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

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

public class GtCRSManager implements CoordinateReferenceSystemManager {

        private CRSCatalogManager catalogManager = null; 

        public GtCRSManager() {

        }

        @Override

        public CoordinateReferenceSystem getCoordinateReferenceSystem(CRSDefinition definition)

                        throws UnsupportedCoordinateReferenceSystemException,

                                ParseException {

                if (definition instanceof DefaultCRSDefinition) {

                        return new DefaultCRS((DefaultCRSDefinition)definition);

                }

                else {

                        // FIXME: definition.toString? definition.toWKT? definition.export?

                        return getCoordinateReferenceSystem(definition, definition.toWKT());

                }

        }

        /**

         * Used for CRSDefinition that are not instanceof DefaultCRSDefinition

         * 

         * @param definition

         * @param wktDefinition

         * @return

         * @throws UnsupportedCoordinateReferenceSystemException 

         */

        protected CoordinateReferenceSystem getCoordinateReferenceSystem(CRSDefinition definition, String wktDefinition) throws UnsupportedCoordinateReferenceSystemException {

                try {

                        org.opengis.referencing.crs.CoordinateReferenceSystem crs = CRS.parseWKT(wktDefinition);

                        return new DefaultCRS(crs, definition);

                } catch (FactoryException e) {

                        throw new UnsupportedCoordinateReferenceSystemException(e);

                } 

        }

        @Override

        public CoordinateReferenceSystem parseCoordinateReferenceSystem(String def)

                        throws UnsupportedCoordinateReferenceSystemException, ParseException {

                CRSDefinition definition = getCatalogManager().parseCRSDefinition(def);

                if (definition instanceof DefaultCRSDefinition) {

                        return new DefaultCRS((DefaultCRSDefinition)definition);

                }

                return getCoordinateReferenceSystem(definition, def);

        }

        @Override

        public CoordinateReferenceSystem parseCoordinateReferenceSystem(String def, Format format)

                        throws UnsupportedCoordinateReferenceSystemException,

                                        ParseException, UnsupportedFormatException {

                if (format==Format.WKT1) {

                        parseCoordinateReferenceSystem(def);

                }

                throw new UnsupportedFormatException(format);

        }

        @Override

        public CoordinateTransformation parseCoordinateTransformation(String wkt)

                        throws UnsupportedTransformationException, ParseException {

                TransformationDefinition definition = getCatalogManager().parseTransformationDefinition(wkt);

                if (definition instanceof DefaultTransformationDefinition) {

                        // FIXME: We should some way decide whether the direct or inverse transformation has to be used.

                        // It is a bit tricky since we don't provide different abstractions for CoordinateOperation and MathTransform

                        return new DefaultTransformation((DefaultTransformationDefinition)definition);

                }

                return getCoordinateTransformation(definition, wkt);

        }

        @Override

        public CoordinateTransformation parseCoordinateTransformation(String def, Format format)

                        throws UnsupportedTransformationException,

                        ParseException, UnsupportedFormatException {

                if (format==Format.WKT1) {

                        return parseCoordinateTransformation(def);

                }

                throw new UnsupportedFormatException(format);

        }

        /**

         * Used for TransformationDefinition that are not instanceof DefaultTransformationDefinition

         * 

         * @param definition

         * @param wktDefinition

         * @return

         * @throws UnsupportedTransformationException 

         */

        protected CoordinateTransformation getCoordinateTransformation(TransformationDefinition definition, String wktDef)

                        throws UnsupportedTransformationException, ParseException {

                // FIXME: We should some way decide whether the direct or inverse transformation has to be used.

                // It is a bit tricky since we don't provide different abstractions for CoordinateOperation and MathTransform

                Parser parser = new Parser();

                Object obj = parser.parseObject(wktDef);

                return new DefaultTransformation((CoordinateOperation) obj, definition);

        }

        @Override

        public CoordinateTransformation getCoordinateTransformation(TransformationDefinition definition)

                        throws UnsupportedTransformationException, ParseException {

                if (definition instanceof DefaultTransformationDefinition) {

                        // FIXME: We should some way decide whether the direct or inverse transformation has to be used.

                        // It is a bit tricky since we don't provide different abstractions for CoordinateOperation and MathTransform

                        return new DefaultTransformation((DefaultTransformationDefinition)definition);

                }

                return getCoordinateTransformation(definition, definition.toWKT());

        }

        @Override

        public void setCatalogManager(CRSCatalogManager manager) {

                this.catalogManager = manager;

        }

        public CRSCatalogManager getCatalogManager() {

                if( this.catalogManager == null ) {

                        this.catalogManager = CRSCatalogLocator.getManager();

                }

                return this.catalogManager;

        }

}