terrainReasoningJob.h

Go to the documentation of this file.

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

#pragma once

#include "terrainReasoning/terrainReasoningDefines.h"
#include "terrainInterface/terrainInterface.h"
#include "vrfutil/scriptGeometry.h"
#include "vrfutil/asciiSerializable.h"
#include "vrfutil/algorithmManager.h"

#include "vlutil/vlMutex.h"

#include "features/featureGeometry.h"
#include "features/pathPlanner.h"

#include <boost/scoped_ptr.hpp>

class DtAsyncJobMapEntry;
class DtPhysicalWorld;

namespace vrfTrl
{
   void ArrangePositionsLeftToRight2D(const std::vector<std::pair<DtLocation3D, DtLocation3D> >& inPoints,
      const DtLocation3D& originPoint,
      const DtLocation3D& destinationPoint,
      std::vector<std::pair<DtLocation3D, DtLocation3D> >& outPoints);

   DtLocation3D FindAreaCenter2D(const std::list<DtLocation3D>& targetAreaCorners);

   void MakeRelativeSearchArea2D(const DtLocation3D& origin,
      const DtLocation3D& referencePoint,
      double widthSideSide,
      double depthForwardBack,
      std::list<DtLocation3D>& searchAreaCorners);

   void ConvertToLocalVectorList(const std::list<DtLocation3D>& sourceLocations, DtLocalVertexList& resultsList, DtTerrainInterface* pTerrainIf, bool bClamp = true);
}

class DT_DLL_terrainReasoning DtHilltopQueryResult : public DtAsyncJobResult
{
public:
   DtHilltopQueryResult();
   DtHilltopQueryResult(const DtHilltopQueryResult&);
   virtual ~DtHilltopQueryResult();

   const DtHilltopQueryResult& operator=(const DtHilltopQueryResult&);

   virtual void copyResultFrom(const DtHilltopQueryResult& orig);

   std::vector<DtLocation3D> myHighPoints;
};


class DT_DLL_terrainReasoning DtHilltopQueryJob : public DtAsyncDetachedJob
{
public:

   explicit DtHilltopQueryJob(DtTerrainInterface *, 
      const std::list<DtLocation3D>& corners, 
      int nPointsToReturn, 
      bool bDebug);

   virtual ~DtHilltopQueryJob();

   void message(Severity severity, std::string msg);

   tbb::task* onExecute();

   tbb::task* onException();

protected:
   DtTerrainInterface *pMyTerrainInterface;
   std::list<DtLocation3D> myCorners;
   int nMyPointsToReturn;
   bool bMyDebug;

};

class DT_DLL_terrainReasoning DtVehiclePositionQueryResult : public DtAsyncJobResult
{
public:
   DtVehiclePositionQueryResult();
   DtVehiclePositionQueryResult(const DtVehiclePositionQueryResult&);
   virtual ~DtVehiclePositionQueryResult();

   const DtVehiclePositionQueryResult& operator=(const DtVehiclePositionQueryResult&);

   virtual void copyResultFrom(const DtVehiclePositionQueryResult& orig);

   std::vector<std::pair<DtLocation3D, DtLocation3D> > myPositionPairs;
};

class DT_DLL_terrainReasoning DtVehiclePositionQuery : public DtAsyncDetachedJob
{
public:

   /*
   findVehiclePlatoonFightingPositions(taskParameters.numberOfPoints,
   taskParameters.targetArea:getLocations3D(),
   taskParameters.battlePosition,
   maxVolume, -- full dimensions of hide position
   maxVolume:getUp() * 1.34, --67% of total height for shooting height
   maxVolume:getUp(), -- half height for target height
   10,
   searchWidthForward * 2.0, -- how much forward and back to search forward and back
   searchWidthSide * 2.0 -- how much side to side to search
   )
   */
   explicit DtVehiclePositionQuery(DtTerrainInterface *,
      int nPositionPairsToReturn, 
      const std::list<DtLocation3D>& targetAreaCorners,
      const DtLocation3D& originPoint,
      const DtVectorOffset3D& hideVolume,
      double shootHeight,
      double targetHeight,
      double forwardBackSearchLimit,
      double sideSideSearchLimit,
     double maxSlopeDegrees,
      double positionSpacing,
      bool bDebug);

   virtual ~DtVehiclePositionQuery();

   void message(Severity severity, std::string msg);

   tbb::task* onExecute();

   tbb::task* onException();

protected:
   DtTerrainInterface * pMyTerrainInterface;
   std::list<DtLocation3D> myTargetAreaCorners;
   int myNumberPositionPairsToReturn;
   DtLocation3D myOriginPoint;
   DtVectorOffset3D myHideVolume;
   double myShootHeight;
   double myTargetHeight;
   double myForwardBackSearchLimit;
   double mySideSideSearchLimit;
   double myMaxSlopeDegrees;
   double myPositionSpacing;
   bool bMyDebug;

};

class DT_DLL_terrainReasoning DtFindSinglePositionQuery : public DtAsyncDetachedJob
{
public:

   /*
   findSinglePosition(taskParameters.targetArea:getLocations3D(),
      targetHeightMeters, -- 2/3 vehicle height, for example.
      double viewHeightMeters, -- 2/3 vehicle height, for example.
      double hideHeightMeters, -- 1.1x vehicle height, for example.
      double forwardBackSearchLimitMeters, -- 50m forward + 50m backward = 100m
      double forwardBackSearchIntervalMeters, -- half vehicle length, for example.
      bool bDebug
   )
   */
   explicit DtFindSinglePositionQuery(DtTerrainInterface *,
      const std::list<DtLocation3D>& targetAreaCorners,
      const DtLocation3D& pivotPoint,
      double targetHeightMeters,
      double viewHeightMeters,
      double hideHeightMeters,
      double forwardBackSearchLimitMeters,
      double forwardBackSearchIntervalMeters,
     double maxSlopeDegrees,
      bool bDebug);

   virtual ~DtFindSinglePositionQuery();

   void message(Severity severity, std::string msg);

   tbb::task* onExecute();

   tbb::task* onException();

protected:
   DtTerrainInterface * pMyTerrainInterface;
   std::list<DtLocation3D> myTargetAreaCorners;
   DtLocation3D myOriginPoint;
   double myHideHeight;
   double myViewHeight;
   double myTargetHeight;
   double myForwardBackSearchLimit;
   double myForwardBackSearchInterval;
   double myMaxSlopeDegrees;

   bool bMyDebug;

};

class DT_DLL_terrainReasoning DtFindPositionGroupsInAreaQueryResult : public DtAsyncJobResult
{
public:
   typedef std::vector<std::pair<DtLocation3D, DtLocation3D> > PositionPairs;
   typedef struct Group
   {
      DtLocation3D pivotPoint;
      PositionPairs positions;
      double scoreViewPctAverage;
      double scoreCoverPctAverage;
      double scoreOverallPctAverage;
   } PositionGroup;

   DtFindPositionGroupsInAreaQueryResult();
   DtFindPositionGroupsInAreaQueryResult(const DtFindPositionGroupsInAreaQueryResult&);
   virtual ~DtFindPositionGroupsInAreaQueryResult();

   const DtFindPositionGroupsInAreaQueryResult& operator=(const DtFindPositionGroupsInAreaQueryResult&);

   virtual void copyResultFrom(const DtFindPositionGroupsInAreaQueryResult& orig);


   std::vector<PositionGroup> groups;
};

class DT_DLL_terrainReasoning DtFindPositionGroupsInAreaUsingHilltopsQuery : public DtAsyncDetachedJob
{
public:

   
   explicit DtFindPositionGroupsInAreaUsingHilltopsQuery(DtTerrainInterface *,
      const std::list<DtLocation3D>& sourceAreaVertices,
      unsigned int gridResolutionMeters,
      double prominenceMeters,
      unsigned int prominenceRangeMeters,
      const std::list<DtLocation3D>& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double targetsHeightMeters,
      double viewHeightMeters,
      double hideHeightMeters,
      double forwardBackSearchLimitMeters,
      double sideToSideSearchLimitMeters,
      double forwardBackSearchIntervalMeters,
      double maxSlopeDegrees,
      double sideToSideSearchIntervalMeters,
      double positionsSpacing,
      unsigned int positionsCount,
      bool bDebug);

   virtual ~DtFindPositionGroupsInAreaUsingHilltopsQuery();

   void message(Severity severity, std::string msg);

   tbb::task* onExecute();

   tbb::task* onException();

protected:
   DtTerrainInterface * pMyTerrainInterface;
   std::list<DtLocation3D> mySourceAreaCorners;
   std::list<DtLocation3D> myTargetAreaCorners;
   unsigned int myNumberPositionsPerGroupRequested;
   unsigned int myTargetsAreaSampleCount;
   unsigned int myGridResolutionMeters;
   double myProminenceMeters;
   unsigned int myProminenceRangeMeters;
   double myTargetHeight;
   double myShootHeight;
   double myHideHight;
   double myForwardBackSearchLimitMeters;
   double mySideSideSearchLimit;
   double myForwardBackSearchIntervalMeters;
   double myMaxSlopeDegrees;
   double mySideSideSearchIntervalMeters;
   double myPositionsSpacing;
   bool bMyDebug;

};

class DT_DLL_terrainReasoning DtFindPositionGroupsInAreaUsingRidgeQuery : public DtAsyncDetachedJob
{
public:

   explicit DtFindPositionGroupsInAreaUsingRidgeQuery(DtTerrainInterface *,
      const std::list<DtLocation3D>& sourceAreaVertices,
      const std::list<DtLocation3D>& targetsAreaVertices,  
      unsigned int targetsAreaSampleCount,
      double targetsHeightMeters,
      double viewHeightMeters,
      double hideHeightMeters,
      double coverRangeMeters,
      double lateralRangeMeters,
      double forwardBackRangeMeters,
      double forwardBackIntervalMeters,
     double maxSlopeDegrees,
      double lateralIntervalMeters,
      double positionsSpacing,
      unsigned int positionsCount,
      bool bDebug);

   virtual ~DtFindPositionGroupsInAreaUsingRidgeQuery();

   void message(Severity severity, std::string msg);

   tbb::task* onExecute();

   tbb::task* onException();

protected:
   DtTerrainInterface * pMyTerrainInterface;
   std::list<DtLocation3D> mySourceAreaCorners;
   std::list<DtLocation3D> myTargetAreaCorners;
   unsigned int myNumberPositionsPerGroupRequested;
   unsigned int myTargetsAreaSampleCount;
   double myTargetHeight;
   double myShootHeight;
   double myHideHight;
   double myCoverRange;
   double myForwardBackSearchLimitMeters;
   double mySideSideSearchLimit;
   double myForwardBackSearchIntervalMeters;
   double myMaxSlopeDegrees;
   double mySideSideSearchIntervalMeters;
   double myPositionsSpacing;
   bool bMyDebug;

};