osgEarthTerrainSourceTracker.h

Go to the documentation of this file.

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


#pragma once

#include <vantageTerrainImplementation/terrainSourceTracker.h>
#include <vantageTerrainImplementation/pageInVisitor.h>
#include <vantageTerrainImplementation/bulletUtil.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationUtil.h>

#include <terrainInterface/terrainProcessPolygonsBox.h>

#include <vrfutil/vertexList.h>

//Mak Terrain Toolkit includes
#include <geometry/sphere.h>

//#include <vlutil/vlSmartPointers.h>

#include <osgTerrain/TerrainTile>
#include <osgEarth/Profile>
#include <osgEarth/TileKey>
#include <osgEarth/MapNode>
#include <osgEarth/TerrainTileModel>

#include <string>
#include <list>
#include <vector>

#include <boost/ptr_container/ptr_vector.hpp>

#include <tbb/spin_rw_mutex.h>

class DtPageInTilesCommand;
class DtPageOutTilesCommand;
class DtVantageTerrainEngine;
class DtPoint;
class DtGeodeticCoord;
class DtTerrainPagingChord;
class DtTerrainPagingSphere;
class DtTerrainPagingShape;
class DtOsgEarthTerrainSourceTracker;
class DtOsgEarthTerrainSourcePager;
class DtTerrainIntersectOptions;
class DtTerrainIntersectStatus;

typedef std::list<osgEarth::TileKey> DtTileKeyList;

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

      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 DtOsgEarthTerrainSourceTracker& tracker,
      const osgEarth::TileKey& key);

   virtual ~DtTileData();

   const DtOsgEarthTerrainSourceTracker& tracker;

   const osgEarth::TileKey tileKey;

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

   Extent extent;

   virtual void addMaskExtents(const 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;

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

   virtual unsigned numberOfVertices() const = 0;

   virtual unsigned numberOfTrianglesForVertices() const;

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

   virtual DtVector getTriangleVertices(unsigned xindex, unsigned yindex) const;

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

   virtual void heightfieldIndexForTriangleIndex(
      unsigned triangleXIndex, unsigned triangleYIndex,
      unsigned& heightFieldXUsed, unsigned& heightFieldYUsed) const = 0;

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

   tbb::atomic<unsigned int> numTriangles;

   bool pendingRemoval;

   virtual DtTerrainIntersectIDType getLastUsed() const = 0;

   virtual bool updateLastUsed(DtTerrainIntersectIDType value) = 0;

   virtual bool findIntersections(
      const DtChord& chord,
      unsigned x1, unsigned y1, unsigned x2, unsigned y2,
      DtVrfChordIntersectRecordList& intList,
      DtIntersectionRecord::DtIntersectionType irtFlag,
      bool singleCell = false,
      bool insideValidAreaChecked = false) const;

   virtual bool findIntersections(
      const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      DtIntersectionRecord::DtIntersectionType irtFlag) 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;

protected:
   mutable tbb::spin_rw_mutex maskExtentsMutex;

   Extent::Vector maskExtents;

   IndexExtent::Vector maskIndexExtents;
};

class DT_DLL_vantageTerrainImplementation DtOsgEarthTerrainSourceTracker : public DtTerrainSourceTracker
{
public:
   class TileDataCallback;

   DtOsgEarthTerrainSourceTracker(
      DtVantageTerrainEngine*, DtPagerCommandQueue* commandQueue, 
      osgEarth::MapNode* mapNode);

   virtual bool useRawElevation() const;

   virtual boost::optional<DtTerrainIntersectOptions::Fidelity> intersectFidelity() const;

   virtual unsigned maxLOD() const;
   virtual void setMaxLOD(unsigned);

   virtual unsigned getMaxLODForBilinearIntersection() const;
   virtual void setMaxLODForBilinearIntersection(unsigned);

   virtual double triangleOutputMergeTolerance() const;
   virtual void setTriangleOutputMergeTolerance(double tol);
   virtual double intersetionTriangleMergeTolerance() const;
   virtual void setIntersectionTriangleMergeTolerance(double tol);

   virtual unsigned minElevationIndexLOD() const;
   virtual void setMinElevationIndexLOD(unsigned);
   virtual unsigned maxElevationIndexLOD() const;
   virtual void setMaxElevationIndexLOD(unsigned);

   virtual double maxChordLengthBeforeSplitSquared() const;
   virtual void setMaxChordLengthBeforeSplit(double);

   virtual unsigned maxElevationChordSplitTestLOD() const;
   virtual void setMaxElevationChordSplitTestLOD(unsigned);

   virtual unsigned tileCount() const;

   virtual unsigned cellCount() const;

   virtual osgEarth::MapNode* mapNode() const;

   virtual bool init(DtTerrainSourcePager&);

   virtual void addPagedInTile(
      const osgEarth::TileKey& tilekey,
      const boost::shared_ptr<DtTileData>& tileData);

   virtual void removePagedInTile(const osgEarth::TileKey tileKey);

   virtual bool dataAvailable(DtPagingMetaDataPtr metaData, 
      DtTerrainPagingGeometryPtr geometry);

   virtual bool findHeightFieldIntersections(
      DtTerrainIntersectStatus& status,
      const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      const DtTerrainIntersectOptions& options) const;

   virtual bool halveChordAndFindHeightFieldIntrx(
      const DtChord& chord, DtChord convertedChord,
      const DtTerrainIntersectOptions& options,
      DtTerrainIntersectStatus& status, 
      DtVrfChordIntersectRecordList& intList) const;

   virtual bool splitChordAt180AndFindHeightFieldIntrx(
      const DtChord& chord, 
      const DtTerrainIntersectOptions& options,
      DtTerrainIntersectStatus& status,
      DtVrfChordIntersectRecordList& intList) const;

   virtual void processTriangles(
      DtTriangleOutputInterface& output,
      const DtTerrainProcessPolygonsBox& box) const;

   virtual void pageInData(DtPagingMetaDataPtr metaData,
      DtTerrainPagingGeometryPtr geometry);

   virtual DtTerrainIntersectIDType findOldestPagedData(unsigned int& numTrianglesOut);

   virtual void pageOutOldestData(const int priority);

   virtual bool canPageOutData(DtTerrainIntersectIDType intersectId);

   virtual osgEarth::TileKey getBestTileKey(const osgEarth::TileKey&) const;

   virtual void findMissingTiles(const DtTerrainPagingGeometryPtr& geometry, DtTileKeyList& tiles) const;

   class DT_DLL_vantageTerrainImplementation IndexInterface
   {
   public:
      virtual bool processIndex(const DtString& name) { return true; }
      virtual bool process(const osgEarth::TileKey& key) { return true; }
      virtual bool traverse(const osgEarth::TileKey& key) { return true; }
      virtual void tileWritten(const osgEarth::TileKey& key, double min, double max) { }
   };

   class DT_DLL_vantageTerrainImplementation IndexOutputInterface
   {
   public:
      static std::auto_ptr<IndexOutputInterface> Create(const DtFilename&, unsigned precision);

      virtual ~IndexOutputInterface();

      virtual void write(const osgEarth::TileKey& tile, double min, double max, bool valid) = 0;
   };

   virtual void writeIndex(IndexInterface&, IndexOutputInterface&) const;
   virtual bool writeIndexLayers(IndexInterface&, unsigned precision) const;

   class DT_DLL_vantageTerrainImplementation IndexInputInterface
   {
   public:
      static std::auto_ptr<IndexInputInterface> Create(const DtFilename&);

      virtual ~IndexInputInterface();

      virtual bool read(unsigned& lod, unsigned& x, unsigned& y, double& min, double& max, bool& valid) = 0;
   };

   struct DT_DLL_vantageTerrainImplementation IndexConfig
   {
      std::string name;
      osgEarth::URI file;
      bool isDefault;
      double minTolerance, maxTolerance;
      unsigned minlod, maxlod;
      osgEarth::GeoExtent extent;

      explicit IndexConfig(const DtOsgEarthTerrainSourceTracker&, const osgEarth::Config&);
      explicit IndexConfig(const DtOsgEarthTerrainSourceTracker&);
   };

   virtual std::vector<IndexConfig> getIndexConfigInfoForLayer(
      const osgEarth::ElevationLayer& layer) const;

   virtual void readIndex(
      IndexInputInterface&,
      unsigned layerNumber,
      const IndexConfig& idxConfig);

   virtual bool readIndexLayers();

protected:

   virtual DtPageInTilesCommand* createPageInTilesCommand(
      DtPagingMetaDataPtr metaData);

   virtual DtPageOutTilesCommand* createPageOutTilesCommand(
      DtPagingMetaDataPtr metaData);

protected:
    
   class DT_DLL_vantageTerrainImplementation TileSpatialIndex
   {
   public:
      struct DT_DLL_vantageTerrainImplementation ElevationRange
      {
         static boost::optional<ElevationRange> Merge(
            const boost::optional<ElevationRange>& r1,
            const boost::optional<ElevationRange>& r2);

         double min, max;

         ElevationRange();
         ElevationRange(double min, double max);

         void merge(const ElevationRange&);
      };

      TileSpatialIndex(
         const DtOsgEarthTerrainSourceTracker& tracker,
         const osgEarth::TileKey& tilekey,
         TileSpatialIndex* parent);

      void getExtent(DtVector& lower, DtVector& upper, bool useElevation = true) const;
      void getSubTileExtent(unsigned i, DtVector& lower, DtVector& upper, bool useElevation = true) const;

      bool intersects(const DtTerrainPagingGeometry& geometry) const;
      bool intersectsSubTile(const DtTerrainPagingGeometry& geometry, int i) const;

      bool chordIntersects(const DtChord& chord, bool useElevation = true) const;
      bool extentIntersects(const DtExtent& extent) const;
      bool sphereIntersects(const DtSphere& sphere) const;
      bool shapeIntersects(const DtLocalVertexList& shape) const;
      bool chordIntersectsSubTile(const DtChord& chord, int i, bool useElevation = true) const;
      bool extentIntersectsSubTile(const DtExtent& shape, int i) const;
      bool sphereIntersectsSubTile(const DtSphere& sphere, int i) const;
      bool shapeIntersectsSubTile(const DtLocalVertexList& shape, int i) const;

      void findMissing(
         const DtTerrainPagingGeometry& geometry,
         DtTileKeyList& missing) const;

      bool findData(
         const DtTerrainPagingGeometry* geometry,
         std::vector< boost::shared_ptr<DtTileData> >& data,
         TileDataCallback* callback = 0) const;

      boost::optional<double> getMaxAltForChord(const DtChord& chord, unsigned maxlod) const;

      boost::shared_ptr<DtTileData> findOldest() const;

      bool addTile(const osgEarth::TileKey& key, const boost::shared_ptr<DtTileData>& data);

      void removeTile(const osgEarth::TileKey& tilekey);

      unsigned tileCount() const;

      unsigned cellCount() const;

      const osgEarth::TileKey tileKey() const { return myTileKey;  }

      TileSpatialIndex* setAltitudeRange(
         const osgEarth::TileKey& key,
         const ElevationRange& range,
         const ElevationRange& offsets,
         unsigned layerNum,
         bool coversTile);

      bool postProcessIndexLayer(unsigned layerNum);

      void writeIndex(
         IndexInterface& iface,
         IndexOutputInterface& output,
         osgEarth::ElevationLayer* layer = 0) const;

   protected:
      bool isTileEmpty() const;

      virtual void recomputePagedInData();

      const DtOsgEarthTerrainSourceTracker& myTracker;
      TileSpatialIndex* myParent;

      const osgEarth::TileKey myTileKey;
      const osgEarth::GeoExtent myGeoExtent;
      const bool myUseElevationFlag;

      boost::optional<ElevationRange> myElevationRange;

      struct ValidElevationRange
      {
         ElevationRange range;
         bool coversTile;

         ValidElevationRange(const ElevationRange& range, bool coversTile)
            : range(range), coversTile(coversTile) { }
      };

      std::vector< boost::optional<ValidElevationRange> > myPreviousLayersElevationRange;

      bool myPinned;

      struct SubTileSlot
      {
         osgEarth::GeoExtent extent;
         boost::scoped_ptr<TileSpatialIndex> subtile;
      };

      SubTileSlot& getOrCreateSlot(unsigned i);

      void pageOutSlotIfUnused(unsigned i);

      SubTileSlot mySubTiles[4];

      boost::shared_ptr<DtTileData> myTileData;

      bool myAllPagedInFlag;

      bool myMaxDataLevelFlag;
   };

   virtual void convertGeometry(
      const DtTerrainPagingGeometryPtr& geometry,
      std::vector<DtTerrainPagingGeometryPtr>& output) const;

   virtual bool convertGeometry(
      const DtTerrainPagingChord& geometry,
      std::vector<DtTerrainPagingGeometryPtr>& output) const;

   virtual bool convertGeometry(
      const DtTerrainPagingSphere& geometry,
      std::vector<DtTerrainPagingGeometryPtr>& output) const;

   virtual bool convertGeometry(
      const DtTerrainPagingShape& geometry,
      std::vector<DtTerrainPagingGeometryPtr>& output) const;

   virtual bool nearCenterOfEarth(const DtChord& chord) const;

   virtual bool aboveAllTerrain(
      const DtChord& geocentricChord,
      const DtChord& geodeticCoord) const;

   virtual bool shortEnoughForIntersection(
      const DtChord& geocentricChord,
      const DtChord& geodeticChord,
      double chordLengthSq) const;

   virtual bool crosses180Lon(const DtChord& geodeticChord) const;

   virtual bool findData(
      const DtTerrainPagingGeometry* geometry,
      std::vector< boost::shared_ptr<DtTileData> >& data,
      const DtPagingMetaDataPtr& metaData = DtPagingMetaDataPtr(),
      TileDataCallback* callback = 0) const;

   virtual bool findData(
      const DtTerrainPagingGeometry* geometry,
      std::vector< boost::shared_ptr<DtTileData> >& data,
      TileDataCallback* callback) const;

   virtual void findMissing(
      const DtTerrainPagingGeometry& geometry,
      DtTileKeyList& missing) const;

   virtual boost::shared_ptr<DtTileData> findOldest() const;
   virtual boost::shared_ptr<DtTileData> findOldestUnlocked() const;

   typedef boost::ptr_vector<TileSpatialIndex> TileRoots;

   const osg::ref_ptr<osgEarth::MapNode> myMapNode;

   osgEarth::ElevationLayerVector myElevationLayers;

   osgEarth::ElevationLayerVector myFlattenedElevationLayers;

   const bool myUseRawElevation;

   unsigned int myMaxLOD;

   unsigned int myMaxLODForBilinearIntersection;

   double myTriangleOutputMergeTolerance;
   double myIntersetionTriangleMergeTolerance;

   unsigned myMinElevationIndexLOD;
   unsigned myMaxElevationIndexLOD;

   double myMaxChordLengthBeforeSplitSquared;

   unsigned myMaxElevationChordSplitLOD;

   TileRoots myTileSpatialIndexRoots;

   const double myWorldWidth;

   DtTerrainIntersectOptions::Fidelity myFidelity;

   boost::weak_ptr<DtTileData> myOldestData;
};

class DT_DLL_vantageTerrainImplementation DtOsgEarthTerrainSourceTracker::TileDataCallback
{
public:
   explicit TileDataCallback();

   virtual bool operator()(const boost::shared_ptr<DtTileData>& tile) = 0;

private:
   friend class DtOsgEarthTerrainSourceTracker;

   bool myIsFinished;
};