893 lines
30 KiB
C++
893 lines
30 KiB
C++
/******************************************************************************
|
|
*
|
|
* 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 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);
|
|
PROJ_DLL static CartesianCSNNPtr
|
|
create(const util::PropertyMap &properties,
|
|
const CoordinateSystemAxisNNPtr &axis1,
|
|
const CoordinateSystemAxisNNPtr &axis2,
|
|
const CoordinateSystemAxisNNPtr &axis3);
|
|
|
|
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
|