featureContext.h

Go to the documentation of this file.

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


#pragma once

#include <features/attributeConfigParser.h>
#include <features/featureContext.h>
#include <features/featureSet.h>
#include <features/feature.h>
#include <features/pathFeature.h>
#include <features/aStarGraph.h>
#include <features/areaFeature.h>
#include <features/asyncLoadingFeatureSet.h>

#include <vrfutil/consoleCommandManager.h>
#include <vrfutil/terrainInterfaceConfig.h>

#include <boost/ptr_container/ptr_map.hpp>

#include <tbb/mutex.h>

#include <map>
#include <string>

class DtVectorNetwork;

namespace osg
{
   template<typename T>
   class ref_ptr;
}

namespace osgEarth
{
   class Map;
}

namespace MAKVRinTerra
{
   class DtFeatureContext;
   class DtFeaturesDebugger;
   class DtUnusedFeatureTileTracker;

   class DT_DLL_features DtFeatureDatabase
   {
   public:
      typedef boost::function<DtFeatureSet* (std::string)> FeatureSetCreatorFcn;

      typedef DtQueueLoadingFeatureSet<DtFeatureSet>::Queue LoadingQueue;

      DtFeatureDatabase();

      virtual ~DtFeatureDatabase();

      virtual bool init(const DtTerrainInterfaceConfig&);

      static void AddFeatureSetCreator(std::string extension, FeatureSetCreatorFcn factory);

      static DtFeatureSet* CreateFeatureSetFromFile(std::string file);

      static DtFeatureSet* ConfigureAttribute(
         DtFeatureSet* set, std::string attribute, std::string value);

      static std::unique_ptr<DtFeatureSet> ConfigureAttribute(
         std::unique_ptr<DtFeatureSet> set, std::string attribute, std::string value);

      static DtFeatureSet* ConfigureAttributes(
         DtFeatureSet*,
         const DtAttributeConfigParser::TransformVector& transforms,
         DtAttributeConfigParser& parser);

      virtual bool loadSrcSpecConfigFor(std::string sourceFile, std::string attribute);

      virtual bool loadConfig(std::string configFile, DtQuery schema);

      virtual std::unique_ptr<DtFeatureSet> addFeatureSource(std::string file, bool page=true);

      virtual std::unique_ptr<DtFeatureSet> addFeatureSource(
         osg::ref_ptr<osgEarth::Map> map,
         std::string earthfile=std::string(), bool page=true,
         const std::vector<std::string>& loadIfNameBeginsWith = std::vector<std::string>());

      virtual std::unique_ptr<DtFeatureSet> addFeatureSource(DtFeatureSet* fs, bool page=true);

      virtual void addFeatureSource(std::shared_ptr<DtFeatureSet> fs, bool page=true);

      virtual std::unique_ptr<DtFeatureSet> addFeatureSource(
         DtFeatureSet* fs,
         const DtTerrainInterfaceConfig& config);

      virtual void addFeatureSource(
         std::shared_ptr<DtFeatureSet> fs,
         const DtTerrainInterfaceConfig& config);

      virtual std::unique_ptr<DtFeatureSet> addVectorNetworkFeatureSource(
         DtVectorNetwork* network, std::string sourceFile);

      virtual std::unique_ptr<DtFeatureSet> addFeatureSource(
         DtFeatureSet* fs, std::string source, bool page=true);

      void addToDebugger(DtFeatureSet* fs);

      const DtTerrainInterfaceConfig& config() const;

      std::shared_ptr<DtAttributeConfigParser> parser() const;

      std::shared_ptr<DtUnusedFeatureTileTracker> tracker() const;

      std::shared_ptr<DtFeaturesDebugger> debugger() const;

      std::shared_ptr<LoadingQueue> loadingQueue() const;

      virtual DtFeatureSet* makeSourcePagetables(const DtProj& proj);

      virtual std::unique_ptr<DtFeatureSet> features(const std::string& queryName) const;

      virtual std::unique_ptr<DtFeatureSet> allFeatures() const;

      virtual void setBlockOnAsynchronousOperations(bool blockIn);

   private:
      struct Record
      {
         typedef std::shared_ptr<Record> Ptr;
         typedef std::vector<Ptr> Vector;

         std::unique_ptr<DtFeatureSet> featureSet;
         DtTerrainInterfaceConfig config;

         Record(DtFeatureSet*, const DtTerrainInterfaceConfig&);
      };

      DtTerrainInterfaceConfig myTerrainInterfaceConfig;

      std::shared_ptr<DtFeaturesDebugger> myDebugger;
      std::shared_ptr<DtAttributeConfigParser> myParser;
      std::shared_ptr<DtUnusedFeatureTileTracker> myUnusedTracker;

      Record::Vector myRecords;
      DtFeatureSet::List myFeatures;

      std::shared_ptr<LoadingQueue> myLoadingQueue;

      bool myBlockOnAsynchronousOperations;
   };

   class DT_DLL_features DtFeatureContext
   {
   public:
      static DtFeatureContext* Create(DtFeatureDatabase& db, const DtProj& proj);

      DtFeatureContext(DtFeatureDatabase& loader, const DtProj& proj);

      ~DtFeatureContext();

      void shutdown(bool block = true);

      std::unique_ptr<DtFeatureSet> features(const std::string& queryName) const;

      std::unique_ptr<DtFeatureSet> allFeatures() const;

      std::unique_ptr<DtAreaFeatureSet> areas(
         const std::string& type,
         const std::shared_ptr<DtVrfCallbackQueue>& = std::shared_ptr<DtVrfCallbackQueue>());

      typedef DtAreaFeatureSetAdapter::Config AreaConfig;

      std::unique_ptr<DtAreaFeatureSet> areas(
         const AreaConfig& cfg,
         const std::shared_ptr<DtVrfCallbackQueue>& = std::shared_ptr<DtVrfCallbackQueue>());

      std::unique_ptr<DtPathFeatureSet> paths(std::string type);

      DtAStarGraph::Ptr pathFinder(std::string type);

      DtProj::CPtr projection() const;

      void cleanUpPathFinders();

      virtual void setBlockOnAsynchronousOperations(bool blockIn);
   private:
      DtProj::CPtr myProjection;

      DtTerrainInterfaceConfig myTerrainInterfaceConfig;

      std::unique_ptr<DtFeatureSet> mySourceFeatures;

      typedef boost::ptr_map<const std::string, DtFeatureSet> FeatureSetMap;
      typedef DtQueueLoadingFeatureSet<DtFeatureSet>::Queue FeatureQueue;
      FeatureSetMap myFeatureSets;
      mutable std::mutex myFeatureSetMutex;
      std::shared_ptr<FeatureQueue> myFeatureLoadingQueue;

      typedef boost::ptr_map<const AreaConfig, DtAreaFeatureSet>  AreaFeatureSetMap;
      typedef DtQueueLoadingFeatureSet<DtAreaFeatureSet>::Queue AreaQueue;
      AreaFeatureSetMap myAreaFeatureSets;
      mutable std::mutex myAreasMutex;
      std::shared_ptr<AreaQueue> myAreaLoadingQueue;

      typedef boost::ptr_map<const std::string, DtAStarGraph::Ptr> PathFinderMap;
      PathFinderMap myPathFinders;
      mutable std::mutex myPathFindersMutex;

      std::shared_ptr<DtFeaturesDebugger> myDebugger;

      std::shared_ptr<DtAttributeConfigParser> myAttributeParser;

      DtUnusedFeatureTileTracker::Ptr myUnusedTracker;

      bool myBlockOnAsynchronousOperations;
   };
}