terrainUtility.h

Go to the documentation of this file.

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


#pragma once
#define _USE_MATH_DEFINES 
#include <math.h>
#include <stdlib.h>
#define MAX_VERTICES 1000

class DtArea
{
public:
   int nvert;
   float vertx[MAX_VERTICES];
   float verty[MAX_VERTICES];
};

using namespace std;
class DtIntMatrix
{
public:
   DtIntMatrix(int x = 0, int y = 0) : mCountX(0), mCountY(0), mBuffer(NULL) { SetDimensions(x, y); }
   ~DtIntMatrix() { free(mBuffer); }
   size_t Size() const { return mCountX * mCountY; }
   size_t CountX() const { return mCountX; }
   size_t CountY() const { return mCountY; }
   void SetDimensions(int x, int y);
   void Set(int x, int y, int value);
   int Get(int x, int y) const;
private:
   int* mBuffer;
   size_t mCountX;
   size_t mCountY;
};

class DtIntMatrixSlice
{
public:
   DtIntMatrixSlice(const DtIntMatrix& grid, int ind, bool isX);
   int Get(int ind) const;
   int Size() const { return mSize; }
private:
   const DtIntMatrix& mSource;
   int mX;
   int mY;
   int mDx;
   int mDy;
   int mSize;
};



class DtTerrainUtility
{
public:
   static bool IsPointInsidePolygon(const DtArea& polygon, float testx, float testy)
   {
      int i, j, c = 0;
      for (i = 0, j = polygon.nvert - 1; i < polygon.nvert; j = i++) {
         if (((polygon.verty[i] > testy) != (polygon.verty[j] > testy)) &&
            (testx < (polygon.vertx[j] - polygon.vertx[i]) * (testy - polygon.verty[i]) /
               (polygon.verty[j] - polygon.verty[i]) + polygon.vertx[i]))
            c = !c;
      }
      return c;
   };
   static bool PolygonsOverlap(const DtArea& polygon1, const DtArea& polygon2)
   {
      int i;
      for (i = 0; i < polygon1.nvert; i++) {
         if (IsPointInsidePolygon(polygon2, polygon1.vertx[i], polygon1.verty[i]))
            return true;
      }
      for (i = 0; i < polygon2.nvert; i++) {
         if (IsPointInsidePolygon(polygon1, polygon2.vertx[i], polygon2.verty[i]))
            return true;
      }
      return false;
   };
   static float polygonArea(const DtArea& polygon)
   {
      float area = 0;
      int j = polygon.nvert - 1;
      for (int i = 0; i < polygon.nvert; i++)
      {
         area += (polygon.vertx[j] + polygon.vertx[i]) * (polygon.verty[j] - polygon.verty[i]);
         j = i;  
      }
      return (float)fabs(area / 2.0);
   }
   static void PolygonBoundaries(const DtArea& polygon, float& minx, float& miny, float& maxx, float& maxy)
   {
      minx = polygon.vertx[0];
      miny = polygon.verty[0];
      maxx = polygon.vertx[0];
      maxy = polygon.verty[0];
      for (int i = 1; i < polygon.nvert; i++) {
         if (minx > polygon.vertx[i])
            minx = polygon.vertx[i];
         if (miny > polygon.verty[i])
            miny = polygon.verty[i];
         if (maxx < polygon.vertx[i])
            maxx = polygon.vertx[i];
         if (maxy < polygon.verty[i])
            maxy = polygon.verty[i];
      }
   };
   static double Distance(double x1, double y1, double x2, double y2)
   {
      double dx = x1 - x2;
      double dy = y1 - y2;
      return sqrt(dx * dx + dy * dy);
   }
   static double DegreeBetween(double x1, double y1, double x2, double y2);
   static void PointFromPointDistanceDegree(double originX, double originY, double distance, double degree, 
      double& pointX, double& pointY);
};