proj.h

Go to the documentation of this file.

#pragma once

#include <features/featuresDefines.h>

#include <geometry/point.h>
#include <matrix/coordTransform.h>

#include <vlutil/vlMutex.h>
#include <vrfutil/taggedException.h>

#include <boost/enable_shared_from_this.hpp>
#include <boost/optional.hpp>
#include <boost/noncopyable.hpp>
#include <boost/tuple/tuple.hpp>

#include <iosfwd>
#include <list>

class Coordinate_System;
class OGRSpatialReference;

namespace osgEarth {
   class SpatialReference;
}

namespace MAKVRinTerra
{

class DtFeatureGeometry;

class DT_DLL_features DtProj : public boost::enable_shared_from_this<DtProj>
{
public:
   typedef boost::shared_ptr<DtProj>       Ptr;
   typedef boost::shared_ptr<const DtProj> CPtr;

   typedef boost::error_info<DtProj, DtProj::CPtr> ErrorInfo;
   typedef boost::tuple<ErrorInfo,ErrorInfo> ConvertErrorInfo;
   typedef DtTaggedException<DtProj> Exception;
   friend class DtTaggedException<DtProj>;

   enum AngleUnits
   {
      Degrees,
      Radians
   };

   enum AngleOrder
   {
      LatLong,
      LongLat
   };

   class DT_DLL_features Bounds
   {
   public:
      static Bounds Make(const DtProj& proj);

      struct LineSegment
      {
         LineSegment(const DtPoint& p1, const DtPoint& p2)
            : point1(p1), point2(p2) { }

         DtPoint point1, point2;
      };

      Bounds();

      Bounds(const DtProj& proj, double xmin, double ymin, double xmax, double ymax);
      Bounds(const DtProj& proj);

      bool isValid() const;

      double xmin() const;
      double ymin() const;
      double xmax() const;
      double ymax() const;

      const DtProj& projection() const;

      bool intersects(const DtPoint&) const;
      bool intersects(const LineSegment&, bool* contained = 0) const;

      Bounds makeSubBounds(unsigned x, unsigned y, unsigned xgrid, unsigned ygrid) const;
      Bounds makeSubBounds(unsigned n, unsigned xgrid, unsigned ygrid) const;

   private:
      double myXmin;
      double myYmin;
      double myXmax;
      double myYmax;
      DtProj::CPtr myProjection;
   };

   static DtProj::CPtr Make(
      std::string projString, boost::optional<AngleUnits> = boost::optional<AngleUnits>());
   static DtProj::CPtr Make(const Coordinate_System*);
   static DtProj::CPtr Make(std::auto_ptr<Coordinate_System>);
   static DtProj::CPtr Make(const OGRSpatialReference*);
   static DtProj::CPtr Make(const osgEarth::SpatialReference*);

   static DtProj::Ptr MakeCopy(const DtProj&);

   static DtProj::CPtr LocalTopo(const DtProj &, DtPoint localposition);

   static DtProj::CPtr Geocentric();
   static DtProj::CPtr FlatEarth();
   static DtProj::CPtr Geodetic();
   static DtProj::CPtr GeodeticInDegrees();

   std::string projString() const;

   std::string print() const;
   std::string printDetailed() const;

   const Coordinate_System* coordinateSystem() const;
   const DtCoordTransform* transform() const;

   bool is2D() const;

   bool isLocal2D() const;

   bool isRectangular() const;

   bool isLocalTopo() const;

   bool inRadians() const;
   bool inDegrees() const;
   bool isLatLong() const;
   bool isLongLat() const;

   bool isGeodetic() const;
   bool isGeocentric() const;
   bool isFlatEarth() const;
   bool isUTM() const;

   void setAngleUnits(AngleUnits);

   bool operator==(const DtProj &) const;
   bool operator!=(const DtProj & p) const { return !(*this == p); }

   static void Convert(
      const DtProj & from, const DtProj & to,
      long count, int offset, double* x, double* y, double* z);

   static void Convert(const DtProj & from, const DtProj & to, long count, DtPoint* points);
   static void Convert(const DtProj & from, const DtProj & to, DtPoint & point);
   static void Convert(const DtProj & from, const DtProj & to, std::vector<DtPoint> & points);
   static void Convert(const DtProj & from, const DtProj & to, std::list<DtPoint> & points);

   static void ConvertToSame2DProjection(DtFeatureGeometry &, DtFeatureGeometry &);

   struct ProjData
   {
      mutable DtMutex mutex;
      std::string projString;
      void* context;
      void* proj;

      static ProjData* Make(const Coordinate_System*);

      ProjData();
      ProjData(std::string);
      ~ProjData();

      bool operator==(const ProjData&) const;
      bool operator!=(const ProjData&) const;
   };

private:
   //Create a proj from a proj string
   explicit DtProj(std::string projString, boost::optional<AngleUnits>);
   
   //Create a proj from a Coordinate_System object
   explicit DtProj(std::auto_ptr<Coordinate_System> cs);
   
   //Create a topo proj from a reference point
   explicit DtProj(const DtProj&, DtPoint);

   //Copy constructor
   explicit DtProj(const DtProj&);

   boost::shared_ptr<ProjData> myProjData;
   boost::shared_ptr<Coordinate_System> myCS;
   boost::optional<AngleUnits> myAngleUnits;
   boost::optional<AngleOrder> myAngleOrder;
   boost::optional<DtCoordTransform> myTransform;
};

DT_DLL_features std::ostream& operator<<(std::ostream&, const DtProj&);
DT_DLL_features std::ostream& operator<<(std::ostream&, const DtProj::Bounds&);

}