navArea.h

Go to the documentation of this file.

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



#pragma once

#include "vrfNavigation/vrfNavigationDefines.h"
#include <string>
#include "vrfNavigation/navDataTag.h"
#include "vrfNavigation/navSectorName.h"
#include "vrfNavigation/navBot.h"
#include <matrix/vlVector.h>
#include "vrfutil/localVertexList.h"
#include "boost/shared_ptr.hpp"
#include "boost/weak_ptr.hpp"
#include <readerWriter/rwString.h>
#include "vrfutil/rwUUID.h"
#include <tbb/spin_mutex.h>

class Coordinate_System;
class DtExtent;
class DtSimObject;
class DtTerrainInterface;
struct DtInputNavTag;
class DtNavEdge;
class DtPersistentPointAlongHeadingQuery;
class DtObjectsCollectorInExtentQuery;

enum DtOnGraphVertexVisitedResult
{
   DtOnGraphVertexVisited_IgnoreVertex_GoOn,
   DtOnGraphVertexVisited_IgnoreVertex_StopWithBestSoFar,
   DtOnGraphVertexVisited_StopOnThisVertex,
   DtOnGraphVertexVisited_VertexIsTheBestSoFar_GoOn,
   DtOnGraphVertexVisited_NeedToCheckRefinePathToThisVertex
};

enum DtOnPathToGraphVertexComputedResult
{
   DtOnPathToGraphVertexComputed_IgnoreVertex_GoOn,
   DtOnPathToGraphVertexComputed_IgnoreVertex_StopWithBestSoFar,
   DtOnPathToGraphVertexComputed_StopOnThisVertex,
   DtOnPathToGraphVertexComputed_VertexIsTheBestSoFar_GoOn,
};

typedef std::set<DtNavSectorName> DtNavSectorNames;

class DT_DLL_vrfNavigation DtNavAreaQuery
{
public:
   typedef boost::shared_ptr<DtNavAreaQuery> Ptr;
   typedef boost::weak_ptr<DtNavAreaQuery> WeakPtr;

   DtNavAreaQuery() { };
   virtual ~DtNavAreaQuery() { };

   virtual bool complete() = 0;

   virtual bool tick() = 0;

   virtual bool success() = 0;

   virtual bool navDataChanged() = 0;

   virtual bool outOfWorkingMemory() = 0;

   virtual bool hadComputationError() = 0;

   virtual std::vector<DtVector> results() = 0;

   virtual double outputValue() { return 0.0; };

   virtual std::vector<DtVector> debugPoints() { return std::vector<DtVector>(); };

   virtual void* internalQuery() = 0;
};

class DT_DLL_vrfNavigation DtNavAreaNullQuery : public DtNavAreaQuery
{
public:
   DtNavAreaNullQuery() : DtNavAreaQuery() { };
   virtual ~DtNavAreaNullQuery() { };

   virtual bool complete() { return true; };
   virtual bool tick() { return true; };
   virtual bool success() { return true; };
   virtual void cancel() {};
   virtual bool navDataChanged() { return false; };
   virtual bool outOfWorkingMemory() { return false; };
   virtual bool hadComputationError() { return false; };
   virtual std::vector<DtVector> results() { return std::vector<DtVector>(); };
   virtual void *internalQuery(void) { return 0; };
};

struct DT_DLL_vrfNavigation DtNavAreaConfig
{
   DtNavAreaConfig() : workingMemorySize(16), regenerateAtRuntime(true), 
      maxRegenerationThreads(2), regenerationDelay(2.5), queryTimeBudget(1),
      regenerationFileDirectory() {};

   int workingMemorySize;

   double queryTimeBudget;

   bool regenerateAtRuntime;

   int maxRegenerationThreads;

   double regenerationDelay;

   DtFilename regenerationFileDirectory;
};

class DT_DLL_vrfNavigation DtNavRegenRequestIdData
{
public:
   virtual ~DtNavRegenRequestIdData() {};

protected:
   DtNavRegenRequestIdData() {};
   DtNavRegenRequestIdData(const DtNavRegenRequestIdData&) {};
};


typedef boost::weak_ptr<DtNavRegenRequestIdData> DtNavRegenRequestId;

class DtNavGenerationThreadCounter
{
public:
   DtNavGenerationThreadCounter(unsigned maxThreads) : myMaxThreads(maxThreads), myUsedThreads(0) {};

   void setMaxThreads(unsigned maxThreads)
   {
      myMaxThreads = maxThreads;
   }

   unsigned maxThreads() const { return myMaxThreads; }

   bool claimThread()
   {
      if (myUsedThreads < myMaxThreads)
      {
         ++myUsedThreads;
         return true;
      }
      return false;
   }

   void releaseThread()
   {
      if (myUsedThreads > 0)
      {
         --myUsedThreads;
      }
   }

   void releaseAllThreads()
   {
      myUsedThreads = 0;
   }

private:

   unsigned myMaxThreads;
   unsigned myUsedThreads;
};

class DT_DLL_vrfNavigation DtNavArea
{
public:
   struct DtNavDataDebugInfo
   {
      DtString navAreaName;
      int port;
      std::vector<DtRwString> profiles;
      DtString status;
   };

   typedef unsigned NavAreaId;
   struct DtNavTriangleInfo
   {
      DtNavTriangleInfo() : navTag(0, 0) {};
      DtVector points[3];
      DtNavTag navTag;
   };

   struct DtNavTriangleInfoExt
   {
      DtNavTriangleInfoExt() : navTagExt(0, 0) {};
      DtVector points[3];
      DtNavTagExt navTagExt;
   };

   typedef DtNavArea* (*DtNavAreaCreatorFcn)();
   typedef DtOnGraphVertexVisitedResult (*DtPointOfInterestEvaluatorFcn)(const DtVector& localPoint, void* userData);
   typedef DtOnGraphVertexVisitedResult (*DtPointOfInterestNavTagEvaluatorFcn)(const DtVector& localPoint, const DtNavTag& tag, void* userData);
   typedef void (*DtSearchAreaPointCostModifierEvaluatorFcn)(const DtVector& localPoint, float* currentCost, void* userData);
   typedef DtOnPathToGraphVertexComputedResult(*DtPathCalculatedEvaluatorFcn)(const DtVector& localPoint, double pathCost, void* userData);
   typedef void(*DtSectorRegenerationCb)(void* userData);

   static DtNavArea* create();

   static void setNavAreaCreatorFcn(DtNavAreaCreatorFcn fcn);


   static bool navAreaDebuggingEnabled();
   static void setNavAreaDebuggingEnabled(bool enable);

   virtual ~DtNavArea() {};
   virtual bool initialize(NavAreaId navAreaId, Coordinate_System* coordSys, 
      DtTerrainInterface* terrainIf, DtNavAreaConfig config,
      DtNavGenerationThreadCounter* threadCounter,
      bool parallelQueryQueueProcessing = false,
      std::vector<DtString> profiles = std::vector<DtString>()) = 0;

   virtual NavAreaId navAreaId() const = 0;

   virtual void update(float deltaTimeInSeconds) = 0;

   virtual void processQueues() = 0;

   virtual bool loadNavData(const DtString& path, const DtVariableBindingsList& variableBindings = 
      DtReaderWriter::nullVariableReference(), bool objectNavData = false) = 0;

   virtual bool inNavArea(const DtVector& localPos) const = 0;

   virtual bool validPosition(const DtString& profile, const DtVector& localPos, 
      DtNavTag* navTag = 0, DtVector* outPos = 0) = 0;

   virtual bool navTopoPosition(const DtVector& localPosition,
      DtVector& navPosition) const = 0;

   virtual bool localPosition(const DtVector& navPosition,
      DtVector& localPosition) const = 0;

   virtual bool navTopoVector(const DtVector& localVector,
      DtVector& navVector) const = 0;

   virtual bool localVector(const DtVector& navPosition,
      DtVector& localVector) const = 0;
   
   virtual bool validForProfile(const DtString& profile) const = 0;

   virtual DtNavDataDebugInfo* debugInfo() = 0;

   virtual void setExtent(DtExtent* e) = 0;
   virtual DtExtent localExtent() = 0;


   virtual double areaWidth() const = 0;
   virtual double areaLength() const = 0;

   virtual void cancelQuery(DtNavAreaQuery::Ptr) = 0;

   virtual DtNavAreaQuery::Ptr findNearbyPointOfInterest(const DtString& profile, 
      const DtVector& startLocalPos, int tag = DtNavDataTagAny, double propagationRadius = 200.,
      DtPointOfInterestEvaluatorFcn evalFcn = 0, DtPathCalculatedEvaluatorFcn pathFcn = 0,
      void* evalFcnUserData = 0) = 0;

   virtual DtNavAreaQuery::Ptr findNearbyPointOfInterestUsingNavTag(const DtString& profile, 
      const DtVector& startLocalPos, bool useHighPriorityQueue, int tag = DtNavDataTagAny, 
      double propagationRadius = 200., DtPointOfInterestNavTagEvaluatorFcn evalFcn = 0,
      DtPathCalculatedEvaluatorFcn pathFcn = 0, void* evalFcnUserData = 0) = 0;

   virtual void findNearbyNavEdgesUsingNavTags(const DtString& profile, double searchRadius, 
      const DtVector& fromFromHere, const std::vector<DtInputNavTag>& navTagVals, 
      std::list<const DtNavEdge*>& result) const = 0;

   virtual void findVerticesUsingNavTags(const DtString& profile, double searchRadius, 
      const DtVector& fromFromHere, const std::vector<DtInputNavTag>& navTagVals, 
      std::list<DtVector>& result) const = 0;

   virtual DtNavAreaQuery::Ptr findBestExitPoint(const DtString& profile, DtNavBot* searcher,
      const DtVector& startLocalPos, const DtVector& destination, int tag = DtNavDataTagAny,
      double propagationRadius = 200., DtPointOfInterestEvaluatorFcn evalFcn = 0,
      DtPathCalculatedEvaluatorFcn pathFcn = 0, void* evalFcnUserData = 0) = 0;

   virtual bool findInsidePositionFromOutsidePosition(const DtString& profile,
      double searchRadius, double searchHeight, const DtVector& fromFromHere,
      DtVector& result, int& halfEdgeType) const = 0;

   virtual DtNavAreaQuery::Ptr findBestPathTo(const DtString& profile, const DtVector& start,
      const std::vector<DtVector>& localDestinationPositions, DtNavBot* searcher, int tag = -1,
      DtSearchAreaPointCostModifierEvaluatorFcn = 0, DtPointOfInterestEvaluatorFcn = 0, 
      DtPathCalculatedEvaluatorFcn = 0, void* usrData = 0, bool startMovingWhenFound = false) = 0;

   virtual DtNavAreaQuery::Ptr findPathToLocation(const DtString& profile, const DtVector& start,
      const DtVector& destination, bool useAbstractGraphs = true,
      const DtVector& locationToAvoid = DtVector(), double avoidanceRadius = 0,
      DtNavBot::DtNavBotPathLocationEvalFcn costEvalFcn = 0, void* costEvalFcnUsrData = 0) = 0;

   virtual bool findFarthestPositionAlongHeading(const DtString& profile, const DtVector& start,
      double heading, double maxDistance, DtVector& result, bool& reachedMaxDist) const = 0;

   virtual bool doesNavIntersectBetweenTwoPoints(const DtString& profile, const DtVector& start,
      const DtVector& end) const = 0;

   virtual DtPersistentPointAlongHeadingQuery* createPeristentPointAlongHeadingQuery(const DtString& profile) const = 0;
   virtual DtObjectsCollectorInExtentQuery* createObjectsCollectorInExtentQuery(const DtString& profile) const = 0;

   //User callback to check randomly generated points. The callback function
   //should return true if the point is acceptable.
   typedef bool (*DtLocalPointUserEvalCallback)(const DtVector& localVector, DtNavAreaQuery* query, void* userData);
   static bool emptyCallback(const DtVector&, DtNavAreaQuery*, void*);

   virtual DtNavAreaQuery::Ptr generateRandomPoints(const DtString& profile,
      const DtVector& localAccessibilityPoint = DtVector::zero(),
      double minRadius = -1,
      double maxRadius = -1,
      const DtLocalVertexList& boundingArea = DtLocalVertexList(),
      unsigned numberOfPoints = 1,
      double minDistanceBetweenPoints = 0.0,
      const DtString& placementRestriction = DtString::nullString(),
      bool isStrict = true,
      bool tightlyPack = false,
      bool needLos = false,
      bool groundClamp = false,
      const DtLocalVertexList& leftOfLine = DtLocalVertexList(),
      DtLocalPointUserEvalCallback callbackFcn = emptyCallback,
      void* userData = 0) = 0;

   virtual bool tagVolumesToBeIntegrated() const = 0;

   const DtSimObject* attachedObject() { return myAttachedObject; }

   void setAttachedObject(const DtSimObject* object) { myAttachedObject = object; }

  virtual  std::vector<DtVector> searchInArea(const DtString& profile,
      const DtVector& startLocalPos, double radius, double postSpacing, DtNavBot* searcher,
      DtPointOfInterestEvaluatorFcn evalFcn = 0, void* evalFcnUserData = 0, int tag = -1) const = 0;

  virtual bool navTrianglesInArea(const DtString& profile, const DtVector& location, double radius,
     std::list<DtNavTriangleInfo>& triangles) = 0;

  virtual unsigned newNavTagId() = 0;

  virtual void associateNavTagIdWithObject(unsigned tagVolumeId, const DtUUID& objectUUID) = 0;

  virtual void disassociateNavTagId(unsigned navTagId) = 0;

  virtual DtUUID uuidFromNavTagId(unsigned navTagId) const = 0;

  virtual unsigned navTagVolumeIdFromUuid(const DtUUID& objectUUID) = 0;

  virtual const DtNavSectorNames& sectorsQueuedForRegeneration() const = 0;

  virtual const DtNavSectorNames& sectorsBeingRegenerated() const = 0;

  virtual void addSectorRegenerationCallback(DtSectorRegenerationCb cb, void* usr) = 0;
  virtual void removeSectorRegenerationCallback(DtSectorRegenerationCb cb, void* usr) = 0;

  virtual DtNavRegenRequestId requestNavDataGeneration(const DtVector& location, double radius,
     const std::set<DtString>& profiles = std::set<DtString>()) = 0;

  virtual void requestNavDataReversion(DtNavRegenRequestId id) = 0;

  virtual void pauseNavDataRegeneration() = 0;

  virtual void resumeNavDataRegeneration() = 0;

  virtual bool revertNavData() = 0;

  virtual unsigned addNavEdge(const DtString& profile, std::vector<DtVector>& LocalPoints,
     const DtInputNavTag& navTag, const DtUUID& associatedObject = DtUUID::nullUUID()) = 0;

  virtual unsigned addNavIEdge(const DtString& profile, std::vector<DtVector>& LocalPoints, std::vector< std::vector<DtVector> >& localIPoints,
     const DtInputNavTag& navTag, const DtInputNavTag& entryExitNavTag, const DtUUID& associatedObject = DtUUID::nullUUID()) = 0;

  virtual void removeNavEdge(unsigned edgeId) = 0;

  virtual unsigned addCoverPoint(const DtString& profile, const DtVector& localPoint,
     bool& creationComplete) = 0;

  virtual bool isCoverPointCreated(unsigned coverPointId) = 0;

  virtual void removeCoverPoint(unsigned coverPointId) = 0;

  virtual unsigned numberOfPendingQueries() const = 0;

public:

  virtual void printNavDataInfoForLocation(const DtVector& location, std::ostream& strm) const = 0;

protected:
   static DtNavAreaCreatorFcn theNavAreaCreatorFcn;

   static bool theNavAreaDebuggingEnabled;

   const DtSimObject* myAttachedObject;
};