coordinatesystem.hpp

/******************************************************************************
 *
 * 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 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

namespace cs {

// ---------------------------------------------------------------------------

class AxisDirection : public util::CodeList {
  public:
    PROJ_DLL static const AxisDirection *
    valueOf(const std::string &nameIn) noexcept;

    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;
};

// ---------------------------------------------------------------------------

class Meridian;
using MeridianPtr = std::shared_ptr<Meridian>;
using MeridianNNPtr = util::nn<MeridianPtr>;

class Meridian : public common::IdentifiedObject, public io::IWKTExportable {
  public:
    PROJ_DLL ~Meridian() override;

    PROJ_DLL const common::Angle &longitude() PROJ_CONST_DECL;

    // non-standard
    PROJ_DLL static MeridianNNPtr create(const common::Angle &longitudeIn);

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

  protected:
#ifdef DOXYGEN_ENABLED
    Angle angle_;
#endif

    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;
using CoordinateSystemAxisPtr = std::shared_ptr<CoordinateSystemAxis>;
using CoordinateSystemAxisNNPtr = util::nn<CoordinateSystemAxisPtr>;

class CoordinateSystemAxis final : public common::IdentifiedObject,
                                   public io::IWKTExportable {
  public:
    PROJ_DLL ~CoordinateSystemAxis() override;

    PROJ_DLL const std::string &abbreviation() PROJ_CONST_DECL;
    PROJ_DLL const AxisDirection &direction() PROJ_CONST_DECL;
    PROJ_DLL const common::UnitOfMeasure &unit() PROJ_CONST_DECL;
    PROJ_DLL const util::optional<double> &minimumValue() PROJ_CONST_DECL;
    PROJ_DLL const util::optional<double> &maximumValue() PROJ_CONST_DECL;
    PROJ_DLL const MeridianPtr &meridian() PROJ_CONST_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 bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

    void _exportToWKT(io::WKTFormatter *formatter, int order,
                      bool disableAbbrev) const;

    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    static std::string normalizeAxisName(const std::string &str);

    static CoordinateSystemAxisNNPtr
    createLAT_NORTH(const common::UnitOfMeasure &unit);
    static CoordinateSystemAxisNNPtr
    createLONG_EAST(const common::UnitOfMeasure &unit);


  private:
    PROJ_OPAQUE_PRIVATE_DATA
    CoordinateSystemAxis(const CoordinateSystemAxis &other) = delete;
    CoordinateSystemAxis &operator=(const CoordinateSystemAxis &other) = delete;

    CoordinateSystemAxis();
    /* cppcheck-suppress unusedPrivateFunction */
    INLINED_MAKE_SHARED
};

// ---------------------------------------------------------------------------

class CoordinateSystem : public common::IdentifiedObject,
                         public io::IWKTExportable {
  public:
    PROJ_DLL ~CoordinateSystem() override;

    PROJ_DLL const std::vector<CoordinateSystemAxisNNPtr> &
    axisList() PROJ_CONST_DECL;


    void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_DLL virtual std::string getWKT2Type(bool) const = 0;

    PROJ_DLL bool
    isEquivalentTo(const util::IComparable *other,
                   util::IComparable::Criterion criterion =
                       util::IComparable::Criterion::STRICT) const override;

  protected:
    explicit CoordinateSystem(
        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    CoordinateSystem(const CoordinateSystem &other) = delete;
    CoordinateSystem &operator=(const CoordinateSystem &other) = delete;
};

using CoordinateSystemPtr = std::shared_ptr<CoordinateSystem>;
using CoordinateSystemNNPtr = util::nn<CoordinateSystemPtr>;

// ---------------------------------------------------------------------------

class SphericalCS;
using SphericalCSPtr = std::shared_ptr<SphericalCS>;
using SphericalCSNNPtr = util::nn<SphericalCSPtr>;

class SphericalCS final : public CoordinateSystem {
  public:
    PROJ_DLL ~SphericalCS() override;

    // non-standard

    PROJ_DLL static SphericalCSNNPtr
    create(const util::PropertyMap &properties,
           const CoordinateSystemAxisNNPtr &axis1,
           const CoordinateSystemAxisNNPtr &axis2,
           const CoordinateSystemAxisNNPtr &axis3);

  protected:
    explicit SphericalCS(const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool) const override { return "spherical"; }

  private:
    SphericalCS(const SphericalCS &other) = delete;
};

// ---------------------------------------------------------------------------

class EllipsoidalCS;
using EllipsoidalCSPtr = std::shared_ptr<EllipsoidalCS>;
using EllipsoidalCSNNPtr = util::nn<EllipsoidalCSPtr>;

class EllipsoidalCS final : public CoordinateSystem {
  public:
    PROJ_DLL ~EllipsoidalCS() override;

    // 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);

    enum class AxisOrder {
        LAT_NORTH_LONG_EAST,
        LAT_NORTH_LONG_EAST_HEIGHT_UP,
        LONG_EAST_LAT_NORTH,
        LONG_EAST_LAT_NORTH_HEIGHT_UP,
        OTHER
    };

    AxisOrder axisOrder() const;

  protected:
    explicit EllipsoidalCS(
        const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool) const override { return "ellipsoidal"; }

  protected:
    EllipsoidalCS(const EllipsoidalCS &other) = delete;
};

// ---------------------------------------------------------------------------

class VerticalCS;
using VerticalCSPtr = std::shared_ptr<VerticalCS>;
using VerticalCSNNPtr = util::nn<VerticalCSPtr>;

class VerticalCS final : public CoordinateSystem {
  public:
    PROJ_DLL ~VerticalCS() override;

    PROJ_DLL static VerticalCSNNPtr
    create(const util::PropertyMap &properties,
           const CoordinateSystemAxisNNPtr &axis);

    PROJ_DLL static VerticalCSNNPtr
    createGravityRelatedHeight(const common::UnitOfMeasure &unit);

  protected:
    explicit VerticalCS(const CoordinateSystemAxisNNPtr &axisIn);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool) const override { return "vertical"; }

  private:
    VerticalCS(const VerticalCS &other) = delete;
};

// ---------------------------------------------------------------------------

class CartesianCS;
using CartesianCSPtr = std::shared_ptr<CartesianCS>;
using CartesianCSNNPtr = util::nn<CartesianCSPtr>;

class CartesianCS final : public CoordinateSystem {
  public:
    PROJ_DLL ~CartesianCS() override;

    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
    createGeocentric(const common::UnitOfMeasure &unit);

  protected:
    explicit CartesianCS(const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool) const override {
        return "Cartesian"; // uppercase is intended
    }

  private:
    CartesianCS(const CartesianCS &other) = delete;
};

// ---------------------------------------------------------------------------

class OrdinalCS;
using OrdinalCSPtr = std::shared_ptr<OrdinalCS>;
using OrdinalCSNNPtr = util::nn<OrdinalCSPtr>;

class OrdinalCS final : public CoordinateSystem {
  public:
    PROJ_DLL ~OrdinalCS() override;

    PROJ_DLL static OrdinalCSNNPtr
    create(const util::PropertyMap &properties,
           const std::vector<CoordinateSystemAxisNNPtr> &axisIn);

  protected:
    explicit OrdinalCS(const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool) const override { return "ordinal"; }

  private:
    OrdinalCS(const OrdinalCS &other) = delete;
};

// ---------------------------------------------------------------------------

class ParametricCS;
using ParametricCSPtr = std::shared_ptr<ParametricCS>;
using ParametricCSNNPtr = util::nn<ParametricCSPtr>;

class ParametricCS final : public CoordinateSystem {
  public:
    PROJ_DLL ~ParametricCS() override;

    PROJ_DLL static ParametricCSNNPtr
    create(const util::PropertyMap &properties,
           const CoordinateSystemAxisNNPtr &axisIn);

  protected:
    explicit ParametricCS(const std::vector<CoordinateSystemAxisNNPtr> &axisIn);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool) const override { return "parametric"; }

  private:
    ParametricCS(const ParametricCS &other) = delete;
};

// ---------------------------------------------------------------------------

class TemporalCS;
using TemporalCSPtr = std::shared_ptr<TemporalCS>;
using TemporalCSNNPtr = util::nn<TemporalCSPtr>;

class TemporalCS : public CoordinateSystem {
  public:
    PROJ_DLL ~TemporalCS() override;

  protected:
    explicit TemporalCS(const CoordinateSystemAxisNNPtr &axis);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool use2018Keywords) const override = 0;

  private:
    TemporalCS(const TemporalCS &other) = delete;
};

// ---------------------------------------------------------------------------

class DateTimeTemporalCS;
using DateTimeTemporalCSPtr = std::shared_ptr<DateTimeTemporalCS>;
using DateTimeTemporalCSNNPtr = util::nn<DateTimeTemporalCSPtr>;

class DateTimeTemporalCS final : public TemporalCS {
  public:
    PROJ_DLL ~DateTimeTemporalCS() override;

    PROJ_DLL static DateTimeTemporalCSNNPtr
    create(const util::PropertyMap &properties,
           const CoordinateSystemAxisNNPtr &axis);

  protected:
    explicit DateTimeTemporalCS(const CoordinateSystemAxisNNPtr &axis);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool use2018Keywords) const override;

  private:
    DateTimeTemporalCS(const DateTimeTemporalCS &other) = delete;
};

// ---------------------------------------------------------------------------

class TemporalCountCS;
using TemporalCountCSPtr = std::shared_ptr<TemporalCountCS>;
using TemporalCountCSNNPtr = util::nn<TemporalCountCSPtr>;

class TemporalCountCS final : public TemporalCS {
  public:
    PROJ_DLL ~TemporalCountCS() override;

    PROJ_DLL static TemporalCountCSNNPtr
    create(const util::PropertyMap &properties,
           const CoordinateSystemAxisNNPtr &axis);

  protected:
    explicit TemporalCountCS(const CoordinateSystemAxisNNPtr &axis);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool use2018Keywords) const override;

  private:
    TemporalCountCS(const TemporalCountCS &other) = delete;
};

// ---------------------------------------------------------------------------

class TemporalMeasureCS;
using TemporalMeasureCSPtr = std::shared_ptr<TemporalMeasureCS>;
using TemporalMeasureCSNNPtr = util::nn<TemporalMeasureCSPtr>;

class TemporalMeasureCS final : public TemporalCS {
  public:
    PROJ_DLL ~TemporalMeasureCS() override;

    PROJ_DLL static TemporalMeasureCSNNPtr
    create(const util::PropertyMap &properties,
           const CoordinateSystemAxisNNPtr &axis);

  protected:
    explicit TemporalMeasureCS(const CoordinateSystemAxisNNPtr &axis);
    INLINED_MAKE_SHARED

    std::string getWKT2Type(bool use2018Keywords) const override;

  private:
    TemporalMeasureCS(const TemporalMeasureCS &other) = delete;
};

} // namespace cs

NS_PROJ_END

#endif //  CS_HH_INCLUDED