featureToGeometryConverter.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright 2013 VT MAK
*******************************************************************************/



#pragma once

#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <features/feature.h>
#include <features/featureSet.h>
#include <features/featureGeometry.h>
#include <vector>
#include <geometry/surface.h>
#include <geometry/extent.h>

#include <tbb/tbb_thread.h>
#include <tbb/spin_rw_mutex.h>
#include <tbb/mutex.h>

#include <boost/ptr_container/ptr_map.hpp>

class DtCollisionWorld;
class DtTerrainImplementation;

class DT_DLL_vantageTerrainImplementation DtThreadedTriangulator
{
public:
   typedef std::vector<MAKVRinTerra::DtFeatureGeometry> GeometryArray;

   DtThreadedTriangulator(const MAKVRinTerra::DtProj&, DtCollisionWorld*);

   virtual ~DtThreadedTriangulator();

   virtual void addProcessGeometry(const GeometryArray&, const DtSurface&, bool triangulate);

   static void threadMain(DtThreadedTriangulator*);

   virtual void process();

   virtual void stop();

   virtual void start();

   virtual bool isStopped() const;

   virtual bool isRunning() const;

   virtual void cancel();

   virtual bool isCancelled() const;

   virtual bool isProcessing() const;

   virtual void join();

protected:
   virtual MAKVRinTerra::DtFeatureGeometry::Point preProcessGeometry(const MAKVRinTerra::DtFeatureGeometry::Point& geom,
      const DtSurface& surface) const;

   virtual void tessellate(const GeometryArray& pointFeatures, const DtSurface& defaultSurface);

   virtual void triangulate(const GeometryArray& pointFeatures, const DtSurface& defaultSurface);

protected:
   MAKVRinTerra::DtProj::Ptr myProjection;
   DtCollisionWorld* myCollisionWorld;
   tbb::tbb_thread* myThread;
   mutable tbb::spin_rw_mutex myMutex;
   bool myStop;
   bool myRunning;
   bool myCancelled;
   bool myProcessing;

   struct ProcessGeometry
   {
      GeometryArray geometry;
      DtSurface surface;
      bool triangulate;
   };

   typedef std::vector<ProcessGeometry> ProcessGeometries;

   ProcessGeometries myProcessGeometries;
};

class DT_DLL_vantageTerrainImplementation DtFeatureToGeometryConverter
{
public:
   enum QueryType
   {
      QUERY_DEFAULT = 0,
      POINT_SELECT = 1,
      AREA_SELECT = 2,
      SURFACE_SELECT = 3 
   };

   typedef std::pair<std::string, QueryType> Query;
   typedef std::map<std::string, Query> Queries;

   DtFeatureToGeometryConverter();

   virtual ~DtFeatureToGeometryConverter();

   virtual void convertToGeometry(const DtPoint& pnt, const DtTerrainImplementation*, DtCollisionWorld*);

   virtual void reset();

   virtual void addQuery(const std::string& key, const std::string& value, QueryType = QUERY_DEFAULT);

   virtual std::string addQuery(const std::string& value, QueryType = QUERY_DEFAULT);
   std::string addQueryByAreaSelect(const std::string& value)
   {
      return addQuery(value, AREA_SELECT);
   }

   std::string addQueryByPointSelect(const std::string& value)
   {
      return addQuery(value, POINT_SELECT);
   }

   virtual void removeQuery(const std::string& key);

   virtual const Queries& queries() const;

   virtual bool determineSurfaceType(const DtPoint&, const DtTerrainImplementation* fc, const std::string& query, DtSurface& surface);

   virtual bool hasSurface(const MAKVRinTerra::DtFeatureGeometry&, DtSurface&);

   virtual void setSeaLevel(double);
   virtual double seaLevel() const;

   virtual DtCollisionWorld* collisionWorld();

protected:
   typedef std::pair<MAKVRinTerra::DtFeatureGeometry, DtSurface> SurfaceDefinition;
   typedef std::vector<SurfaceDefinition> Surfaces;

   struct AreaInformation
   {
      AreaInformation() {};

      AreaInformation(const AreaInformation& orig)
         : geometry(orig.geometry), extent(orig.extent), query(orig.query), retries(orig.retries) {};

      AreaInformation& operator=(const AreaInformation& orig) { geometry = orig.geometry;
      extent = orig.extent; query = orig.query; retries = orig.retries; return *this; };

      MAKVRinTerra::DtFeatureGeometry geometry;
      DtExtent extent;
      std::string query;
      int retries;
   };

   typedef std::vector<AreaInformation> AreasCovered;

   virtual void addForConversion(const MAKVRinTerra::DtFeature&, const DtTerrainImplementation* fc, DtCollisionWorld* c);

   virtual MAKVRinTerra::DtFeatureGeometry generateIntersection(const DtPoint&, const DtTerrainImplementation* fc, QueryType,
      MAKVRinTerra::DtFeatureGeometry& coverageArea);

   virtual bool shouldIntersectWith(const DtPoint&, const DtTerrainImplementation*, MAKVRinTerra::DtFeatureGeometry&, QueryType,
      const std::string& query, bool& firstTime, AreasCovered::iterator&);

   virtual void createGeometryFromPoints(const DtTerrainImplementation*, DtCollisionWorld*,
      const std::vector<MAKVRinTerra::DtFeatureGeometry>&) const;

   virtual void createGeometryFromAreas(const DtTerrainImplementation*, DtCollisionWorld*, const MAKVRinTerra::DtFeatureGeometry&) const;

   virtual void createGeometry(const std::vector<MAKVRinTerra::DtFeatureGeometry>&,
      const DtSurface&, const DtTerrainImplementation*, DtCollisionWorld*, bool triangulate) const;

   virtual bool shouldAddAsSurface(const MAKVRinTerra::DtFeature& , DtSurface& surface) const;

   virtual void addNewSurfaceGeometries(const Surfaces&, const DtTerrainImplementation* fc, const std::string& query);

   virtual bool noIntersectionFound(const MAKVRinTerra::DtFeatureGeometry&, DtSurface&) const;

   virtual std::auto_ptr<MAKVRinTerra::DtFeatureSet> createOrReturnSavedQuery(const DtTerrainImplementation* fc,
      std::string query, bool readDirectly = false);

   virtual void coverageArea(const MAKVRinTerra::DtFeature& feature);

   virtual void addAreaCovered(const MAKVRinTerra::DtFeatureGeometry geom, const std::string& query, int retries = 0);

   virtual AreaInformation createAreaInfo(const MAKVRinTerra::DtFeatureGeometry& geom, const std::string& query,
      int retries = 0) const;

   virtual void updateLastIntersection(const DtPoint&, bool valid, const DtSurface& surface);

protected:
   std::vector<MAKVRinTerra::DtFeatureGeometry> myPointFeatures;

   Queries myQueries;

   Surfaces myNewSurfaces;

   struct LandArea
   {
      DtExtent extent;
      SurfaceDefinition area;
   };

   typedef std::vector<LandArea> LandAreas;

   LandAreas myLandAreas;
   struct LastIntersection
   {
      DtPoint location;
      bool result;
      DtSurface surface;
   };

   LastIntersection myLastIntersection;
   double mySeaLevel;

   typedef boost::ptr_map<std::string, MAKVRinTerra::DtFeatureSet> SavedQueries;
   SavedQueries mySavedQueries;

   AreasCovered myAreasCovered;
   AreasCovered myCoverageAreas;

   MAKVRinTerra::DtFeatureGeometry myIntersectArea;

   DtCollisionWorld* myCollisionWorld;

   bool myCoverageAreasInitialized;

   mutable DtThreadedTriangulator* myThreadedGeometryTriangulator;
   mutable DtThreadedTriangulator* myThreadedSurfaceTriangulator;
   mutable tbb::spin_rw_mutex myMutex;
   mutable tbb::spin_rw_mutex myLastLocationMutex;

   bool myUseGeosGeometryForLandAreas;
};