tileSpatialIndex.h

Go to the documentation of this file.

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


#pragma once

#include <vantageTerrainImplementation/terrainSourceTracker.h>
#include <vantageTerrainImplementation/vantageTerrainImplementationDefines.h>
#include <vantageTerrainImplementation/tileData.h>

#include <osgEarth/ElevationLayer>

#include <boost/ptr_container/ptr_vector.hpp>

#include <tbb/spin_rw_mutex.h>

class DtTerrainPagingGeometry;
class DtChord;
class DtExtent;
class DtSphere;
class DtLocalVertexList;
class TileDataCallback;
class TileSpatialIndex;
class IndexInterface;
class IndexOutputInterface;
class DtTerrainPagingChord;
class DtTerrainPagingSphere;
class DtTerrainPagingShape;

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

typedef boost::ptr_vector<TileSpatialIndex> TileRoots;

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

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

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

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

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

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

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

   void getTiles(std::vector<osgEarth::TileKey>& keys, unsigned lod);

   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;

   void setBlackList(bool value);
   bool blackList() const;


protected:

   bool findDataChord(
      const DtTerrainPagingChord* geometry, std::vector<std::shared_ptr<DtTileData>>& data, bool verifyInCache,
      TileDataCallback* callback = 0) const;

   bool findDataShape(
      const DtTerrainPagingShape* geometry,
      std::vector< std::shared_ptr<DtTileData> >& data, bool verifyInCache,
      TileDataCallback* callback = 0) const;

   bool findDataSphere(
      const DtTerrainPagingSphere* geometry,
      std::vector< std::shared_ptr<DtTileData> >& data, bool verifyInCache,
      TileDataCallback* callback = 0) 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;

   bool isTileEmpty() const;

   virtual void recomputePagedInData();

   bool allPagedIn() const;

   const DtTerrainSourceTracker& 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;
      std::unique_ptr<TileSpatialIndex> subtile;
   };

   SubTileSlot& getOrCreateSlot(unsigned i);

   void pageOutSlotIfUnused(unsigned i);

   SubTileSlot mySubTiles[4];

   std::shared_ptr<DtTileData> myTileData;

   bool myAllPagedInFlag;

   bool myMaxDataLevelFlag;

   mutable tbb::spin_rw_mutex myMutex;

   bool myBlacklist;
};