@crossbind/port-proj-win32 0.0.0-bootstrap.0 → 2.0.0-beta.63

package/dist/prebuilt/win32-arm64-mt-release/include/proj/coordinatesystem.hpp

@@ -0,0 +1,909 @@
+/******************************************************************************
+ *
+ * Project:  PROJ
+ * Purpose:  ISO19111:2019 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 CS_HH_INCLUDED
+#define CS_HH_INCLUDED
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "common.hpp"
+#include "io.hpp"
+#include "util.hpp"
+
+NS_PROJ_START
+
+/** osgeo.proj.cs namespace
+
+    \brief Coordinate systems and their axis.
+*/
+namespace cs {
+
+// ---------------------------------------------------------------------------
+
+/** \brief Exception that can be thrown when an invalid coordinate system is
+ * attempted to be constructed.
+ *
+ * @since 9.9
+ */
+class PROJ_GCC_DLL InvalidCoordinateSystem : public util::Exception {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_INTERNAL explicit InvalidCoordinateSystem(const char *message);
+    PROJ_INTERNAL explicit InvalidCoordinateSystem(const std::string &message);
+    PROJ_DLL InvalidCoordinateSystem(const InvalidCoordinateSystem &other);
+    PROJ_DLL ~InvalidCoordinateSystem() override;
+    //! @endcond
+};
+
+// ---------------------------------------------------------------------------
+
+/** \brief The direction of positive increase in the coordinate value for a
+ * coordinate system axis.
+ *
+ * \remark Implements AxisDirection from \ref ISO_19111_2019
+ */
+class AxisDirection : public util::CodeList {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL static const AxisDirection *
+    valueOf(const std::string &nameIn) noexcept;
+    //! @endcond
+
+    AxisDirection(const AxisDirection &) = delete;
+    AxisDirection &operator=(const AxisDirection &) = delete;
+    AxisDirection(AxisDirection &&) = delete;
+    AxisDirection &operator=(AxisDirection &&) = delete;
+
+    PROJ_DLL static const AxisDirection NORTH;
+    PROJ_DLL static const AxisDirection NORTH_NORTH_EAST;
+    PROJ_DLL static const AxisDirection NORTH_EAST;
+    PROJ_DLL static const AxisDirection EAST_NORTH_EAST;
+    PROJ_DLL static const AxisDirection EAST;
+    PROJ_DLL static const AxisDirection EAST_SOUTH_EAST;
+    PROJ_DLL static const AxisDirection SOUTH_EAST;
+    PROJ_DLL static const AxisDirection SOUTH_SOUTH_EAST;
+    PROJ_DLL static const AxisDirection SOUTH;
+    PROJ_DLL static const AxisDirection SOUTH_SOUTH_WEST;
+    PROJ_DLL static const AxisDirection SOUTH_WEST;
+    PROJ_DLL static const AxisDirection
+        WEST_SOUTH_WEST; // note: was forgotten in WKT2-2015
+    PROJ_DLL static const AxisDirection WEST;
+    PROJ_DLL static const AxisDirection WEST_NORTH_WEST;
+    PROJ_DLL static const AxisDirection NORTH_WEST;
+    PROJ_DLL static const AxisDirection NORTH_NORTH_WEST;
+    PROJ_DLL static const AxisDirection UP;
+    PROJ_DLL static const AxisDirection DOWN;
+    PROJ_DLL static const AxisDirection GEOCENTRIC_X;
+    PROJ_DLL static const AxisDirection GEOCENTRIC_Y;
+    PROJ_DLL static const AxisDirection GEOCENTRIC_Z;
+    PROJ_DLL static const AxisDirection COLUMN_POSITIVE;
+    PROJ_DLL static const AxisDirection COLUMN_NEGATIVE;
+    PROJ_DLL static const AxisDirection ROW_POSITIVE;
+    PROJ_DLL static const AxisDirection ROW_NEGATIVE;
+    PROJ_DLL static const AxisDirection DISPLAY_RIGHT;
+    PROJ_DLL static const AxisDirection DISPLAY_LEFT;
+    PROJ_DLL static const AxisDirection DISPLAY_UP;
+    PROJ_DLL static const AxisDirection DISPLAY_DOWN;
+    PROJ_DLL static const AxisDirection FORWARD;
+    PROJ_DLL static const AxisDirection AFT;
+    PROJ_DLL static const AxisDirection PORT;
+    PROJ_DLL static const AxisDirection STARBOARD;
+    PROJ_DLL static const AxisDirection CLOCKWISE;
+    PROJ_DLL static const AxisDirection COUNTER_CLOCKWISE;
+    PROJ_DLL static const AxisDirection TOWARDS;
+    PROJ_DLL static const AxisDirection AWAY_FROM;
+    PROJ_DLL static const AxisDirection FUTURE;
+    PROJ_DLL static const AxisDirection PAST;
+    PROJ_DLL static const AxisDirection UNSPECIFIED;
+
+  private:
+    explicit AxisDirection(const std::string &nameIn);
+
+    static std::map<std::string, const AxisDirection *> registry;
+};
+
+// ---------------------------------------------------------------------------
+
+/** \brief Meaning of the axis value range specified through minimumValue and
+ * maximumValue
+ *
+ * \remark Implements RangeMeaning from \ref ISO_19111_2019
+ * \since 9.2
+ */
+class RangeMeaning : public util::CodeList {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL static const RangeMeaning *
+    valueOf(const std::string &nameIn) noexcept;
+    //! @endcond
+
+    PROJ_DLL static const RangeMeaning EXACT;
+    PROJ_DLL static const RangeMeaning WRAPAROUND;
+
+  protected:
+    friend class util::optional<RangeMeaning>;
+    RangeMeaning();
+
+  private:
+    explicit RangeMeaning(const std::string &nameIn);
+
+    static std::map<std::string, const RangeMeaning *> registry;
+};
+
+// ---------------------------------------------------------------------------
+
+class Meridian;
+/** Shared pointer of Meridian. */
+using MeridianPtr = std::shared_ptr<Meridian>;
+/** Non-null shared pointer of Meridian. */
+using MeridianNNPtr = util::nn<MeridianPtr>;
+
+/** \brief The meridian that the axis follows from the pole, for a coordinate
+ * reference system centered on a pole.
+ *
+ * \note There is no modelling for this concept in \ref ISO_19111_2019
+ *
+ * \remark Implements MERIDIAN from \ref WKT2
+ */
+class PROJ_GCC_DLL Meridian : public common::IdentifiedObject,
+                              public io::IJSONExportable {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~Meridian() override;
+    //! @endcond
+
+    PROJ_DLL const common::Angle &longitude() PROJ_PURE_DECL;
+
+    // non-standard
+    PROJ_DLL static MeridianNNPtr create(const common::Angle &longitudeIn);
+
+    //! @cond Doxygen_Suppress
+    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
+        const override; // throw(io::FormattingException)
+
+    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
+        const override; // throw(FormattingException)
+                        //! @endcond
+
+  protected:
+#ifdef DOXYGEN_ENABLED
+    Angle angle_;
+#endif
+
+    PROJ_INTERNAL explicit Meridian(const common::Angle &longitudeIn);
+    INLINED_MAKE_SHARED
+
+  private:
+    PROJ_OPAQUE_PRIVATE_DATA
+    Meridian(const Meridian &other) = delete;
+    Meridian &operator=(const Meridian &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class CoordinateSystemAxis;
+/** Shared pointer of CoordinateSystemAxis. */
+using CoordinateSystemAxisPtr = std::shared_ptr<CoordinateSystemAxis>;
+/** Non-null shared pointer of CoordinateSystemAxis. */
+using CoordinateSystemAxisNNPtr = util::nn<CoordinateSystemAxisPtr>;
+
+/** \brief The definition of a coordinate system axis.
+ *
+ * \remark Implements CoordinateSystemAxis from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL CoordinateSystemAxis final : public common::IdentifiedObject,
+                                                public io::IJSONExportable {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~CoordinateSystemAxis() override;
+    //! @endcond
+
+    PROJ_DLL const std::string &abbreviation() PROJ_PURE_DECL;
+    PROJ_DLL const AxisDirection &direction() PROJ_PURE_DECL;
+    PROJ_DLL const common::UnitOfMeasure &unit() PROJ_PURE_DECL;
+    PROJ_DLL const util::optional<double> &minimumValue() PROJ_PURE_DECL;
+    PROJ_DLL const util::optional<double> &maximumValue() PROJ_PURE_DECL;
+    PROJ_DLL const util::optional<RangeMeaning> &rangeMeaning() PROJ_PURE_DECL;
+    PROJ_DLL const MeridianPtr &meridian() PROJ_PURE_DECL;
+
+    // Non-standard
+    PROJ_DLL static CoordinateSystemAxisNNPtr
+    create(const util::PropertyMap &properties,
+           const std::string &abbreviationIn, const AxisDirection &directionIn,
+           const common::UnitOfMeasure &unitIn,
+           const MeridianPtr &meridianIn = nullptr);
+
+    PROJ_DLL static CoordinateSystemAxisNNPtr
+    create(const util::PropertyMap &properties,
+           const std::string &abbreviationIn, const AxisDirection &directionIn,
+           const common::UnitOfMeasure &unitIn,
+           const util::optional<double> &minimumValueIn,
+           const util::optional<double> &maximumValueIn,
+           const util::optional<RangeMeaning> &rangeMeaningIn,
+           const MeridianPtr &meridianIn = nullptr);
+
+    PROJ_PRIVATE :
+
+        //! @cond Doxygen_Suppress
+        PROJ_INTERNAL bool
+        _isEquivalentTo(
+            const util::IComparable *other,
+            util::IComparable::Criterion criterion =
+                util::IComparable::Criterion::STRICT,
+            const io::DatabaseContextPtr &dbContext = nullptr) const override;
+
+    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter, int order,
+                                    bool disableAbbrev) const;
+
+    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
+        const override; // throw(io::FormattingException)
+
+    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
+        const override; // throw(FormattingException)
+
+    PROJ_INTERNAL static std::string normalizeAxisName(const std::string &str);
+
+    PROJ_INTERNAL static CoordinateSystemAxisNNPtr
+    createLAT_NORTH(const common::UnitOfMeasure &unit);
+    PROJ_INTERNAL static CoordinateSystemAxisNNPtr
+    createLONG_EAST(const common::UnitOfMeasure &unit);
+
+    PROJ_INTERNAL CoordinateSystemAxisNNPtr
+    alterUnit(const common::UnitOfMeasure &newUnit) const;
+
+    //! @endcond
+
+  private:
+    PROJ_OPAQUE_PRIVATE_DATA
+    CoordinateSystemAxis(const CoordinateSystemAxis &other) = delete;
+    CoordinateSystemAxis &operator=(const CoordinateSystemAxis &other) = delete;
+
+    PROJ_INTERNAL CoordinateSystemAxis();
+    /* cppcheck-suppress unusedPrivateFunction */
+    INLINED_MAKE_SHARED
+};
+
+// ---------------------------------------------------------------------------
+
+/** \brief Abstract class modelling a coordinate system (CS)
+ *
+ * A CS is the non-repeating sequence of coordinate system axes that spans a
+ * given coordinate space. A CS is derived from a set of mathematical rules for
+ * specifying how coordinates in a given space are to be assigned to points.
+ * The coordinate values in a coordinate tuple shall be recorded in the order
+ * in which the coordinate system axes associations are recorded.
+ *
+ * \remark Implements CoordinateSystem from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL CoordinateSystem : public common::IdentifiedObject,
+                                      public io::IJSONExportable {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~CoordinateSystem() override;
+    //! @endcond
+
+    PROJ_DLL const std::vector<CoordinateSystemAxisNNPtr> &
+    axisList() PROJ_PURE_DECL;
+
+    PROJ_PRIVATE :
+
+        //! @cond Doxygen_Suppress
+        PROJ_INTERNAL void
+        _exportToWKT(io::WKTFormatter *formatter)
+            const override; // throw(io::FormattingException)
+
+    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
+        const override; // throw(FormattingException)
+
+    PROJ_INTERNAL virtual std::string getWKT2Type(bool) const = 0;
+
+    PROJ_INTERNAL bool _isEquivalentTo(
+        const util::IComparable *other,
+        util::IComparable::Criterion criterion =
+            util::IComparable::Criterion::STRICT,
+        const io::DatabaseContextPtr &dbContext = nullptr) const override;
+    //! @endcond
+
+  protected:
+    PROJ_INTERNAL explicit CoordinateSystem(
+        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+
+  private:
+    PROJ_OPAQUE_PRIVATE_DATA
+    CoordinateSystem(const CoordinateSystem &other) = delete;
+    CoordinateSystem &operator=(const CoordinateSystem &other) = delete;
+};
+
+/** Shared pointer of CoordinateSystem. */
+using CoordinateSystemPtr = std::shared_ptr<CoordinateSystem>;
+/** Non-null shared pointer of CoordinateSystem. */
+using CoordinateSystemNNPtr = util::nn<CoordinateSystemPtr>;
+
+// ---------------------------------------------------------------------------
+
+class SphericalCS;
+/** Shared pointer of SphericalCS. */
+using SphericalCSPtr = std::shared_ptr<SphericalCS>;
+/** Non-null shared pointer of SphericalCS. */
+using SphericalCSNNPtr = util::nn<SphericalCSPtr>;
+
+/** \brief A three-dimensional coordinate system in Euclidean space with one
+ * distance measured from the origin and two angular coordinates.
+ *
+ * Not to be confused with an ellipsoidal coordinate system based on an
+ * ellipsoid "degenerated" into a sphere. A SphericalCS shall have three
+ * axis associations.
+ *
+ * \remark Implements SphericalCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL SphericalCS final : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~SphericalCS() override;
+    //! @endcond
+
+    // non-standard
+
+    PROJ_DLL static SphericalCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2,
+           const CoordinateSystemAxisNNPtr &axis3);
+
+    PROJ_DLL static SphericalCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2);
+
+    /** Value of getWKT2Type() */
+    static constexpr const char *WKT2_TYPE = "spherical";
+
+  protected:
+    PROJ_INTERNAL explicit SphericalCS(
+        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool) const override {
+        return WKT2_TYPE;
+    }
+
+  private:
+    SphericalCS(const SphericalCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class EllipsoidalCS;
+/** Shared pointer of EllipsoidalCS. */
+using EllipsoidalCSPtr = std::shared_ptr<EllipsoidalCS>;
+/** Non-null shared pointer of EllipsoidalCS. */
+using EllipsoidalCSNNPtr = util::nn<EllipsoidalCSPtr>;
+
+/** \brief A two- or three-dimensional coordinate system in which position is
+ * specified by geodetic latitude, geodetic longitude, and (in the
+ * three-dimensional case) ellipsoidal height.
+ *
+ * An EllipsoidalCS shall have two or three associations.
+ *
+ * \remark Implements EllipsoidalCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL EllipsoidalCS final : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~EllipsoidalCS() override;
+    //! @endcond
+
+    // non-standard
+    PROJ_DLL static EllipsoidalCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2);
+
+    PROJ_DLL static EllipsoidalCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2,
+           const CoordinateSystemAxisNNPtr &axis3);
+
+    PROJ_DLL static EllipsoidalCSNNPtr
+    createLatitudeLongitude(const common::UnitOfMeasure &unit);
+
+    PROJ_DLL static EllipsoidalCSNNPtr createLatitudeLongitudeEllipsoidalHeight(
+        const common::UnitOfMeasure &angularUnit,
+        const common::UnitOfMeasure &linearUnit);
+
+    PROJ_DLL static EllipsoidalCSNNPtr
+    createLongitudeLatitude(const common::UnitOfMeasure &unit);
+
+    PROJ_DLL static EllipsoidalCSNNPtr createLongitudeLatitudeEllipsoidalHeight(
+        const common::UnitOfMeasure &angularUnit,
+        const common::UnitOfMeasure &linearUnit);
+
+    /** Value of getWKT2Type() */
+    static constexpr const char *WKT2_TYPE = "ellipsoidal";
+
+    //! @cond Doxygen_Suppress
+
+    /** \brief Typical axis order. */
+    enum class AxisOrder {
+        /** Latitude(North), Longitude(East) */
+        LAT_NORTH_LONG_EAST,
+        /** Latitude(North), Longitude(East), Height(up) */
+        LAT_NORTH_LONG_EAST_HEIGHT_UP,
+        /** Longitude(East), Latitude(North) */
+        LONG_EAST_LAT_NORTH,
+        /** Longitude(East), Latitude(North), Height(up) */
+        LONG_EAST_LAT_NORTH_HEIGHT_UP,
+        /** Other axis order. */
+        OTHER
+    };
+
+    PROJ_INTERNAL AxisOrder axisOrder() const;
+
+    PROJ_INTERNAL EllipsoidalCSNNPtr
+    alterAngularUnit(const common::UnitOfMeasure &angularUnit) const;
+
+    PROJ_INTERNAL EllipsoidalCSNNPtr
+    alterLinearUnit(const common::UnitOfMeasure &linearUnit) const;
+
+    //! @endcond
+
+  protected:
+    PROJ_INTERNAL explicit EllipsoidalCS(
+        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool) const override {
+        return WKT2_TYPE;
+    }
+
+  protected:
+    EllipsoidalCS(const EllipsoidalCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class VerticalCS;
+/** Shared pointer of VerticalCS. */
+using VerticalCSPtr = std::shared_ptr<VerticalCS>;
+/** Non-null shared pointer of VerticalCS. */
+using VerticalCSNNPtr = util::nn<VerticalCSPtr>;
+
+/** \brief A one-dimensional coordinate system used to record the heights or
+ * depths of points.
+ *
+ * Such a coordinate system is usually dependent on the Earth's gravity field.
+ * A VerticalCS shall have one axis association.
+ *
+ * \remark Implements VerticalCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL VerticalCS final : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~VerticalCS() override;
+    //! @endcond
+
+    PROJ_DLL static VerticalCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis);
+
+    PROJ_DLL static VerticalCSNNPtr
+    createGravityRelatedHeight(const common::UnitOfMeasure &unit);
+
+    /** Value of getWKT2Type() */
+    static constexpr const char *WKT2_TYPE = "vertical";
+
+    PROJ_PRIVATE :
+        //! @cond Doxygen_Suppress
+        PROJ_INTERNAL VerticalCSNNPtr
+        alterUnit(const common::UnitOfMeasure &unit) const;
+
+    //! @endcond
+
+  protected:
+    PROJ_INTERNAL explicit VerticalCS(const CoordinateSystemAxisNNPtr &axisIn);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool) const override {
+        return WKT2_TYPE;
+    }
+
+  private:
+    VerticalCS(const VerticalCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class CartesianCS;
+/** Shared pointer of CartesianCS. */
+using CartesianCSPtr = std::shared_ptr<CartesianCS>;
+/** Non-null shared pointer of CartesianCS. */
+using CartesianCSNNPtr = util::nn<CartesianCSPtr>;
+
+/** \brief A two- or three-dimensional coordinate system in Euclidean space
+ * with orthogonal straight axes.
+ *
+ * All axes shall have the same length unit. A CartesianCS shall have two or
+ * three axis associations; the number of associations shall equal the
+ * dimension of the CS.
+ *
+ * \remark Implements CartesianCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL CartesianCS final : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~CartesianCS() override;
+    //! @endcond
+
+    PROJ_DLL static CartesianCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2, bool enforceSameUnit = true);
+    PROJ_DLL static CartesianCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2,
+           const CoordinateSystemAxisNNPtr &axis3, bool enforceSameUnit = true);
+
+    PROJ_DLL static CartesianCSNNPtr
+    createEastingNorthing(const common::UnitOfMeasure &unit);
+
+    PROJ_DLL static CartesianCSNNPtr
+    createNorthingEasting(const common::UnitOfMeasure &unit);
+
+    PROJ_DLL static CartesianCSNNPtr
+    createNorthPoleEastingSouthNorthingSouth(const common::UnitOfMeasure &unit);
+
+    PROJ_DLL static CartesianCSNNPtr
+    createSouthPoleEastingNorthNorthingNorth(const common::UnitOfMeasure &unit);
+
+    PROJ_DLL static CartesianCSNNPtr
+    createWestingSouthing(const common::UnitOfMeasure &unit);
+
+    PROJ_DLL static CartesianCSNNPtr
+    createGeocentric(const common::UnitOfMeasure &unit);
+
+    /** Value of getWKT2Type() */
+    static constexpr const char *WKT2_TYPE =
+        "Cartesian"; // uppercase is intended
+
+    PROJ_PRIVATE :
+        //! @cond Doxygen_Suppress
+        PROJ_INTERNAL CartesianCSNNPtr
+        alterUnit(const common::UnitOfMeasure &unit) const;
+
+    //! @endcond
+
+  protected:
+    PROJ_INTERNAL explicit CartesianCS(
+        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool) const override {
+        return WKT2_TYPE;
+    }
+
+  private:
+    CartesianCS(const CartesianCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class AffineCS;
+/** Shared pointer of AffineCS. */
+using AffineCSPtr = std::shared_ptr<AffineCS>;
+/** Non-null shared pointer of AffineCS. */
+using AffineCSNNPtr = util::nn<AffineCSPtr>;
+
+/** \brief A two- or three-dimensional coordinate system in Euclidean space
+ * with straight axes that are not necessarily orthogonal.
+ *
+ * \remark Implements AffineCS from \ref ISO_19111_2019
+ * \since 9.2
+ */
+class PROJ_GCC_DLL AffineCS final : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~AffineCS() override;
+    //! @endcond
+
+    /** Value of getWKT2Type() */
+    static constexpr const char *WKT2_TYPE = "affine";
+
+    PROJ_DLL static AffineCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2);
+    PROJ_DLL static AffineCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis1,
+           const CoordinateSystemAxisNNPtr &axis2,
+           const CoordinateSystemAxisNNPtr &axis3);
+
+    PROJ_PRIVATE :
+        //! @cond Doxygen_Suppress
+        PROJ_INTERNAL AffineCSNNPtr
+        alterUnit(const common::UnitOfMeasure &unit) const;
+
+    //! @endcond
+
+  protected:
+    PROJ_INTERNAL explicit AffineCS(
+        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool) const override {
+        return WKT2_TYPE;
+    }
+
+  private:
+    AffineCS(const AffineCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class OrdinalCS;
+/** Shared pointer of OrdinalCS. */
+using OrdinalCSPtr = std::shared_ptr<OrdinalCS>;
+/** Non-null shared pointer of OrdinalCS. */
+using OrdinalCSNNPtr = util::nn<OrdinalCSPtr>;
+
+/** \brief n-dimensional coordinate system in which every axis uses integers.
+ *
+ * The number of associations shall equal the
+ * dimension of the CS.
+ *
+ * \remark Implements OrdinalCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL OrdinalCS final : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~OrdinalCS() override;
+    //! @endcond
+
+    PROJ_DLL static OrdinalCSNNPtr
+    create(const util::PropertyMap &properties,
+           const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+
+    /** Value of getWKT2Type() */
+    static constexpr const char *WKT2_TYPE = "ordinal";
+
+  protected:
+    PROJ_INTERNAL explicit OrdinalCS(
+        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool) const override {
+        return WKT2_TYPE;
+    }
+
+  private:
+    OrdinalCS(const OrdinalCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class ParametricCS;
+/** Shared pointer of ParametricCS. */
+using ParametricCSPtr = std::shared_ptr<ParametricCS>;
+/** Non-null shared pointer of ParametricCS. */
+using ParametricCSNNPtr = util::nn<ParametricCSPtr>;
+
+/** \brief one-dimensional coordinate reference system which uses parameter
+ * values or functions that may vary monotonically with height.
+ *
+ * \remark Implements ParametricCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL ParametricCS final : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~ParametricCS() override;
+    //! @endcond
+
+    PROJ_DLL static ParametricCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axisIn);
+
+    /** Value of getWKT2Type() */
+    static constexpr const char *WKT2_TYPE = "parametric";
+
+  protected:
+    PROJ_INTERNAL explicit ParametricCS(
+        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool) const override {
+        return WKT2_TYPE;
+    }
+
+  private:
+    ParametricCS(const ParametricCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class TemporalCS;
+/** Shared pointer of TemporalCS. */
+using TemporalCSPtr = std::shared_ptr<TemporalCS>;
+/** Non-null shared pointer of TemporalCS. */
+using TemporalCSNNPtr = util::nn<TemporalCSPtr>;
+
+/** \brief (Abstract class) A one-dimensional coordinate system used to record
+ * time.
+ *
+ * A TemporalCS shall have one axis association.
+ *
+ * \remark Implements TemporalCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL TemporalCS : public CoordinateSystem {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~TemporalCS() override;
+    //! @endcond
+
+    /** WKT2:2015 type */
+    static constexpr const char *WKT2_2015_TYPE = "temporal";
+
+  protected:
+    PROJ_INTERNAL explicit TemporalCS(const CoordinateSystemAxisNNPtr &axis);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string
+    getWKT2Type(bool use2019Keywords) const override = 0;
+
+  private:
+    TemporalCS(const TemporalCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class DateTimeTemporalCS;
+/** Shared pointer of DateTimeTemporalCS. */
+using DateTimeTemporalCSPtr = std::shared_ptr<DateTimeTemporalCS>;
+/** Non-null shared pointer of DateTimeTemporalCS. */
+using DateTimeTemporalCSNNPtr = util::nn<DateTimeTemporalCSPtr>;
+
+/** \brief A one-dimensional coordinate system used to record time in dateTime
+ * representation as defined in ISO 8601.
+ *
+ * A DateTimeTemporalCS shall have one axis association. It does not use
+ * axisUnitID; the temporal quantities are defined through the ISO 8601
+ * representation.
+ *
+ * \remark Implements DateTimeTemporalCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL DateTimeTemporalCS final : public TemporalCS {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~DateTimeTemporalCS() override;
+    //! @endcond
+
+    PROJ_DLL static DateTimeTemporalCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis);
+
+    /** WKT2:2019 type */
+    static constexpr const char *WKT2_2019_TYPE = "TemporalDateTime";
+
+  protected:
+    PROJ_INTERNAL explicit DateTimeTemporalCS(
+        const CoordinateSystemAxisNNPtr &axis);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool use2019Keywords) const override;
+
+  private:
+    DateTimeTemporalCS(const DateTimeTemporalCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class TemporalCountCS;
+/** Shared pointer of TemporalCountCS. */
+using TemporalCountCSPtr = std::shared_ptr<TemporalCountCS>;
+/** Non-null shared pointer of TemporalCountCS. */
+using TemporalCountCSNNPtr = util::nn<TemporalCountCSPtr>;
+
+/** \brief A one-dimensional coordinate system used to record time as an
+ * integer count.
+ *
+ * A TemporalCountCS shall have one axis association.
+ *
+ * \remark Implements TemporalCountCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL TemporalCountCS final : public TemporalCS {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~TemporalCountCS() override;
+    //! @endcond
+
+    PROJ_DLL static TemporalCountCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis);
+
+    /** WKT2:2019 type */
+    static constexpr const char *WKT2_2019_TYPE = "TemporalCount";
+
+  protected:
+    PROJ_INTERNAL explicit TemporalCountCS(
+        const CoordinateSystemAxisNNPtr &axis);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool use2019Keywords) const override;
+
+  private:
+    TemporalCountCS(const TemporalCountCS &other) = delete;
+};
+
+// ---------------------------------------------------------------------------
+
+class TemporalMeasureCS;
+/** Shared pointer of TemporalMeasureCS. */
+using TemporalMeasureCSPtr = std::shared_ptr<TemporalMeasureCS>;
+/** Non-null shared pointer of TemporalMeasureCS. */
+using TemporalMeasureCSNNPtr = util::nn<TemporalMeasureCSPtr>;
+
+/** \brief A one-dimensional coordinate system used to record a time as a
+ * real number.
+ *
+ * A TemporalMeasureCS shall have one axis association.
+ *
+ * \remark Implements TemporalMeasureCS from \ref ISO_19111_2019
+ */
+class PROJ_GCC_DLL TemporalMeasureCS final : public TemporalCS {
+  public:
+    //! @cond Doxygen_Suppress
+    PROJ_DLL ~TemporalMeasureCS() override;
+    //! @endcond
+
+    PROJ_DLL static TemporalMeasureCSNNPtr
+    create(const util::PropertyMap &properties,
+           const CoordinateSystemAxisNNPtr &axis);
+
+    /** WKT2:2019 type */
+    static constexpr const char *WKT2_2019_TYPE = "TemporalMeasure";
+
+  protected:
+    PROJ_INTERNAL explicit TemporalMeasureCS(
+        const CoordinateSystemAxisNNPtr &axis);
+    INLINED_MAKE_SHARED
+
+    PROJ_INTERNAL std::string getWKT2Type(bool use2019Keywords) const override;
+
+  private:
+    TemporalMeasureCS(const TemporalMeasureCS &other) = delete;
+};
+
+} // namespace cs
+
+NS_PROJ_END
+
+#endif //  CS_HH_INCLUDED