PROJ C++ API
crs.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 CRS_HH_INCLUDED
30 #define CRS_HH_INCLUDED
31 
32 #include <memory>
33 #include <string>
34 #include <vector>
35 
36 #include "common.hpp"
37 #include "coordinateoperation.hpp"
38 #include "coordinatesystem.hpp"
39 #include "datum.hpp"
40 #include "io.hpp"
41 #include "util.hpp"
42 
43 NS_PROJ_START
44 
49 namespace crs {
50 
51 // ---------------------------------------------------------------------------
52 
53 class GeographicCRS;
55 using GeographicCRSPtr = std::shared_ptr<GeographicCRS>;
57 using GeographicCRSNNPtr = util::nn<GeographicCRSPtr>;
58 
59 class VerticalCRS;
61 using VerticalCRSPtr = std::shared_ptr<VerticalCRS>;
63 using VerticalCRSNNPtr = util::nn<VerticalCRSPtr>;
64 
65 class BoundCRS;
67 using BoundCRSPtr = std::shared_ptr<BoundCRS>;
69 using BoundCRSNNPtr = util::nn<BoundCRSPtr>;
70 
71 // ---------------------------------------------------------------------------
72 
73 class CRS;
75 using CRSPtr = std::shared_ptr<CRS>;
77 using CRSNNPtr = util::nn<CRSPtr>;
78 
84 class CRS : public common::ObjectUsage, public io::IWKTExportable {
85  public:
87  PROJ_DLL ~CRS() override;
89 
90  // Non-standard
91 
92  PROJ_DLL GeodeticCRSPtr extractGeodeticCRS() const;
93  PROJ_DLL GeographicCRSPtr extractGeographicCRS() const;
94  PROJ_DLL VerticalCRSPtr extractVerticalCRS() const;
95  PROJ_DLL CRSNNPtr
96  createBoundCRSToWGS84IfPossible(io::DatabaseContextPtr dbContext) const;
97  PROJ_DLL CRSNNPtr stripVerticalComponent() const;
98 
100  PROJ_DLL virtual CRSNNPtr shallowClone() const = 0;
101 
102  PROJ_DLL const BoundCRSPtr &canonicalBoundCRS() PROJ_CONST_DECL;
103 
104  PROJ_PRIVATE :
106  const GeodeticCRS *
107  extractGeodeticCRSRaw() const;
109 
110  protected:
111  CRS();
112  CRS(const CRS &other);
113  friend class BoundCRS;
114  void setCanonicalBoundCRS(const BoundCRSNNPtr &boundCRS);
115 
116  private:
117  PROJ_OPAQUE_PRIVATE_DATA
118 };
119 
120 // ---------------------------------------------------------------------------
121 
128 class SingleCRS : public CRS {
129  public:
131  PROJ_DLL ~SingleCRS() override;
133 
134  PROJ_DLL const datum::DatumPtr &datum() PROJ_CONST_DECL;
135  PROJ_DLL const datum::DatumEnsemblePtr &datumEnsemble() PROJ_CONST_DECL;
136  PROJ_DLL const cs::CoordinateSystemNNPtr &
137  coordinateSystem() PROJ_CONST_DECL;
138 
139  PROJ_PRIVATE :
141  void
142  exportDatumOrDatumEnsembleToWkt(io::WKTFormatter *formatter)
143  const; // throw(io::FormattingException)
145 
146  protected:
147  SingleCRS(const datum::DatumPtr &datumIn,
148  const datum::DatumEnsemblePtr &datumEnsembleIn,
149  const cs::CoordinateSystemNNPtr &csIn);
150  SingleCRS(const SingleCRS &other);
151 
152  bool _isEquivalentTo(const util::IComparable *other,
153  util::IComparable::Criterion criterion =
154  util::IComparable::Criterion::STRICT) const;
155 
156  private:
157  PROJ_OPAQUE_PRIVATE_DATA
158  SingleCRS &operator=(const SingleCRS &other) = delete;
159 };
160 
162 using SingleCRSPtr = std::shared_ptr<SingleCRS>;
164 using SingleCRSNNPtr = util::nn<SingleCRSPtr>;
165 
166 // ---------------------------------------------------------------------------
167 
168 class GeodeticCRS;
170 using GeodeticCRSPtr = std::shared_ptr<GeodeticCRS>;
172 using GeodeticCRSNNPtr = util::nn<GeodeticCRSPtr>;
173 
183 class GeodeticCRS : virtual public SingleCRS, public io::IPROJStringExportable {
184  public:
186  PROJ_DLL ~GeodeticCRS() override;
188 
189  PROJ_DLL const datum::GeodeticReferenceFramePtr &datum() PROJ_CONST_DECL;
190 
191  PROJ_DLL const datum::PrimeMeridianNNPtr &primeMeridian() PROJ_CONST_DECL;
192  PROJ_DLL const datum::EllipsoidNNPtr &ellipsoid() PROJ_CONST_DECL;
193 
194  // coordinateSystem() returns either a EllipsoidalCS, SphericalCS or
195  // CartesianCS
196 
197  PROJ_DLL const std::vector<operation::PointMotionOperationNNPtr> &
198  velocityModel() PROJ_CONST_DECL;
199 
200  // Non-standard
201 
202  PROJ_DLL bool isGeocentric() PROJ_CONST_DECL;
203 
204  PROJ_DLL static GeodeticCRSNNPtr
205  create(const util::PropertyMap &properties,
207  const cs::SphericalCSNNPtr &cs);
208 
209  PROJ_DLL static GeodeticCRSNNPtr
210  create(const util::PropertyMap &properties,
212  const cs::CartesianCSNNPtr &cs);
213 
214  PROJ_DLL static GeodeticCRSNNPtr
215  create(const util::PropertyMap &properties,
217  const datum::DatumEnsemblePtr &datumEnsemble,
218  const cs::SphericalCSNNPtr &cs);
219 
220  PROJ_DLL static GeodeticCRSNNPtr
221  create(const util::PropertyMap &properties,
223  const datum::DatumEnsemblePtr &datumEnsemble,
224  const cs::CartesianCSNNPtr &cs);
225 
226  PROJ_DLL bool
227  isEquivalentTo(const util::IComparable *other,
228  util::IComparable::Criterion criterion =
229  util::IComparable::Criterion::STRICT) const override;
230 
231  PROJ_DLL CRSNNPtr shallowClone() const override;
232 
233  PROJ_DLL static const GeodeticCRSNNPtr EPSG_4978; // WGS 84 Geocentric
234 
235  PROJ_PRIVATE :
237  void
238  addDatumInfoToPROJString(io::PROJStringFormatter *formatter) const;
239 
240  void addGeocentricUnitConversionIntoPROJString(
241  io::PROJStringFormatter *formatter) const;
242 
243  void _exportToWKT(io::WKTFormatter *formatter)
244  const override; // throw(io::FormattingException)
245 
246  void _exportToPROJString(io::PROJStringFormatter *formatter)
247  const override; // throw(FormattingException)
248 
250 
251  protected:
253  const datum::DatumEnsemblePtr &datumEnsembleIn,
254  const cs::EllipsoidalCSNNPtr &csIn);
256  const datum::DatumEnsemblePtr &datumEnsembleIn,
257  const cs::SphericalCSNNPtr &csIn);
259  const datum::DatumEnsemblePtr &datumEnsembleIn,
260  const cs::CartesianCSNNPtr &csIn);
261  GeodeticCRS(const GeodeticCRS &other);
262  INLINED_MAKE_SHARED
263 
264  static GeodeticCRSNNPtr createEPSG_4978();
265 
266  private:
267  PROJ_OPAQUE_PRIVATE_DATA
268 
269  GeodeticCRS &operator=(const GeodeticCRS &other) = delete;
270 };
271 
272 // ---------------------------------------------------------------------------
273 
283 class GeographicCRS : public GeodeticCRS {
284  public:
286  PROJ_DLL ~GeographicCRS() override;
288 
289  PROJ_DLL const cs::EllipsoidalCSNNPtr &coordinateSystem() PROJ_CONST_DECL;
290 
291  // Non-standard
292  PROJ_DLL static GeographicCRSNNPtr
293  create(const util::PropertyMap &properties,
295  const cs::EllipsoidalCSNNPtr &cs);
296  PROJ_DLL static GeographicCRSNNPtr
297  create(const util::PropertyMap &properties,
299  const datum::DatumEnsemblePtr &datumEnsemble,
300  const cs::EllipsoidalCSNNPtr &cs);
301 
302  PROJ_DLL bool is2DPartOf3D(const GeographicCRSNNPtr &other) PROJ_CONST_DECL;
303 
304  PROJ_DLL static const GeographicCRSNNPtr EPSG_4267; // NAD27
305  PROJ_DLL static const GeographicCRSNNPtr EPSG_4269; // NAD83
306  PROJ_DLL static const GeographicCRSNNPtr EPSG_4326; // WGS 84 2D
307  PROJ_DLL static const GeographicCRSNNPtr OGC_CRS84; // CRS84 (Long, Lat)
308  PROJ_DLL static const GeographicCRSNNPtr EPSG_4807; // NTF Paris
309  PROJ_DLL static const GeographicCRSNNPtr EPSG_4979; // WGS 84 3D
310 
311  PROJ_DLL CRSNNPtr shallowClone() const override;
312 
313  PROJ_PRIVATE :
315  void
316  addAngularUnitConvertAndAxisSwap(
317  io::PROJStringFormatter *formatter) const;
318 
319  void _exportToPROJString(io::PROJStringFormatter *formatter)
320  const override; // throw(FormattingException)
321 
323 
324  protected:
326  const datum::DatumEnsemblePtr &datumEnsembleIn,
327  const cs::EllipsoidalCSNNPtr &csIn);
328  GeographicCRS(const GeographicCRS &other);
329  INLINED_MAKE_SHARED
330 
331  static GeographicCRSNNPtr createEPSG_4267();
332  static GeographicCRSNNPtr createEPSG_4269();
333  static GeographicCRSNNPtr createEPSG_4326();
334  static GeographicCRSNNPtr createOGC_CRS84();
335  static GeographicCRSNNPtr createEPSG_4807();
336  static GeographicCRSNNPtr createEPSG_4979();
337 
338  private:
339  PROJ_OPAQUE_PRIVATE_DATA
340 
341  GeographicCRS &operator=(const GeographicCRS &other) = delete;
342 };
343 
344 // ---------------------------------------------------------------------------
345 
362 class VerticalCRS : virtual public SingleCRS, public io::IPROJStringExportable {
363  public:
365  PROJ_DLL ~VerticalCRS() override;
367 
368  PROJ_DLL const datum::VerticalReferenceFramePtr datum() const;
369  PROJ_DLL const cs::VerticalCSNNPtr coordinateSystem() const;
370  PROJ_DLL const std::vector<operation::TransformationNNPtr> &
371  geoidModel() PROJ_CONST_DECL;
372  PROJ_DLL const std::vector<operation::PointMotionOperationNNPtr> &
373  velocityModel() PROJ_CONST_DECL;
374 
375  PROJ_DLL bool
376  isEquivalentTo(const util::IComparable *other,
377  util::IComparable::Criterion criterion =
378  util::IComparable::Criterion::STRICT) const override;
379 
380  PROJ_DLL static VerticalCRSNNPtr
381  create(const util::PropertyMap &properties,
382  const datum::VerticalReferenceFrameNNPtr &datumIn,
383  const cs::VerticalCSNNPtr &csIn);
384 
385  PROJ_DLL static VerticalCRSNNPtr
386  create(const util::PropertyMap &properties,
387  const datum::VerticalReferenceFramePtr &datumIn,
388  const datum::DatumEnsemblePtr &datumEnsembleIn,
389  const cs::VerticalCSNNPtr &csIn);
390 
391  PROJ_DLL CRSNNPtr shallowClone() const override;
392 
393  PROJ_PRIVATE :
395  void
396  addLinearUnitConvert(io::PROJStringFormatter *formatter) const;
397 
398  void _exportToWKT(io::WKTFormatter *formatter)
399  const override; // throw(io::FormattingException)
400 
402 
403  protected:
405  const datum::DatumEnsemblePtr &datumEnsembleIn,
406  const cs::VerticalCSNNPtr &csIn);
407  VerticalCRS(const VerticalCRS &other);
408 
409  void _exportToPROJString(io::PROJStringFormatter *formatter)
410  const override; // throw(FormattingException)
411 
412  INLINED_MAKE_SHARED
413 
414  private:
415  PROJ_OPAQUE_PRIVATE_DATA
416  VerticalCRS &operator=(const VerticalCRS &other) = delete;
417 };
418 
419 // ---------------------------------------------------------------------------
420 
433 class DerivedCRS : virtual public SingleCRS {
434  public:
436  PROJ_DLL ~DerivedCRS() override;
438 
439  PROJ_DLL const SingleCRSNNPtr &baseCRS() PROJ_CONST_DECL;
440  PROJ_DLL const operation::ConversionNNPtr derivingConversion() const;
441 
442  PROJ_DLL bool
443  isEquivalentTo(const util::IComparable *other,
444  util::IComparable::Criterion criterion =
445  util::IComparable::Criterion::STRICT) const override;
446  PROJ_PRIVATE :
449  derivingConversionRef() PROJ_CONST_DECL;
451 
452  protected:
453  DerivedCRS(const SingleCRSNNPtr &baseCRSIn,
454  const operation::ConversionNNPtr &derivingConversionIn,
455  const cs::CoordinateSystemNNPtr &cs);
456  DerivedCRS(const DerivedCRS &other);
457 
458  void setDerivingConversionCRS();
459 
460  void baseExportToPROJString(
461  io::PROJStringFormatter *formatter) const; // throw(FormattingException)
462 
463  void baseExportToWKT(
464  io::WKTFormatter *&formatter, const std::string &keyword,
465  const std::string &baseKeyword) const; // throw(FormattingException)
466 
467  private:
468  PROJ_OPAQUE_PRIVATE_DATA
469  DerivedCRS &operator=(const DerivedCRS &other) = delete;
470 };
471 
473 using DerivedCRSPtr = std::shared_ptr<DerivedCRS>;
475 using DerivedCRSNNPtr = util::nn<DerivedCRSPtr>;
476 
477 // ---------------------------------------------------------------------------
478 
479 class ProjectedCRS;
481 using ProjectedCRSPtr = std::shared_ptr<ProjectedCRS>;
483 using ProjectedCRSNNPtr = util::nn<ProjectedCRSPtr>;
484 
497 class ProjectedCRS final : public DerivedCRS, public io::IPROJStringExportable {
498  public:
500  PROJ_DLL ~ProjectedCRS() override;
502 
503  PROJ_DLL const GeodeticCRSNNPtr &baseCRS() PROJ_CONST_DECL;
504  PROJ_DLL const cs::CartesianCSNNPtr &coordinateSystem() PROJ_CONST_DECL;
505 
506  PROJ_DLL static ProjectedCRSNNPtr
507  create(const util::PropertyMap &properties,
508  const GeodeticCRSNNPtr &baseCRSIn,
509  const operation::ConversionNNPtr &derivingConversionIn,
510  const cs::CartesianCSNNPtr &csIn);
511 
512  PROJ_DLL bool
513  isEquivalentTo(const util::IComparable *other,
514  util::IComparable::Criterion criterion =
515  util::IComparable::Criterion::STRICT) const override;
516 
517  PROJ_DLL CRSNNPtr shallowClone() const override;
518 
519  PROJ_PRIVATE :
521  void
522  addUnitConvertAndAxisSwap(io::PROJStringFormatter *formatter,
523  bool axisSpecFound) const;
524 
525  void _exportToWKT(io::WKTFormatter *formatter)
526  const override; // throw(io::FormattingException)
527 
529 
530  protected:
531  ProjectedCRS(const GeodeticCRSNNPtr &baseCRSIn,
532  const operation::ConversionNNPtr &derivingConversionIn,
533  const cs::CartesianCSNNPtr &csIn);
534  ProjectedCRS(const ProjectedCRS &other);
535 
536  void _exportToPROJString(io::PROJStringFormatter *formatter)
537  const override; // throw(FormattingException)
538 
539  INLINED_MAKE_SHARED
540 
541  private:
542  PROJ_OPAQUE_PRIVATE_DATA
543  ProjectedCRS &operator=(const ProjectedCRS &other) = delete;
544 };
545 
546 // ---------------------------------------------------------------------------
547 
548 class TemporalCRS;
550 using TemporalCRSPtr = std::shared_ptr<TemporalCRS>;
552 using TemporalCRSNNPtr = util::nn<TemporalCRSPtr>;
553 
559 class TemporalCRS : virtual public SingleCRS {
560  public:
562  PROJ_DLL ~TemporalCRS() override;
564 
565  PROJ_DLL const datum::TemporalDatumNNPtr datum() const;
566 
567  PROJ_DLL const cs::TemporalCSNNPtr coordinateSystem() const;
568 
569  PROJ_DLL static TemporalCRSNNPtr
570  create(const util::PropertyMap &properties,
571  const datum::TemporalDatumNNPtr &datumIn,
572  const cs::TemporalCSNNPtr &csIn);
573 
575  void _exportToWKT(io::WKTFormatter *formatter)
576  const override; // throw(io::FormattingException)
578 
579  PROJ_DLL bool
580  isEquivalentTo(const util::IComparable *other,
581  util::IComparable::Criterion criterion =
582  util::IComparable::Criterion::STRICT) const override;
583 
584  PROJ_DLL CRSNNPtr shallowClone() const override;
585 
586  protected:
587  TemporalCRS(const datum::TemporalDatumNNPtr &datumIn,
588  const cs::TemporalCSNNPtr &csIn);
589  TemporalCRS(const TemporalCRS &other);
590 
591  INLINED_MAKE_SHARED
592 
593  private:
594  PROJ_OPAQUE_PRIVATE_DATA
595  TemporalCRS &operator=(const TemporalCRS &other) = delete;
596 };
597 
598 // ---------------------------------------------------------------------------
599 
600 class EngineeringCRS;
602 using EngineeringCRSPtr = std::shared_ptr<EngineeringCRS>;
604 using EngineeringCRSNNPtr = util::nn<EngineeringCRSPtr>;
605 
618 class EngineeringCRS : virtual public SingleCRS {
619  public:
621  PROJ_DLL ~EngineeringCRS() override;
623 
624  PROJ_DLL const datum::EngineeringDatumNNPtr datum() const;
625 
626  PROJ_DLL static EngineeringCRSNNPtr
627  create(const util::PropertyMap &properties,
628  const datum::EngineeringDatumNNPtr &datumIn,
629  const cs::CoordinateSystemNNPtr &csIn);
630 
632  void _exportToWKT(io::WKTFormatter *formatter)
633  const override; // throw(io::FormattingException)
635 
636  PROJ_DLL bool
637  isEquivalentTo(const util::IComparable *other,
638  util::IComparable::Criterion criterion =
639  util::IComparable::Criterion::STRICT) const override;
640 
641  PROJ_DLL CRSNNPtr shallowClone() const override;
642 
643  protected:
645  const cs::CoordinateSystemNNPtr &csIn);
646  EngineeringCRS(const EngineeringCRS &other);
647 
648  INLINED_MAKE_SHARED
649 
650  private:
651  PROJ_OPAQUE_PRIVATE_DATA
652  EngineeringCRS &operator=(const EngineeringCRS &other) = delete;
653 };
654 
655 // ---------------------------------------------------------------------------
656 
657 class ParametricCRS;
659 using ParametricCRSPtr = std::shared_ptr<ParametricCRS>;
661 using ParametricCRSNNPtr = util::nn<ParametricCRSPtr>;
662 
672 class ParametricCRS : virtual public SingleCRS {
673  public:
675  PROJ_DLL ~ParametricCRS() override;
677 
678  PROJ_DLL const datum::ParametricDatumNNPtr datum() const;
679 
680  PROJ_DLL const cs::ParametricCSNNPtr coordinateSystem() const;
681 
682  PROJ_DLL static ParametricCRSNNPtr
683  create(const util::PropertyMap &properties,
684  const datum::ParametricDatumNNPtr &datumIn,
685  const cs::ParametricCSNNPtr &csIn);
686 
688  void _exportToWKT(io::WKTFormatter *formatter)
689  const override; // throw(io::FormattingException)
691 
692  PROJ_DLL bool
693  isEquivalentTo(const util::IComparable *other,
694  util::IComparable::Criterion criterion =
695  util::IComparable::Criterion::STRICT) const override;
696 
697  PROJ_DLL CRSNNPtr shallowClone() const override;
698 
699  protected:
701  const cs::ParametricCSNNPtr &csIn);
702  ParametricCRS(const ParametricCRS &other);
703 
704  INLINED_MAKE_SHARED
705 
706  private:
707  PROJ_OPAQUE_PRIVATE_DATA
708  ParametricCRS &operator=(const ParametricCRS &other) = delete;
709 };
710 
711 // ---------------------------------------------------------------------------
712 
713 class CompoundCRS;
715 using CompoundCRSPtr = std::shared_ptr<CompoundCRS>;
717 using CompoundCRSNNPtr = util::nn<CompoundCRSPtr>;
718 
732 class CompoundCRS final : public CRS, public io::IPROJStringExportable {
733  public:
735  PROJ_DLL ~CompoundCRS() override;
737 
738  PROJ_DLL const std::vector<CRSNNPtr> &
739  componentReferenceSystems() PROJ_CONST_DECL;
740 
742  void _exportToWKT(io::WKTFormatter *formatter)
743  const override; // throw(io::FormattingException)
745 
746  PROJ_DLL bool
747  isEquivalentTo(const util::IComparable *other,
748  util::IComparable::Criterion criterion =
749  util::IComparable::Criterion::STRICT) const override;
750 
751  PROJ_DLL static CompoundCRSNNPtr
752  create(const util::PropertyMap &properties,
753  const std::vector<CRSNNPtr> &components);
754 
755  PROJ_DLL CRSNNPtr shallowClone() const override;
756 
757  protected:
758  // relaxed: standard say SingleCRSNNPtr
759  explicit CompoundCRS(const std::vector<CRSNNPtr> &components);
760  CompoundCRS(const CompoundCRS &other);
761 
762  void _exportToPROJString(io::PROJStringFormatter *formatter)
763  const override; // throw(FormattingException)
764 
765  INLINED_MAKE_SHARED
766 
767  private:
768  PROJ_OPAQUE_PRIVATE_DATA
769  CompoundCRS &operator=(const CompoundCRS &other) = delete;
770 };
771 
772 // ---------------------------------------------------------------------------
773 
799 class BoundCRS final : public CRS, public io::IPROJStringExportable {
800  public:
802  PROJ_DLL ~BoundCRS() override;
804 
805  PROJ_DLL const CRSNNPtr &baseCRS() PROJ_CONST_DECL;
806  PROJ_DLL CRSNNPtr baseCRSWithCanonicalBoundCRS() const;
807 
808  PROJ_DLL const CRSNNPtr &hubCRS() PROJ_CONST_DECL;
809  PROJ_DLL const operation::TransformationNNPtr &
810  transformation() PROJ_CONST_DECL;
811 
813  void _exportToWKT(io::WKTFormatter *formatter)
814  const override; // throw(io::FormattingException)
816 
817  PROJ_DLL bool
818  isEquivalentTo(const util::IComparable *other,
819  util::IComparable::Criterion criterion =
820  util::IComparable::Criterion::STRICT) const override;
821 
822  PROJ_DLL static BoundCRSNNPtr
823  create(const CRSNNPtr &baseCRSIn, const CRSNNPtr &hubCRSIn,
824  const operation::TransformationNNPtr &transformationIn);
825 
826  PROJ_DLL static BoundCRSNNPtr
827  createFromTOWGS84(const CRSNNPtr &baseCRSIn,
828  const std::vector<double> &TOWGS84Parameters);
829 
830  PROJ_DLL static BoundCRSNNPtr
831  createFromNadgrids(const CRSNNPtr &baseCRSIn, const std::string &filename);
832 
833  PROJ_DLL CRSNNPtr shallowClone() const override;
834 
835  protected:
836  BoundCRS(const CRSNNPtr &baseCRSIn, const CRSNNPtr &hubCRSIn,
837  const operation::TransformationNNPtr &transformationIn);
838  BoundCRS(const BoundCRS &other);
839  INLINED_MAKE_SHARED
840 
841  void _exportToPROJString(io::PROJStringFormatter *formatter)
842  const override; // throw(FormattingException)
843 
844  BoundCRSNNPtr shallowCloneAsBoundCRS() const;
845  bool isTOWGS84Compatible() const;
846  std::string getHDatumPROJ4GRIDS() const;
847  std::string getVDatumPROJ4GRIDS() const;
848 
849  private:
850  PROJ_OPAQUE_PRIVATE_DATA
851  BoundCRS &operator=(const BoundCRS &other) = delete;
852 };
853 
854 // ---------------------------------------------------------------------------
855 
856 class DerivedGeodeticCRS;
858 using DerivedGeodeticCRSPtr = std::shared_ptr<DerivedGeodeticCRS>;
860 using DerivedGeodeticCRSNNPtr = util::nn<DerivedGeodeticCRSPtr>;
861 
869 class DerivedGeodeticCRS final : public GeodeticCRS, public DerivedCRS {
870  public:
872  PROJ_DLL ~DerivedGeodeticCRS() override;
874 
875  PROJ_DLL const GeodeticCRSNNPtr baseCRS() const;
876 
877  PROJ_DLL static DerivedGeodeticCRSNNPtr
878  create(const util::PropertyMap &properties,
879  const GeodeticCRSNNPtr &baseCRSIn,
880  const operation::ConversionNNPtr &derivingConversionIn,
881  const cs::CartesianCSNNPtr &csIn);
882 
883  PROJ_DLL static DerivedGeodeticCRSNNPtr
884  create(const util::PropertyMap &properties,
885  const GeodeticCRSNNPtr &baseCRSIn,
886  const operation::ConversionNNPtr &derivingConversionIn,
887  const cs::SphericalCSNNPtr &csIn);
888 
890  void _exportToWKT(io::WKTFormatter *formatter)
891  const override; // throw(io::FormattingException)
893 
894  PROJ_DLL bool
895  isEquivalentTo(const util::IComparable *other,
896  util::IComparable::Criterion criterion =
897  util::IComparable::Criterion::STRICT) const override;
898 
899  PROJ_DLL CRSNNPtr shallowClone() const override;
900 
901  protected:
902  DerivedGeodeticCRS(const GeodeticCRSNNPtr &baseCRSIn,
903  const operation::ConversionNNPtr &derivingConversionIn,
904  const cs::CartesianCSNNPtr &csIn);
905  DerivedGeodeticCRS(const GeodeticCRSNNPtr &baseCRSIn,
906  const operation::ConversionNNPtr &derivingConversionIn,
907  const cs::SphericalCSNNPtr &csIn);
909 
910  void _exportToPROJString(io::PROJStringFormatter *formatter)
911  const override; // throw(FormattingException)
912 
913  INLINED_MAKE_SHARED
914 
915  private:
916  PROJ_OPAQUE_PRIVATE_DATA
917  DerivedGeodeticCRS &operator=(const DerivedGeodeticCRS &other) = delete;
918 };
919 
920 // ---------------------------------------------------------------------------
921 
924 using DerivedGeographicCRSPtr = std::shared_ptr<DerivedGeographicCRS>;
926 using DerivedGeographicCRSNNPtr = util::nn<DerivedGeographicCRSPtr>;
927 
937 class DerivedGeographicCRS final : public GeographicCRS, public DerivedCRS {
938  public:
940  PROJ_DLL ~DerivedGeographicCRS() override;
942 
943  PROJ_DLL const GeodeticCRSNNPtr baseCRS() const;
944 
945  PROJ_DLL static DerivedGeographicCRSNNPtr
946  create(const util::PropertyMap &properties,
947  const GeodeticCRSNNPtr &baseCRSIn,
948  const operation::ConversionNNPtr &derivingConversionIn,
949  const cs::EllipsoidalCSNNPtr &csIn);
950 
952  void _exportToWKT(io::WKTFormatter *formatter)
953  const override; // throw(io::FormattingException)
955 
956  PROJ_DLL bool
957  isEquivalentTo(const util::IComparable *other,
958  util::IComparable::Criterion criterion =
959  util::IComparable::Criterion::STRICT) const override;
960 
961  PROJ_DLL CRSNNPtr shallowClone() const override;
962 
963  protected:
964  DerivedGeographicCRS(const GeodeticCRSNNPtr &baseCRSIn,
965  const operation::ConversionNNPtr &derivingConversionIn,
966  const cs::EllipsoidalCSNNPtr &csIn);
968 
969  void _exportToPROJString(io::PROJStringFormatter *formatter)
970  const override; // throw(FormattingException)
971 
972  INLINED_MAKE_SHARED
973 
974  private:
975  PROJ_OPAQUE_PRIVATE_DATA
976  DerivedGeographicCRS &operator=(const DerivedGeographicCRS &other) = delete;
977 };
978 
979 // ---------------------------------------------------------------------------
980 
981 class DerivedProjectedCRS;
983 using DerivedProjectedCRSPtr = std::shared_ptr<DerivedProjectedCRS>;
985 using DerivedProjectedCRSNNPtr = util::nn<DerivedProjectedCRSPtr>;
986 
996 class DerivedProjectedCRS final : public DerivedCRS,
998  public:
1000  PROJ_DLL ~DerivedProjectedCRS() override;
1002 
1003  PROJ_DLL const ProjectedCRSNNPtr baseCRS() const;
1004 
1005  PROJ_DLL static DerivedProjectedCRSNNPtr
1006  create(const util::PropertyMap &properties,
1007  const ProjectedCRSNNPtr &baseCRSIn,
1008  const operation::ConversionNNPtr &derivingConversionIn,
1009  const cs::CoordinateSystemNNPtr &csIn);
1010 
1012  void _exportToWKT(io::WKTFormatter *formatter)
1013  const override; // throw(io::FormattingException)
1015 
1016  PROJ_DLL bool
1017  isEquivalentTo(const util::IComparable *other,
1018  util::IComparable::Criterion criterion =
1019  util::IComparable::Criterion::STRICT) const override;
1020 
1021  PROJ_DLL CRSNNPtr shallowClone() const override;
1022 
1023  protected:
1024  DerivedProjectedCRS(const ProjectedCRSNNPtr &baseCRSIn,
1025  const operation::ConversionNNPtr &derivingConversionIn,
1026  const cs::CoordinateSystemNNPtr &csIn);
1028 
1029  void _exportToPROJString(io::PROJStringFormatter *formatter)
1030  const override; // throw(FormattingException)
1031 
1032  INLINED_MAKE_SHARED
1033 
1034  private:
1035  PROJ_OPAQUE_PRIVATE_DATA
1036  DerivedProjectedCRS &operator=(const DerivedProjectedCRS &other) = delete;
1037 };
1038 
1039 // ---------------------------------------------------------------------------
1040 
1041 class DerivedVerticalCRS;
1043 using DerivedVerticalCRSPtr = std::shared_ptr<DerivedVerticalCRS>;
1045 using DerivedVerticalCRSNNPtr = util::nn<DerivedVerticalCRSPtr>;
1046 
1053 class DerivedVerticalCRS final : public VerticalCRS, public DerivedCRS {
1054  public:
1056  PROJ_DLL ~DerivedVerticalCRS() override;
1058 
1059  PROJ_DLL const VerticalCRSNNPtr baseCRS() const;
1060 
1061  PROJ_DLL static DerivedVerticalCRSNNPtr
1062  create(const util::PropertyMap &properties,
1063  const VerticalCRSNNPtr &baseCRSIn,
1064  const operation::ConversionNNPtr &derivingConversionIn,
1065  const cs::VerticalCSNNPtr &csIn);
1066 
1068  void _exportToWKT(io::WKTFormatter *formatter)
1069  const override; // throw(io::FormattingException)
1071 
1072  PROJ_DLL bool
1073  isEquivalentTo(const util::IComparable *other,
1074  util::IComparable::Criterion criterion =
1075  util::IComparable::Criterion::STRICT) const override;
1076 
1077  PROJ_DLL CRSNNPtr shallowClone() const override;
1078 
1079  protected:
1080  DerivedVerticalCRS(const VerticalCRSNNPtr &baseCRSIn,
1081  const operation::ConversionNNPtr &derivingConversionIn,
1082  const cs::VerticalCSNNPtr &csIn);
1083  DerivedVerticalCRS(const DerivedVerticalCRS &other);
1084 
1085  void _exportToPROJString(io::PROJStringFormatter *formatter)
1086  const override; // throw(FormattingException)
1087 
1088  INLINED_MAKE_SHARED
1089 
1090  private:
1091  PROJ_OPAQUE_PRIVATE_DATA
1092  DerivedVerticalCRS &operator=(const DerivedVerticalCRS &other) = delete;
1093 };
1094 
1095 // ---------------------------------------------------------------------------
1096 
1099 template <class DerivedCRSTraits>
1100 class DerivedCRSTemplate final : public DerivedCRSTraits::BaseType,
1101  public DerivedCRS {
1102  protected:
1104  typedef typename DerivedCRSTraits::BaseType BaseType;
1106  typedef typename DerivedCRSTraits::CSType CSType;
1107 
1108  public:
1110  PROJ_DLL ~DerivedCRSTemplate() override;
1112 
1114  typedef typename util::nn<std::shared_ptr<DerivedCRSTemplate>> NNPtr;
1116  typedef util::nn<std::shared_ptr<BaseType>> BaseNNPtr;
1118  typedef util::nn<std::shared_ptr<CSType>> CSNNPtr;
1119 
1124  PROJ_DLL const BaseNNPtr baseCRS() const;
1125 
1138  PROJ_DLL static NNPtr
1139  create(const util::PropertyMap &properties, const BaseNNPtr &baseCRSIn,
1140  const operation::ConversionNNPtr &derivingConversionIn,
1141  const CSNNPtr &csIn);
1142 
1144  void _exportToWKT(io::WKTFormatter *formatter)
1145  const override; // throw(io::FormattingException)
1146 
1147  PROJ_DLL bool
1148  isEquivalentTo(const util::IComparable *other,
1149  util::IComparable::Criterion criterion =
1150  util::IComparable::Criterion::STRICT) const override;
1151 
1152  PROJ_DLL CRSNNPtr shallowClone() const override;
1154 
1155  protected:
1156  DerivedCRSTemplate(const BaseNNPtr &baseCRSIn,
1157  const operation::ConversionNNPtr &derivingConversionIn,
1158  const CSNNPtr &csIn);
1159  DerivedCRSTemplate(const DerivedCRSTemplate &other);
1160 
1161  INLINED_MAKE_SHARED
1162 
1163  private:
1164  PROJ_OPAQUE_PRIVATE_DATA
1165  DerivedCRSTemplate &operator=(const DerivedCRSTemplate &other) = delete;
1166 };
1167 
1168 // ---------------------------------------------------------------------------
1169 
1171 struct DerivedEngineeringCRSTraits {
1172  typedef EngineeringCRS BaseType;
1173  typedef cs::CoordinateSystem CSType;
1174  // old x86_64-w64-mingw32-g++ has issues with static variables. use method
1175  // instead
1176  inline static const std::string &CRSName();
1177  inline static const std::string &WKTKeyword();
1178  inline static const std::string &WKTBaseKeyword();
1179  static const bool wkt2_2018_only = true;
1180 };
1182 
1190 #ifdef DOXYGEN_ENABLED
1192  : public DerivedCRSTemplate<DerivedEngineeringCRSTraits> {};
1193 #else
1195 #endif
1196 
1197 #ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE
1199 #endif
1200 
1202 using DerivedEngineeringCRSPtr = std::shared_ptr<DerivedEngineeringCRS>;
1204 using DerivedEngineeringCRSNNPtr = util::nn<DerivedEngineeringCRSPtr>;
1205 
1206 // ---------------------------------------------------------------------------
1207 
1209 struct DerivedParametricCRSTraits {
1210  typedef ParametricCRS BaseType;
1211  typedef cs::ParametricCS CSType;
1212  // old x86_64-w64-mingw32-g++ has issues with static variables. use method
1213  // instead
1214  inline static const std::string &CRSName();
1215  inline static const std::string &WKTKeyword();
1216  inline static const std::string &WKTBaseKeyword();
1217  static const bool wkt2_2018_only = false;
1218 };
1220 
1227 #ifdef DOXYGEN_ENABLED
1230 #else
1232 #endif
1233 
1234 #ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE
1236 #endif
1237 
1239 using DerivedParametricCRSPtr = std::shared_ptr<DerivedParametricCRS>;
1241 using DerivedParametricCRSNNPtr = util::nn<DerivedParametricCRSPtr>;
1242 
1243 // ---------------------------------------------------------------------------
1244 
1246 struct DerivedTemporalCRSTraits {
1247  typedef TemporalCRS BaseType;
1248  typedef cs::TemporalCS CSType;
1249  // old x86_64-w64-mingw32-g++ has issues with static variables. use method
1250  // instead
1251  inline static const std::string &CRSName();
1252  inline static const std::string &WKTKeyword();
1253  inline static const std::string &WKTBaseKeyword();
1254  static const bool wkt2_2018_only = false;
1255 };
1257 
1264 #ifdef DOXYGEN_ENABLED
1266 };
1267 #else
1269 #endif
1270 
1271 #ifndef DO_NOT_DEFINE_EXTERN_DERIVED_CRS_TEMPLATE
1272 extern template class DerivedCRSTemplate<DerivedTemporalCRSTraits>;
1273 #endif
1274 
1276 using DerivedTemporalCRSPtr = std::shared_ptr<DerivedTemporalCRS>;
1278 using DerivedTemporalCRSNNPtr = util::nn<DerivedTemporalCRSPtr>;
1279 
1280 // ---------------------------------------------------------------------------
1281 
1282 } // namespace crs
1283 
1284 NS_PROJ_END
1285 
1286 #endif // CRS_HH_INCLUDED
util::nn< EllipsoidPtr > EllipsoidNNPtr
Definition: datum.hpp:233
std::shared_ptr< DerivedCRS > DerivedCRSPtr
Definition: crs.hpp:473
A coordinate reference system having a vertical reference frame and a one-dimensional vertical coordi...
Definition: crs.hpp:362
std::shared_ptr< TemporalCRS > TemporalCRSPtr
Definition: crs.hpp:550
static const GeographicCRSNNPtr EPSG_4267
EPSG:4267 / "NAD27" 2D GeographicCRS.
Definition: crs.hpp:304
Interface for an object that can be compared to another.
Definition: util.hpp:292
static const GeographicCRSNNPtr EPSG_4807
EPSG:4807 / "NTF (Paris)" 2D GeographicCRS.
Definition: crs.hpp:308
std::shared_ptr< GeodeticReferenceFrame > GeodeticReferenceFramePtr
Definition: datum.hpp:348
util::nn< TemporalCSPtr > TemporalCSNNPtr
Definition: coordinatesystem.hpp:540
A derived coordinate reference system which has either a geodetic or a geographic coordinate referenc...
Definition: crs.hpp:937
util::nn< DerivedParametricCRSPtr > DerivedParametricCRSNNPtr
Definition: crs.hpp:1241
Abstract class modelling a coordinate system (CS)
Definition: coordinatesystem.hpp:232
(Abstract class) A one-dimensional coordinate system used to record time.
Definition: coordinatesystem.hpp:549
std::shared_ptr< VerticalReferenceFrame > VerticalReferenceFramePtr
Definition: datum.hpp:512
util::nn< std::shared_ptr< BaseType > > BaseNNPtr
Definition: crs.hpp:1116
std::shared_ptr< VerticalCRS > VerticalCRSPtr
Definition: crs.hpp:61
std::shared_ptr< EngineeringCRS > EngineeringCRSPtr
Definition: crs.hpp:602
util::nn< CoordinateSystemPtr > CoordinateSystemNNPtr
Definition: coordinatesystem.hpp:268
Formatter to PROJ strings.
Definition: io.hpp:303
Contextually local coordinate reference system associated with an engineering datum.
Definition: crs.hpp:672
util::nn< std::shared_ptr< DerivedCRSTemplate > > NNPtr
Definition: crs.hpp:1114
std::shared_ptr< SingleCRS > SingleCRSPtr
Definition: crs.hpp:162
Usage of a CRS-related object.
Definition: common.hpp:399
std::shared_ptr< CRS > CRSPtr
Definition: coordinateoperation.hpp:45
util::nn< VerticalCSPtr > VerticalCSNNPtr
Definition: coordinatesystem.hpp:384
A coordinate reference system associated with a geodetic reference frame and a three-dimensional Cart...
Definition: crs.hpp:183
util::nn< CompoundCRSPtr > CompoundCRSNNPtr
Definition: crs.hpp:717
A derived coordinate reference system which has a vertical coordinate reference system as its base CR...
Definition: crs.hpp:1053
std::shared_ptr< CompoundCRS > CompoundCRSPtr
Definition: crs.hpp:715
Template representing a derived coordinate reference system.
Definition: crs.hpp:1100
std::shared_ptr< Datum > DatumPtr
Definition: datum.hpp:97
one-dimensional coordinate reference system which uses parameter values or functions that may vary mo...
Definition: coordinatesystem.hpp:514
util::nn< GeodeticCRSPtr > GeodeticCRSNNPtr
Definition: crs.hpp:172
std::shared_ptr< BoundCRS > BoundCRSPtr
Definition: crs.hpp:67
util::nn< ParametricCSPtr > ParametricCSNNPtr
Definition: coordinatesystem.hpp:507
A coordinate reference system associated with a geodetic reference frame and a two- or three-dimensio...
Definition: crs.hpp:283
Abstract class modelling a coordinate reference system which is usually single but may be compound...
Definition: crs.hpp:84
static const GeographicCRSNNPtr EPSG_4326
EPSG:4326 / "WGS 84" 2D GeographicCRS.
Definition: crs.hpp:306
Criterion
Comparison criterion.
Definition: util.hpp:299
util::nn< PrimeMeridianPtr > PrimeMeridianNNPtr
Definition: datum.hpp:163
std::shared_ptr< DerivedGeographicCRS > DerivedGeographicCRSPtr
Definition: crs.hpp:924
static const GeographicCRSNNPtr EPSG_4979
EPSG:4979 / "WGS 84" 3D GeographicCRS.
Definition: crs.hpp:309
util::nn< SingleCRSPtr > SingleCRSNNPtr
Definition: crs.hpp:164
util::nn< DerivedCRSPtr > DerivedCRSNNPtr
Definition: crs.hpp:475
Abstract class modelling a single coordinate reference system that is defined through the application...
Definition: crs.hpp:433
util::nn< VerticalReferenceFramePtr > VerticalReferenceFrameNNPtr
Definition: datum.hpp:514
std::shared_ptr< GeodeticCRS > GeodeticCRSPtr
Definition: crs.hpp:170
util::nn< ProjectedCRSPtr > ProjectedCRSNNPtr
Definition: crs.hpp:483
util::nn< EngineeringDatumPtr > EngineeringDatumNNPtr
Definition: datum.hpp:682
A derived coordinate reference system which has either a geodetic or a geographic coordinate referenc...
Definition: crs.hpp:869
A coordinate reference system describing the position of points through two or more independent singl...
Definition: crs.hpp:732
util::nn< DerivedGeodeticCRSPtr > DerivedGeodeticCRSNNPtr
Definition: crs.hpp:860
A derived coordinate reference system which has an engineering coordinate reference system as its bas...
Definition: crs.hpp:1191
util::nn< DerivedEngineeringCRSPtr > DerivedEngineeringCRSNNPtr
Definition: crs.hpp:1204
std::shared_ptr< DerivedParametricCRS > DerivedParametricCRSPtr
Definition: crs.hpp:1239
util::nn< CRSPtr > CRSNNPtr
Definition: coordinateoperation.hpp:46
util::nn< SphericalCSPtr > SphericalCSNNPtr
Definition: coordinatesystem.hpp:276
A derived coordinate reference system which has a projected coordinate reference system as its base C...
Definition: crs.hpp:996
util::nn< BoundCRSPtr > BoundCRSNNPtr
Definition: crs.hpp:69
std::shared_ptr< DatabaseContext > DatabaseContextPtr
Definition: io.hpp:126
Wrapper of a std::map<std::string, BaseObjectNNPtr>
Definition: util.hpp:410
std::shared_ptr< DerivedProjectedCRS > DerivedProjectedCRSPtr
Definition: crs.hpp:983
std::shared_ptr< ParametricCRS > ParametricCRSPtr
Definition: crs.hpp:659
Abstract class modelling a coordinate reference system consisting of one Coordinate System and either...
Definition: crs.hpp:128
A coordinate reference system with an associated transformation to a target/hub CRS.
Definition: crs.hpp:799
A derived coordinate reference system which has a geodetic (usually geographic) coordinate reference ...
Definition: crs.hpp:497
A coordinate reference system associated with a temporal datum and a one-dimensional temporal coordin...
Definition: crs.hpp:559
Contextually local coordinate reference system associated with an engineering datum.
Definition: crs.hpp:618
util::nn< TemporalCRSPtr > TemporalCRSNNPtr
Definition: crs.hpp:552
util::nn< std::shared_ptr< CSType > > CSNNPtr
Definition: crs.hpp:1118
util::nn< TransformationPtr > TransformationNNPtr
Definition: coordinateoperation.hpp:1277
Interface for an object that can be exported to a PROJ string.
Definition: io.hpp:451
util::nn< ParametricDatumPtr > ParametricDatumNNPtr
Definition: datum.hpp:729
static const GeodeticCRSNNPtr EPSG_4978
EPSG:4978 / "WGS 84" Geocentric.
Definition: crs.hpp:233
util::nn< ParametricCRSPtr > ParametricCRSNNPtr
Definition: crs.hpp:661
util::nn< GeodeticReferenceFramePtr > GeodeticReferenceFrameNNPtr
Definition: datum.hpp:350
util::nn< DerivedProjectedCRSPtr > DerivedProjectedCRSNNPtr
Definition: crs.hpp:985
util::nn< DerivedTemporalCRSPtr > DerivedTemporalCRSNNPtr
Definition: crs.hpp:1278
std::shared_ptr< DerivedVerticalCRS > DerivedVerticalCRSPtr
Definition: crs.hpp:1043
std::shared_ptr< DerivedGeodeticCRS > DerivedGeodeticCRSPtr
Definition: crs.hpp:858
util::nn< GeographicCRSPtr > GeographicCRSNNPtr
Definition: crs.hpp:57
util::nn< CartesianCSPtr > CartesianCSNNPtr
Definition: coordinatesystem.hpp:423
util::nn< TemporalDatumPtr > TemporalDatumNNPtr
Definition: datum.hpp:633
Formatter to WKT strings.
Definition: io.hpp:143
std::shared_ptr< DatumEnsemble > DatumEnsemblePtr
Definition: datum.hpp:105
util::nn< EngineeringCRSPtr > EngineeringCRSNNPtr
Definition: crs.hpp:604
util::nn< VerticalCRSPtr > VerticalCRSNNPtr
Definition: crs.hpp:63
Interface for an object that can be exported to WKT.
Definition: io.hpp:423
util::nn< DerivedVerticalCRSPtr > DerivedVerticalCRSNNPtr
Definition: crs.hpp:1045
std::shared_ptr< DerivedEngineeringCRS > DerivedEngineeringCRSPtr
Definition: crs.hpp:1202
static const GeographicCRSNNPtr OGC_CRS84
OGC:CRS84 / "CRS 84" 2D GeographicCRS (long, lat)
Definition: crs.hpp:307
std::shared_ptr< GeographicCRS > GeographicCRSPtr
Definition: crs.hpp:55
A derived coordinate reference system which has a temporal coordinate reference system as its base CR...
Definition: crs.hpp:1265
util::nn< ConversionPtr > ConversionNNPtr
Definition: coordinateoperation.hpp:581
util::nn< EllipsoidalCSPtr > EllipsoidalCSNNPtr
Definition: coordinatesystem.hpp:317
std::shared_ptr< DerivedTemporalCRS > DerivedTemporalCRSPtr
Definition: crs.hpp:1276
A derived coordinate reference system which has a parametric coordinate reference system as its base ...
Definition: crs.hpp:1228
static const GeographicCRSNNPtr EPSG_4269
EPSG:4269 / "NAD83" 2D GeographicCRS.
Definition: crs.hpp:305
std::shared_ptr< ProjectedCRS > ProjectedCRSPtr
Definition: crs.hpp:481
util::nn< DerivedGeographicCRSPtr > DerivedGeographicCRSNNPtr
Definition: crs.hpp:926