featureGeometry.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2012 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <features/featuresDefines.h>
#include <features/proj.h>

#include <geometry/point.h>
#include <vrfutil/objectCounter.h>

#include <boost/function.hpp>

#include <iosfwd>

namespace MAKVRinTerra
{
   class DT_DLL_features DtFeatureGeometry
      : public DtObjectDebugger<DtFeatureGeometry>
   {
   public:
      typedef DtTaggedException<struct InvalidGeometryTag>   InvalidGeometry;
      typedef DtTaggedException<struct BadGeometryCastTag>   BadGeometryCast;

      enum Type
      {
         UnknownType = -1,
         PointType = 0,
         PathType = 1,
         AreaType = 2,
      };

      template <Type T> class Handle;

      typedef DtFeatureGeometry  Unknown;
      typedef Handle<PointType>  Point;
      typedef Handle<PathType>   Path;
      typedef Handle<AreaType>   Area;

      typedef std::vector<DtFeatureGeometry> GeometryVector;
      typedef std::vector<DtPoint>           PointVector;

      class Implementation;
      class EmptyImplementation;
      class RelationshipMatrix;

      typedef boost::shared_ptr<Implementation>       ImplPtr;

      typedef boost::shared_ptr<const Implementation> ImplCPtr;

      typedef std::string Hash;

      static std::string ToString(Type);

      static DtFeatureGeometry FromWKT(const std::string&, const DtProj&);


      static Area MakeBox(Point, double length, double width, double rotation);
      static Area MakeBox(const DtProj&, double xmin, double ymin, double xmax, double ymax);
      static Area MakeBox(const DtProj::Bounds&);


      static Area MakeArea(const DtProj&, const std::vector<DtPoint>& points);
      static Area MakeArea(const DtProj&, const std::vector<DtVector>& points);
      static Path MakePath(const DtProj&, const std::vector<DtPoint>& points);
      static Path MakePath(const DtProj&, const std::vector<DtVector>& points);


      static DtFeatureGeometry MakeSet(const GeometryVector&, const DtProj&);
      static DtFeatureGeometry MakeSet(const GeometryVector&);

      template <typename Container>
      static DtFeatureGeometry MakeSet(const Container& cont)
      {
         return MakeSet(GeometryVector(cont.begin(), cont.end()));
      }

      template <typename Iterator>
      static DtFeatureGeometry MakeSet(Iterator i, Iterator end)
      {
         return MakeSet(GeometryVector(i,end));
      }

      static GeometryVector Flatten(DtFeatureGeometry);

      static std::vector<Path> MergeLines(DtFeatureGeometry);

      static DtFeatureGeometry SimplifySet(const GeometryVector&, const DtProj&);
      static DtFeatureGeometry SimplifySet(const GeometryVector&);

      DtFeatureGeometry();

      //DtFeatureGeometry(const ImplPtr&);
      DtFeatureGeometry(const ImplCPtr&);
      DtFeatureGeometry(Implementation*);

      template <Type T>
      DtFeatureGeometry(const Handle<T>& h)
         : myImpl(h.myImpl)
      {
      }

      DtFeatureGeometry& operator=(const DtFeatureGeometry&);

      template <Type T>
      DtFeatureGeometry& operator=(const Handle<T>& h)
      {
         myImpl = h.myImpl;
         return *this;
      }

      Type type() const;

      std::string description() const;

      std::string toWKT() const;

      bool isValid() const;

      bool isEmpty() const;

      bool isUnknown() const;

      bool isPoint() const;

      bool isPath() const;

      bool isArea() const;

      unsigned dimension() const;

      Area asArea() const;

      Hash hash() const;

      template <typename T>
      boost::shared_ptr<T> cast();

      template <typename T>
      boost::shared_ptr<const T> cast() const;

      const DtProj& projection() const;

      typedef boost::function<DtPoint (const DtPoint&)> TransformFunction;

      void transform(const TransformFunction& func);

      void convert(const DtProj& p);

      void convertToLocalTopo();

      void prepare();

      DtFeatureGeometry simplify(double tolerance) const;

      unsigned numberOfPoints() const;

      std::auto_ptr<PointVector> points() const;

      std::auto_ptr<PointVector> pointsWithHeight() const;

      boost::optional<DtPoint> singlePointWithHeight() const;

      std::auto_ptr<PointVector> pointsWithoutHeight() const;

      unsigned numberOfSubGeometries() const;

      std::auto_ptr<GeometryVector> subGeometries() const;

      std::auto_ptr<RelationshipMatrix> relate(DtFeatureGeometry) const;

      bool equals(DtFeatureGeometry g) const;

      bool intersects(DtFeatureGeometry g) const;

      bool overlaps(DtFeatureGeometry g) const;

      bool crosses(DtFeatureGeometry g) const;

      bool covers(DtFeatureGeometry g) const;

      bool within(DtFeatureGeometry g) const;

      bool touches(DtFeatureGeometry g) const;

      bool contains(DtFeatureGeometry g) const;

      DtProj::Bounds bounds() const;

      DtFeatureGeometry extent() const;

      double length() const;

      double area() const;

      Point centroid() const;

      double distanceTo(DtFeatureGeometry g, const DtProj& p) const;

      DtFeatureGeometry unionWith(DtFeatureGeometry g) const;

      DtFeatureGeometry intersectionWith(DtFeatureGeometry g) const;

      DtFeatureGeometry differenceWith(DtFeatureGeometry g) const;

      DtFeatureGeometry buffer(double width) const;

      DtFeatureGeometry buffer(double width, unsigned quadrantSegments) const;

      DtFeatureGeometry bufferWithFlatCap(double width, unsigned segments) const;

      DtFeatureGeometry convexHull() const;

      DtFeatureGeometry boundary() const;

      DtFeatureGeometry::Point closestPointTo(
         DtFeatureGeometry g, const DtProj&, double* distanceTo = 0) const;

      DtFeatureGeometry::Point closestPointTo(
         DtFeatureGeometry g, double* distanceTo = 0) const;

      ImplPtr  implementation();
      ImplCPtr implementation() const;

      class DT_DLL_features Mutex
      {
      public:
         virtual ~Mutex();

         virtual void lock() = 0;
         virtual void unlock() = 0;
      };

   protected:
      class DT_DLL_features Lock : boost::noncopyable
      {
      public:
         explicit Lock(const Implementation&);

         explicit Lock(const Implementation&, const Implementation&);

         ~Lock();

      private:
         Mutex* mutex1;
         Mutex* mutex2;
      };

      ImplPtr myImpl;
   };

   template <typename T>
   boost::shared_ptr<T> DtFeatureGeometry::cast()
   {
      return boost::dynamic_pointer_cast<T>(implementation());
   }

   template <typename T>
   boost::shared_ptr<const T> DtFeatureGeometry::cast() const
   {
      return boost::dynamic_pointer_cast<const T>(implementation());
   }

   class DT_DLL_features DtFeatureGeometry::Implementation
      : public boost::enable_shared_from_this<DtFeatureGeometry::Implementation>
      , public DtObjectDebugger<DtFeatureGeometry::Implementation>
   {
   public:
      typedef DtFeatureGeometry::ImplPtr  Ptr;
      typedef DtFeatureGeometry::ImplCPtr CPtr;

      typedef DtFeatureGeometry::Type                 Type;
      typedef std::vector<DtFeatureGeometry>          GeometryVector;
      typedef std::vector<DtPoint>                    PointVector;

      virtual ~Implementation();

      virtual Mutex& getMutex() const;

      virtual std::string description() const;

      virtual std::string toWKT() const;

      virtual bool isValid() const;

      virtual bool isEmpty() const;

      virtual unsigned dimension() const;

      virtual Hash hash() const;

      virtual DtFeatureGeometry clone() const = 0;

      virtual bool unique() const;

      virtual const DtProj & projection() const = 0;

      typedef boost::function<DtPoint (const DtPoint&)> TransformFunction;

      virtual void transform(const TransformFunction&) = 0;

      virtual void convert(const DtProj &) = 0;

      virtual void prepare();

      virtual DtFeatureGeometry simplify(double tolerance) const;

      virtual Type type() const = 0;

      virtual unsigned numberOfPoints() const = 0;

      virtual std::auto_ptr<PointVector> points() const = 0;

      virtual boost::optional<DtPoint> singlePoint() const;

      virtual unsigned numberOfSubGeometries() const = 0;

      virtual std::auto_ptr<GeometryVector> subGeometries() const = 0;

      virtual std::auto_ptr<RelationshipMatrix> relate(DtFeatureGeometry) const;

      virtual bool equals(DtFeatureGeometry) const = 0;

      virtual bool intersects(DtFeatureGeometry) const = 0;

      virtual bool overlaps(DtFeatureGeometry) const = 0;

      virtual bool crosses(DtFeatureGeometry) const = 0;

      virtual bool covers(DtFeatureGeometry) const = 0;

      virtual bool within(DtFeatureGeometry) const = 0;

      virtual bool touches(DtFeatureGeometry) const = 0;

      virtual bool contains(DtFeatureGeometry) const = 0;

      virtual DtProj::Bounds bounds() const;

      virtual DtFeatureGeometry extent() const;

      virtual double length() const = 0;

      virtual double area() const = 0;

      virtual Point centroid() const = 0;

      virtual double distanceTo(DtFeatureGeometry, const DtProj &) const = 0;

      virtual DtFeatureGeometry unionWith(DtFeatureGeometry) const = 0;

      virtual DtFeatureGeometry intersectionWith(DtFeatureGeometry) const = 0;

      virtual DtFeatureGeometry differenceWith(DtFeatureGeometry) const = 0;

      virtual DtFeatureGeometry buffer(double width, unsigned segments) const = 0;

      virtual DtFeatureGeometry bufferWithFlatCap(double width, unsigned segments) const = 0;

      virtual DtFeatureGeometry convexHull() const = 0;

      virtual DtFeatureGeometry boundary() const = 0;

      virtual DtFeatureGeometry::Point closestPointTo(
         DtFeatureGeometry, const DtProj&, double* distanceTo = 0) const = 0;

   protected:
      explicit Implementation();
      explicit Implementation(const Implementation&);

      Hash myHash;
   };

   class DtFeatureGeometry::EmptyImplementation
      : public DtFeatureGeometry::Implementation
      , public DtObjectDebugger<DtFeatureGeometry::Implementation>
   {
   public:
      typedef boost::shared_ptr<EmptyImplementation> Ptr;

      EmptyImplementation();

      DtFeatureGeometry clone() const;

      const DtProj & projection() const;
      void transform(const TransformFunction&);
      void convert(const DtProj &);
      Type type() const;
      bool isValid() const;

      unsigned numberOfPoints() const;
      std::auto_ptr<PointVector> points() const;
      boost::optional<DtPoint> singlePoint() const;

      unsigned numberOfSubGeometries() const;
      std::auto_ptr<GeometryVector> subGeometries() const;

      Point centroid() const;
      bool equals(DtFeatureGeometry) const;
      bool intersects(DtFeatureGeometry) const;
      bool overlaps(DtFeatureGeometry) const;
      bool crosses(DtFeatureGeometry) const;
      bool covers(DtFeatureGeometry) const;
      bool within(DtFeatureGeometry) const;
      bool touches(DtFeatureGeometry) const;
      bool contains(DtFeatureGeometry) const;
      double length() const;
      double area() const;
      double distanceTo(DtFeatureGeometry, const DtProj&) const;
      DtFeatureGeometry unionWith(DtFeatureGeometry g) const;
      DtFeatureGeometry intersectionWith(DtFeatureGeometry g) const;
      DtFeatureGeometry differenceWith(DtFeatureGeometry g) const;
      DtFeatureGeometry buffer(double width, unsigned segments) const;
      DtFeatureGeometry bufferWithFlatCap(double width, unsigned segments) const;
      DtFeatureGeometry convexHull() const;
      DtFeatureGeometry boundary() const;
      DtFeatureGeometry::Point closestPointTo(
         DtFeatureGeometry g, const DtProj&, double* distanceTo = 0) const;

   private:
      DtProj::CPtr myProjection;
   };

   class DT_DLL_features DtFeatureGeometry::RelationshipMatrix
      : boost::noncopyable
      , public DtObjectDebugger<DtFeatureGeometry::RelationshipMatrix>
   {
   public:
      virtual ~RelationshipMatrix();

      virtual bool equals() const;
      virtual bool intersects() const;
      virtual bool disjoint() const;
      virtual bool covers() const;
      virtual bool coveredBy() const;
      virtual bool within() const;
      virtual bool touches() const;
      virtual bool overlaps() const;
      virtual bool crosses() const;
      virtual bool contains() const;
   };

   template <>
   class DT_DLL_features DtFeatureGeometry::Handle<DtFeatureGeometry::PointType>
      : public DtFeatureGeometry
   {
   public:
      friend class DtFeatureGeometry;

      static DtFeatureGeometry::Point Make(const DtPoint& p, const DtProj& proj);
      static DtFeatureGeometry::Point Make(const DtVector& v, const DtProj& proj);

      Handle();
      Handle(const DtFeatureGeometry&);
      Handle(const Implementation::Ptr&);

      Handle(const DtPoint&, const DtProj& proj);
      Handle(const DtVector&, const DtProj& proj);

      DtPoint point() const;
      DtPoint pointWithHeight() const;
      DtPoint pointWithoutHeight() const;
   };

   template <>
   class DT_DLL_features DtFeatureGeometry::Handle<DtFeatureGeometry::PathType>
      : public DtFeatureGeometry
   {
   public:
      friend class DtFeatureGeometry;

      typedef std::vector<DtFeatureGeometry::Path> Vector;

      static DtFeatureGeometry::Path Make(const PointVector& points, const DtProj& proj);

      static DtFeatureGeometry::Path Make(
         const DtPoint& p1, const DtPoint& p2,
         const DtProj& proj);

      static DtFeatureGeometry::Path Make(
         const DtPoint& p1, const DtPoint& p2, const DtPoint& p3,
         const DtProj& proj);

      template <typename Container>
      static DtFeatureGeometry::Path Make(const Container& cont, const DtProj& proj)
      {
         return Make(PointVector(cont.begin(), cont.end()), proj);
      }

      template <typename Iterator>
      static DtFeatureGeometry::Path Make(Iterator i, Iterator end, const DtProj& proj)
      {
         return Make(PointVector(i,end), proj);
      }

      Handle();
      Handle(const DtFeatureGeometry&);
      Handle(const Implementation::Ptr&);

      Path reversed() const;
   };

   template <>
   class DT_DLL_features DtFeatureGeometry::Handle<DtFeatureGeometry::AreaType>
      : public DtFeatureGeometry
   {
   public:
      friend class DtFeatureGeometry;

      typedef std::vector<DtFeatureGeometry::Area> Vector;

      Handle();
      Handle(const DtFeatureGeometry&);
      Handle(const Implementation::Ptr&);

      Path outerBoundary() const;

      unsigned numberOfHoles() const;
      std::auto_ptr<GeometryVector> holes() const;

      Path findShortestPerimeter(Path) const;
   };

   DT_DLL_features std::ostream& operator<< (std::ostream&, DtFeatureGeometry::Type);
   DT_DLL_features std::ostream& operator<< (std::ostream&, const DtFeatureGeometry&);

   template <DtFeatureGeometry::Type T>
   std::ostream& operator<< (std::ostream& str, const DtFeatureGeometry::Handle<T>& g)
   {
      return str << DtFeatureGeometry(g);
   }
}

DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtFeatureGeometry);
DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtFeatureGeometry::Implementation);
DT_DEFINE_OBJECT_DEBUGGER_NAME(MAKVRinTerra::DtFeatureGeometry::RelationshipMatrix);