tileData.h

Go to the documentation of this file.

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


#pragma once
#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>

#include <terrainInterface/terrainProcessPolygonsBox.h>
#include <terrainInterface/terrainIntersectOptions.h>

#include <osgEarth/Feature>
#include <osgEarth/TerrainTileModel>
#include <osgEarth/TileKey>

#include <vrfutil/vrfChordIntersectRecordList.h>

#include <terrainCS/coordSystem.h>

#include <geometry/surface.h>
#include <geometry/chord.h>

#include <boost/shared_ptr.hpp>

#include <tbb/atomic.h>
#include <tbb/spin_rw_mutex.h>

#include <vector>
#include <string>
#include <map>

class DtTerrainSourceTracker;

struct DT_DLL_vantageTerrainImplementation DtTileData
{
   enum TileType
   {
      Normal,
      Empty
   };

   struct DT_DLL_vantageTerrainImplementation Extent
   {
      typedef std::vector<Extent> Vector;

      static Vector Simplify(const Vector& extents);

      explicit Extent(const osgEarth::TileKey&);
      explicit Extent(const DtVector& min, const DtVector& max);
      bool operator==(const Extent & rhs) const;

      DtVector min, max;
   };

   struct DT_DLL_vantageTerrainImplementation IndexExtent
   {
      typedef std::vector<IndexExtent> Vector;

      explicit IndexExtent(const DtTileData& tile, const Extent& extent);

      unsigned minx, miny, maxx, maxy;
   };

   explicit DtTileData(
      const DtTerrainSourceTracker& tracker,
      const osgEarth::TileKey& key);

   virtual ~DtTileData();

   virtual bool inUse() const { return false; };

   const DtTerrainSourceTracker& tracker;

   double elevationTolerance;

   CS_Type cstype;

   const osgEarth::TileKey tileKey;

   osg::ref_ptr<osgEarth::TerrainTileModel> tileModel;

   Extent extent;
   DtExtent dtExtent;

   bool setSoilType(const DtPoint & geodeticPt, DtSurface & surface, bool blockIfUnavailable, bool& landDataAvailable) const;

   DtSurface setSoilType(const DtTerrainTriangleStruct & tri, bool blockIfUnavailable) const;

   virtual void addMaskExtents(const Extent::Vector& extents);

   virtual void addMaskExtent(const Extent& extent);

   virtual void removeMaskExtent(const Extent& extent);

   virtual void getMaskExtents(Extent::Vector& extents);

   virtual bool insideValidArea(const DtPoint& p) const;

   virtual bool extentInsideValidArea(unsigned x1, unsigned y1, unsigned x2, unsigned y2) const;

   virtual bool extentOutsideValidArea(unsigned x1, unsigned y1, unsigned x2, unsigned y2) const;

   virtual bool addActiveTileKey(const osgEarth::TileKey& key) = 0;

   virtual void recomputeActiveTileKeyAreas() = 0;

   TileType type;

   std::vector< osg::ref_ptr<osg::Node> > geometries;

   std::vector< osg::ref_ptr<osg::Node> > features;

   std::vector < osgEarth::TileKey > featuresTileKey;
   std::vector < std::string > featuresLayerName;

   virtual std::string description() const = 0;

   virtual unsigned numberOfVertices() const = 0;

   virtual unsigned numberOfTrianglesForVertices() const;

   virtual void getTriangleVerticesGridSpaced(unsigned xindex, unsigned yindex, double& x, double& y) const = 0;

   virtual void getTriangleVertices(unsigned xindex, unsigned yindex, double& x, double& y) const = 0;


   virtual void getTriangleIndices(double x, double y, unsigned& xindex, unsigned& yindex) const = 0;

   virtual double getTriangleIdxVsHeightFieldIdxRatio() const;

   virtual double interpolateHeight(
      unsigned triangleXIndex, unsigned triangleYIndex,
      unsigned* heightFieldXUsed = 0, unsigned* heightFieldYUsed = 0) const = 0;

   virtual double heightField(unsigned col, unsigned row) const = 0;

   virtual bool getLandCoverName(const DtPoint & pt, std::string & landCoverName, bool &dataAvailable, bool blockOnUnavailable) const = 0;

   virtual int getLandCoverValue(const DtPoint & pt, bool & dataAvailable, bool blockOnUnavailable) const = 0;

   tbb::atomic<unsigned int> numTriangles;

   bool pendingRemoval;

   virtual DtTerrainIntersectIDType getLastUsed() const = 0;

   virtual bool updateLastUsed(DtTerrainIntersectIDType value) = 0;

   virtual bool findIntersectionsNonRecursive(
      const DtChord& chord,
      unsigned x1, unsigned y1, unsigned x2, unsigned y2,
      DtVrfChordIntersectRecordList& intList,
      const DtTerrainIntersectOptions& options,
      DtIntersectionRecord::DtIntersectionType irtFlag) const;

     
   virtual bool findIntersections(
      const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      const DtTerrainIntersectOptions& options) const = 0;

   virtual void findTriangles(
      const DtTerrainProcessPolygonsBox& box,
      unsigned x1, unsigned y1, unsigned x2, unsigned y2,
      DtTriangleOutputInterface&,
      bool singleCell = false,
      bool insideValidAreaChecked = false) const;

   virtual void findTriangles(
      const DtTerrainProcessPolygonsBox& box,
      DtTriangleOutputInterface&) const = 0;

   virtual osgEarth::FeatureList& groundFeatureList();

   virtual void forceLoadAllData(bool isBlocking = true) { }
protected:

   virtual void checkIntersect(const DtChord& chord, const int& cellX, const int& cellY,
      DtVrfChordIntersectRecordList& intList,
      const DtTerrainIntersectOptions& options,
      DtIntersectionRecord::DtIntersectionType irtFlag,
      bool tileLargeEnoughForBilinear,
      bool& foundIntersection) const;

   mutable tbb::spin_rw_mutex maskExtentsMutex;


   Extent::Vector maskExtents;

   Extent::Vector unSimplifiedMaskExtents;

   IndexExtent::Vector maskIndexExtents;

   osgEarth::FeatureList myGroundFeatureList;
};

class TileData : public DtTileData
{
public:
   TileData(const DtTerrainSourceTracker& tracker,
      const osgEarth::TileKey& key);

   DtTerrainIntersectIDType getLastUsed() const;

   bool updateLastUsed(DtTerrainIntersectIDType value);

   bool addActiveTileKey(const osgEarth::TileKey& key);

   void recomputeActiveTileKeyAreas();

   bool insideValidArea(const DtPoint& p) const;

   bool extentInsideValidArea(unsigned x1, unsigned y1, unsigned x2, unsigned y2) const;

   bool extentOutsideValidArea(unsigned x1, unsigned y1, unsigned x2, unsigned y2) const;

   bool getLandCoverName(const DtPoint & pt, std::string & landCoverName, bool & dataAvailable, bool blockOnUnavailable) const;

   int getLandCoverValue(const DtPoint & pt, bool & dataAvailable, bool blockOnUnavailable) const;


protected:
   tbb::atomic<DtTerrainIntersectIDType> myLastUsed;

   typedef std::set<osgEarth::TileKey> TileKeySet;

   TileKeySet myInactiveTileKeys;
   TileKeySet myActiveTileKeys;

   mutable tbb::spin_rw_mutex myInactiveAreasMutex;
   Extent::Vector myInactiveAreas;
   IndexExtent::Vector myInactiveIndexAreas;
};

typedef std::map< osgEarth::TileKey, boost::shared_ptr<DtTileData> > DtTerrainTileMap;