Application: gvSIG desktop » gvSIG projections

package org.gvsig.geotools.proj.catalog;

import java.io.File;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.regex.Pattern;

import javax.sql.DataSource;

import org.geotools.factory.FactoryFinder;

import org.geotools.factory.FactoryNotFoundException;

import org.geotools.factory.Hints;

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

import org.geotools.referencing.CRS;

import org.geotools.referencing.CRS.AxisOrder;

import org.geotools.referencing.ReferencingFactoryFinder;

import org.geotools.referencing.factory.AbstractAuthorityFactory;

import org.geotools.referencing.factory.BufferedAuthorityFactory;

import org.geotools.referencing.factory.epsg.HsqlEpsgDatabase;

import org.geotools.referencing.factory.epsg.ThreadedEpsgFactory;

import org.geotools.referencing.wkt.MathTransformParser;

import org.geotools.referencing.wkt.Parser;

import org.geotools.resources.i18n.ErrorKeys;

import org.geotools.resources.i18n.Errors;

import org.gvsig.geotools.proj.catalog.extent.DefaultExtent;

import org.gvsig.geotools.proj.catalog.extent.DefaultGeographicBoundingBox;

import org.gvsig.geotools.proj.catalog.extent.DefaultVerticalExtent;

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

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

import org.gvsig.proj.catalog.CRSCatalogManager;

import org.gvsig.proj.catalog.CRSDefinition;

import org.gvsig.proj.catalog.CRSType;

import org.gvsig.proj.catalog.TextSerialization;

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

import org.gvsig.proj.catalog.TransformationDefinition;

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

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

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

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

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

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

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

import org.opengis.referencing.AuthorityFactory;

import org.opengis.referencing.FactoryException;

import org.opengis.referencing.NoSuchAuthorityCodeException;

import org.opengis.referencing.crs.CRSAuthorityFactory;

import org.opengis.referencing.crs.CRSFactory;

import org.opengis.referencing.crs.CompoundCRS;

import org.opengis.referencing.crs.CoordinateReferenceSystem;

import org.opengis.referencing.crs.GeocentricCRS;

import org.opengis.referencing.crs.GeographicCRS;

import org.opengis.referencing.cs.CartesianCS;

import org.opengis.referencing.cs.CoordinateSystem;

import org.opengis.referencing.cs.EllipsoidalCS;

import org.opengis.referencing.cs.SphericalCS;

import org.opengis.referencing.cs.VerticalCS;

import org.opengis.referencing.datum.EngineeringDatum;

import org.opengis.referencing.datum.GeodeticDatum;

import org.opengis.referencing.datum.VerticalDatum;

import org.opengis.referencing.operation.Conversion;

import org.opengis.referencing.operation.CoordinateOperation;

import org.opengis.referencing.operation.CoordinateOperationAuthorityFactory;

import org.opengis.referencing.operation.CoordinateOperationFactory;

import org.opengis.referencing.operation.MathTransform;

import org.opengis.referencing.operation.Projection;

public class GtCRSCatalogManager implements CRSCatalogManager {

        private static final String EPSG_DB_SUBFOLDER = "epsg";        

        private static final List<TextSerialization.Format> SUPPORTED_FORMATS = Arrays.asList(TextSerialization.Format.WKT1);

        private static final List<String> supportedAuthorities = Collections.unmodifiableList(Arrays.asList("EPSG", "ESRI", "USER"));        

        public GtCRSCatalogManager() {

        }

        @Override

        public List<String> getAuthorityNames() {

                return supportedAuthorities;

                //return new ArrayList<String>(CRS.getSupportedAuthorities(true));

        }

        protected String toCode(String authorityName, String relCode) {

                return authorityName + ":" + relCode;

        }

        @Override

        public List<String> getCodes() {

                ArrayList<String> codes = new ArrayList<String>();

                Set<String> authorities = CRS.getSupportedAuthorities(true);

                for (String auth: authorities) {

                        CRSAuthorityFactory factory = ReferencingFactoryFinder.getCRSAuthorityFactory(auth, null);

                        try {

                                for (String code: factory.getAuthorityCodes(CoordinateReferenceSystem.class)) {

                                        codes.add(toCode(auth, code));

                                }

                        } catch (FactoryException | FactoryNotFoundException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                }

                return codes;

        }

        @Override

        public List<String> getCodes(String authorityName) {

                // FIXME handle other authorities

                ArrayList<String> codes = new ArrayList<String>();

                if ("EPSG".equals(authorityName)) {

                        try {

                                CRSAuthorityFactory factory = ReferencingFactoryFinder.getCRSAuthorityFactory(authorityName, null);

                                for (String code: factory.getAuthorityCodes(CoordinateReferenceSystem.class)) {

                                        codes.add(toCode(authorityName, code));

                                }

                        } catch (FactoryException | FactoryNotFoundException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                }

                return codes;

        }

        @Override

        public List<String> search(String searchString) {

                // FIXME handle other authorities

                return searchEpsg(searchString, null, null);

        }

        @Override

        public List<String> search(String authority, String searchString) {

                // FIXME handle other authorities

                if (authority.equals("EPSG")) {

                        return searchEpsg(searchString, null, null);

                }

                return Collections.emptyList();

        }

        @Override

        public List<String> search(String authority, String searchString, CRSType[] includeTypes, CRSType[] excludeTypes) {

                // FIXME handle other authorities

                if (authority.equals("EPSG")) {

                        return searchEpsg(searchString, includeTypes, excludeTypes);

                }

                return Collections.emptyList();

        }

        protected List<String> searchEpsg(String searchString, CRSType[] includeTypes, CRSType[] excludeTypes) {

                // FIXME handle other authorities

                CRSAuthorityFactory factory = ReferencingFactoryFinder.getCRSAuthorityFactory("EPSG", null);

                if (factory instanceof ThreadedEpsgFactory) {

                        ThreadedEpsgFactory epsgFactory = (ThreadedEpsgFactory) factory;

                        try {

                                DataSource ds = epsgFactory.getDataSource();

                                Connection c = ds.getConnection();

                                return searchEpsg(searchString, c, includeTypes, excludeTypes);

                        } catch (SQLException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                        }

                }

                return Collections.EMPTY_LIST;

        }

        private boolean isExcluded(CRSType type,  CRSType[] excludeTypes) {

                for (CRSType excluded: excludeTypes) {

                        if (type.equals(excluded)) {

                                return true;

                        }

            }

                return false;

        }

    public synchronized List<String> searchEpsg(String searchString, Connection conn,

                    CRSType[] includeTypes, CRSType[] excludeTypes) throws SQLException

    {

            ArrayList<String> codes = new ArrayList<String>();

            if (searchString == null) {

                    searchString = "";

            }

            else if (searchString.startsWith("EPSG:")) {

                    searchString = searchString.substring(5);

            }

            searchString = "%" + searchString.toLowerCase() + "%";

            StringBuilder builder = new StringBuilder("SELECT COORD_REF_SYS_CODE,"

                +       " COORD_REF_SYS_NAME,"

                +       " AREA_OF_USE_CODE,"

                +       " CRS_SCOPE,"

                +       " REMARKS,"

                +       " COORD_REF_SYS_KIND,"

                +       " COORD_SYS_CODE,"       // Null for CompoundCRS

                +       " DATUM_CODE,"           // Null for ProjectedCRS

                +       " SOURCE_GEOGCRS_CODE,"  // For ProjectedCRS

                +       " PROJECTION_CONV_CODE," // For ProjectedCRS

                +       " CMPD_HORIZCRS_CODE,"   // For CompoundCRS only

                +       " CMPD_VERTCRS_CODE,"     // For CompoundCRS only

                +       " DEPRECATED"

                + " FROM epsg_coordinatereferencesystem"

                + " WHERE DEPRECATED = 0 AND (COORD_REF_SYS_CODE LIKE ? OR LCASE(COORD_REF_SYS_NAME) LIKE ?"

                + " OR LCASE(REMARKS) LIKE ?"

                + " OR LCASE(CRS_SCOPE) LIKE ?)");

            if (includeTypes != null) {

                    boolean first = true;

                    builder.append(" AND (");

                    for (CRSType type: includeTypes) {

                            if (first) {

                                    first = false;

                                    builder.append("COORD_REF_SYS_KIND LIKE '").append(type.toEpsgString()).append("'");

                            }

                            else {

                                    builder.append(" OR COORD_REF_SYS_KIND LIKE '").append(type.toEpsgString()).append("'");

                            }

                    }

                    builder.append(")");

            }

            if (excludeTypes != null) {

                    boolean first = true;

                    builder.append(" AND NOT(");

                    for (CRSType type: excludeTypes) {

                            if (first) {

                                    first = false;

                                    builder.append("COORD_REF_SYS_KIND LIKE '").append(type.toEpsgString()).append("'");

                            }

                            else {

                                    builder.append(" OR COORD_REF_SYS_KIND LIKE '").append(type.toEpsgString()).append("'");

                            }

                    }

                    builder.append(")");

            }

        try {

            // FIXME: JOIN query with area of use. Maybe also with  COORD_SYS_CODE to search for coord sys name

            final PreparedStatement stmt;

            stmt = conn.prepareStatement(builder.toString());

            stmt.setString(1, searchString);

            stmt.setString(2, searchString);

            stmt.setString(3, searchString);

            stmt.setString(4, searchString);

            ResultSet result = stmt.executeQuery();

            while (result.next()) {

                final String epsg    = result.getString(1);//getString(result, 1, code);

                final String name    = result.getString(2);//getString(result, 2, code);

                final String area    = result.getString(3);

                final String scope   = result.getString(4);

                final String remarks = result.getString(5);

                final String kind = result.getString(6);

                final String csCode  = result.getString(7);

                final String dmCode    = result.getString( 8); // geographic

                final String geoCode = result.getString(9);

                final String opCode  = result.getString(10);

                // vertical:

                final String code1 = result.getString(11);

                final String code2 = result.getString(12);

                codes.add("EPSG:"+epsg);

            }

            result.close();

        } catch (SQLException exception) {

            throw exception;

        }

        conn.close();

        return codes;

    }

        @Override

        public DefaultCRSDefinition getCRSDefinition(String code) throws UnsupportedCoordinateReferenceSystemException {

                CoordinateReferenceSystem crs;

                CoordinateReferenceSystem internalCrs;

                try {

                        crs = CRS.decode(code, false);

                        if (CRS.getAxisOrder(crs) == AxisOrder.NORTH_EAST) {

                                internalCrs = CRS.decode(code, true);

                        }

                        else {

                                internalCrs = crs;

                        }

                        return new DefaultCRSDefinition(crs, internalCrs, null);

                }  catch (NoSuchAuthorityCodeException e) {

                        throw new UnsupportedCoordinateReferenceSystemException(code, e);

                } catch (FactoryException e) {

                        throw new UnsupportedCoordinateReferenceSystemException(code, e);

                }

        }

        public DefaultCRSDefinition getCRSDefinition(CoordinateReferenceSystem crs) throws UnsupportedCoordinateReferenceSystemException {

                return new DefaultCRSDefinition(crs);

        }

        @Override

        public CRSDefinition getCompoundCRS(CRSDefinition... crsList) throws UnsupportedCoordinateReferenceSystemException {

                ArrayList<CoordinateReferenceSystem> components = new ArrayList<CoordinateReferenceSystem>();

                for (CRSDefinition def: crsList) {

                        if (def instanceof DefaultCRSDefinition) {

                                components.add(((DefaultCRSDefinition)def).getInternalCRS());        

                        }

                        else {

                                def = parseCRSDefinition(def.toWKT());

                        }

                }

            CRSFactory crsFactory = ReferencingFactoryFinder.getCRSFactory(null);

                CoordinateReferenceSystem compoundCRS;

                try {

                    Map<String, String> properties = new HashMap<String, String>();

                    crsFactory.createCompoundCRS(properties, components.toArray(new CoordinateReferenceSystem[components.size()]));

                        compoundCRS = crsFactory.createCompoundCRS(properties, components.toArray(new CoordinateReferenceSystem[components.size()]));;

                        return new DefaultCRSDefinition(compoundCRS);

                } catch (FactoryException e) {

                        throw new UnsupportedCoordinateReferenceSystemException(e);

                }

        }

        /**

         * Removes axis definition from a WKT string

         * 

         * @param wktDef

         * @return A WKT string without any axis definition

         */

        private static String removeWktAxis(String wktDef) {

                return WKTUtils.removeAxisDefinition(wktDef);

        }

        @Override

        public DefaultCRSDefinition parseCRSDefinition(String def) throws UnsupportedCoordinateReferenceSystemException {

                CoordinateReferenceSystem crs;

                CoordinateReferenceSystem internalCrs;

                try {

                        crs = CRS.parseWKT(def);

                        if (CRS.getAxisOrder(crs)==AxisOrder.NORTH_EAST) {

                                String id = GtUtils.getIdentifier(crs);

                                if (id != null && id.startsWith("EPSG:")) { //FIXME: could this also work for other authorities such as ESRI?

                                        internalCrs = CRS.decode(id, true);

                                }

                                else {

                                        // Hack: remove the axis from the WKT. It could be better to try to derive a CRS with default axis order, but I don't see the way for non EPSG CRSs 

                                        internalCrs = CRS.parseWKT(removeWktAxis(def));

                                }

                        }

                        else {

                                internalCrs = crs;

                        }

                } catch (NoSuchAuthorityCodeException e) {

                        throw new UnsupportedCoordinateReferenceSystemException(def, e);

                } catch (FactoryException e) {

                        throw new UnsupportedCoordinateReferenceSystemException(def, e);

                }

                return new DefaultCRSDefinition(crs, internalCrs, def);

        }

        @Override

        public DefaultCRSDefinition parseCRSDefinition(String def, Format format)

                        throws UnsupportedCoordinateReferenceSystemException, UnsupportedFormatException {

                if (SUPPORTED_FORMATS.contains(format)) {

                        parseCRSDefinition(def);

                }

                throw new UnsupportedFormatException(format);

        }

        @Override

        public TransformationDefinition getTransformationDefinition(String code)

                        throws UnsupportedTransformationException {

                try {

                        AuthorityFactory factory = ReferencingFactoryFinder.getCoordinateOperationAuthorityFactory(

                                        "EPSG",

                                        null);

                        CoordinateOperation op;

                        if (factory instanceof AbstractAuthorityFactory) {

                                op = ((AbstractAuthorityFactory)factory).createCoordinateOperation(code);

                        }

                        else {

                                Object obj;

                                // We need to check the returned object type, since AuthorityFactory.createObject()

                                // will not create a CoordinateOperatoin if there is a CRS that has the same code as the coordinate operation 

                                obj = factory.createObject(code);

                                if (obj instanceof CoordinateOperation) {

                                        // we have it

                                        op = (CoordinateOperation) obj;

                                }

                                else { // we found another object having the same code, sigh 

                                        throw new UnsupportedTransformationException(code);

                                }

                        }

                        return new DefaultTransformationDefinition(op,

                                        getCRSDefinition(op.getSourceCRS()), getCRSDefinition(op.getTargetCRS()));

                } catch (FactoryException | CoordinateReferenceSystemException e) {

                        throw new UnsupportedTransformationException(code, e);

                }

        }

        @Override

        public TransformationDefinition parseTransformationDefinition(String def, String sourceCRS, String targetCRS)

                        throws UnsupportedTransformationException, ParseException {

                DefaultCRSDefinition source;

                try {

                        source = parseCRSDefinition(sourceCRS);

                        DefaultCRSDefinition target = parseCRSDefinition(sourceCRS);

                        MathTransformParser parser = new MathTransformParser();

                        MathTransform mt = parser.parseMathTransform(def);

                        return new DefaultTransformationDefinition(mt, source, target);

                } catch (CoordinateReferenceSystemException e) {

                        throw new UnsupportedTransformationException(e);

                }

        }

        @Override

        public TransformationDefinition parseTransformationDefinition(String def, String sourceCRS, String targetCRS,

                        Format format) throws UnsupportedTransformationException, ParseException, UnsupportedFormatException {

                if (format==Format.WKT1) {

                        return parseTransformationDefinition(def, sourceCRS, targetCRS);

                }

                throw new UnsupportedFormatException(format);

        }

        @Override

        public DefaultTransformationDefinition parseTransformationDefinition(String def)

                        throws ParseException, CoordinateReferenceSystemException {

                // This implementation don't support this method because only WKT1 format is supported,

                // but try to parse to raise an indicative exception 

                MathTransformParser parser = new MathTransformParser();

                parser.parseMathTransform(def);

                throw new CoordinateReferenceSystemException("Not enough information to construct the transformation. WKT1 does not encode source and target CRSs");

        }

        @Override

        public DefaultTransformationDefinition parseTransformationDefinition(String def, Format format)

                        throws ParseException, CoordinateReferenceSystemException {

                if (SUPPORTED_FORMATS.contains(format)) {

                        parseTransformationDefinition(def);

                }

                throw new UnsupportedFormatException(format);

        }

        @Override

        public String registerCoordinateReferenceSystem(String wktDefinition, String description) {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String registerTransformation(String wktDefinition, String sourceCRS, String targetCRS, String description)

                        throws UnsupportedTransformationException, ParseException {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String registerCoordinateTransformationPVT(String sourceCRS, String targetCRS, String description,

                        float xTraslation, float yTraslation, float zTraslation, float xRotation, float yRotation, float zRotation,

                        float scaleDifference) {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String registerCoordinateTransformationCFR(String sourceCRS, String targetCRS, String description,

                        float xTraslation, float yTraslation, float zTraslation, float xRotation, float yRotation, float zRotation,

                        float scaleDifference) {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String registerCoordinateTransformation(String sourceCRS, String targetCRS, String description,

                        File ntv2Grid) {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public List<TransformationDefinition> getCoordinateTransformations(CRSDefinition source, CRSDefinition target)

                        throws UnsupportedTransformationException {

                DefaultCRSDefinition sourceDef = (DefaultCRSDefinition) source;

                DefaultCRSDefinition targetDef = (DefaultCRSDefinition) target;

                ArrayList<TransformationDefinition> transforms = new ArrayList<TransformationDefinition>();

                try {

                        CoordinateReferenceSystem sourceCRS = sourceDef.getInternalCRS();

                        CoordinateReferenceSystem targetCRS = targetDef.getInternalCRS();

                CoordinateOperationFactory operationFactory = CRS.getCoordinateOperationFactory(false);

                Set<CoordinateOperation> ops = operationFactory.findOperations(sourceCRS, targetCRS);

                for (CoordinateOperation op: ops) {

                        if (GtUtils.getIdentifier(op) == null) {

                                CoordinateOperation defOp = GtUtils.getDefiningOperation(op);

                                if (GtUtils.getIdentifier(defOp) == null) {

                                        /**

                                         * When Geotools computes the inverse transformation, we loose the identifier, which

                                         * makes the transformation quite useless for the final users since they can't distinguish

                                         * it from any other operation. Therefore, we skip operations lacking an identifier, and

                                         * we'll add them later requesting the inverse operation. It is quite hacky but I can't see

                                         * a better approach

                                         */

                                        continue;

                                }

                        }

                        DefaultTransformationDefinition def = new DefaultTransformationDefinition(op, sourceDef, targetDef);

                        transforms.add(def);

                }

                // now we'll try the inverse transformation

                ops = operationFactory.findOperations(targetCRS, sourceCRS);

                for (CoordinateOperation op: ops) {

                        if (GtUtils.getIdentifier(op) == null) {

                                CoordinateOperation defOp = GtUtils.getDefiningOperation(op);

                                if (GtUtils.getIdentifier(defOp) == null) {

                                        continue;

                                }

                        }

                        DefaultTransformationDefinition def = new DefaultTransformationDefinition(op, sourceDef, targetDef);

                        transforms.add(def);

                }

                } catch (FactoryException e) {

                        // FIXME: we should log instead of raising an exception

                        throw new UnsupportedTransformationException(e);

                }

                return transforms;

        }

        @Override

        public List<TransformationDefinition> getCoordinateTransformations(String source, String target) throws UnsupportedTransformationException {

                try {

                        DefaultCRSDefinition sourceDef = getCRSDefinition(source);

                        DefaultCRSDefinition targetDef = getCRSDefinition(target);

                        return getCoordinateTransformations(sourceDef, targetDef);

                } catch (UnsupportedCoordinateReferenceSystemException e) {

                        // FIXME: we should log instead of raising an exception

                        throw new UnsupportedTransformationException(e);

                }

        }

        /**

         * Sets the path to the folder to be used by the library to load the CRS and

         * transformation definitions. The specified path must contain one or more subfolders,

         * containg the CRS and transformation database in the appropriate format:

         * <ul><li>for EPSG database: a "epsg" subfolder must exist, which contains a HSQL database

         * called "EPSG". The structure of this database must be the same used by Geotools,

         * which is essentially based in the EPSG data model.</li>

         * </ul>

         * 

         * This method only has effect when it is called before any other method in the manager

         * (before instantiating any CRS, transformation, etc). 

         * 

         * @param path The path to the folder containing the system CRS and transformation

         * definitions

         */

        @Override

        public void setSystemDataPath(File path) {

                System.setProperty(HsqlEpsgDatabase.DIRECTORY_KEY, path.getAbsolutePath() + "/" + EPSG_DB_SUBFOLDER);

        }

        @Override

        public void setUserDataPath(File path) {

                // TODO Auto-generated method stub

        }

        @Override

        public List<TextSerialization.Format> getSupportedFormats() {

                // TODO Auto-generated method stub

                return SUPPORTED_FORMATS;

        }

        @Override

        public GeographicBoundingBox createBoundingBox(double westBoundLongitude, double eastBoundLongitude,

                        double northBoundLatitude, double southBoundLatitude) {

                return new DefaultGeographicBoundingBox(westBoundLongitude, eastBoundLongitude, northBoundLatitude, southBoundLatitude);

        }

        @Override

        public VerticalExtent createVerticalExtent(CRSDefinition crs, double minValue, double maxValue) {

                return new DefaultVerticalExtent(crs, minValue, maxValue);

        }

        @Override

        public Extent createExtent(String description, 

                        Collection<GeographicBoundingBox> horizontalBoundingBoxList,

                        Collection<VerticalExtent> verticalBoundingBoxList) {

                return new DefaultExtent(description, horizontalBoundingBoxList, verticalBoundingBoxList);

        }

}