indexingFeatureSet.h

Go to the documentation of this file.

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


#pragma once

#include <features/featuresDefines.h>
#include <features/featureSet.h>
#include <features/featureSetList.h>
#include <features/featureSetWrappers.h>
#include <features/tileFeature.h>

#include <vrfutil/terrainInterfaceConfig.h>

#include <tbb/atomic.h>

namespace MAKVRinTerra
{
   template <typename FS, typename S = typename FS::Sink>
   class DtIndexingFeatureSet
      : public FS
      , public boost::enable_shared_from_this<DtIndexingFeatureSet<FS,S> >
   {
   public:
      typedef boost::shared_ptr<DtIndexingFeatureSet>       Ptr;
      typedef boost::shared_ptr<const DtIndexingFeatureSet> CPtr;
      typedef boost::weak_ptr<DtIndexingFeatureSet>         WPtr;

      typedef typename FS::Feature         Feature;
      typedef typename FS::ForEachFunction ForEachFunction;
      typedef typename FS::LoadedCallback  LoadedCallback;
      typedef typename FS::DetachCallback  DetachCallback;

      typedef S                  Sink;
      typedef typename Sink::Ptr SinkPtr;

      class Config : public DtTerrainInterfaceConfig
      {
      public:
         typedef boost::shared_ptr<Config> Ptr;

         explicit Config(FS* input)
            : inputSink(Sink::Make(input))
         {
         }

         explicit Config(const SinkPtr& input)
            : inputSink(input ? input : Sink::Make(0))
         {
         }

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

         void addTile(const DtFeature& feature)
         {
            if (tileFeatures)
               tileFeatures->addFeature(feature);
         }

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

         const SinkPtr inputSink;
      };

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

      static FS* Make(Config* cfg, const DtProj::Bounds& bounds)
      {
         return Make(boost::shared_ptr<Config>(cfg), bounds);
      }

      static FS* Make(const boost::shared_ptr<Config>& cfg, const DtProj::Bounds& bounds)
      {
         Ptr set(new DtIndexingFeatureSet(typename Config::Ptr(cfg), bounds));
         set->init();

         return FS::Wrap(set);
      }

      ~DtIndexingFeatureSet()
      {
         myTileFeature.setDeleted();
      }

      FS* clone() const
      {
         return FS::Wrap(this->shared_from_this());
      }

      std::string label() const
      {
         return myConfig->inputSink->label() + " index level " 
            + boost::lexical_cast<std::string>(myLevel);
      }

      bool loaded(double timeout) const
      {
         return myFeatures->loaded(timeout);
      }

      DetachCallback addLoadedCallback(const LoadedCallback& cb) const
      {
         return myFeatures->addLoadedCallback(cb);
      }

      unsigned numberOfFeatures() const
      {
         return myFeatures->numberOfFeatures();
      }

      bool empty() const
      {
         return myFeatures->empty();
      }

      FS* filter(
         const DtQuery& query,
         const boost::optional<DtFeatureGeometry>& geometry,
         DtLoadType load) const
      {
         if (!geometry)
            return myFeatures->filter(query, boost::none_t(), load);

         if (myState != ACTIVE)
            return myFeatures->filter(query, geometry, load);

         bool covers[4] = { false, false, false, false };
         bool intersections[4] = { false, false, false, false };
         size_t lastIntersection = 0;

         unsigned numIntersects = 0;
         bool done = false;

         for (unsigned i=0; !done && i != 4; ++i)
         {
            std::auto_ptr<DtFeatureGeometry::RelationshipMatrix> matrix
               = geometry->relate(getSubtile(i).geometry());

            if (!matrix->intersects())
               continue;

            switch (geometry->type())
            {
            case DtFeatureGeometry::PointType:
               done = true;
               intersections[i] = true;
               ++numIntersects;
               lastIntersection = i;
               break;

            case DtFeatureGeometry::PathType:
               intersections[i] = true;
               ++numIntersects;
               lastIntersection = i;

               if (matrix->coveredBy())
                  done = true;

               break;

            default:
               if (matrix->touches())
                  continue;

               intersections[i] = true;
               ++numIntersects;
               lastIntersection = i;

               if (matrix->covers())
                  covers[i] = true;

               if (matrix->coveredBy())
                  done = true;

               break;
            }
         }

         switch (numIntersects)
         {
         case 0:  return 0;
         case 1:  return getSubtile(lastIntersection).indexedFeatures().filter(
                     query,
                     !covers[lastIntersection] ? geometry : boost::none_t(),
                     load);
         }

         std::auto_ptr< DtFeatureSetList<FS> > list(new DtFeatureSetList<FS>(4));
         for (size_t i=0; i != 4; ++i)
         {
            if (!intersections[i])
               continue;

            list->add(getSubtile(i).indexedFeatures().filter(
               query,
               !covers[i] ? geometry : boost::none_t(),
               load));
         }

         return list.release();
      }

      void forEachFeatureParallel(const ForEachFunction& func) const
      {
         myFeatures->forEachFeatureParallel(func);
      }

      DetachCallback forEachFeatureAsync(const ForEachFunction& func) const
      {
         return myFeatures->forEachFeatureAsync(func);
      }

   protected:
      class Subtile;

      DtIndexingFeatureSet(const Ptr& parent, const Subtile& subtile)
         : myConfig(parent->myConfig)
         , myLevel(parent->myLevel + 1)
         , myParent(parent)
         , myTileGeometry(subtile.geometry())
         , myFeatures(subtile.sink())
         , mySubtile0(*myFeatures, subtile.bounds(), 0)
         , mySubtile1(*myFeatures, subtile.bounds(), 1)
         , mySubtile2(*myFeatures, subtile.bounds(), 2)
         , mySubtile3(*myFeatures, subtile.bounds(), 3)
         , myTileFeature(myTileGeometry.boundary(), 0xAA00FF, 1)
      {
         myState = START;
         myConfig->addTile(myTileFeature);
      }

      DtIndexingFeatureSet(
         const boost::shared_ptr<Config>& cfg,
         const DtProj::Bounds& bounds)
         : myConfig(cfg)
         , myLevel(0)
         , myTileGeometry(DtFeatureGeometry::MakeBox(bounds))
         , myFeatures(cfg->inputSink)
         , mySubtile0(*myFeatures, bounds, 0)
         , mySubtile1(*myFeatures, bounds, 1)
         , mySubtile2(*myFeatures, bounds, 2)
         , mySubtile3(*myFeatures, bounds, 3)
         , myTileFeature(myTileGeometry.boundary(), 0xAA00FF, 1)
      {
         myState = START;
      }

      const Subtile& getSubtile(unsigned i) const
      {
         switch (i)
         {
         case 0: return mySubtile0;
         case 1: return mySubtile1;
         case 2: return mySubtile2;
         case 3: return mySubtile3;
         }

         assert(false);
         DtTHROW_NEW(DtException, "Tile index out of bounds");
      }

      void init()
      {
         Ptr This(this->shared_from_this());
         
         mySubtile0.init(This);
         mySubtile1.init(This);
         mySubtile2.init(This);
         mySubtile3.init(This);
      }

      bool activateSubtiles()
      {
         if (myState.compare_and_swap(ACTIVATING, START) != START)
            return false;

         try
         {
            Ptr This(this->shared_from_this());
            mySubtile0.activate(This);
            mySubtile1.activate(This);
            mySubtile2.activate(This);
            mySubtile3.activate(This);
         }
         catch (...)
         {
            myState = FAULT;
            throw;
         }

         if (myState.compare_and_swap(ACTIVE, ACTIVATING) != ACTIVATING)
         {
            DtWarn << "Error activating subtile" << std::endl;
            myState = FAULT;
            return false;
         }

         return true;
      }

      const boost::shared_ptr<Config> myConfig;

      const int myLevel;

      const WPtr myParent;

      const DtFeatureGeometry::Area myTileGeometry;

      SinkPtr myFeatures;

      class Subtile
      {
         DtProj::Bounds myBounds;
         DtFeatureGeometry myGeometry;
         SinkPtr mySink;
         boost::shared_ptr<DtIndexingFeatureSet> myIndexingSet;

      public:
         const DtFeatureGeometry& geometry() const { return myGeometry; }
         const DtProj::Bounds& bounds() const      { return myBounds; }
         const SinkPtr& sink() const    { return mySink; }
         const FS& indexedFeatures() const         { return *myIndexingSet; }

         Subtile(const Sink& parentFeatures, const DtProj::Bounds& pbounds, unsigned i)
            : myBounds(pbounds.makeSubBounds(i,2,2))
            , myGeometry(DtFeatureGeometry::MakeBox(bounds()))
            , mySink(Sink::Make(parentFeatures, geometry()))
         {
         }

         void init(const Ptr& parent)
         {
            Caller caller(parent, *this);
            mySink->addLoadedCallback(caller);

            checkIndex(*parent);
         }

         void activate(const Ptr& parent)
         {
            myIndexingSet.reset(new DtIndexingFeatureSet(parent, *this));
            myIndexingSet->init();
         }

      private:
         void checkIndex(DtIndexingFeatureSet& parent)
         {
            try
            {
               if (!mySink->loaded())
                  return;
            }
            catch (DtFeatureSetLoadingException&)
            {
               return;
            }

            if (parent.myLevel >= parent.myConfig->featuresMaxIndexLOD)
               return;

            size_t pc = parent.numberOfFeatures();
            size_t c = mySink->numberOfFeatures();

            assert(pc >= c);

            if (pc <= parent.myConfig->minFeaturesToIndexTile)
               return;

            if (c > 0)
            {
               if (pc/(double)c >= parent.myConfig->featuresIndexRatio)
                  parent.activateSubtiles();
            }
            else
            {
               //if (pc > 0)
            }
         }

         class Caller
         {
         public:
            explicit Caller(const Ptr& set, Subtile& subtile)
               : set(set), subtile(subtile)
            {
            }

            void operator()() const
            {
               Ptr p(set.lock());
               if (p)
                  subtile.checkIndex(*p);
            }

         private:
            WPtr set;
            Subtile& subtile;
         };
      };

      friend class Subtile;

      Subtile mySubtile0;
      Subtile mySubtile1;
      Subtile mySubtile2;
      Subtile mySubtile3;

      enum State
      {
         START, ACTIVATING, ACTIVE, FAULT
      };

      tbb::atomic<State> myState;

      DtTileFeature myTileFeature;
   };
}