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 <boost/function.hpp>

#include <iosfwd>

namespace tbb
{
   class recursive_mutex;
}

namespace MAKVRinTerra
{
   class DT_DLL_features DtFeatureGeometry
   {
   public:
      typedef TaggedException<struct InvalidGeometryTag>   InvalidGeometry;
      typedef TaggedException<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;

      typedef tbb::recursive_mutex Mutex;

      static std::string ToString(Type);


      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&, std::vector<DtPoint> points);
      static Area MakeArea(const DtProj&, std::vector<DtVector> points);
      static Path MakePath(const DtProj&, std::vector<DtPoint> points);
      static Path MakePath(const DtProj&, std::vector<DtVector> points);


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

      DtFeatureGeometry();

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

      template <Type T>
      DtFeatureGeometry(const Handle<T>&);

      DtFeatureGeometry& operator=(const DtFeatureGeometry& g)
      {
         myImpl = g.myImpl;
         myHash = g.myHash;
         return *this;
      }

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

      Type type() const;

      std::string description() 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;

      ImplCPtr implementation() const;

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

      const DtProj& projection() const;

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

      void transform(TransformFunction func);

      void convert(const DtProj &p);

      unsigned numberOfPoints() const;

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

      std::auto_ptr<PointVector> pointsWithHeight() 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 covers(DtFeatureGeometry g) const;

      bool within(DtFeatureGeometry g) const;

      bool touches(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 convexHull() const;

      DtFeatureGeometry boundary() const;

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

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

         Lock(const Implementation&, const Implementation&);

         ~Lock();

      private:
         Mutex* myMutex1;
         Mutex* myMutex2;
      };

      ImplPtr myImpl;
      Hash myHash;
   };

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

   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:
      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 bool isValid() const;

      virtual bool isEmpty() const;

      virtual unsigned dimension() 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(TransformFunction) = 0;

      virtual void convert(const DtProj &) = 0;

      virtual Type type() const = 0;

      virtual unsigned numberOfPoints() const = 0;

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

      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 covers(DtFeatureGeometry) const = 0;

      virtual bool within(DtFeatureGeometry) const = 0;

      virtual bool touches(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 convexHull() const = 0;

      virtual DtFeatureGeometry boundary() const = 0;

      virtual DtFeatureGeometry::Point closestPointTo(DtFeatureGeometry, double* distanceTo = NULL) const = 0;
   };

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

      EmptyImplementation();

      DtFeatureGeometry clone() const;

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

      unsigned numberOfPoints() const;
      std::auto_ptr<PointVector> points() 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 covers(DtFeatureGeometry) const;
      bool within(DtFeatureGeometry) const;
      bool touches(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 convexHull() const;
      DtFeatureGeometry boundary() const;
      DtFeatureGeometry::Point closestPointTo(DtFeatureGeometry g, double* distanceTo = NULL) const;

   private:
      DtProj::CPtr myProjection;
   };

   class DT_DLL_features DtFeatureGeometry::RelationshipMatrix : boost::noncopyable
   {
   public:
      virtual ~RelationshipMatrix();

      virtual bool intersects() const;
      virtual bool covers() const;
      virtual bool within() const;
      virtual bool touches() const;
   };

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

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

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

      DtPoint point() const;
      DtPoint pointWithHeight() const;

      using DtFeatureGeometry::projection;
      using DtFeatureGeometry::transform;
      using DtFeatureGeometry::convert;
      using DtFeatureGeometry::centroid;
      using DtFeatureGeometry::equals;
      using DtFeatureGeometry::intersects;
      using DtFeatureGeometry::overlaps;
      using DtFeatureGeometry::covers;
      using DtFeatureGeometry::within;
      using DtFeatureGeometry::touches;
      using DtFeatureGeometry::length;
      using DtFeatureGeometry::area;
      using DtFeatureGeometry::distanceTo;
      using DtFeatureGeometry::unionWith;
      using DtFeatureGeometry::intersectionWith;
      using DtFeatureGeometry::buffer;
      using DtFeatureGeometry::convexHull;
      using DtFeatureGeometry::boundary;
      using DtFeatureGeometry::isEmpty;
      using DtFeatureGeometry::isValid;
      using DtFeatureGeometry::hash;
      using DtFeatureGeometry::asArea;
   };

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

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

      static DtFeatureGeometry::Path Make(const PointVector& points, 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;

      using DtFeatureGeometry::numberOfPoints;
      using DtFeatureGeometry::points;
      using DtFeatureGeometry::pointsWithHeight;
      using DtFeatureGeometry::projection;
      using DtFeatureGeometry::transform;
      using DtFeatureGeometry::convert;
      using DtFeatureGeometry::centroid;
      using DtFeatureGeometry::equals;
      using DtFeatureGeometry::intersects;
      using DtFeatureGeometry::overlaps;
      using DtFeatureGeometry::covers;
      using DtFeatureGeometry::within;
      using DtFeatureGeometry::touches;
      using DtFeatureGeometry::length;
      using DtFeatureGeometry::area;
      using DtFeatureGeometry::distanceTo;
      using DtFeatureGeometry::unionWith;
      using DtFeatureGeometry::intersectionWith;
      using DtFeatureGeometry::buffer;
      using DtFeatureGeometry::convexHull;
      using DtFeatureGeometry::boundary;
      using DtFeatureGeometry::isEmpty;
      using DtFeatureGeometry::isValid;
      using DtFeatureGeometry::closestPointTo;
      using DtFeatureGeometry::hash;
      using DtFeatureGeometry::asArea;
   };

   template <>
   class DT_DLL_features DtFeatureGeometry::Handle<DtFeatureGeometry::AreaType>
      : protected 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;

      using DtFeatureGeometry::projection;
      using DtFeatureGeometry::transform;
      using DtFeatureGeometry::convert;
      using DtFeatureGeometry::centroid;
      using DtFeatureGeometry::overlaps;
      using DtFeatureGeometry::covers;
      using DtFeatureGeometry::within;
      using DtFeatureGeometry::touches;
      using DtFeatureGeometry::equals;
      using DtFeatureGeometry::intersects;
      using DtFeatureGeometry::length;
      using DtFeatureGeometry::area;
      using DtFeatureGeometry::distanceTo;
      using DtFeatureGeometry::unionWith;
      using DtFeatureGeometry::intersectionWith;
      using DtFeatureGeometry::buffer;
      using DtFeatureGeometry::convexHull;
      using DtFeatureGeometry::boundary;
      using DtFeatureGeometry::isEmpty;
      using DtFeatureGeometry::isValid;
      using DtFeatureGeometry::hash;
      using DtFeatureGeometry::asArea;
   };

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