PROJ C++ API
datum.hpp
1 /******************************************************************************
2  *
3  * Project: PROJ
4  * Purpose: ISO19111:2018 implementation
5  * Author: Even Rouault <even dot rouault at spatialys dot com>
6  *
7  ******************************************************************************
8  * Copyright (c) 2018, Even Rouault <even dot rouault at spatialys dot com>
9  *
10  * Permission is hereby granted, free of charge, to any person obtaining a
11  * copy of this software and associated documentation files (the "Software"),
12  * to deal in the Software without restriction, including without limitation
13  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
14  * and/or sell copies of the Software, and to permit persons to whom the
15  * Software is furnished to do so, subject to the following conditions:
16  *
17  * The above copyright notice and this permission notice shall be included
18  * in all copies or substantial portions of the Software.
19  *
20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
25  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26  * DEALINGS IN THE SOFTWARE.
27  ****************************************************************************/
28 
29 #ifndef DATUM_HH_INCLUDED
30 #define DATUM_HH_INCLUDED
31 
32 #include <memory>
33 #include <string>
34 #include <vector>
35 
36 #include "common.hpp"
37 #include "io.hpp"
38 #include "util.hpp"
39 
40 NS_PROJ_START
41 
46 namespace datum {
47 
48 // ---------------------------------------------------------------------------
49 
64 class Datum : public common::ObjectUsage {
65  public:
67  PROJ_DLL ~Datum() override;
69 
70  PROJ_DLL const util::optional<std::string> &anchorDefinition() const;
71  PROJ_DLL const util::optional<common::DateTime> &publicationDate() const;
72  PROJ_DLL const common::IdentifiedObjectPtr &conventionalRS() const;
73 
74  protected:
75  Datum();
76 
77  bool _isEquivalentTo(const util::IComparable *other,
79  util::IComparable::Criterion::STRICT) const;
80 
81 #ifdef DOXYGEN_ENABLED
82  std::string *anchorDefinition_;
83  Date *publicationDate_;
84  common::IdentifiedObject *conventionalRS_;
85 #endif
86 
87  protected:
88  void setAnchor(const util::optional<std::string> &anchor);
89 
90  private:
91  PROJ_OPAQUE_PRIVATE_DATA
92  Datum &operator=(const Datum &other) = delete;
93  Datum(const Datum &other) = delete;
94 };
95 
97 using DatumPtr = std::shared_ptr<Datum>;
99 using DatumNNPtr = util::nn<DatumPtr>;
100 
101 // ---------------------------------------------------------------------------
102 
103 class DatumEnsemble;
105 using DatumEnsemblePtr = std::shared_ptr<DatumEnsemble>;
107 using DatumEnsembleNNPtr = util::nn<DatumEnsemblePtr>;
108 
120  public io::IWKTExportable {
121  public:
123  PROJ_DLL ~DatumEnsemble() override;
125 
126  PROJ_DLL const std::vector<DatumNNPtr> &datums() const;
127  PROJ_DLL const metadata::PositionalAccuracyNNPtr &
128  positionalAccuracy() const;
129 
130  PROJ_DLL static DatumEnsembleNNPtr create(
131  const util::PropertyMap &properties,
132  const std::vector<DatumNNPtr> &datumsIn,
133  const metadata::PositionalAccuracyNNPtr &accuracy); // throw(Exception)
134 
136  void _exportToWKT(io::WKTFormatter *formatter)
137  const override; // throw(io::FormattingException)
139 
140  protected:
141 #ifdef DOXYGEN_ENABLED
142  Datum datums_[];
143  PositionalAccuracy positionalAccuracy_;
144 #endif
145 
146  DatumEnsemble(const std::vector<DatumNNPtr> &datumsIn,
147  const metadata::PositionalAccuracyNNPtr &accuracy);
148  INLINED_MAKE_SHARED
149 
150  private:
151  PROJ_OPAQUE_PRIVATE_DATA
152 
153  DatumEnsemble(const DatumEnsemble &other) = delete;
154  DatumEnsemble &operator=(const DatumEnsemble &other) = delete;
155 };
156 
157 // ---------------------------------------------------------------------------
158 
159 class PrimeMeridian;
161 using PrimeMeridianPtr = std::shared_ptr<PrimeMeridian>;
163 using PrimeMeridianNNPtr = util::nn<PrimeMeridianPtr>;
164 
173  public io::IWKTExportable,
175  public:
177  PROJ_DLL ~PrimeMeridian() override;
179 
180  PROJ_DLL const common::Angle &longitude() PROJ_CONST_DECL;
181 
182  // non-standard
183  PROJ_DLL static PrimeMeridianNNPtr
184  create(const util::PropertyMap &properties,
185  const common::Angle &longitudeIn);
186 
187  PROJ_DLL static const PrimeMeridianNNPtr GREENWICH;
188  PROJ_DLL static const PrimeMeridianNNPtr PARIS;
189 
191  void _exportToWKT(io::WKTFormatter *formatter)
192  const override; // throw(io::FormattingException)
194 
195  PROJ_DLL bool
196  isEquivalentTo(const util::IComparable *other,
197  util::IComparable::Criterion criterion =
198  util::IComparable::Criterion::STRICT) const override;
199 
200  PROJ_PRIVATE :
201 
202  void
203  _exportToPROJString(io::PROJStringFormatter *formatter)
204  const override; // throw(FormattingException)
205 
207  static std::string getPROJStringWellKnownName(const common::Angle &angle);
209 
210  protected:
211 #ifdef DOXYGEN_ENABLED
212  Angle greenwichLongitude_;
213 #endif
214 
215  explicit PrimeMeridian(const common::Angle &angle = common::Angle());
216  INLINED_MAKE_SHARED
217 
218  private:
219  PROJ_OPAQUE_PRIVATE_DATA
220  PrimeMeridian(const PrimeMeridian &other) = delete;
221  PrimeMeridian &operator=(const PrimeMeridian &other) = delete;
222 
223  static const PrimeMeridianNNPtr createGREENWICH();
224  static const PrimeMeridianNNPtr createPARIS();
225 };
226 
227 // ---------------------------------------------------------------------------
228 
229 class Ellipsoid;
231 using EllipsoidPtr = std::shared_ptr<Ellipsoid>;
233 using EllipsoidNNPtr = util::nn<EllipsoidPtr>;
234 
243 class Ellipsoid final : public common::IdentifiedObject,
244  public io::IWKTExportable,
246  public:
248  PROJ_DLL ~Ellipsoid() override;
250 
251  PROJ_DLL const common::Length &semiMajorAxis() PROJ_CONST_DECL;
252 
253  // Inlined from SecondDefiningParameter union
254  PROJ_DLL const util::optional<common::Scale> &
255  inverseFlattening() PROJ_CONST_DECL;
256  PROJ_DLL const util::optional<common::Length> &
257  semiMinorAxis() PROJ_CONST_DECL;
258  PROJ_DLL bool isSphere() PROJ_CONST_DECL;
259 
260  PROJ_DLL const util::optional<common::Length> &
261  semiMedianAxis() PROJ_CONST_DECL;
262 
263  // non-standard
264 
265  PROJ_DLL common::Scale computeInverseFlattening() const;
266  PROJ_DLL common::Length computeSemiMinorAxis() const;
267 
268  PROJ_DLL const std::string &celestialBody() PROJ_CONST_DECL;
269 
270  PROJ_DLL static const std::string EARTH;
271 
272  PROJ_DLL static EllipsoidNNPtr
273  createSphere(const util::PropertyMap &properties,
274  const common::Length &radius,
275  const std::string &celestialBody = EARTH);
276 
277  PROJ_DLL static EllipsoidNNPtr
278  createFlattenedSphere(const util::PropertyMap &properties,
279  const common::Length &semiMajorAxisIn,
280  const common::Scale &invFlattening,
281  const std::string &celestialBody = EARTH);
282 
283  PROJ_DLL static EllipsoidNNPtr
284  createTwoAxis(const util::PropertyMap &properties,
285  const common::Length &semiMajorAxisIn,
286  const common::Length &semiMinorAxisIn,
287  const std::string &celestialBody = EARTH);
288 
289  PROJ_DLL EllipsoidNNPtr identify() const;
290 
291  PROJ_DLL static const EllipsoidNNPtr CLARKE_1866;
292  PROJ_DLL static const EllipsoidNNPtr WGS84;
293  PROJ_DLL static const EllipsoidNNPtr GRS1980;
294 
296  void _exportToWKT(io::WKTFormatter *formatter)
297  const override; // throw(io::FormattingException)
299 
300  PROJ_DLL bool
301  isEquivalentTo(const util::IComparable *other,
302  util::IComparable::Criterion criterion =
303  util::IComparable::Criterion::STRICT) const override;
304 
305  PROJ_PRIVATE : void _exportToPROJString(io::PROJStringFormatter *formatter)
306  const override; // throw(FormattingException)
307 
308  protected:
309 #ifdef DOXYGEN_ENABLED
310  common::Length semiMajorAxis_;
311  common::Scale *inverseFlattening_;
312  common::Length *semiMinorAxis_;
313  bool isSphere_;
314  common::Length *semiMedianAxis_;
315 #endif
316 
317  explicit Ellipsoid(const common::Length &radius,
318  const std::string &celestialBody);
319 
320  Ellipsoid(const common::Length &semiMajorAxisIn,
321  const common::Scale &invFlattening,
322  const std::string &celestialBody);
323 
324  Ellipsoid(const common::Length &semiMajorAxisIn,
325  const common::Length &semiMinorAxisIn,
326  const std::string &celestialBody);
327 
328  Ellipsoid(const Ellipsoid &other);
329 
330  INLINED_MAKE_SHARED
331 
332  static const EllipsoidNNPtr createCLARKE_1866();
333  static const EllipsoidNNPtr createWGS84();
334  static const EllipsoidNNPtr createGRS1980();
335 
336  private:
337  PROJ_OPAQUE_PRIVATE_DATA
338  Ellipsoid &operator=(const Ellipsoid &other) = delete;
339 
340  bool lookForProjWellKnownEllps(std::string &projEllpsName,
341  std::string &ellpsName) const;
342 };
343 
344 // ---------------------------------------------------------------------------
345 
348 using GeodeticReferenceFramePtr = std::shared_ptr<GeodeticReferenceFrame>;
350 using GeodeticReferenceFrameNNPtr = util::nn<GeodeticReferenceFramePtr>;
351 
368  public:
370  PROJ_DLL ~GeodeticReferenceFrame() override;
372 
373  PROJ_DLL const PrimeMeridianNNPtr &primeMeridian() PROJ_CONST_DECL;
374 
375  // We constraint more than the standard into which the ellipsoid might
376  // be omitted for a CRS with a non-ellipsoidal CS
377  PROJ_DLL const EllipsoidNNPtr &ellipsoid() PROJ_CONST_DECL;
378 
379  // non-standard
380  PROJ_DLL static GeodeticReferenceFrameNNPtr
381  create(const util::PropertyMap &properties, const EllipsoidNNPtr &ellipsoid,
382  const util::optional<std::string> &anchor,
383  const PrimeMeridianNNPtr &primeMeridian);
384 
385  PROJ_DLL static const GeodeticReferenceFrameNNPtr
386  EPSG_6267; // North American Datum 1927
387  PROJ_DLL static const GeodeticReferenceFrameNNPtr
388  EPSG_6269; // North American Datum 1983
389  PROJ_DLL static const GeodeticReferenceFrameNNPtr EPSG_6326; // WGS 84
390 
392  void _exportToWKT(io::WKTFormatter *formatter)
393  const override; // throw(io::FormattingException)
395 
396  PROJ_DLL bool
397  isEquivalentTo(const util::IComparable *other,
398  util::IComparable::Criterion criterion =
399  util::IComparable::Criterion::STRICT) const override;
400 
401  protected:
402 #ifdef DOXYGEN_ENABLED
403  PrimeMeridian primeMeridian_;
404  Ellipsoid *ellipsoid_;
405 #endif
406 
407  GeodeticReferenceFrame(const EllipsoidNNPtr &ellipsoidIn,
408  const PrimeMeridianNNPtr &primeMeridianIn);
409  INLINED_MAKE_SHARED
410 
411  static const GeodeticReferenceFrameNNPtr createEPSG_6267();
412  static const GeodeticReferenceFrameNNPtr createEPSG_6269();
413  static const GeodeticReferenceFrameNNPtr createEPSG_6326();
414 
415  private:
416  PROJ_OPAQUE_PRIVATE_DATA
417  GeodeticReferenceFrame(const GeodeticReferenceFrame &other) = delete;
419  operator=(const GeodeticReferenceFrame &other) = delete;
420 };
421 
422 // ---------------------------------------------------------------------------
423 
427  std::shared_ptr<DynamicGeodeticReferenceFrame>;
430  util::nn<DynamicGeodeticReferenceFramePtr>;
431 
441  public:
443  PROJ_DLL ~DynamicGeodeticReferenceFrame() override;
445 
446  PROJ_DLL const common::Measure &frameReferenceEpoch() const;
447  PROJ_DLL const util::optional<std::string> &deformationModelName() const;
448 
449  // non-standard
450  PROJ_DLL static DynamicGeodeticReferenceFrameNNPtr
451  create(const util::PropertyMap &properties, const EllipsoidNNPtr &ellipsoid,
452  const util::optional<std::string> &anchor,
453  const PrimeMeridianNNPtr &primeMeridian,
454  const common::Measure &frameReferenceEpochIn,
455  const util::optional<std::string> &deformationModelNameIn);
456 
457  PROJ_DLL bool
458  isEquivalentTo(const util::IComparable *other,
459  util::IComparable::Criterion criterion =
460  util::IComparable::Criterion::STRICT) const override;
461 
463  void _exportToWKT(io::WKTFormatter *formatter)
464  const override; // throw(io::FormattingException)
466 
467  protected:
468 #ifdef DOXYGEN_ENABLED
469  Measure frameReferenceEpoch_;
470 #endif
471 
473  const EllipsoidNNPtr &ellipsoidIn,
474  const PrimeMeridianNNPtr &primeMeridianIn,
475  const common::Measure &frameReferenceEpochIn,
476  const util::optional<std::string> &deformationModelNameIn);
477  INLINED_MAKE_SHARED
478 
479  private:
480  PROJ_OPAQUE_PRIVATE_DATA
482  delete;
484  operator=(const DynamicGeodeticReferenceFrame &other) = delete;
485 };
486 
487 // ---------------------------------------------------------------------------
488 
495  public:
496  PROJ_DLL static const RealizationMethod LEVELLING;
497  PROJ_DLL static const RealizationMethod GEOID;
498  PROJ_DLL static const RealizationMethod TIDAL;
499 
500  private:
501  PROJ_FRIEND_OPTIONAL(RealizationMethod);
502  PROJ_DLL explicit RealizationMethod(
503  const std::string &nameIn = std::string());
504  PROJ_DLL RealizationMethod(const RealizationMethod &other);
505  PROJ_DLL RealizationMethod &operator=(const RealizationMethod &other);
506 };
507 
508 // ---------------------------------------------------------------------------
509 
512 using VerticalReferenceFramePtr = std::shared_ptr<VerticalReferenceFrame>;
514 using VerticalReferenceFrameNNPtr = util::nn<VerticalReferenceFramePtr>;
515 
525  public:
527  PROJ_DLL ~VerticalReferenceFrame() override;
529 
530  PROJ_DLL const util::optional<RealizationMethod> &realizationMethod() const;
531 
533  void _exportToWKT(io::WKTFormatter *formatter)
534  const override; // throw(io::FormattingException)
536 
537  // non-standard
538  PROJ_DLL static VerticalReferenceFrameNNPtr
539  create(const util::PropertyMap &properties,
540  const util::optional<std::string> &anchor =
542  const util::optional<RealizationMethod> &realizationMethodIn =
544 
545  PROJ_DLL bool
546  isEquivalentTo(const util::IComparable *other,
547  util::IComparable::Criterion criterion =
548  util::IComparable::Criterion::STRICT) const override;
549 
550  protected:
551 #ifdef DOXYGEN_ENABLED
552  RealizationMethod realizationMethod_;
553 #endif
554 
555  explicit VerticalReferenceFrame(
556  const util::optional<RealizationMethod> &realizationMethodIn);
557  INLINED_MAKE_SHARED
558 
559  private:
560  PROJ_OPAQUE_PRIVATE_DATA
561 };
562 
563 // ---------------------------------------------------------------------------
564 
568  std::shared_ptr<DynamicVerticalReferenceFrame>;
571  util::nn<DynamicVerticalReferenceFramePtr>;
572 
582  public:
584  PROJ_DLL ~DynamicVerticalReferenceFrame() override;
586 
587  PROJ_DLL const common::Measure &frameReferenceEpoch() const;
588  PROJ_DLL const util::optional<std::string> &deformationModelName() const;
589 
590  // non-standard
591  PROJ_DLL static DynamicVerticalReferenceFrameNNPtr
592  create(const util::PropertyMap &properties,
593  const util::optional<std::string> &anchor,
594  const util::optional<RealizationMethod> &realizationMethodIn,
595  const common::Measure &frameReferenceEpochIn,
596  const util::optional<std::string> &deformationModelNameIn);
597 
598  PROJ_DLL bool
599  isEquivalentTo(const util::IComparable *other,
600  util::IComparable::Criterion criterion =
601  util::IComparable::Criterion::STRICT) const override;
602 
604  void _exportToWKT(io::WKTFormatter *formatter)
605  const override; // throw(io::FormattingException)
607 
608  protected:
609 #ifdef DOXYGEN_ENABLED
610  Measure frameReferenceEpoch_;
611 #endif
612 
614  const util::optional<RealizationMethod> &realizationMethodIn,
615  const common::Measure &frameReferenceEpochIn,
616  const util::optional<std::string> &deformationModelNameIn);
617  INLINED_MAKE_SHARED
618 
619  private:
620  PROJ_OPAQUE_PRIVATE_DATA
622  delete;
624  operator=(const DynamicVerticalReferenceFrame &other) = delete;
625 };
626 
627 // ---------------------------------------------------------------------------
628 
629 class TemporalDatum;
631 using TemporalDatumPtr = std::shared_ptr<TemporalDatum>;
633 using TemporalDatumNNPtr = util::nn<TemporalDatumPtr>;
634 
640 class TemporalDatum final : public Datum, public io::IWKTExportable {
641  public:
643  PROJ_DLL ~TemporalDatum() override;
645 
646  PROJ_DLL const common::DateTime &temporalOrigin() const;
647  PROJ_DLL const std::string &calendar() const;
648 
650  void _exportToWKT(io::WKTFormatter *formatter)
651  const override; // throw(io::FormattingException)
653 
654  PROJ_DLL static const std::string CALENDAR_PROLEPTIC_GREGORIAN;
655 
656  // non-standard
657  PROJ_DLL static TemporalDatumNNPtr
658  create(const util::PropertyMap &properties,
659  const common::DateTime &temporalOriginIn,
660  const std::string &calendarIn);
661 
662  PROJ_DLL bool
663  isEquivalentTo(const util::IComparable *other,
664  util::IComparable::Criterion criterion =
665  util::IComparable::Criterion::STRICT) const override;
666 
667  protected:
668  TemporalDatum(const common::DateTime &temporalOriginIn,
669  const std::string &calendarIn);
670  INLINED_MAKE_SHARED
671 
672  private:
673  PROJ_OPAQUE_PRIVATE_DATA
674 };
675 
676 // ---------------------------------------------------------------------------
677 
678 class EngineeringDatum;
680 using EngineeringDatumPtr = std::shared_ptr<EngineeringDatum>;
682 using EngineeringDatumNNPtr = util::nn<EngineeringDatumPtr>;
683 
693 class EngineeringDatum final : public Datum, public io::IWKTExportable {
694  public:
696  PROJ_DLL ~EngineeringDatum() override;
698 
700  void _exportToWKT(io::WKTFormatter *formatter)
701  const override; // throw(io::FormattingException)
703 
704  // non-standard
705  PROJ_DLL static EngineeringDatumNNPtr
706  create(const util::PropertyMap &properties,
707  const util::optional<std::string> &anchor =
709 
710  PROJ_DLL bool
711  isEquivalentTo(const util::IComparable *other,
712  util::IComparable::Criterion criterion =
713  util::IComparable::Criterion::STRICT) const override;
714 
715  protected:
717  INLINED_MAKE_SHARED
718 
719  private:
720  PROJ_OPAQUE_PRIVATE_DATA
721 };
722 
723 // ---------------------------------------------------------------------------
724 
725 class ParametricDatum;
727 using ParametricDatumPtr = std::shared_ptr<ParametricDatum>;
729 using ParametricDatumNNPtr = util::nn<ParametricDatumPtr>;
730 
737 class ParametricDatum final : public Datum, public io::IWKTExportable {
738  public:
740  PROJ_DLL ~ParametricDatum() override;
742 
744  void _exportToWKT(io::WKTFormatter *formatter)
745  const override; // throw(io::FormattingException)
747 
748  // non-standard
749  PROJ_DLL static ParametricDatumNNPtr
750  create(const util::PropertyMap &properties,
751  const util::optional<std::string> &anchor =
753 
754  PROJ_DLL bool
755  isEquivalentTo(const util::IComparable *other,
756  util::IComparable::Criterion criterion =
757  util::IComparable::Criterion::STRICT) const override;
758 
759  protected:
760  ParametricDatum();
761  INLINED_MAKE_SHARED
762 
763  private:
764  PROJ_OPAQUE_PRIVATE_DATA
765 };
766 
767 } // namespace datum
768 
769 NS_PROJ_END
770 
771 #endif // DATUM_HH_INCLUDED
util::nn< EllipsoidPtr > EllipsoidNNPtr
Definition: datum.hpp:233
The specification of the method by which the vertical reference frame is realized.
Definition: datum.hpp:494
Interface for an object that can be compared to another.
Definition: util.hpp:292
std::shared_ptr< EngineeringDatum > EngineeringDatumPtr
Definition: datum.hpp:680
static const GeodeticReferenceFrameNNPtr EPSG_6267
The EPSG:6267 / "North_American_Datum_1927" GeodeticReferenceFrame.
Definition: datum.hpp:386
std::shared_ptr< GeodeticReferenceFrame > GeodeticReferenceFramePtr
Definition: datum.hpp:348
util::nn< DatumEnsemblePtr > DatumEnsembleNNPtr
Definition: datum.hpp:107
Abstract class to define an enumeration of values.
Definition: util.hpp:611
std::shared_ptr< VerticalReferenceFrame > VerticalReferenceFramePtr
Definition: datum.hpp:512
static const PrimeMeridianNNPtr PARIS
The Paris PrimeMeridian.
Definition: datum.hpp:188
The definition of the origin and orientation of an engineering coordinate reference system...
Definition: datum.hpp:693
static const std::string EARTH
Earth celestial body.
Definition: datum.hpp:270
Formatter to PROJ strings.
Definition: io.hpp:303
util::nn< DynamicGeodeticReferenceFramePtr > DynamicGeodeticReferenceFrameNNPtr
Definition: datum.hpp:430
Numeric value associated with a UnitOfMeasure.
Definition: common.hpp:136
Usage of a CRS-related object.
Definition: common.hpp:399
std::shared_ptr< ParametricDatum > ParametricDatumPtr
Definition: datum.hpp:727
The origin meridian from which longitude values are determined.
Definition: datum.hpp:172
std::shared_ptr< Datum > DatumPtr
Definition: datum.hpp:97
The definition of the relationship of a temporal coordinate system to an object. The object is normal...
Definition: datum.hpp:640
Numeric value, with a linear unit of measure.
Definition: common.hpp:204
util::nn< DynamicVerticalReferenceFramePtr > DynamicVerticalReferenceFrameNNPtr
Definition: datum.hpp:571
Criterion
Comparison criterion.
Definition: util.hpp:299
static const EllipsoidNNPtr WGS84
The EPSG:7030 / "WGS 84" Ellipsoid.
Definition: datum.hpp:292
Date-time value, as a ISO:8601 encoded string, or other string encoding.
Definition: common.hpp:223
util::nn< PrimeMeridianPtr > PrimeMeridianNNPtr
Definition: datum.hpp:163
A textual description and/or a set of parameters identifying a particular reference level surface use...
Definition: datum.hpp:524
A vertical reference frame in which some of the defining parameters have time dependency.
Definition: datum.hpp:581
Textual description and/or a set of parameters identifying a particular reference surface used as the...
Definition: datum.hpp:737
util::nn< VerticalReferenceFramePtr > VerticalReferenceFrameNNPtr
Definition: datum.hpp:514
std::shared_ptr< PrimeMeridian > PrimeMeridianPtr
Definition: datum.hpp:161
static const GeodeticReferenceFrameNNPtr EPSG_6269
The EPSG:6269 / "North_American_Datum_1983" GeodeticReferenceFrame.
Definition: datum.hpp:388
util::nn< EngineeringDatumPtr > EngineeringDatumNNPtr
Definition: datum.hpp:682
A geometric figure that can be used to describe the approximate shape of an object.
Definition: datum.hpp:243
static const std::string CALENDAR_PROLEPTIC_GREGORIAN
The proleptic Gregorian calendar.
Definition: datum.hpp:654
Wrapper of a std::map<std::string, BaseObjectNNPtr>
Definition: util.hpp:410
A geodetic reference frame in which some of the parameters describe time evolution of defining statio...
Definition: datum.hpp:440
static const RealizationMethod TIDAL
The realization is through a tidal model or by tidal predictions.
Definition: datum.hpp:498
static const GeodeticReferenceFrameNNPtr EPSG_6326
The EPSG:6326 / "WGS_1984" GeodeticReferenceFrame.
Definition: datum.hpp:389
std::shared_ptr< TemporalDatum > TemporalDatumPtr
Definition: datum.hpp:631
util::nn< PositionalAccuracyPtr > PositionalAccuracyNNPtr
Definition: metadata.hpp:410
static const RealizationMethod GEOID
The realization is through a geoid height model or a height correction model. This is applied to a sp...
Definition: datum.hpp:497
Numeric value, with a angular unit of measure.
Definition: common.hpp:186
std::shared_ptr< IdentifiedObject > IdentifiedObjectPtr
Definition: common.hpp:261
static const EllipsoidNNPtr CLARKE_1866
The EPSG:7008 / "Clarke 1866" Ellipsoid.
Definition: datum.hpp:291
Interface for an object that can be exported to a PROJ string.
Definition: io.hpp:451
Numeric value, without a physical unit of measure.
Definition: common.hpp:168
util::nn< ParametricDatumPtr > ParametricDatumNNPtr
Definition: datum.hpp:729
util::nn< GeodeticReferenceFramePtr > GeodeticReferenceFrameNNPtr
Definition: datum.hpp:350
std::shared_ptr< DynamicGeodeticReferenceFrame > DynamicGeodeticReferenceFramePtr
Definition: datum.hpp:427
std::shared_ptr< Ellipsoid > EllipsoidPtr
Definition: datum.hpp:231
std::shared_ptr< DynamicVerticalReferenceFrame > DynamicVerticalReferenceFramePtr
Definition: datum.hpp:568
util::nn< TemporalDatumPtr > TemporalDatumNNPtr
Definition: datum.hpp:633
Abstract class of the relationship of a coordinate system to an object, thus creating a coordinate re...
Definition: datum.hpp:64
static const EllipsoidNNPtr GRS1980
The EPSG:7019 / "GRS 1980" Ellipsoid.
Definition: datum.hpp:293
Formatter to WKT strings.
Definition: io.hpp:143
std::shared_ptr< DatumEnsemble > DatumEnsemblePtr
Definition: datum.hpp:105
Interface for an object that can be exported to WKT.
Definition: io.hpp:423
A collection of two or more geodetic or vertical reference frames (or if not geodetic or vertical ref...
Definition: datum.hpp:119
util::nn< DatumPtr > DatumNNPtr
Definition: datum.hpp:99
static const PrimeMeridianNNPtr GREENWICH
The Greenwich PrimeMeridian.
Definition: datum.hpp:187
Loose transposition of std::optional available from C++17.
Definition: util.hpp:178
The definition of the position, scale and orientation of a geocentric Cartesian 3D coordinate system ...
Definition: datum.hpp:367
static const RealizationMethod LEVELLING
The realization is by adjustment of a levelling network fixed to one or more tide gauges...
Definition: datum.hpp:496
Identifications of a CRS-related object.
Definition: common.hpp:269