diff options
Diffstat (limited to 'include/proj/crs.hpp')
| -rw-r--r-- | include/proj/crs.hpp | 1361 |
1 files changed, 1361 insertions, 0 deletions
diff --git a/include/proj/crs.hpp b/include/proj/crs.hpp new file mode 100644 index 00000000..252c90e3 --- /dev/null +++ b/include/proj/crs.hpp @@ -0,0 +1,1361 @@ +/****************************************************************************** + * + * Project: PROJ + * Purpose: ISO19111:2018 implementation + * Author: Even Rouault <even dot rouault at spatialys dot com> + * + ****************************************************************************** + * Copyright (c) 2018, Even Rouault <even dot rouault at spatialys dot com> + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + ****************************************************************************/ + +#ifndef CRS_HH_INCLUDED +#define CRS_HH_INCLUDED + +#include <memory> +#include <string> +#include <vector> + +#include "common.hpp" +#include "coordinateoperation.hpp" +#include "coordinatesystem.hpp" +#include "datum.hpp" +#include "io.hpp" +#include "util.hpp" + +NS_PROJ_START + +/** osgeo.proj.crs namespace + + \brief CRS (coordinate reference system = coordinate system with a datum). +*/ +namespace crs { + +// --------------------------------------------------------------------------- + +class GeographicCRS; +/** Shared pointer of GeographicCRS */ +using GeographicCRSPtr = std::shared_ptr<GeographicCRS>; +/** Non-null shared pointer of GeographicCRS */ +using GeographicCRSNNPtr = util::nn<GeographicCRSPtr>; + +class VerticalCRS; +/** Shared pointer of VerticalCRS */ +using VerticalCRSPtr = std::shared_ptr<VerticalCRS>; +/** Non-null shared pointer of VerticalCRS */ +using VerticalCRSNNPtr = util::nn<VerticalCRSPtr>; + +class BoundCRS; +/** Shared pointer of BoundCRS */ +using BoundCRSPtr = std::shared_ptr<BoundCRS>; +/** Non-null shared pointer of BoundCRS */ +using BoundCRSNNPtr = util::nn<BoundCRSPtr>; + +// --------------------------------------------------------------------------- + +class CRS; +/** Shared pointer of CRS */ +using CRSPtr = std::shared_ptr<CRS>; +/** Non-null shared pointer of CRS */ +using CRSNNPtr = util::nn<CRSPtr>; + +/** \brief Abstract class modelling a coordinate reference system which is + * usually single but may be compound. + * + * \remark Implements CRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL CRS : public common::ObjectUsage { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~CRS() override; + //! @endcond + + // Non-standard + + PROJ_DLL GeodeticCRSPtr extractGeodeticCRS() const; + PROJ_DLL GeographicCRSPtr extractGeographicCRS() const; + PROJ_DLL VerticalCRSPtr extractVerticalCRS() const; + PROJ_DLL CRSNNPtr createBoundCRSToWGS84IfPossible( + const io::DatabaseContextPtr &dbContext) const; + PROJ_DLL CRSNNPtr stripVerticalComponent() const; + + PROJ_DLL const BoundCRSPtr &canonicalBoundCRS() PROJ_CONST_DECL; + + PROJ_DLL std::list<std::pair<CRSNNPtr, int>> + identify(const io::AuthorityFactoryPtr &authorityFactory) const; + + PROJ_PRIVATE : + //! @cond Doxygen_Suppress + PROJ_INTERNAL const GeodeticCRS * + extractGeodeticCRSRaw() const; + + PROJ_FOR_TEST CRSNNPtr shallowClone() const; + + //! @endcond + + protected: + PROJ_INTERNAL CRS(); + PROJ_INTERNAL CRS(const CRS &other); + friend class BoundCRS; + PROJ_INTERNAL void setCanonicalBoundCRS(const BoundCRSNNPtr &boundCRS); + + PROJ_INTERNAL virtual CRSNNPtr _shallowClone() const = 0; + + PROJ_INTERNAL virtual std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const; + + private: + PROJ_OPAQUE_PRIVATE_DATA +}; + +// --------------------------------------------------------------------------- + +/** \brief Abstract class modelling a coordinate reference system consisting of + * one Coordinate System and either one datum::Datum or one + * datum::DatumEnsemble. + * + * \remark Implements SingleCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL SingleCRS : public CRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~SingleCRS() override; + //! @endcond + + PROJ_DLL const datum::DatumPtr &datum() PROJ_CONST_DECL; + PROJ_DLL const datum::DatumEnsemblePtr &datumEnsemble() PROJ_CONST_DECL; + PROJ_DLL const cs::CoordinateSystemNNPtr & + coordinateSystem() PROJ_CONST_DECL; + + PROJ_PRIVATE : + //! @cond Doxygen_Suppress + PROJ_INTERNAL void + exportDatumOrDatumEnsembleToWkt(io::WKTFormatter *formatter) + const; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL SingleCRS(const datum::DatumPtr &datumIn, + const datum::DatumEnsemblePtr &datumEnsembleIn, + const cs::CoordinateSystemNNPtr &csIn); + PROJ_INTERNAL SingleCRS(const SingleCRS &other); + + PROJ_INTERNAL bool + baseIsEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const; + + private: + PROJ_OPAQUE_PRIVATE_DATA + SingleCRS &operator=(const SingleCRS &other) = delete; +}; + +/** Shared pointer of SingleCRS */ +using SingleCRSPtr = std::shared_ptr<SingleCRS>; +/** Non-null shared pointer of SingleCRS */ +using SingleCRSNNPtr = util::nn<SingleCRSPtr>; + +// --------------------------------------------------------------------------- + +class GeodeticCRS; +/** Shared pointer of GeodeticCRS */ +using GeodeticCRSPtr = std::shared_ptr<GeodeticCRS>; +/** Non-null shared pointer of GeodeticCRS */ +using GeodeticCRSNNPtr = util::nn<GeodeticCRSPtr>; + +/** \brief A coordinate reference system associated with a geodetic reference + * frame and a three-dimensional Cartesian or spherical coordinate system. + * + * If the geodetic reference frame is dynamic or if the geodetic CRS has an + * association to a velocity model then the geodetic CRS is dynamic, else it + * is static. + * + * \remark Implements GeodeticCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL GeodeticCRS : virtual public SingleCRS, + public io::IPROJStringExportable { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~GeodeticCRS() override; + //! @endcond + + PROJ_DLL const datum::GeodeticReferenceFramePtr &datum() PROJ_CONST_DECL; + + PROJ_DLL const datum::PrimeMeridianNNPtr &primeMeridian() PROJ_CONST_DECL; + PROJ_DLL const datum::EllipsoidNNPtr &ellipsoid() PROJ_CONST_DECL; + + // coordinateSystem() returns either a EllipsoidalCS, SphericalCS or + // CartesianCS + + PROJ_DLL const std::vector<operation::PointMotionOperationNNPtr> & + velocityModel() PROJ_CONST_DECL; + + // Non-standard + + PROJ_DLL bool isGeocentric() PROJ_CONST_DECL; + + PROJ_DLL static GeodeticCRSNNPtr + create(const util::PropertyMap &properties, + const datum::GeodeticReferenceFrameNNPtr &datum, + const cs::SphericalCSNNPtr &cs); + + PROJ_DLL static GeodeticCRSNNPtr + create(const util::PropertyMap &properties, + const datum::GeodeticReferenceFrameNNPtr &datum, + const cs::CartesianCSNNPtr &cs); + + PROJ_DLL static GeodeticCRSNNPtr + create(const util::PropertyMap &properties, + const datum::GeodeticReferenceFramePtr &datum, + const datum::DatumEnsemblePtr &datumEnsemble, + const cs::SphericalCSNNPtr &cs); + + PROJ_DLL static GeodeticCRSNNPtr + create(const util::PropertyMap &properties, + const datum::GeodeticReferenceFramePtr &datum, + const datum::DatumEnsemblePtr &datumEnsemble, + const cs::CartesianCSNNPtr &cs); + + PROJ_DLL static const GeodeticCRSNNPtr EPSG_4978; // WGS 84 Geocentric + + PROJ_DLL std::list<std::pair<GeodeticCRSNNPtr, int>> + identify(const io::AuthorityFactoryPtr &authorityFactory) const; + + PROJ_PRIVATE : + //! @cond Doxygen_Suppress + PROJ_INTERNAL void + addDatumInfoToPROJString(io::PROJStringFormatter *formatter) const; + + PROJ_INTERNAL void addGeocentricUnitConversionIntoPROJString( + io::PROJStringFormatter *formatter) const; + + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + //! @endcond + + protected: + PROJ_INTERNAL GeodeticCRS(const datum::GeodeticReferenceFramePtr &datumIn, + const datum::DatumEnsemblePtr &datumEnsembleIn, + const cs::EllipsoidalCSNNPtr &csIn); + PROJ_INTERNAL GeodeticCRS(const datum::GeodeticReferenceFramePtr &datumIn, + const datum::DatumEnsemblePtr &datumEnsembleIn, + const cs::SphericalCSNNPtr &csIn); + PROJ_INTERNAL GeodeticCRS(const datum::GeodeticReferenceFramePtr &datumIn, + const datum::DatumEnsemblePtr &datumEnsembleIn, + const cs::CartesianCSNNPtr &csIn); + PROJ_INTERNAL GeodeticCRS(const GeodeticCRS &other); + + PROJ_INTERNAL static GeodeticCRSNNPtr createEPSG_4978(); + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + + GeodeticCRS &operator=(const GeodeticCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +/** \brief A coordinate reference system associated with a geodetic reference + * frame and a two- or three-dimensional ellipsoidal coordinate system. + * + * If the geodetic reference frame is dynamic or if the geographic CRS has an + * association to a velocity model then the geodetic CRS is dynamic, else it is + * static. + * + * \remark Implements GeographicCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL GeographicCRS : public GeodeticCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~GeographicCRS() override; + //! @endcond + + PROJ_DLL const cs::EllipsoidalCSNNPtr &coordinateSystem() PROJ_CONST_DECL; + + // Non-standard + PROJ_DLL static GeographicCRSNNPtr + create(const util::PropertyMap &properties, + const datum::GeodeticReferenceFrameNNPtr &datum, + const cs::EllipsoidalCSNNPtr &cs); + PROJ_DLL static GeographicCRSNNPtr + create(const util::PropertyMap &properties, + const datum::GeodeticReferenceFramePtr &datum, + const datum::DatumEnsemblePtr &datumEnsemble, + const cs::EllipsoidalCSNNPtr &cs); + + PROJ_DLL static const GeographicCRSNNPtr EPSG_4267; // NAD27 + PROJ_DLL static const GeographicCRSNNPtr EPSG_4269; // NAD83 + PROJ_DLL static const GeographicCRSNNPtr EPSG_4326; // WGS 84 2D + PROJ_DLL static const GeographicCRSNNPtr OGC_CRS84; // CRS84 (Long, Lat) + PROJ_DLL static const GeographicCRSNNPtr EPSG_4807; // NTF Paris + PROJ_DLL static const GeographicCRSNNPtr EPSG_4979; // WGS 84 3D + + PROJ_PRIVATE : + //! @cond Doxygen_Suppress + PROJ_INTERNAL void + addAngularUnitConvertAndAxisSwap( + io::PROJStringFormatter *formatter) const; + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_DLL bool + is2DPartOf3D(util::nn<const GeographicCRS *> other) PROJ_CONST_DECL; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + //! @endcond + + protected: + PROJ_INTERNAL GeographicCRS(const datum::GeodeticReferenceFramePtr &datumIn, + const datum::DatumEnsemblePtr &datumEnsembleIn, + const cs::EllipsoidalCSNNPtr &csIn); + PROJ_INTERNAL GeographicCRS(const GeographicCRS &other); + + PROJ_INTERNAL static GeographicCRSNNPtr createEPSG_4267(); + PROJ_INTERNAL static GeographicCRSNNPtr createEPSG_4269(); + PROJ_INTERNAL static GeographicCRSNNPtr createEPSG_4326(); + PROJ_INTERNAL static GeographicCRSNNPtr createOGC_CRS84(); + PROJ_INTERNAL static GeographicCRSNNPtr createEPSG_4807(); + PROJ_INTERNAL static GeographicCRSNNPtr createEPSG_4979(); + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + + GeographicCRS &operator=(const GeographicCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +/** \brief A coordinate reference system having a vertical reference frame and + * a one-dimensional vertical coordinate system used for recording + * gravity-related heights or depths. + * + * Vertical CRSs make use of the direction of gravity to define the concept of + * height or depth, but the relationship with gravity may not be + * straightforward. If the vertical reference frame is dynamic or if the + * vertical CRS has an association to a velocity model then the CRS is dynamic, + * else it is static. + * + * \note Ellipsoidal heights cannot be captured in a vertical coordinate + * reference system. They exist only as an inseparable part of a 3D coordinate + * tuple defined in a geographic 3D coordinate reference system. + * + * \remark Implements VerticalCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL VerticalCRS : virtual public SingleCRS, + public io::IPROJStringExportable { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~VerticalCRS() override; + //! @endcond + + PROJ_DLL const datum::VerticalReferenceFramePtr datum() const; + PROJ_DLL const cs::VerticalCSNNPtr coordinateSystem() const; + PROJ_DLL const std::vector<operation::TransformationNNPtr> & + geoidModel() PROJ_CONST_DECL; + PROJ_DLL const std::vector<operation::PointMotionOperationNNPtr> & + velocityModel() PROJ_CONST_DECL; + + PROJ_DLL static VerticalCRSNNPtr + create(const util::PropertyMap &properties, + const datum::VerticalReferenceFrameNNPtr &datumIn, + const cs::VerticalCSNNPtr &csIn); + + PROJ_DLL static VerticalCRSNNPtr + create(const util::PropertyMap &properties, + const datum::VerticalReferenceFramePtr &datumIn, + const datum::DatumEnsemblePtr &datumEnsembleIn, + const cs::VerticalCSNNPtr &csIn); + + PROJ_DLL std::list<std::pair<VerticalCRSNNPtr, int>> + identify(const io::AuthorityFactoryPtr &authorityFactory) const; + + PROJ_PRIVATE : + //! @cond Doxygen_Suppress + PROJ_INTERNAL void + addLinearUnitConvert(io::PROJStringFormatter *formatter) const; + + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + //! @endcond + + protected: + PROJ_INTERNAL VerticalCRS(const datum::VerticalReferenceFramePtr &datumIn, + const datum::DatumEnsemblePtr &datumEnsembleIn, + const cs::VerticalCSNNPtr &csIn); + PROJ_INTERNAL VerticalCRS(const VerticalCRS &other); + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + private: + PROJ_OPAQUE_PRIVATE_DATA + VerticalCRS &operator=(const VerticalCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +/** \brief Abstract class modelling a single coordinate reference system that + * is defined through the application of a specified coordinate conversion to + * the definition of a previously established single coordinate reference + * system referred to as the base CRS. + * + * A derived coordinate reference system inherits its datum (or datum ensemble) + * from its base CRS. The coordinate conversion between the base and derived + * coordinate reference system is implemented using the parameters and + * formula(s) specified in the definition of the coordinate conversion. + * + * \remark Implements DerivedCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL DerivedCRS : virtual public SingleCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~DerivedCRS() override; + //! @endcond + + PROJ_DLL const SingleCRSNNPtr &baseCRS() PROJ_CONST_DECL; + PROJ_DLL const operation::ConversionNNPtr derivingConversion() const; + + PROJ_PRIVATE : + //! @cond Doxygen_Suppress + const operation::ConversionNNPtr & + derivingConversionRef() PROJ_CONST_DECL; + //! @endcond + + protected: + PROJ_INTERNAL + DerivedCRS(const SingleCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::CoordinateSystemNNPtr &cs); + PROJ_INTERNAL DerivedCRS(const DerivedCRS &other); + + PROJ_INTERNAL void setDerivingConversionCRS(); + + PROJ_INTERNAL void baseExportToPROJString( + io::PROJStringFormatter *formatter) const; // throw(FormattingException) + + PROJ_INTERNAL void baseExportToWKT( + io::WKTFormatter *&formatter, const std::string &keyword, + const std::string &baseKeyword) const; // throw(FormattingException) + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + private: + PROJ_OPAQUE_PRIVATE_DATA + DerivedCRS &operator=(const DerivedCRS &other) = delete; +}; + +/** Shared pointer of DerivedCRS */ +using DerivedCRSPtr = std::shared_ptr<DerivedCRS>; +/** Non-null shared pointer of DerivedCRS */ +using DerivedCRSNNPtr = util::nn<DerivedCRSPtr>; + +// --------------------------------------------------------------------------- + +class ProjectedCRS; +/** Shared pointer of ProjectedCRS */ +using ProjectedCRSPtr = std::shared_ptr<ProjectedCRS>; +/** Non-null shared pointer of ProjectedCRS */ +using ProjectedCRSNNPtr = util::nn<ProjectedCRSPtr>; + +/** \brief A derived coordinate reference system which has a geodetic + * (usually geographic) coordinate reference system as its base CRS, thereby + * inheriting a geodetic reference frame, and is converted using a map + * projection. + * + * It has a Cartesian coordinate system, usually two-dimensional but may be + * three-dimensional; in the 3D case the base geographic CRSs ellipsoidal + * height is passed through unchanged and forms the vertical axis of the + * projected CRS's Cartesian coordinate system. + * + * \remark Implements ProjectedCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL ProjectedCRS final : public DerivedCRS, + public io::IPROJStringExportable { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~ProjectedCRS() override; + //! @endcond + + PROJ_DLL const GeodeticCRSNNPtr &baseCRS() PROJ_CONST_DECL; + PROJ_DLL const cs::CartesianCSNNPtr &coordinateSystem() PROJ_CONST_DECL; + + PROJ_DLL static ProjectedCRSNNPtr + create(const util::PropertyMap &properties, + const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::CartesianCSNNPtr &csIn); + + PROJ_DLL std::list<std::pair<ProjectedCRSNNPtr, int>> + identify(const io::AuthorityFactoryPtr &authorityFactory) const; + + PROJ_PRIVATE : + //! @cond Doxygen_Suppress + PROJ_INTERNAL void + addUnitConvertAndAxisSwap(io::PROJStringFormatter *formatter, + bool axisSpecFound) const; + + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + + //! @endcond + + protected: + PROJ_INTERNAL + ProjectedCRS(const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::CartesianCSNNPtr &csIn); + PROJ_INTERNAL ProjectedCRS(const ProjectedCRS &other); + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + private: + PROJ_OPAQUE_PRIVATE_DATA + ProjectedCRS &operator=(const ProjectedCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class TemporalCRS; +/** Shared pointer of TemporalCRS */ +using TemporalCRSPtr = std::shared_ptr<TemporalCRS>; +/** Non-null shared pointer of TemporalCRS */ +using TemporalCRSNNPtr = util::nn<TemporalCRSPtr>; + +/** \brief A coordinate reference system associated with a temporal datum and a + * one-dimensional temporal coordinate system. + * + * \remark Implements TemporalCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL TemporalCRS : virtual public SingleCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~TemporalCRS() override; + //! @endcond + + PROJ_DLL const datum::TemporalDatumNNPtr datum() const; + + PROJ_DLL const cs::TemporalCSNNPtr coordinateSystem() const; + + PROJ_DLL static TemporalCRSNNPtr + create(const util::PropertyMap &properties, + const datum::TemporalDatumNNPtr &datumIn, + const cs::TemporalCSNNPtr &csIn); + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL TemporalCRS(const datum::TemporalDatumNNPtr &datumIn, + const cs::TemporalCSNNPtr &csIn); + PROJ_INTERNAL TemporalCRS(const TemporalCRS &other); + + INLINED_MAKE_SHARED + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + private: + PROJ_OPAQUE_PRIVATE_DATA + TemporalCRS &operator=(const TemporalCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class EngineeringCRS; +/** Shared pointer of EngineeringCRS */ +using EngineeringCRSPtr = std::shared_ptr<EngineeringCRS>; +/** Non-null shared pointer of EngineeringCRS */ +using EngineeringCRSNNPtr = util::nn<EngineeringCRSPtr>; + +/** \brief Contextually local coordinate reference system associated with an + * engineering datum. + * + * It is applied either to activities on or near the surface of the Earth + * without geodetic corrections, or on moving platforms such as road vehicles, + * vessels, aircraft or spacecraft, or as the internal CRS of an image. + * + * In \ref WKT2, it maps to a ENGINEERINGCRS / ENGCRS keyword. In \ref WKT1, + * it maps to a LOCAL_CS keyword. + * + * \remark Implements EngineeringCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL EngineeringCRS : virtual public SingleCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~EngineeringCRS() override; + //! @endcond + + PROJ_DLL const datum::EngineeringDatumNNPtr datum() const; + + PROJ_DLL static EngineeringCRSNNPtr + create(const util::PropertyMap &properties, + const datum::EngineeringDatumNNPtr &datumIn, + const cs::CoordinateSystemNNPtr &csIn); + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL EngineeringCRS(const datum::EngineeringDatumNNPtr &datumIn, + const cs::CoordinateSystemNNPtr &csIn); + PROJ_INTERNAL EngineeringCRS(const EngineeringCRS &other); + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + EngineeringCRS &operator=(const EngineeringCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class ParametricCRS; +/** Shared pointer of ParametricCRS */ +using ParametricCRSPtr = std::shared_ptr<ParametricCRS>; +/** Non-null shared pointer of ParametricCRS */ +using ParametricCRSNNPtr = util::nn<ParametricCRSPtr>; + +/** \brief Contextually local coordinate reference system associated with an + * engineering datum. + * + * This is applied either to activities on or near the surface of the Earth + * without geodetic corrections, or on moving platforms such as road vehicles + * vessels, aircraft or spacecraft, or as the internal CRS of an image. + * + * \remark Implements ParametricCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL ParametricCRS : virtual public SingleCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~ParametricCRS() override; + //! @endcond + + PROJ_DLL const datum::ParametricDatumNNPtr datum() const; + + PROJ_DLL const cs::ParametricCSNNPtr coordinateSystem() const; + + PROJ_DLL static ParametricCRSNNPtr + create(const util::PropertyMap &properties, + const datum::ParametricDatumNNPtr &datumIn, + const cs::ParametricCSNNPtr &csIn); + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL ParametricCRS(const datum::ParametricDatumNNPtr &datumIn, + const cs::ParametricCSNNPtr &csIn); + PROJ_INTERNAL ParametricCRS(const ParametricCRS &other); + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + ParametricCRS &operator=(const ParametricCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class CompoundCRS; +/** Shared pointer of CompoundCRS */ +using CompoundCRSPtr = std::shared_ptr<CompoundCRS>; +/** Non-null shared pointer of CompoundCRS */ +using CompoundCRSNNPtr = util::nn<CompoundCRSPtr>; + +/** \brief A coordinate reference system describing the position of points + * through two or more independent single coordinate reference systems. + * + * \note Two coordinate reference systems are independent of each other + * if coordinate values in one cannot be converted or transformed into + * coordinate values in the other. + * + * \note As a departure to \ref ISO_19111_2018, we allow to build a CompoundCRS + * from CRS objects, whereas ISO19111:2018 restricts the components to + * SingleCRS. + * + * \remark Implements CompoundCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL CompoundCRS final : public CRS, + public io::IPROJStringExportable { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~CompoundCRS() override; + //! @endcond + + PROJ_DLL const std::vector<CRSNNPtr> & + componentReferenceSystems() PROJ_CONST_DECL; + + PROJ_DLL std::list<std::pair<CompoundCRSNNPtr, int>> + identify(const io::AuthorityFactoryPtr &authorityFactory) const; + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + PROJ_DLL static CompoundCRSNNPtr + create(const util::PropertyMap &properties, + const std::vector<CRSNNPtr> &components); + + protected: + // relaxed: standard say SingleCRSNNPtr + PROJ_INTERNAL explicit CompoundCRS(const std::vector<CRSNNPtr> &components); + PROJ_INTERNAL CompoundCRS(const CompoundCRS &other); + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + CompoundCRS &operator=(const CompoundCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +/** \brief A coordinate reference system with an associated transformation to + * a target/hub CRS. + * + * The definition of a CRS is not dependent upon any relationship to an + * independent CRS. However in an implementation that merges datasets + * referenced to differing CRSs, it is sometimes useful to associate the + * definition of the transformation that has been used with the CRS definition. + * This facilitates the interrelationship of CRS by concatenating + * transformations via a common or hub CRS. This is sometimes referred to as + * "early-binding". \ref WKT2 permits the association of an abridged coordinate + * transformation description with a coordinate reference system description in + * a single text string. In a BoundCRS, the abridged coordinate transformation + * is applied to the source CRS with the target CRS being the common or hub + * system. + * + * Coordinates referring to a BoundCRS are expressed into its source/base CRS. + * + * This abstraction can for example model the concept of TOWGS84 datum shift + * present in \ref WKT1. + * + * \note Contrary to other CRS classes of this package, there is no + * \ref ISO_19111_2018 modelling of a BoundCRS. + * + * \remark Implements BoundCRS from \ref WKT2 + */ +class PROJ_GCC_DLL BoundCRS final : public CRS, + public io::IPROJStringExportable { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~BoundCRS() override; + //! @endcond + + PROJ_DLL const CRSNNPtr &baseCRS() PROJ_CONST_DECL; + PROJ_DLL CRSNNPtr baseCRSWithCanonicalBoundCRS() const; + + PROJ_DLL const CRSNNPtr &hubCRS() PROJ_CONST_DECL; + PROJ_DLL const operation::TransformationNNPtr & + transformation() PROJ_CONST_DECL; + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + PROJ_DLL static BoundCRSNNPtr + create(const CRSNNPtr &baseCRSIn, const CRSNNPtr &hubCRSIn, + const operation::TransformationNNPtr &transformationIn); + + PROJ_DLL static BoundCRSNNPtr + createFromTOWGS84(const CRSNNPtr &baseCRSIn, + const std::vector<double> &TOWGS84Parameters); + + PROJ_DLL static BoundCRSNNPtr + createFromNadgrids(const CRSNNPtr &baseCRSIn, const std::string &filename); + + protected: + PROJ_INTERNAL + BoundCRS(const CRSNNPtr &baseCRSIn, const CRSNNPtr &hubCRSIn, + const operation::TransformationNNPtr &transformationIn); + PROJ_INTERNAL BoundCRS(const BoundCRS &other); + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + PROJ_INTERNAL BoundCRSNNPtr shallowCloneAsBoundCRS() const; + PROJ_INTERNAL bool isTOWGS84Compatible() const; + PROJ_INTERNAL std::string getHDatumPROJ4GRIDS() const; + PROJ_INTERNAL std::string getVDatumPROJ4GRIDS() const; + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + BoundCRS &operator=(const BoundCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class DerivedGeodeticCRS; +/** Shared pointer of DerivedGeodeticCRS */ +using DerivedGeodeticCRSPtr = std::shared_ptr<DerivedGeodeticCRS>; +/** Non-null shared pointer of DerivedGeodeticCRS */ +using DerivedGeodeticCRSNNPtr = util::nn<DerivedGeodeticCRSPtr>; + +/** \brief A derived coordinate reference system which has either a geodetic + * or a geographic coordinate reference system as its base CRS, thereby + * inheriting a geodetic reference frame, and associated with a 3D Cartesian + * or spherical coordinate system. + * + * \remark Implements DerivedGeodeticCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL DerivedGeodeticCRS final : public GeodeticCRS, + public DerivedCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~DerivedGeodeticCRS() override; + //! @endcond + + PROJ_DLL const GeodeticCRSNNPtr baseCRS() const; + + PROJ_DLL static DerivedGeodeticCRSNNPtr + create(const util::PropertyMap &properties, + const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::CartesianCSNNPtr &csIn); + + PROJ_DLL static DerivedGeodeticCRSNNPtr + create(const util::PropertyMap &properties, + const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::SphericalCSNNPtr &csIn); + + //! @cond Doxygen_Suppress + void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL + DerivedGeodeticCRS(const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::CartesianCSNNPtr &csIn); + PROJ_INTERNAL + DerivedGeodeticCRS(const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::SphericalCSNNPtr &csIn); + PROJ_INTERNAL DerivedGeodeticCRS(const DerivedGeodeticCRS &other); + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + DerivedGeodeticCRS &operator=(const DerivedGeodeticCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class DerivedGeographicCRS; +/** Shared pointer of DerivedGeographicCRS */ +using DerivedGeographicCRSPtr = std::shared_ptr<DerivedGeographicCRS>; +/** Non-null shared pointer of DerivedGeographicCRS */ +using DerivedGeographicCRSNNPtr = util::nn<DerivedGeographicCRSPtr>; + +/** \brief A derived coordinate reference system which has either a geodetic or + * a geographic coordinate reference system as its base CRS, thereby inheriting + * a geodetic reference frame, and an ellipsoidal coordinate system. + * + * A derived geographic CRS can be based on a geodetic CRS only if that + * geodetic CRS definition includes an ellipsoid. + * + * \remark Implements DerivedGeographicCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL DerivedGeographicCRS final : public GeographicCRS, + public DerivedCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~DerivedGeographicCRS() override; + //! @endcond + + PROJ_DLL const GeodeticCRSNNPtr baseCRS() const; + + PROJ_DLL static DerivedGeographicCRSNNPtr + create(const util::PropertyMap &properties, + const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::EllipsoidalCSNNPtr &csIn); + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL + DerivedGeographicCRS(const GeodeticCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::EllipsoidalCSNNPtr &csIn); + PROJ_INTERNAL DerivedGeographicCRS(const DerivedGeographicCRS &other); + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + DerivedGeographicCRS &operator=(const DerivedGeographicCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class DerivedProjectedCRS; +/** Shared pointer of DerivedProjectedCRS */ +using DerivedProjectedCRSPtr = std::shared_ptr<DerivedProjectedCRS>; +/** Non-null shared pointer of DerivedProjectedCRS */ +using DerivedProjectedCRSNNPtr = util::nn<DerivedProjectedCRSPtr>; + +/** \brief A derived coordinate reference system which has a projected + * coordinate reference system as its base CRS, thereby inheriting a geodetic + * reference frame, but also inheriting the distortion characteristics of the + * base projected CRS. + * + * A DerivedProjectedCRS is not a ProjectedCRS. + * + * \remark Implements DerivedProjectedCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL DerivedProjectedCRS final + : public DerivedCRS, + public io::IPROJStringExportable { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~DerivedProjectedCRS() override; + //! @endcond + + PROJ_DLL const ProjectedCRSNNPtr baseCRS() const; + + PROJ_DLL static DerivedProjectedCRSNNPtr + create(const util::PropertyMap &properties, + const ProjectedCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::CoordinateSystemNNPtr &csIn); + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL + DerivedProjectedCRS(const ProjectedCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::CoordinateSystemNNPtr &csIn); + PROJ_INTERNAL DerivedProjectedCRS(const DerivedProjectedCRS &other); + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + DerivedProjectedCRS &operator=(const DerivedProjectedCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +class DerivedVerticalCRS; +/** Shared pointer of DerivedVerticalCRS */ +using DerivedVerticalCRSPtr = std::shared_ptr<DerivedVerticalCRS>; +/** Non-null shared pointer of DerivedVerticalCRS */ +using DerivedVerticalCRSNNPtr = util::nn<DerivedVerticalCRSPtr>; + +/** \brief A derived coordinate reference system which has a vertical + * coordinate reference system as its base CRS, thereby inheriting a vertical + * reference frame, and a vertical coordinate system. + * + * \remark Implements DerivedVerticalCRS from \ref ISO_19111_2018 + */ +class PROJ_GCC_DLL DerivedVerticalCRS final : public VerticalCRS, + public DerivedCRS { + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~DerivedVerticalCRS() override; + //! @endcond + + PROJ_DLL const VerticalCRSNNPtr baseCRS() const; + + PROJ_DLL static DerivedVerticalCRSNNPtr + create(const util::PropertyMap &properties, + const VerticalCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::VerticalCSNNPtr &csIn); + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL + DerivedVerticalCRS(const VerticalCRSNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const cs::VerticalCSNNPtr &csIn); + PROJ_INTERNAL DerivedVerticalCRS(const DerivedVerticalCRS &other); + + PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter) + const override; // throw(FormattingException) + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + PROJ_INTERNAL std::list<std::pair<CRSNNPtr, int>> + _identify(const io::AuthorityFactoryPtr &authorityFactory) const override; + + INLINED_MAKE_SHARED + + private: + PROJ_OPAQUE_PRIVATE_DATA + DerivedVerticalCRS &operator=(const DerivedVerticalCRS &other) = delete; +}; + +// --------------------------------------------------------------------------- + +/** \brief Template representing a derived coordinate reference system. + */ +template <class DerivedCRSTraits> +class PROJ_GCC_DLL DerivedCRSTemplate final : public DerivedCRSTraits::BaseType, + public DerivedCRS { + protected: + /** Base type */ + typedef typename DerivedCRSTraits::BaseType BaseType; + /** CSType */ + typedef typename DerivedCRSTraits::CSType CSType; + + public: + //! @cond Doxygen_Suppress + PROJ_DLL ~DerivedCRSTemplate() override; + //! @endcond + + /** Non-null shared pointer of DerivedCRSTemplate */ + typedef typename util::nn<std::shared_ptr<DerivedCRSTemplate>> NNPtr; + /** Non-null shared pointer of BaseType */ + typedef util::nn<std::shared_ptr<BaseType>> BaseNNPtr; + /** Non-null shared pointer of CSType */ + typedef util::nn<std::shared_ptr<CSType>> CSNNPtr; + + /** \brief Return the base CRS of a DerivedCRSTemplate. + * + * @return the base CRS. + */ + PROJ_DLL const BaseNNPtr baseCRS() const; + + /** \brief Instanciate a DerivedCRSTemplate from a base CRS, a deriving + * conversion and a cs::CoordinateSystem. + * + * @param properties See \ref general_properties. + * At minimum the name should be defined. + * @param baseCRSIn base CRS. + * @param derivingConversionIn the deriving conversion from the base CRS to + * this + * CRS. + * @param csIn the coordinate system. + * @return new DerivedCRSTemplate. + */ + PROJ_DLL static NNPtr + create(const util::PropertyMap &properties, const BaseNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const CSNNPtr &csIn); + + //! @cond Doxygen_Suppress + PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter) + const override; // throw(io::FormattingException) + //! @endcond + + protected: + PROJ_INTERNAL + DerivedCRSTemplate(const BaseNNPtr &baseCRSIn, + const operation::ConversionNNPtr &derivingConversionIn, + const CSNNPtr &csIn); + PROJ_INTERNAL DerivedCRSTemplate(const DerivedCRSTemplate &other); + + PROJ_INTERNAL CRSNNPtr _shallowClone() const override; + + PROJ_INTERNAL bool + _isEquivalentTo(const util::IComparable *other, + util::IComparable::Criterion criterion = + util::IComparable::Criterion::STRICT) const override; + + INLINED_MAKE_SHARED + + private: + struct PROJ_INTERNAL Private; + std::unique_ptr<Private> d; + + DerivedCRSTemplate &operator=(const DerivedCRSTemplate &other) = delete; +}; + +// --------------------------------------------------------------------------- + +//! @cond Doxygen_Suppress +struct PROJ_GCC_DLL DerivedEngineeringCRSTraits { + typedef EngineeringCRS BaseType; + typedef cs::CoordinateSystem CSType; + // old x86_64-w64-mingw32-g++ has issues with static variables. use method + // instead + inline static const std::string &CRSName(); + inline static const std::string &WKTKeyword(); + inline static const std::string &WKTBaseKeyword(); + static const bool wkt2_2018_only = true; +}; +//! @endcond + +/** \brief A derived coordinate reference system which has an engineering + * coordinate reference system as its base CRS, thereby inheriting an + * engineering datum, and is associated with one of the coordinate system + * types for an EngineeringCRS + * + * \remark Implements DerivedEngineeringCRS from \ref ISO_19111_2018 + */ +#ifdef DOXYGEN_ENABLED +class DerivedEngineeringCRS + : public DerivedCRSTemplate<DerivedEngineeringCRSTraits> {}; +#else +using DerivedEngineeringCRS = DerivedCRSTemplate<DerivedEngineeringCRSTraits>; +#endif + +#ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE +extern template class DerivedCRSTemplate<DerivedEngineeringCRSTraits>; +#endif + +/** Shared pointer of DerivedEngineeringCRS */ +using DerivedEngineeringCRSPtr = std::shared_ptr<DerivedEngineeringCRS>; +/** Non-null shared pointer of DerivedEngineeringCRS */ +using DerivedEngineeringCRSNNPtr = util::nn<DerivedEngineeringCRSPtr>; + +// --------------------------------------------------------------------------- + +//! @cond Doxygen_Suppress +struct PROJ_GCC_DLL DerivedParametricCRSTraits { + typedef ParametricCRS BaseType; + typedef cs::ParametricCS CSType; + // old x86_64-w64-mingw32-g++ has issues with static variables. use method + // instead + inline static const std::string &CRSName(); + inline static const std::string &WKTKeyword(); + inline static const std::string &WKTBaseKeyword(); + static const bool wkt2_2018_only = false; +}; +//! @endcond + +/** \brief A derived coordinate reference system which has a parametric + * coordinate reference system as its base CRS, thereby inheriting a parametric + * datum, and a parametric coordinate system. + * + * \remark Implements DerivedParametricCRS from \ref ISO_19111_2018 + */ +#ifdef DOXYGEN_ENABLED +class DerivedParametricCRS + : public DerivedCRSTemplate<DerivedParametricCRSTraits> {}; +#else +using DerivedParametricCRS = DerivedCRSTemplate<DerivedParametricCRSTraits>; +#endif + +#ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE +extern template class DerivedCRSTemplate<DerivedParametricCRSTraits>; +#endif + +/** Shared pointer of DerivedParametricCRS */ +using DerivedParametricCRSPtr = std::shared_ptr<DerivedParametricCRS>; +/** Non-null shared pointer of DerivedParametricCRS */ +using DerivedParametricCRSNNPtr = util::nn<DerivedParametricCRSPtr>; + +// --------------------------------------------------------------------------- + +//! @cond Doxygen_Suppress +struct PROJ_GCC_DLL DerivedTemporalCRSTraits { + typedef TemporalCRS BaseType; + typedef cs::TemporalCS CSType; + // old x86_64-w64-mingw32-g++ has issues with static variables. use method + // instead + inline static const std::string &CRSName(); + inline static const std::string &WKTKeyword(); + inline static const std::string &WKTBaseKeyword(); + static const bool wkt2_2018_only = false; +}; +//! @endcond + +/** \brief A derived coordinate reference system which has a temporal + * coordinate reference system as its base CRS, thereby inheriting a temporal + * datum, and a temporal coordinate system. + * + * \remark Implements DerivedTemporalCRS from \ref ISO_19111_2018 + */ +#ifdef DOXYGEN_ENABLED +class DerivedTemporalCRS : public DerivedCRSTemplate<DerivedTemporalCRSTraits> { +}; +#else +using DerivedTemporalCRS = DerivedCRSTemplate<DerivedTemporalCRSTraits>; +#endif + +#ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE +extern template class DerivedCRSTemplate<DerivedTemporalCRSTraits>; +#endif + +/** Shared pointer of DerivedTemporalCRS */ +using DerivedTemporalCRSPtr = std::shared_ptr<DerivedTemporalCRS>; +/** Non-null shared pointer of DerivedTemporalCRS */ +using DerivedTemporalCRSNNPtr = util::nn<DerivedTemporalCRSPtr>; + +// --------------------------------------------------------------------------- + +} // namespace crs + +NS_PROJ_END + +#endif // CRS_HH_INCLUDED |