pagingFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/feature.h>
#include <features/featureSet.h>
#include <features/featureSetUtils.h>
#include <features/featureSetWrappers.h>
#include <features/featureGeometry.h>
#include <features/asyncLoadingFeatureSet.h>
#include <features/indexingFeatureSet.h>
#include <features/tileFeature.h>

#include <vrfutil/terrainInterfaceConfig.h>

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

#include <boost/logic/tribool.hpp>

namespace MAKVRinTerra
{
   class DtUnusedFeatureTileTracker;

   template <typename FS>
   class DT_DLL_features DtPagingFeatureSetSubset;

   template <typename FS>
   class DT_DLL_features DtPagingFeatureSet
      : public DtFeatureSetWrapper<FS, boost::shared_ptr, DtPagingFeatureSetSubset<FS> >
      , public DtObjectDebugger< DtPagingFeatureSet<FS> >
   {
   public:
      typedef DtFeatureSetWrapper<FS, boost::shared_ptr, DtPagingFeatureSetSubset<FS> > Base;

      using Base::filter;

      template <template <class> class PtrT> class DT_DLL_features GridTemplate;
      typedef DtPagingFeatureSetSubset<FS> Subset;
      class DT_DLL_features Grid;
      class DT_DLL_features WeakGrid;
      class DT_DLL_features Leaf;

      typedef FS                                      FeatureSet;
      typedef typename FeatureSet::Feature            Feature;
      typedef typename FeatureSet::ForEachFunction    ForEachFunction;

      typedef boost::shared_ptr<DtPagingFeatureSet>   Ptr;
      typedef boost::shared_ptr<Subset>               SubsetPtr;
      typedef boost::shared_ptr<const Subset>         SubsetCPtr;
      typedef boost::shared_ptr<Grid>                 GridPtr;
      typedef boost::shared_ptr<const Grid>           GridCPtr;
      typedef boost::shared_ptr<Leaf>                 LeafPtr;
      typedef boost::shared_ptr<const Leaf>           LeafCPtr;
    
      class DT_DLL_features Config : public DtTerrainInterfaceConfig
      {
      public:
         typedef boost::shared_ptr<Config> Ptr;
         typedef typename DtQueueLoadingFeatureSet<FeatureSet>::Queue Queue;

         boost::shared_ptr<FeatureSet> inputFeatureSet;

         DtUnusedFeatureTileTracker::WeakPtr unusedTileTracker;

         boost::weak_ptr<Queue> taskQueue;

         boost::shared_ptr<DtFeatureSet::Source> tileFeatures;

         explicit Config(FeatureSet*);

         explicit Config(const Config& cfg)
            : inputFeatureSet(cfg.inputFeatureSet)
            , unusedTileTracker(cfg.unusedTileTracker)
            , taskQueue(cfg.taskQueue)
            , tileFeatures(cfg.tileFeatures)
         {
            static_cast<DtTerrainInterfaceConfig&>(*this) = cfg;
         }
      };


      static DtPagingFeatureSet* Make(Config* cfg, const DtProj::Bounds& bounds)
      {
         typename Config::Ptr c(cfg);
         SubsetPtr parentTile(new Grid(c, bounds));
         return new DtPagingFeatureSet(parentTile);
      }

      static DtPagingFeatureSet* Make(const Config& cfg, const DtProj::Bounds& bounds)
      {
         return Make(new Config(cfg), bounds);
      }

      FS* filter(const DtQuery&, const boost::optional<DtFeatureGeometry>&, DtLoadType) const;
      DtPagingFeatureSet* clone() const;
      bool loaded(double) const;

      bool isCacheable(const boost::optional<DtFeatureGeometry>& area) const;
      void cacheEstimate(double& time, double& size, const boost::optional<DtFeatureGeometry>& area) const;

      void cacheData(
         const boost::optional<DtFeatureGeometry>& area,
         DtFeatureCacheProgressCallback* progress) const;

   protected:
      explicit DtPagingFeatureSet(const SubsetCPtr&);
      explicit DtPagingFeatureSet(const DtPagingFeatureSet&);

      typedef tbb::spin_mutex Mutex;

      mutable Mutex myMutex;
      SubsetCPtr myTile;
   };

   template <typename FS>
   class DtPagingFeatureSetSubset
      : virtual public FS
      , public DtObjectDebugger< DtPagingFeatureSetSubset<FS> >
   {
   public:
      typedef typename DtPagingFeatureSet<FS>::SubsetPtr  SubsetPtr;
      typedef typename DtPagingFeatureSet<FS>::SubsetCPtr SubsetCPtr;
      typedef typename DtPagingFeatureSet<FS>::Grid       Grid;
      typedef typename DtPagingFeatureSet<FS>::GridCPtr   GridCPtr;

      typedef typename DtPagingFeatureSet<FS>::Config     Config;

      const Config& config() const { return *myInfo; }
      const FS& input() const { return *config().inputFeatureSet; }
      DtProj::Bounds bounds() const { return myBounds; }
      DtFeatureGeometry::Area tileGeometry() const { return myTileGeometry; }
      SubsetPtr parent() const { return myParent; }
      int level() const { return myLevel; }

      virtual FS* filterCache(
         const DtQuery&,
         const boost::optional<DtFeatureGeometry>&,
         DtLoadType,
         SubsetCPtr& highestSubset,
         const DtProj::Bounds::LineSegment* = 0,
         unsigned indexLevel = 0) const = 0;

      FS* filter(const DtQuery&, const boost::optional<DtFeatureGeometry>&, DtLoadType) const;

      virtual boost::optional<unsigned> sizeEstimate() const = 0;
      virtual void updateStats();

   protected:
      DtPagingFeatureSetSubset(const GridCPtr& parent, unsigned i);
      DtPagingFeatureSetSubset(const typename Config::Ptr&, const DtProj::Bounds&);

      const typename Config::Ptr myInfo;
      const int myLevel;

      const SubsetPtr myParent;

      const DtProj::Bounds myBounds;
      const DtFeatureGeometry::Area myTileGeometry;
   };

   template <typename FS>
   template <template <class> class PtrT>
   class DtPagingFeatureSet<FS>::GridTemplate
      : public DtPagingFeatureSet<FS>::Subset
   {
   public:
      struct Tile
      {
         explicit Tile(const DtProj::Bounds& b, unsigned i);

         const DtProj::Bounds bounds;
         const DtFeatureGeometry::Area tileGeometry;

         DtFeatureSetWrapper<FS, PtrT, Subset> subtile;
      };

      typedef typename FS::DetachCallback DetachCallback;
      typedef typename FS::LoadedCallback LoadedCallback;

      std::string label() const;

      void forEachFeatureParallel(const ForEachFunction&) const;
      DetachCallback forEachFeatureAsync(const ForEachFunction&) const;

      boost::optional<unsigned> sizeEstimate() const;
      void updateStats();

      const DtProj::Bounds& subBounds(unsigned) const;
      const DtFeatureGeometry::Area& subGeometry(unsigned) const;

      Tile& getSubtile(unsigned);
      const Tile& getSubtile(unsigned) const;

      bool loaded(double) const;
      DetachCallback addLoadedCallback(const LoadedCallback&) const;
      unsigned numberOfFeatures() const;
      bool elided() const;
      bool empty() const;

      GridTemplate(const typename Config::Ptr& cfg, const DtProj::Bounds&);

   protected:
      struct Detacher;

      GridTemplate(const GridCPtr& parent, unsigned i);

      typedef tbb::spin_rw_mutex SizeMutex;
      mutable SizeMutex mySizeMutex;

      Tile mySubtile0;
      Tile mySubtile1;
      Tile mySubtile2;
      Tile mySubtile3;

      boost::optional<unsigned> mySizeEstimate;
      const bool myEmptyFlag;
   };

   template <typename FS>
   class DtPagingFeatureSet<FS>::Grid
      : public DtPagingFeatureSet<FS>::template GridTemplate<boost::weak_ptr>
      , public boost::enable_shared_from_this<typename DtPagingFeatureSet<FS>::Grid>
      , public DtObjectDebugger<typename DtPagingFeatureSet<FS>::Grid>
   {
   public:
      FS* filterCache(
         const DtQuery&,
         const boost::optional<DtFeatureGeometry>&,
         DtLoadType,
         SubsetCPtr& highestSubset,
         const DtProj::Bounds::LineSegment*,
         unsigned indexLevel) const;

      void cacheEstimate(double& time, double& size, const boost::optional<DtFeatureGeometry>& area) const;

      void cacheData(
         const boost::optional<DtFeatureGeometry>& area,
         DtFeatureCacheProgressCallback* progress) const;

      FS* clone() const;

      Grid(const typename Config::Ptr& cfg, const DtProj::Bounds&);

   protected:
      virtual bool makeLeaf(unsigned) const;

      Grid(const GridCPtr& parent, unsigned i);
   };

   template <typename FS>
   class DtPagingFeatureSet<FS>::Leaf
      : public DtPagingFeatureSet<FS>::Subset
      , public DtQueueLoadingFeatureSet<FS>
      , public DtObjectDebugger<typename DtPagingFeatureSet<FS>::Leaf>
   {
   public:
      typedef typename FS::ForEachFunction ForEachFunction;
      typedef typename FS::DetachCallback  DetachCallback;

      typedef std::vector<typename Feature::CPtr> FeatureVector;

      ~Leaf();

      bool loaded(double = 0) const;
      unsigned numberOfFeatures() const;
      bool elided() const;
      void forEachFeatureParallel(const ForEachFunction&) const;
      DetachCallback forEachFeatureAsync(const ForEachFunction&) const;

      FS* filter(const DtQuery&, const boost::optional<DtFeatureGeometry>&, DtLoadType) const;

      FS* filterCache(
         const DtQuery&,
         const boost::optional<DtFeatureGeometry>&,
         DtLoadType,
         SubsetCPtr& highestSubset,
         const DtProj::Bounds::LineSegment*,
         unsigned indexLevel) const;

      boost::optional<unsigned> sizeEstimate() const;

      FS* clone() const;

      std::string label() const;

      Leaf(const GridCPtr& parent, unsigned i);

      LeafPtr shared_from_this();
      LeafCPtr shared_from_this() const;

      bool unload();

   protected:
      void makeTileFeature(const DtFeatureGeometry& geom, unsigned color);

      void start(bool wait);
      bool run(bool wait);
      FS* createFeatureSet(FS*) const;
      void inputLoadedCallback();

      typedef tbb::spin_mutex TileFeatureMutex;
      mutable TileFeatureMutex myTileFeatureMutex;
      std::auto_ptr<DtTileFeature> myTileFeature;
   };
}

DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtPagingFeatureSet);
DT_DEFINE_OBJECT_DEBUGGER_NAME_TEMPLATE(MAKVRinTerra::DtPagingFeatureSetSubset);