luaTerrainReasoningJob.h

Go to the documentation of this file.

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

#pragma once

#include <vrfLua/vrfLuaDefines.h>

#include "vrfLua/luaAsyncJob.h"
#include "vrfutil/algorithmManager.h"
#include "vrfutil/scriptGeometry.h"

#include "terrainInterface/terrainInterface.h"

class DtSimManager;
class DtTerrainReasoningJob;
class DtLocation3D;

const DtString DtLuaHilltopQueryJobType = "LuaHilltopQueryJob";

class DT_DLL_vrfLua DtLuaHilltopQueryJob : public DtLuaAsyncJob
{
public:
   typedef std::list<DtLocation3D> Points;

   static boost::shared_ptr<DtLuaHilltopQueryJob> Make(
      DtSimulationServices*,
      const Points& corners,
      unsigned int nPointsToReturn,
      bool bDebug = false);

   DtLuaHilltopQueryJob();

   virtual ~DtLuaHilltopQueryJob();

   luabind::object getObject(lua_State* L, int& index, std::string& message);

   luabind::object getDebugObject(lua_State* L) {return luabind::newtable(L);}

   virtual void cancel(lua_State* L) {};

   //
   //

   static DtAsciiSerializable* creator();

   DtString serialize();
   bool deserialize(const DtString&);
   DtString objectType() const;

   boost::shared_ptr<DtLuaHilltopQueryJob> shared_from_this();
   boost::shared_ptr<const DtLuaHilltopQueryJob> shared_from_this() const;

protected:

   DtLuaHilltopQueryJob(
      DtSimulationServices*,
      const Points& corners,
      unsigned int nPointsToReturn,
      bool bDebug=false);

   void start();
   void run(const DtAlgorithmManager& mgr = DtAlgorithmManager());

   void taskComplete();

   Points myCorners;
   unsigned int nMyPointsToReturn;
   bool bMyDebug;

   DtAsyncJobStatus myStatus;
   std::vector<DtLocation3D> myHighPoints;

   boost::shared_ptr<DtAsyncJobMapEntry> myJobEntry;
};

const DtString DtLuaVehicleFightingPositionQueryJobType = "DtLuaVehicleFightingPositionQueryJob";

class DT_DLL_vrfLua DtLuaVehicleFightingPositionQueryJob : public DtLuaAsyncJob
{
public:
   typedef std::list<DtLocation3D> Points;

   static boost::shared_ptr<DtLuaVehicleFightingPositionQueryJob> Make(
      DtSimulationServices*,
      unsigned int nPointsToReturn,
      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 = false);

   DtLuaVehicleFightingPositionQueryJob();

   virtual ~DtLuaVehicleFightingPositionQueryJob();

   luabind::object getObject(lua_State* L, int& index, std::string& message);

   luabind::object getDebugObject(lua_State* L) { return luabind::newtable(L); }

   virtual void cancel(lua_State* L) {};

   //
   //

   static DtAsciiSerializable* creator();

   DtString serialize();
   bool deserialize(const DtString&);
   DtString objectType() const;

   boost::shared_ptr<DtLuaVehicleFightingPositionQueryJob> shared_from_this();
   boost::shared_ptr<const DtLuaVehicleFightingPositionQueryJob> shared_from_this() const;

protected:

   DtLuaVehicleFightingPositionQueryJob(
      DtSimulationServices*,
      unsigned int nPointsToReturn,
      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 = false);

   void start();
   void run(const DtAlgorithmManager& mgr = DtAlgorithmManager());

   void taskComplete();

   Points myTargetAreaCorners;
   unsigned int nMyPointsToReturn;
   DtLocation3D myOriginPoint;
   DtVectorOffset3D myHideVolume;
   double myShootHeight;
   double myTargetHeight;
   double myForwardBackSearchLimit;
   double mySideSideSearchLimit;
   double myMaxSlopeDegrees;
   double myPositionSpacing;

   DtAsyncJobStatus myStatus;
   std::vector<std::pair<DtLocation3D, DtLocation3D> > myPositionPairs;

   boost::shared_ptr<DtAsyncJobMapEntry> myJobEntry;

   bool bMyDebug;
};

const DtString DtLuaFindSinglePositionQueryJobType = "DtLuaFindSinglePositionQueryJob";

class DT_DLL_vrfLua DtLuaFindSinglePositionQueryJob : public DtLuaAsyncJob
{
public:
   typedef std::list<DtLocation3D> Points;

   static boost::shared_ptr<DtLuaFindSinglePositionQueryJob> Make(
      DtSimulationServices*,
      const std::list<DtLocation3D>& targetAreaCorners,
      const DtLocation3D& pivotPoint,
      double targetHeightMeters,
      double viewHeightMeters,
      double hideHeightMeters,
      double forwardBackSearchLimitMeters,
      double forwardBackSearchIntervalMeters,
     double maxSlopeDegrees,
      bool bDebug = false);

   DtLuaFindSinglePositionQueryJob();

   virtual ~DtLuaFindSinglePositionQueryJob();

   luabind::object getObject(lua_State* L, int& index, std::string& message);

   luabind::object getDebugObject(lua_State* L) { return luabind::newtable(L); }

   virtual void cancel(lua_State* L) {};

   //
   //

   static DtAsciiSerializable* creator();

   DtString serialize();
   bool deserialize(const DtString&);
   DtString objectType() const;

   boost::shared_ptr<DtLuaFindSinglePositionQueryJob> shared_from_this();
   boost::shared_ptr<const DtLuaFindSinglePositionQueryJob> shared_from_this() const;

protected:

   DtLuaFindSinglePositionQueryJob(
      DtSimulationServices*,
      const std::list<DtLocation3D>& targetAreaCorners,
      const DtLocation3D& pivotPoint,
      double targetHeightMeters,
      double viewHeightMeters,
      double hideHeightMeters,
      double forwardBackSearchLimitMeters,
      double forwardBackSearchIntervalMeters,
     double maxSlopeDegrees,
      bool bDebug = false);

   void start();
   void run(const DtAlgorithmManager& mgr = DtAlgorithmManager());

   void taskComplete();

   Points myTargetAreaCorners;
   DtLocation3D myPivotPoint;
   double myHideHeight;
   double myViewHeight;
   double myTargetHeight;
   double myForwardBackSearchLimit;
   double myForwardBackSearchInterval;
   double myMaxSlopeDegrees;
   bool bMyDebug;

   DtAsyncJobStatus myStatus;
   std::vector<DtLocation3D> myFoundPositionPair;

   boost::shared_ptr<DtAsyncJobMapEntry> myJobEntry;
};

namespace LuaTerrainReasoning
{
   typedef std::list<DtLocation3D> Points;

   typedef std::vector<std::pair<DtLocation3D, DtLocation3D> > PositionPairs;
   struct _Group
   {
      DtLocation3D pivotPoint;
      PositionPairs positions;
      double scoreViewPctAverage;
      double scoreCoverPctAverage;
      double scoreOverallPctAverage;
   };
   typedef struct _Group PositionGroup;
};

const DtString DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJobType = "DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob";

class DT_DLL_vrfLua DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob : public DtLuaAsyncJob
{
public:

   static boost::shared_ptr<DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob> Make(
      DtSimulationServices*,
      const std::list<DtLocation3D>& sourceAreaVertices,
      const std::list<DtLocation3D>& targetsAreaVertices,
      double viewHeightMeters,
      double hideHeightMeters,
      double forwardBackSearchLimitMeters,
      double sideToSideSearchLimitMeters,
      double searchIntervalMeters,
     double maxSlopeDegrees,
      double positionsSpacing,
      unsigned int positionsCount,
      bool bDebug = false);

   DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob();

   virtual ~DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob();

   luabind::object getObject(lua_State* L, int& index, std::string& message);

   luabind::object getDebugObject(lua_State* L) { return luabind::newtable(L); }

   virtual void cancel(lua_State* L) {};

   //
   //

   static DtAsciiSerializable* creator();

   virtual void serializePositionPairs(DtString& toString, LuaTerrainReasoning::PositionPairs& pairs);
   virtual void serializePositionGroup(DtString& toString, LuaTerrainReasoning::PositionGroup& group);
   virtual void deserializePositionPairs(std::vector<std::pair<DtLocation3D, DtLocation3D> >& toPairs, const std::vector<DtString>& tokens, unsigned int& tokenIndex);
   virtual void deserializeGroup(LuaTerrainReasoning::PositionGroup& toGroup, const std::vector<DtString>& tokens, unsigned int& tokenIndex);
   virtual void deserializeGroups(std::vector<LuaTerrainReasoning::PositionGroup>& toGroups, const std::vector<DtString>& tokens, unsigned int& tokenIndex );
   virtual void clearGroups(std::vector<LuaTerrainReasoning::PositionGroup>& groups);

   DtString serialize();
   bool deserialize(const DtString&);
   DtString objectType() const;

   boost::shared_ptr<DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob> shared_from_this();
   boost::shared_ptr<const DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob> shared_from_this() const;


protected:

   DtLuaFindPositionGroupsInAreaUsingHilltopsQueryJob(
      DtSimulationServices*,
      const std::list<DtLocation3D>& sourceAreaVertices,
      const std::list<DtLocation3D>& targetsAreaVertices,
      double viewHeightMeters,
      double hideHeightMeters,
      double forwardBackSearchLimitMeters,
      double sideToSideSearchLimitMeters,
      double searchIntervalMeters,
     double maxSlopeDegrees,
      double positionsSpacing,
      unsigned int positionsCount,
      bool bDebug = false);

   void start();
   void run(const DtAlgorithmManager& mgr = DtAlgorithmManager());

   void taskComplete();

   LuaTerrainReasoning::Points mySourceAreaCorners;
   LuaTerrainReasoning::Points 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;

   DtAsyncJobStatus myStatus;

   std::vector<LuaTerrainReasoning::PositionGroup> myPositionGroups;

   boost::shared_ptr<DtAsyncJobMapEntry> myJobEntry;
};

const DtString DtLuaFindPositionGroupsInAreaUsingRidgeQueryJobType = "DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob";

class DT_DLL_vrfLua DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob : public DtLuaAsyncJob
{
public:

   static boost::shared_ptr<DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob> Make(
      DtSimulationServices*,
      const std::list<DtLocation3D>& sourceAreaVertices,
      const std::list<DtLocation3D>& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double viewHeightMeters,
      double hideHeightMeters,
      double coverRangeMeters,
      double sideToSideSearchLimitMeters,
      double lateralSearchIntervalMeters,
      double forwardBackSearchLimitMeters,
      double forwardSearchIntervalMeters,
      double maxSlopeDegrees,
      double positionsSpacing,
      unsigned int positionsCount,
      bool bDebug = false);

   DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob();

   virtual ~DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob();

   luabind::object getObject(lua_State* L, int& index, std::string& message);

   luabind::object getDebugObject(lua_State* L) { return luabind::newtable(L); }

   virtual void cancel(lua_State* L) {};

   //
   //

   static DtAsciiSerializable* creator();

   virtual void serializePositionPairs(DtString& toString, LuaTerrainReasoning::PositionPairs& pairs);
   virtual void serializePositionGroup(DtString& toString, LuaTerrainReasoning::PositionGroup& group);
   virtual void deserializePositionPairs(std::vector<std::pair<DtLocation3D, DtLocation3D> >& toPairs, const std::vector<DtString>& tokens, unsigned int& tokenIndex);
   virtual void deserializeGroup(LuaTerrainReasoning::PositionGroup& toGroup, const std::vector<DtString>& tokens, unsigned int& tokenIndex);
   virtual void deserializeGroups(std::vector<LuaTerrainReasoning::PositionGroup>& toGroups, const std::vector<DtString>& tokens, unsigned int& tokenIndex);
   virtual void clearGroups(std::vector<LuaTerrainReasoning::PositionGroup>& groups);

   DtString serialize();
   bool deserialize(const DtString&);
   DtString objectType() const;

   boost::shared_ptr<DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob> shared_from_this();
   boost::shared_ptr<const DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob> shared_from_this() const;


protected:

   DtLuaFindPositionGroupsInAreaUsingRidgeQueryJob(
      DtSimulationServices*,
      const std::list<DtLocation3D>& sourceAreaVertices,
      const std::list<DtLocation3D>& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double viewHeightMeters,
      double hideHeightMeters,
      double coverRangeMeters,
      double sideToSideSearchLimitMeters,
      double lateralSearchIntervalMeters,
      double forwardBackSearchLimitMeters,
      double forwardSearchIntervalMeters,
      double maxSlopeDegrees,
      double positionsSpacing,
      unsigned int positionsCount,
      bool bDebug = false);

   void start();
   void run(const DtAlgorithmManager& mgr = DtAlgorithmManager());

   void taskComplete();

   LuaTerrainReasoning::Points mySourceAreaCorners;
   LuaTerrainReasoning::Points myTargetAreaCorners;
   unsigned int myNumberPositionsPerGroupRequested;
   unsigned int myTargetsAreaSampleCount;
   unsigned int myGridResolutionMeters;
   double myProminenceMeters;
   unsigned int myProminenceRangeMeters;
   double myTargetHeight;
   double myShootHeight;
   double myHideHight;
   double myCoverRange;
   double mySideSideSearchLimit;
   double mySideSideSearchIntervalMeters;
   double myForwardBackSearchIntervalMeters;
   double myMaxSlopeDegrees;
   double myForwardBackSearchLimitMeters;
   double myPositionsSpacing;
   bool bMyDebug;

   DtAsyncJobStatus myStatus;

   std::vector<LuaTerrainReasoning::PositionGroup> myPositionGroups;

   boost::shared_ptr<DtAsyncJobMapEntry> myJobEntry;
};