pagingFeatureSet.h

Go to the documentation of this file.

#pragma once

#include <features/feature.h>
#include <features/featureSet.h>
#include <features/featureGeometry.h>
#include <features/asyncLoadingFeatureSet.h>

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

#include <boost/logic/tribool.hpp>

namespace MAKVRinTerra
{
   class DtUnusedFeatureTileTracker;
   class DtSharedMemoryFeaturesDebugDrawer;

   template <typename FS>
   class DT_DLL_features DtPagingFeatureSet : public FS
   {
   public:
      class DT_DLL_features Subset;
      class DT_DLL_features Tile;
      class DT_DLL_features Grid;
      class DT_DLL_features WeakGrid;
      class DT_DLL_features Leaf;
      class DT_DLL_features LoadingFeatureSet;

      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<Tile>                 TilePtr;
      typedef boost::shared_ptr<const Tile>           TileCPtr;
      typedef boost::weak_ptr<Tile>                   TileWeakPtr;
      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;

      typedef std::vector<TilePtr>                    TileVector;
     
      typedef boost::function<void (const FeatureSet&, DtFeatureGeometry)> Callback;

      struct Config
      {
         typedef boost::shared_ptr<Config> Ptr;
         typedef typename DtQueueLoadingFeatureSet<FeatureSet>::Queue Queue;

         DtUnusedFeatureTileTracker::Ptr unusedTileTracker;
         boost::scoped_ptr<FeatureSet> inputFeatureSet;
         Callback callback;
         boost::weak_ptr<Queue> taskQueue;
         bool indexSubsets;
         unsigned loadLevelDifference;
         unsigned numberOfFeaturesForIndexing;

         explicit Config(
            FeatureSet*,
            DtUnusedFeatureTileTracker::Ptr = DtUnusedFeatureTileTracker::Ptr(),
            Callback callback = Callback(),
            boost::shared_ptr<Queue> queue = boost::shared_ptr<Queue>());

         int loadLevel() const;
         void setLoadLevel(const Subset&);
      };

      explicit DtPagingFeatureSet(TilePtr, bool cache=true);

      std::string label() const;
      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      FeatureSet* filter(const DtQuery&, DtLoadType) const;
      DtPagingFeatureSet* clone() const;
      bool loaded(double) const;
      unsigned numberOfFeatures() const;
      bool empty() const;

      SubsetPtr subset() const;

   protected:
      explicit DtPagingFeatureSet(const DtPagingFeatureSet&);

      typedef tbb::spin_mutex Mutex;

      TilePtr myTopTile;
      mutable Mutex myMutex;
      bool myCacheTileFlag;
      SubsetPtr myTile;
   };

   template <typename FS>
   class DtPagingFeatureSet<FS>::Subset : virtual public FS
   {
   public:
      virtual DtProj::Bounds bounds() const = 0;
      virtual DtFeatureGeometry::Area tileGeometry() const = 0;
      virtual SubsetPtr parent() const = 0;
      virtual int level() const = 0;

      virtual void drawTiles(DtSharedMemoryFeaturesDebugDrawer&) const = 0;

      virtual SubsetPtr getTiles(
         typename FS::List&, boost::optional<DtFeatureGeometry>) = 0;

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

   template <typename FS>
   class DtPagingFeatureSet<FS>::Tile : public DtPagingFeatureSet<FS>::Subset
   {
   public:
      using Subset::getTiles;

      virtual void forEachFeature(ForEachFunction, DtWaitType) const = 0;
      virtual void forEachFeatureParallel(ForEachFunction, DtWaitType) const = 0;

      virtual SubsetPtr getTiles(
         typename FS::List&, boost::optional<DtFeatureGeometry>, unsigned startLevel) = 0;

      bool index();
      virtual bool index(const FS&) = 0;

      DtProj::Bounds bounds() const;
      DtFeatureGeometry::Area tileGeometry() const;
      SubsetPtr parent() const;

      const Config& config() const;
      const FeatureSet& input() const;
      int level() const;

   protected:
      Tile(GridPtr parent, unsigned i);
      Tile(typename Config::Ptr, const DtProj::Bounds&, int level);

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

      SubsetPtr myParent;

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

   template <typename FS>
   class DtPagingFeatureSet<FS>::Grid
      : public DtPagingFeatureSet<FS>::Tile
      , public boost::enable_shared_from_this<typename DtPagingFeatureSet<FS>::Grid>
   {
   public:
      std::string label() const;

      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction, DtWaitType) const;

      SubsetPtr getTiles(typename FS::List&, boost::optional<DtFeatureGeometry>);
      SubsetPtr getTiles(
         typename FS::List&, boost::optional<DtFeatureGeometry>, unsigned startLevel);

      void drawTiles(DtSharedMemoryFeaturesDebugDrawer&) const;

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

      virtual TilePtr getSubtile(unsigned i, boost::tribool forceLeaf) const = 0;
      virtual TilePtr getLoadedSubtile(unsigned i) const = 0;

      FS* clone() const;

      bool loaded(double) const;
      unsigned numberOfFeatures() const;
      bool empty() const;

      DtProj::Bounds computeSubtileBounds(unsigned i) const;

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

   protected:
      struct ParallelCaller;

      Grid(GridPtr parent, unsigned i);

      typedef tbb::spin_rw_mutex Mutex;

      mutable Mutex myMutex;

      mutable Mutex mySizeMutex;
      boost::optional<unsigned> mySizeEstimate;
   };

   template <typename FS>
   class DtPagingFeatureSet<FS>::WeakGrid : public DtPagingFeatureSet<FS>::Grid
   {
   public:
      WeakGrid(typename Config::Ptr cfg, const DtProj::Bounds&, unsigned level);

      bool index(const FS&);

      TilePtr getSubtile(unsigned i, boost::tribool forceLeaf) const;
      TilePtr getLoadedSubtile(unsigned i) const;


   protected:
      WeakGrid(GridPtr parent, unsigned i);

      TileWeakPtr mySubtiles[9];
   };

   template <typename FS>
   class DtPagingFeatureSet<FS>::Leaf
      : public DtPagingFeatureSet<FS>::Tile
      , public DtQueueLoadingFeatureSet<FS>
   {
   public:
      typedef std::vector<typename Feature::CPtr> FeatureVector;
      typedef typename DtPagingFeatureSet<FS>::Callback Callback;

      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      bool loaded(double = 0) const;
      unsigned numberOfFeatures() const;

      bool index(const FS&);

      SubsetPtr getTiles(
         typename FS::List&, boost::optional<DtFeatureGeometry>);
      SubsetPtr getTiles(
         typename FS::List&, boost::optional<DtFeatureGeometry>, unsigned startLevel);

      void drawTiles(DtSharedMemoryFeaturesDebugDrawer&) const;

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

      FS* clone() const;

      std::string label() const;

      Leaf(GridPtr parent, unsigned i);

      LeafPtr shared_from_this();
      LeafCPtr shared_from_this() const;

      void unload();

   protected:
      void start();
      bool run(const typename DtAsyncLoadingFeatureSet<FS>::Ptr&);
      FS* createFeatureSet(FS*) const;
   };

   template <typename FS>
   class DtPagingFeatureSet<FS>::LoadingFeatureSet : public FS::List
   {
   public:
      explicit LoadingFeatureSet(LeafPtr);
      explicit LoadingFeatureSet(DtUnusedFeatureTileTracker::Sentinel::Ptr);

      std::string label() const;
      void forEachFeature(ForEachFunction, DtWaitType) const;
      void forEachFeatureParallel(ForEachFunction func, DtWaitType) const;
      LoadingFeatureSet* clone() const;

   private:
      struct WrapWithPagingFeature;
      class PagingFeature;

      explicit LoadingFeatureSet(const LoadingFeatureSet&);

      DtUnusedFeatureTileTracker::Sentinel::Ptr mySentinel;
   };
}