terrainReasoner.h

Go to the documentation of this file.

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

#include "terrainReasoning/terrainReasoningDefines.h"
#include "matrix/vlVector.h"
#include <vector>
using namespace std;

class DtPhysicalWorld;
class DtLocalVertexList;
class DtHostQueryImplementation;
class DtIntMatrix;
class DtArea;
class DtTopoPoint;


struct DtViewCoverPosition
{
   DtVector viewPointLocal;
   double viewPct;  
   DtVector coverPointLocal;
   double coverPct; 
};

struct DtViewCoverPositionGroup {
   DtVector pivotPointLocal;
   vector<DtViewCoverPosition> positions;
   double viewPctAvg;     
   double coverPctAvg;   
   double overallPctAvg; 
};

class DT_DLL_terrainReasoning DtTerrainReasoner
{
public:
   typedef DtTerrainReasoner* (*DtTerrainReasonerCreatorFcn)(DtPhysicalWorld& physicalWorld);

protected:
   explicit DtTerrainReasoner(DtPhysicalWorld& physicalWorld);
   
   DtTerrainReasoner(const DtTerrainReasoner& other);
   DtTerrainReasoner& operator=(const DtTerrainReasoner& other);

public:
   virtual ~DtTerrainReasoner();
   
   static DtTerrainReasoner* instance();
   
   static DtTerrainReasoner* createInstance(DtPhysicalWorld& physicalWorld);
   
   static DtTerrainReasoner* creator(DtPhysicalWorld& physicalWorld);

   bool findHilltopsInArea(
      const DtLocalVertexList& areaVertices,
      double gridResolutionMeters,
      double prominenceMeters,
      double prominenceRangeMeters,
      vector<DtVector>& foundHilltopsLocal,
      string* queryString = NULL,
      string* problemDescription = NULL);

   bool findPositionGroup(
      const DtLocalVertexList& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double targetsHeightMeters,
      double viewHeightMeters,
      double coverHeightMeters,
      const DtVector& pivotLocal,
      double forwardRangeMeters,
      double backwardRangeMeters,
      double lateralRangeMeters,
      double verticalIntervalMeters,
      double maxSlopeDegrees,
      double lateralIntervalMeters,
      double positionsLateralSpacingMeters,
      unsigned int positionsCount,
      vector<DtViewCoverPosition>& foundPositions,
      string* queryString = NULL,
      string* problemDescription = NULL);

    bool findPosition(
      const DtLocalVertexList& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double targetsHeightMeters,
      double viewHeightMeters,
      double coverHeightMeters,
      const DtVector& pivotLocal,
      double forwardRangeMeters,
      double backwardRangeMeters,
      double verticalIntervalMeters,
       double maxSlopeDegrees,
       DtViewCoverPosition& foundPosition,
      string* queryString = NULL,
       string* problemDescription = NULL);

   bool findPositionGroupsInArea(
      const DtLocalVertexList& searchAreaVertices,
      double gridResolutionMeters,
      double prominenceMeters,
      double prominenceRangeMeters,
      const DtLocalVertexList& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double targetsHeightMeters,
      double viewHeightMeters,
      double coverHeightMeters,
      double forwardRangeMeters,
      double backwardRangeMeters,
      double lateralRangeMeters,
      double verticalIntervalMeters,
      double maxSlopeDegrees,
      double lateralIntervalMeters,
      double positionsLateralSpacingMeters,
      unsigned int positionsCount,
      vector<DtViewCoverPositionGroup>& foundPositionGroups,
      string* queryString = NULL,
      string* problemDescription = NULL);

   bool findRidgedPositionGroupsInArea(
      const DtLocalVertexList& searchAreaVertices,
      const DtLocalVertexList& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double targetsHeightMeters,
      double viewHeightMeters,
      double coverHeightMeters,
      double coverRangeMeters,
      double lateralRangeMeters,
      double lateralIntervalMeters,
      double verticalRangeMeters,
      double verticalIntervalMeters,
      double maxSlopeDegrees,
      double positionsLateralSpacingMeters,
      unsigned int positionsCount,
      vector<DtViewCoverPositionGroup>& foundPositionGroups,
      string* queryString = NULL,
      string* problemDescription = NULL);

private:
   void findPositionGroupWithHostQuery(
      const DtLocalVertexList& targetsAreaVertices,
      unsigned int targetsAreaSampleCount,
      double targetsHeightMeters,
      double viewHeightMeters,
      double coverHeightMeters,
      const DtVector& pivotLocal,
      unsigned int forwardRangeMeters,
      unsigned int backwardRangeMeters,
      unsigned int lateralRangeMeters,
      unsigned int verticalIntervalMeters,
      double maxSlopeDegrees,
      unsigned int lateralIntervalMeters,
      unsigned int positionsLateralSpacingMeters,
      unsigned int positionsCount,
      DtHostQueryImplementation& hostQuery,
      vector<DtViewCoverPosition>& foundPositions);
   void BuildHeightGrid(double fromX, double fromY, double toX, double toY, int intervalMeters,
      const DtHostQueryImplementation& hostQuery, DtIntMatrix& grid);
   void CovertToArea(const DtLocalVertexList& areaVertices, DtHostQueryImplementation& hostQuery, DtArea& area);
   bool ValidateNoOverlap(string functionName, const DtArea& searchArea, const DtArea& targetArea, string* problemDescription);
      string ValidationMessage(string functionName, bool isError, string offendingParameterName,
      double offendingParameterValue, string description);
   string ValidationMessage(string functionName, bool isError, string offendingParameterName,
      string description);
   bool ValidateAreaVertices(string functionName, const DtLocalVertexList& areaVertices, string name, string* problemDescription);
   bool ValidateGreaterThanZero(string functionName, double value, string name, string* problemDescription);
   bool ValidateLessThan(string functionName,
      double value, string name,
      double refValue, string refName,
      string* problemDescription);
   bool ValidateNotLessThan(string functionName,
      double value, string name,
      double refValue, string refName,
      string* problemDescription,
      bool isError=true);
   bool ValidateGreaterThan(string functionName,
      double value, string name,
      double refValue, string refName,
      string* problemDescription);
   bool ValidateNotGreaterThan(string functionName,
      double value, string name,
      double refValue, string refName,
      string* problemDescription,
      bool isError = true);
   bool ValidateLocatedOutside(string functionName, const DtArea& targetsArea, const DtTopoPoint& pt, string* problemDescription);
   bool ValidateCoverNotLessThanView(string functionName, double coverHeightMeters, double viewHeightMeters, string* problemDescription);
protected:
   DtPhysicalWorld & myPhysicalWorld;

   static DtTerrainReasonerCreatorFcn TheCreatorFcn;
   static DtTerrainReasoner* TheInstance;
};