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

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

      class Implementation;
      class EmptyImplementation;

      typedef boost::shared_ptr<Implementation>       ImplPtr;
      typedef boost::shared_ptr<const Implementation> ImplCPtr;

      typedef tbb::recursive_mutex Mutex;

      template <Type T> class Handle;

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

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

      DtFeatureGeometry();

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

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

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

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

      Type type() const;

      bool isEmpty() const;

      bool isUnknown() const;

      bool isPoint() const;

      bool isPath() const;

      bool isArea() const;

      ImplCPtr implementation() const;

      std::string debugPrint() const;

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

      const DtProj& projection() const;

      DtFeatureGeometry clone() 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;

      unsigned numberOfSubGeometries() const;

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

      DtPoint centroid() const;

      bool intersects(DtFeatureGeometry g) const;

      bool overlaps(DtFeatureGeometry g) const;

      bool covers(DtFeatureGeometry g) const;

      bool within(DtFeatureGeometry g) const;

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

      DtFeatureGeometry unionWith(DtFeatureGeometry g) const;

      DtFeatureGeometry intersectionWith(DtFeatureGeometry g) 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;
   };

   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:
      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 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 DtPoint centroid() 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 double distanceTo(DtFeatureGeometry, const DtProj &) const = 0;

      virtual DtFeatureGeometry unionWith(DtFeatureGeometry) const = 0;

      virtual DtFeatureGeometry intersectionWith(DtFeatureGeometry) 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;

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

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

      DtPoint centroid() const;
      bool intersects(DtFeatureGeometry) const;
      bool overlaps(DtFeatureGeometry) const;
      bool covers(DtFeatureGeometry) const;
      bool within(DtFeatureGeometry) const;
      double distanceTo(DtFeatureGeometry, const DtProj&) const;
      DtFeatureGeometry unionWith(DtFeatureGeometry g) const;
      DtFeatureGeometry intersectionWith(DtFeatureGeometry g) const;
      DtFeatureGeometry::Point closestPointTo(DtFeatureGeometry g, double* distanceTo = NULL) const;

   private:
      DtProj::CPtr myProjection;
   };

   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;

      using DtFeatureGeometry::projection;
      using DtFeatureGeometry::clone;
      using DtFeatureGeometry::transform;
      using DtFeatureGeometry::convert;
      using DtFeatureGeometry::centroid;
      using DtFeatureGeometry::intersects;
      using DtFeatureGeometry::overlaps;
      using DtFeatureGeometry::covers;
      using DtFeatureGeometry::within;
      using DtFeatureGeometry::distanceTo;
      using DtFeatureGeometry::unionWith;
      using DtFeatureGeometry::isEmpty;
      using DtFeatureGeometry::debugPrint;
   };

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

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

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

      using DtFeatureGeometry::projection;
      using DtFeatureGeometry::clone;
      using DtFeatureGeometry::transform;
      using DtFeatureGeometry::convert;
      using DtFeatureGeometry::centroid;
      using DtFeatureGeometry::intersects;
      using DtFeatureGeometry::overlaps;
      using DtFeatureGeometry::covers;
      using DtFeatureGeometry::within;
      using DtFeatureGeometry::distanceTo;
      using DtFeatureGeometry::unionWith;
      using DtFeatureGeometry::isEmpty;
      using DtFeatureGeometry::debugPrint;
      using DtFeatureGeometry::closestPointTo;
   };

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

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

      unsigned numberOfBoundaryPoints() const;
      std::auto_ptr<PointVector> boundaryPoints() const;

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

      using DtFeatureGeometry::projection;
      using DtFeatureGeometry::clone;
      using DtFeatureGeometry::transform;
      using DtFeatureGeometry::convert;
      using DtFeatureGeometry::centroid;
      using DtFeatureGeometry::overlaps;
      using DtFeatureGeometry::covers;
      using DtFeatureGeometry::within;
      using DtFeatureGeometry::intersects;
      using DtFeatureGeometry::distanceTo;
      using DtFeatureGeometry::unionWith;
      using DtFeatureGeometry::isEmpty;
      using DtFeatureGeometry::debugPrint;
   };

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