terrainReasonerAlgos.h

Go to the documentation of this file.

#pragma once
#include <vector>
using namespace std;

class DtTopoPoint
{
public:
   DtTopoPoint(double _x, double _y, double _z) : mx(_x), my(_y), mz(_z) {}
   DtTopoPoint() {}
   inline double x() const { return mx; }
   inline void setX(double _x) { mx = _x; }
   inline double y() const { return my; }
   inline void setY(double _y) { my = _y; }
   inline double z() const { return mz; }
   inline void setZ(double _z) { mz = _z; }
private:
   double mx;
   double my;
   double mz;
};

struct DtGradeResult
{
   int lateralIndex;
   int verticalIndex;
   DtTopoPoint point;
   double grade;
   vector<bool> covered;   
};

class DtHostQueryInterface;
class DtArea;
class DtIntMatrix;
class DtIntMatrixSlice;


class DtTerrainReasonerAlgos
{
public: 
   static bool SolveHilltops(const DtIntMatrix& grid, int prominenceSpan, int prominence,
      vector<int>& hilltopX,  vector<int>& hilltopY, vector<int>& groupIndex);

   static void LocatePositions(const DtArea& area, int sampleFactor,
      const DtTopoPoint& domPoint, int posCount,
      int lateralSpacing, int lateralInterval, int lateralRange,
      int metersFire, int metersCover, int interval,
      double heightFire, double heightCover, double heightTo,
      double maxSlopeDegrees,
      const DtHostQueryInterface& losChecker,
      vector<DtTopoPoint>& samplePoints, vector<DtGradeResult>& fireResult, vector<DtGradeResult>& coverResult);

   static double GradeCoverage(const DtTopoPoint& pointFrom, double heightFrom,
      const vector<DtTopoPoint>& samplePoints, double heightTo, const DtHostQueryInterface& losChecker,
      vector<bool>& covered);

   static void SelectGrades(vector<int>& grades, int selectCount, int spacing, vector<int>& selected);

   static void FindPotentialPositionsAlongCrossSection(
      const DtTopoPoint& originPoint,
      double originHeightMeters,
      const DtTopoPoint& endPoint,
      double startCheckOffsetMeters,
      double startSearchOffsetMeters,
      double searchIntervalMeters,
      double viewHeightMeters,
      double coverHeightMeters,
      double coverRangeMeters,
      const DtHostQueryInterface& losChecker,
      vector<DtTopoPoint>& viewPoints, vector<DtTopoPoint>& coverPoints);

   static void FindPotentialPositionsInArea(
      const DtArea& searchArea,
      const DtArea& targetsArea,
      unsigned int targetsAreaSampleCount,
      double lateralIntervalMeters,
      double verticalIntervalMeters,
      double targetHeightMeters,
      double viewHeightMeters,
      double coverHeightMeters,
      double coverRangeMeters,
      const DtHostQueryInterface& losChecker,
      DtTopoPoint& targetAreaCenter, vector<DtTopoPoint>& viewPoints, vector<DtTopoPoint>& coverPoints);

   static void ClusterPotentialPositions(
      const DtTopoPoint& targetCenter,
      const vector<DtTopoPoint>& viewPoints,
      const vector<DtTopoPoint>& coverPoints,
      double maxGroupWidth,
      double maxGroupDepth,
      vector<DtArea>& clusters,
      vector<DtTopoPoint>& clusterCenters,
      vector<double>& clusterDepths,
      vector<double>& clusterWidths);

private:
   friend class DtTerrainReasonerTester;

   static void ConvertAreasToCrossSections(
      const DtArea& searchArea,
      const DtArea& targetsArea,
      unsigned int targetsAreaSampleCount,
      double lateralIntervalMeters,
      DtTopoPoint& originPoint, 
      vector<double>& startCheckOffsetMeters,
      vector<double>& startSearchOffsetMeters,
      const DtHostQueryInterface& losChecker,
      vector<DtTopoPoint>& endPoints);

   static bool PointInside(const DtTopoPoint& pt, const DtTopoPoint& fromP, const DtTopoPoint& toP);
   static bool LineIntersection(const DtTopoPoint& from1, const DtTopoPoint& to1, const DtTopoPoint& from2, const DtTopoPoint& to2, DtTopoPoint& intersection);
   static void LineAreaIntersection(const DtTopoPoint& fromLine, const DtTopoPoint& toLine, DtArea area, vector<DtTopoPoint>& intersectionVec);

   static int ProminenceCircle(int radius, DtIntMatrix& circle);

   static void FindPeaks(const DtIntMatrixSlice& slice, vector<int>& indices);

   static void GradeSinglePosition(const vector<DtTopoPoint>& samplePoints, const DtTopoPoint& areaCenter,
      const DtTopoPoint& position,
      int metersFire, int metersCover, int interval,
      double heightFire, double heightCover, double heightTo,
      double maxSlopeDegrees,
      const DtHostQueryInterface& _losChecker,
      DtGradeResult& fireResult, DtGradeResult& coverResult);
   static void SelectGradesImp(vector<int>& grades, int fromInd, int toInd,
      vector<int>& indices, int top,
      int selectCount, int spacing, vector<int>& selected);
};


class DtHostQueryInterface
{
public:
   virtual bool checkLineOfSight(double topoFromX, double topoFromY, double heightAboveFrom,
      double topoToX, double topoToY, double heightAboveTo) const = 0;
   virtual double getHeight(double topoX, double topoY) const = 0;
};

class GroupMatch
{
public:
   GroupMatch() : mNextSet(1) { mTranslation.push_back(0); }
   void RecordMatch(int i, int j);
   void Translate(vector<int>& _translation);
   int    NextSet();
private:
   int mNextSet;
   vector<int> mTranslation;
};

class DtSectorCommon
{
public:
   DtSectorCommon(const DtTopoPoint& origin, double maxWidth, double maxDepth);
   const DtTopoPoint& OriginPoint() const {return originPoint;}
   double MaxGroupWidth() const { return maxGroupWidth; }
   double MaxGroupDepth() const { return maxGroupDepth; }
private:
   DtTopoPoint originPoint;
   double maxGroupWidth;
   double maxGroupDepth;
};

class DtSector
{
public:
   DtSector(const DtSectorCommon& common, double degree = 0, double fireDistance = 0, double coverDistance = 0);
   double AddPosition(double degree, double fireDistance, double coverDistance, DtSector& result);
   bool Overlapps(const DtSector& other) const;
   DtArea ContainingRectangle() const;
   DtTopoPoint Center() const;
   double Width() const;
   double Depth() const { return maxDistance - minDistance; }
private:
   DtSectorCommon common;
   double minDegree;
   double maxDegree;
   double minDistance;
   double maxDistance;
};