navGeneration.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2020 MaK Technologies, Inc.
** All rights reserved.
*******************************************************************************/


#pragma once

#include <vrfNavigation/vrfNavigationDefines.h>
#include <vrfNavigation/navigationGeneratorInput.h>
#include <vrfNavigation/navSectorName.h>
#include <vrfutil/rwNavRuntimeConfig.h>
#include <terrainInterface/terrainProcessPolygonsBox.h>
#include <features/featureGeometry.h>

#include <matrix/vlVector.h>

#include <tbb/queuing_rw_mutex.h>
#include <tbb/mutex.h>
#include <tbb/task_arena.h>
#include <tbb/spin_mutex.h>

#include <string>
#include <list>

class DtRwNavigationProfile;
class DtRwNavigationProfileList;
class DtTerrainInterface;
class DtFeatureTagVolumeGenerator;
class DtRwDynamicTerrainInformation;
class DtDynamicLibrary;

namespace MAKVRinTerra
{
   class DtFeature;
   class DtFeatureGeometry;
}

namespace Kaim
{
   class GeneratorInputOutput;
   class GeneratorSector;
}

struct DT_DLL_vrfNavigation DtNavTagColor
{
   DtNavTagColor() : red(0), green(0), blue(0) {};
   unsigned int red;
   unsigned int green;
   unsigned int blue;
};

struct DT_DLL_vrfNavigation DtInputNavTag
{
   DtInputNavTag() : isExclusive(false) {};
   std::vector<unsigned long> navTagData;
   DtNavTagColor color;
   bool isExclusive; 
   bool uniquelyIdentify; 
};


class DT_DLL_vrfNavigation DtLadderNavTag : public DtInputNavTag
{
public:
   DtLadderNavTag();
};

class DT_DLL_vrfNavigation DtLadderEntryExitNavTag : public DtInputNavTag
{
public:
   DtLadderEntryExitNavTag();
};

struct DT_DLL_vrfNavigation DtInputNavTagVolume
{
   std::vector<DtVector> points;
   unsigned int navTagDataIndex;
};

struct DT_DLL_vrfNavigation DtNavTagVolumeSet
{
   std::vector<DtInputNavTag> navTagDataList;
   std::vector<DtInputNavTagVolume> navTagVolumeList;
};

class DT_DLL_vrfNavigation DtTagVolumeGenerator
{
public:
   virtual bool generateTagVolumes(const MAKVRinTerra::DtFeatureGeometry& extentBox,
      bool pruneNoGo, const DtRwNavigationProfile* navProfile, DtNavTagVolumeSet& tagVolumes) = 0;
};

class DT_DLL_vrfNavigation DtNavDataGenerator
{
public:

   enum SectorGenerationStatus
   {
      GenerationNotRequested,
      GenerationInProgress,
      GenerationSucceeded,
      GenerationFailed,
      GenerationStopped
   }; 
   
   static const double LowCoverHeightCheck;
   static const double HighCoverHeightCheck;
   static const unsigned NumCoverCheckAngles;
   static const double CoverChordLengthFactor;

   typedef tbb::queuing_rw_mutex RwMutex;
   typedef tbb::mutex Mutex;

   typedef std::map<DtNavSectorDataType, std::vector<char> > NavDataOutputMap;

   struct SectorGenerationThreadInfo
   {
      SectorGenerationThreadInfo(const DtNavSectorName& sn)
         : sectorName(sn) 
         , timeToComplete(-1)
      {
         stop = false;
         status = GenerationNotRequested;
      }

      DtNavSectorName sectorName;
      NavDataOutputMap outputData;
      std::atomic<SectorGenerationStatus> status;
      DtString statusMsg;
      std::unique_ptr<std::thread> thread;
      std::atomic<bool> stop;
      DtTime timeToComplete;
   };
   typedef std::map<DtNavSectorName, SectorGenerationThreadInfo*> SectorGenerationThreadMap;

   struct TriangleCallbackInfo
   {
      DtNavDataGenerator* generator;
      DtNavTriangles      triangles;
   };


   typedef std::map<DtString, DtString> ProfileRandomIdMap;

   typedef DtRwTemplatedListPtr<DtRwNavigationProfile, true> ProfileConfigList;

   typedef DtNavDataGenerator* (*DtNavDataGeneratorCreatorFcn)();

   struct NavEdgePoints
   {
      NavEdgePoints(const DtVector& p1 = DtVector::zero(),
         const DtVector& p2 = DtVector::zero(), unsigned t = 0)
         : point1(p1), point2(p2), tag(t) {};

      DtVector point1;
      DtVector point2;
      unsigned tag;
   };

   struct NavPoint
   {
      NavPoint(const DtVector& pt = DtVector::zero(), unsigned t = 0)
         : point(pt), tag(t) {};

      DtVector point;
      unsigned tag;
   };

   typedef bool(*DynamicTerrainNavEdgeFunction)(const DtRwDynamicTerrainInformation& dynTerrInfo,
      DtNavDataGenerator* navGenerator, int sectorX, int sectorY, unsigned edgeTag,
      std::list<NavEdgePoints>* edges, SectorGenerationThreadInfo* threadInfo, void* usr);

   typedef bool(*FeatureDataNavEdgeFunction)(const MAKVRinTerra::DtFeature& feature,
      DtNavDataGenerator* navGenerator, int sectorX, int sectorY, unsigned edgeTag,
      std::list<NavEdgePoints>* edges, SectorGenerationThreadInfo* threadInfo, void* usr);

   typedef bool(*GeneralNavEdgeFunction)(DtNavDataGenerator* navGenerator,
      int sectorX, int sectorY, unsigned edgeTag,
      std::list<NavEdgePoints>* edges, SectorGenerationThreadInfo* threadInfo, void* usr);
   
   typedef std::pair<DynamicTerrainNavEdgeFunction, void*> DynamicTerrainNavEdgeFunctionInfo;
   typedef std::pair<FeatureDataNavEdgeFunction, void*> FeatureDataNavEdgeFunctionInfo;
   typedef std::pair<GeneralNavEdgeFunction, void*> GeneralNavEdgeFunctionInfo;

   typedef bool(*DynamicTerrainNavPointFunction)(const DtRwDynamicTerrainInformation& dynTerrInfo,
      DtNavDataGenerator* navGenerator, int sectorX, int sectorY, unsigned pointTag,
      std::list<NavPoint>* points, SectorGenerationThreadInfo* threadInfo, void* usr);

   typedef bool(*FeatureDataNavPointFunction)(const MAKVRinTerra::DtFeature& feature,
      DtNavDataGenerator* navGenerator, int sectorX, int sectorY, unsigned pointTag,
      std::list<NavPoint>* points, SectorGenerationThreadInfo* threadInfo, void* usr);

   typedef bool(*GeneralNavPointFunction)(DtNavDataGenerator* navGenerator,
      int sectorX, int sectorY, unsigned pointTag,
      std::list<NavPoint>* points, SectorGenerationThreadInfo* threadInfo, void* usr);

   typedef std::pair<DynamicTerrainNavPointFunction, void*> DynamicTerrainNavPointFunctionInfo;
   typedef std::pair<FeatureDataNavPointFunction, void*> FeatureDataNavPointFunctionInfo;
   typedef std::pair<GeneralNavPointFunction, void*> GeneralNavPointFunctionInfo;

   static DtNavDataGenerator* create();

   virtual ~DtNavDataGenerator();

   virtual bool initialize(DtTerrainInterface* terrainInterface,
      const DtFilename& navGenConfigFile,
      const DtFilename& runtimeConfigFile,
      const DtFilename& outputPath,
      const DtFilename& terrainFile,
      const DtFilename& regenDirectory,
      bool generateFeatureTagVolumes);

   void addNavEdgeFromDynamicTerrainFunction(const DtString& name, 
      DynamicTerrainNavEdgeFunction fcn, void* usr);

   void addNavEdgeFromFeatureDataFunction(const DtString& name, FeatureDataNavEdgeFunction fcn,
      void* usr);

   void addGeneralNavEdgeFunction(const DtString& name, GeneralNavEdgeFunction fcn,
      void* usr);

   void addNavPointFromDynamicTerrainFunction(const DtString& name,
      DynamicTerrainNavPointFunction fcn, void* usr);

   void addNavPointFromFeatureDataFunction(const DtString& name, FeatureDataNavPointFunction fcn,
      void* usr);

   void addGeneralNavPointFunction(const DtString& name, GeneralNavPointFunction fcn,
      void* usr);

   virtual void setTransitionPointSpacing(double spacing);

   virtual double transitionPointSpacing() const;

   virtual bool generate();

   virtual bool generateSector(const DtNavSectorName& sectorName);

   virtual void stopGeneration();

   virtual SectorGenerationStatus getGenerateSectorStatus(const DtNavSectorName& sectorName,
      NavDataOutputMap& outputNavData);

   virtual SectorGenerationStatus getGenerateSectorStatusNoCleanup(const DtNavSectorName& sectorName) const;

   virtual const DtRwNavigationProfile* profileConfig(const DtString& profileName) const;

   virtual const ProfileConfigList& profileConfigs() const;

   virtual const DtRwNavGenConfig* navGenConfig() const;

   virtual const DtTerrainInterface* terrainInterface() const;

   MAKVRinTerra::DtFeatureGeometry& extentFeatureGeometry();

   MAKVRinTerra::DtFeatureGeometry& extentFeatureGeometry(int sectorX, int sectorY);

   virtual bool terrainHeight(const DtPoint& p, double& height, double* min = 0, double* max = 0) const;

   static void setCreator(DtNavDataGeneratorCreatorFcn creatorFcn);

   static void setNavDataDirectory(const DtFilename& navDataDir);

   static const DtFilename& navDataDirectory();

   static DtFilename replaceSubstrings(const DtFilename& original);

protected:

   friend class TbbintersectTransitionPoint;

   DtNavDataGenerator();

   virtual void loadPlugins(const std::set<DtFilename>& pluginFiles);

   virtual void unloadPlugins();

   virtual bool checkPluginVersion(DtDynamicLibrary* plugin) const;

   virtual void doGenerateSector(SectorGenerationThreadInfo* sectorGenInfo);

   virtual bool shouldStop(SectorGenerationThreadInfo* sectorGenInfo);

   static void triangleCallback(DtTerrainTriangleStruct& triangle, void* usr);
   virtual void processTriangle(DtTerrainTriangleStruct& triangle, DtNavTriangles& triangles);

   static void trianglesFinalizeCallback(int status, void* usr);
   virtual void processTrianglesFinalize(int status, DtNavTriangles& triangles);

   virtual std::vector<DtVector> calculateTransitionPointLocations();

   virtual void getProfileRandomIds(DtRwStringList& profiles, ProfileRandomIdMap& randomIds);

   virtual bool generateProfileNavData(
      const DtRwNavigationProfile* profile,
      DtString randomId);
   
   virtual bool generateSectorNavData(
      const DtRwNavigationProfile* profile,
      const DtNavSectorName& sectorName,
      NavDataOutputMap& outputData,
      SectorGenerationThreadInfo* sectorGenInfo = 0);

   virtual bool generateTransitionPoints(const DtRwNavigationProfile* profile,
      Kaim::GeneratorInputOutput& generatorInputOutput,
      const DtString& randomId, const DtFilename& navDataOutputDir);

   virtual bool generateSectorTransitionPoints(const DtRwNavigationProfile* profile,
      Kaim::GeneratorSector* sector, const DtString& randomId,
      const DtFilename& navDataOutputDir = DtFilename::nullFilename(),
      std::vector<char>* buffer = 0,
      SectorGenerationThreadInfo* sectorGenInfo = 0);

   virtual bool generateCoverPoints(const DtRwNavigationProfile* profile,
      Kaim::GeneratorInputOutput& generatorInputOutput,
      const DtString& randomId, const DtFilename& navDataOutputDir);

   virtual bool generateSectorCoverPoints(const DtRwNavigationProfile* profile,
      Kaim::GeneratorSector* sector, const DtString& randomId,
      const DtFilename& navDataOutputDir = DtFilename::nullFilename(),
      std::vector<char>* buffer = 0,
      SectorGenerationThreadInfo* sectorGenInfo = 0);

   virtual bool generateNavEdges(const DtRwNavigationProfile* profile,
      Kaim::GeneratorInputOutput& generatorInputOutput,
      const DtString& randomId, const DtFilename& navDataOutputDir);

   virtual bool generateSectorNavEdges(const DtRwNavigationProfile* profile,
      Kaim::GeneratorSector* sector, const DtString& randomId,
      const DtFilename& navDataOutputDir = DtFilename::nullFilename(),
      std::vector<char>* buffer = 0,
      SectorGenerationThreadInfo* sectorGenInfo = 0);

   virtual bool computeSectorNavEdges(const DtRwNavigationProfile* profile,
      int sectorX, int sectorY, const DtExtent& sectorExtent,
      SectorGenerationThreadInfo* sectorGenInfo, 
      std::list<NavEdgePoints>& navEdges);

   virtual bool generateNavPoints(const DtRwNavigationProfile* profile,
      Kaim::GeneratorInputOutput& generatorInputOutput,
      const DtString& randomId, const DtFilename& navDataOutputDir);

   virtual bool generateSectorNavPoints(const DtRwNavigationProfile* profile,
      Kaim::GeneratorSector* sector, const DtString& randomId,
      const DtFilename& navDataOutputDir = DtFilename::nullFilename(),
      std::vector<char>* buffer = 0,
      SectorGenerationThreadInfo* sectorGenInfo = 0);

   virtual bool computeSectorNavPoints(const DtRwNavigationProfile* profile,
      int sectorX, int sectorY, const DtExtent& sectorExtent,
      SectorGenerationThreadInfo* sectorGenInfo,
      std::list<NavPoint>& navPoints);


   virtual void setNumberOfProgressSteps(int steps);
   virtual void nextProgressStep(const DtString& stepName, int numSubSteps = 0);
   virtual void nextProgressSubStep();
   virtual void progressComplete();
   virtual void outputProgress(const DtString& stepName = DtString::nullString());


   virtual DtOutputStream& detailOutput();

   virtual DtOutputStream& milestoneOutput();

   virtual DtOutputStream& notableOutput();

   virtual DtOutputStream& errorOutput();



private:

   DtNavDataGenerator(const DtNavDataGenerator&);

   DtNavDataGenerator& operator=(const DtNavDataGenerator& orig);

protected:

   DtRwNavRuntimeConfig myNavRuntimeConfig;

   DtTerrainInterface* myTerrainInterface;

   DtNavigationGeneratorInput myNavGenInput;

   mutable RwMutex myNavGenInputMutex;

   static Mutex theNavDataGenMutex;

   DtFilename myNavGenConfigFile;

   DtFilename myRuntimeConfigFile;

   DtFilename myOutputPath;

   DtFilename myTerrainFile;

   DtFilename myRegenDirectory;

   DtFeatureTagVolumeGenerator* myFeatureTagVolumeGenerator;

   mutable RwMutex myFeatureTagVolumeGeneratorMutex;

   double myTransitionPointSpacing;

   SectorGenerationThreadMap mySectorThreads;

   MAKVRinTerra::DtFeatureGeometry myExtentFeatureGeometry;

   bool myIsInitialized;

   int myNumberOfProgressSteps;
   int myNumberOfProgressSubSteps;
   int myCurrentProgressStep;
   int myCurrentProgressSubStep;

   std::map<DtString, DynamicTerrainNavEdgeFunctionInfo> myDynamicTerrainNavEdgeFunctions;

   std::map<DtString, FeatureDataNavEdgeFunctionInfo> myFeatureDataNavEdgeFunctions;

   std::map<DtString, GeneralNavEdgeFunctionInfo> myGeneralNavEdgeFunctions;

   std::map<DtString, DynamicTerrainNavPointFunctionInfo> myDynamicTerrainNavPointFunctions;

   std::map<DtString, FeatureDataNavPointFunctionInfo> myFeatureDataNavPointFunctions;

   std::map<DtString, GeneralNavPointFunctionInfo> myGeneralNavPointFunctions;

   DtClock myClock;

   std::list<DtDynamicLibrary*> myLoadedPlugins;

   static DtFilename theNavDataDir;
   static DtNavDataGeneratorCreatorFcn theCreatorFcn;

   tbb::task_arena myArena;
};