Application: gvSIG desktop » gvSIG projections

package org.gvsig.geotools.proj.catalog;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

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

import org.geotools.referencing.CRS;

import org.geotools.referencing.wkt.Formatter;

import org.geotools.referencing.wkt.Symbols;

import org.gvsig.geotools.proj.catalog.datum.DefaultDatum;

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

import org.gvsig.proj.catalog.CRSDefinition;

import org.gvsig.proj.catalog.CRSType;

import org.gvsig.proj.catalog.CoordinateSystemAxis;

import org.gvsig.proj.catalog.TextSerialization;

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.datum.Datum;

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

import org.opengis.metadata.Identifier;

import org.opengis.referencing.FactoryException;

import org.opengis.referencing.ReferenceIdentifier;

import org.opengis.referencing.crs.CompoundCRS;

import org.opengis.referencing.crs.CoordinateReferenceSystem;

import org.opengis.referencing.crs.GeneralDerivedCRS;

import org.opengis.referencing.crs.GeocentricCRS;

import org.opengis.referencing.crs.GeographicCRS;

import org.opengis.referencing.crs.ProjectedCRS;

import org.opengis.referencing.crs.SingleCRS;

import org.opengis.referencing.crs.TemporalCRS;

import org.opengis.referencing.crs.VerticalCRS;

import org.opengis.referencing.operation.Conversion;

public class DefaultCRSDefinition implements CRSDefinition {

        private CoordinateReferenceSystem origCrs = null;

        private CoordinateReferenceSystem epsgCrs = null;

        private String wkt = null;

        public DefaultCRSDefinition(String wktDefinition) {

                this.wkt = wktDefinition;

                try {

                        this.origCrs = CRS.parseWKT(wktDefinition);

                } catch (FactoryException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        public DefaultCRSDefinition(CoordinateReferenceSystem crs) {

                this.origCrs = crs;

        }

        public CoordinateReferenceSystem getInternalCRS() {

                return origCrs;

        }

        @Override

        public String getName() {

                return origCrs.getName().toString();

        }

        @Override

        public String getIdentifier() {

                String id = IdentifiedObjectUtils.getIdentifier(origCrs);

                if (id!=null) {

                        return id;

                }

                // FIXME: define in API whether null is allowed

                return IdentifiedObjectUtils.getIdentifier(getEpsgCrs());

        }

        /**

         * Gets an EPSG code which can be considered equivalent to this CRS or

         * null if not found

         * @return

         */

        protected CoordinateReferenceSystem getEpsgCrs() {

                if (epsgCrs==null) {

                        try {

                                String code = CRS.lookupIdentifier(Citations.EPSG, origCrs, true);

                                if (code!=null) {

                                        epsgCrs = CRS.decode("EPSG:"+code);

                                }

                        }

                        catch (FactoryException exc) {}

                }

                return epsgCrs;

        }

        @Override

        public Set<String> getIdentifiers() {

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

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

                        ids.add(id.toString());

                }

                if (!getAuthorityName().equals("EPSG") && getEpsgCrs() != null) {

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

                                ids.add(id.toString());

                        }

                }

                return ids;

        }

        @Override

        public String getAuthorityName() {

                for (Identifier id: origCrs.getName().getAuthority().getIdentifiers()) {

                        return id.getCode();

                }

                return null; // FIXME: define in API whether null is allowed 

        }

        @Override

        public Extent getDomainOfValidity() {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public String getDescription() {

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

        }

        @Override

        public CRSType getType() {

                if (origCrs instanceof ProjectedCRS) {

                        return CRSType.ProjectedCRSType;

                }

                if (origCrs instanceof GeographicCRS) {

                        return CRSType.GeographicCRSType;

                }

                if (origCrs instanceof GeocentricCRS) {

                        return CRSType.GeocentricCRSType;

                }

                if (origCrs instanceof GeneralDerivedCRS) {

                        return CRSType.OtherDerivedCRSType;

                }

                if (origCrs instanceof CompoundCRS) {

                        return CRSType.CompoundCRSType;

                }

                if (origCrs instanceof VerticalCRS) {

                        return CRSType.VerticalCRSType;

                }

                if (origCrs instanceof TemporalCRS) {

                        return CRSType.TemporalCRSType;

                }

                return CRSType.OtherCRSType;

        }

        @Override

        public String toWKT() throws UnsupportedOperationException {

                if (wkt!=null) {

                        return wkt;

                }

                return origCrs.toWKT();

        }

        @Override

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

                return toString(format, convention, 0);

        }

        @Override

        public String toString(TextSerialization.Format format, WKTConvention convention, int indentation) throws UnsupportedOperationException {

                if (format==Format.WKT1) {

                        if (convention==WKTConvention.EPSG) {

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

                                formatter.setAuthority(Citations.EPSG);

                                if (!this.getAuthorityName().equals("EPSG")) {

                                        String id;

                                        try {

                                                id = CRS.lookupIdentifier(Citations.EPSG, this.origCrs, true);

                                                if (id!=null) {

                                                        if (!id.startsWith("EPSG:")) {

                                                                id = "EPSG:" + id;

                                                        }

                                                        CoordinateReferenceSystem crs = CRS.decode(id);

                                                        formatter.append(crs);

                                                        return formatter.toString();

                                                }

                                        } catch (FactoryException e) {

                                        }

                                }

                                formatter.append(this.origCrs);

                                return formatter.toString();

                        }

                        if (convention==WKTConvention.ESRI) {

                                // FIXME: should we consider this.wkt if it is not null??

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

                                formatter.setAuthority(Citations.ESRI);

                                formatter.append(this.origCrs);

                                return formatter.toString();

                        }

                        return toWKT();

                }

                throw new UnsupportedOperationException("Format not supported");

        }

        @Override

        public List<CRSDefinition> getComponents() {

                if (origCrs instanceof CompoundCRS) {

                        ArrayList<CRSDefinition> list = new ArrayList<CRSDefinition>();

                        for (CoordinateReferenceSystem component: ((CompoundCRS) origCrs).getCoordinateReferenceSystems()) {

                                list.add(new DefaultCRSDefinition(component));

                        }

                        return list;

                }

                return null;

        }

        @Override

        public int getAxisCount() {

                return origCrs.getCoordinateSystem().getDimension();

        }

        @Override

        public CoordinateSystemAxis getAxis(int dimension) throws IndexOutOfBoundsException {

                return new DefaultCoordinateSystemAxis(origCrs.getCoordinateSystem().getAxis(dimension));

        }

        @Override

        public CoordinateSystemAxis getAxisInternal(int dimension) throws IndexOutOfBoundsException {

                // TODO Auto-generated method stub

                return null;

        }

        @Override

        public CRSDefinition getBaseCRS() {

                if (origCrs instanceof GeneralDerivedCRS) {

                        CoordinateReferenceSystem base = ((GeneralDerivedCRS)origCrs).getBaseCRS();

                        return new DefaultCRSDefinition(base);

                }

                return null;

        }

        @Override

        public TransformationDefinition getConversionFromBase() {

                if (origCrs instanceof GeneralDerivedCRS) {

                        Conversion conversion = ((GeneralDerivedCRS)origCrs).getConversionFromBase();

                        return new DefaultTransformationDefinition(conversion);

                }

                return null;

        }

        @Override

        public Datum getDatum() {

                if (origCrs instanceof SingleCRS) {

                        SingleCRS singleCrs = (SingleCRS)origCrs;

                        return new DefaultDatum(singleCrs.getDatum());

                }

                else {

                        SingleCRS horizontalCrs = CRS.getHorizontalCRS(origCrs);

                        return new DefaultDatum(horizontalCrs.getDatum());

                }

        }

        @Override

        public Object clone() throws CloneNotSupportedException {

                return new DefaultCRSDefinition(this.origCrs);

        }

        @Override

        public boolean equals(CRSDefinition definition, boolean ignoreAxis, boolean ignoreMetadata) {

                // TODO Auto-generated method stub

                return this.equals(definition);

        }

}