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/pathFinder.h>
#include <features/obstacleFeature.h>
#include <features/asyncLoadingFeatureSet.h>

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

#include <boost/scoped_ptr.hpp>
#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 DtSharedMemoryFeaturesDebugDrawer;
   class DtFeatureContext;
   class DtFeaturesDebugger;
   class DtUnusedFeatureTileTracker;

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

      typedef DtQueueLoadingFeatureSet<DtFeatureSet>::Queue LoadingQueue;

      DtFeatureLoader(boost::shared_ptr<DtTerrainInterfaceConfig> config, DtConsoleCommandManager* manager = 0);

      virtual ~DtFeatureLoader();

      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::auto_ptr<DtFeatureSet> ConfigureAttribute(
         std::auto_ptr<DtFeatureSet> set, std::string attribute, std::string value);

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

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

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

      virtual std::auto_ptr<DtFeatureSet> addFeatureSource(
         osg::ref_ptr<osgEarth::Map> map,
         std::string earthfile=std::string(), bool page=true);

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

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

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

      void addToDebugger(DtFeatureSet* fs, bool draw = false, std::string label = std::string());

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

      boost::shared_ptr<DtTerrainInterfaceConfig> config() const;

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

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

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

      virtual DtFeatureContext* makeContext(const DtProj& proj);

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

         std::auto_ptr<DtFeatureSet> featureSet;
         bool page;

         Record(DtFeatureSet*, bool page);
      };

      boost::shared_ptr<DtTerrainInterfaceConfig> myTerrainInterfaceConfig;
      boost::shared_ptr<DtAttributeConfigParser> myParser;
      boost::shared_ptr<DtUnusedFeatureTileTracker> myUnusedTracker;
      boost::shared_ptr<DtFeaturesDebugger> myDebugger;

      Record::Vector myRecords;
      boost::shared_ptr<LoadingQueue> myLoadingQueue;
   };

   class DT_DLL_features DtFeatureContext
   {
   public:
      DtFeatureContext(
         DtFeatureSet* sourceFeatures,
         DtFeatureSet* features,
         const DtProj& proj,
         DtFeatureLoader& loader);

      ~DtFeatureContext();

      void shutdown();

      std::auto_ptr<DtFeatureSet> features(
         std::string queryName = std::string(),
         bool readDirectly = false);

      std::auto_ptr<DtObstacleFeatureSet> obstacles(std::string type);

      typedef DtObstacleFeatureSetAdapter::Config ObstacleConfig;

      std::auto_ptr<DtObstacleFeatureSet> obstacles(ObstacleConfig cfg);

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

      DtPathFinder& pathFinder(std::string type);

      DtFeaturesDebugger& debugger();

      DtQuery findQuery(std::string name) const;

      DtProj::CPtr projection() const;

      void cleanUpPathFinders();

   private:
      DtProj::CPtr myProjection;

      boost::shared_ptr<DtTerrainInterfaceConfig> myTerrainInterfaceConfig;

      boost::scoped_ptr<DtFeatureSet> mySourceFeatures;

      boost::scoped_ptr<DtFeatureSet> myFeatures;

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

      typedef boost::ptr_map<ObstacleConfig, DtObstacleFeatureSet>  ObstacleFeatureSetMap;
      typedef DtQueueLoadingFeatureSet<DtObstacleFeatureSet>::Queue ObstacleQueue;
      ObstacleFeatureSetMap myObstacleFeatureSets;
      mutable tbb::mutex myObstaclesMutex;
      boost::shared_ptr<ObstacleQueue> myObstacleLoadingQueue;

      typedef boost::ptr_map<std::string, DtPathFinder> PathFinderMap;
      PathFinderMap myPathFinders;
      mutable tbb::mutex myPathFindersMutex;

      boost::shared_ptr<DtAttributeConfigParser> myAttributeParser;

      boost::shared_ptr<DtUnusedFeatureTileTracker> myUnusedTracker;

      boost::shared_ptr<DtFeaturesDebugger> myDebugger;
   };
}