scriptGeometry.h

Go to the documentation of this file.

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

#include <vrfutil/vrfutilDefines.h>
#include <matrix/vlVector.h>
#include <vrfutil/asciiSerializable.h>
#include <matrix/geodeticCoord.h>


class DtVectorGeoc3D;
class DtVector3D;
class DtVectorOffset3D;

class DT_DLL_vrfutil DtLocation3D
   : public DtAsciiSerializable
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtLocation3D>
#endif
{
public:

   DtLocation3D(const DtVector &vect);
   DtLocation3D(const DtGeodeticCoord &geodCoord);
   DtLocation3D(const DtLocation3D& orig);
   DtLocation3D();
   virtual ~DtLocation3D() override;
   DtLocation3D& operator=(const DtLocation3D& orig);

   DtLocation3D(const double latitude, const double longitude,
      const double altitudeMSL);

   DtLocation3D makeCopy() const;

   //-------------------------------------------
   
   virtual DtString objectType() const override;

   virtual DtString serialize() override;

   virtual bool deserialize(const DtString& data) override;

   static DtAsciiSerializable* creator();
   //--------------------------------------------

   DtVector getGeocentric() const;
   DtGeodeticCoord geodLocation() const;

   void setGeodeticFromVector(const DtVector& geodeticData);
   DtVector getGeodeticVector(void) const;

   double getLat() const;
   void   setLat(const double lat);
   double getLon() const;
   void   setLon(const double lon);
   double getAlt() const;
   void   setAlt(const double alt);
   
   double distanceToLocation3D(const DtLocation3D &location) const;

   bool isNearLocation3D(const DtLocation3D &loc, const double error) const;

   bool isInsidePolygon(const std::vector<DtLocation3D> polyPoints)const;

   bool isLeftOfLine(const DtLocation3D &loc1, const DtLocation3D & loc2) const;


   DtVector3D vectorToLoc3D(const DtLocation3D &location) const;

   DtVectorGeoc3D vectorGeocToLoc3D(const DtLocation3D &location) const;

   DtLocation3D addVector3D(const DtVector3D &vec) const;
   
   DtLocation3D addVectorGeoc3D(const DtVectorGeoc3D &vec) const;

   void setGeocentric(double x, double y, double z);

   void getGeocentricCoords(double& x, double& y, double& z) const;

   bool operator==(const DtLocation3D&) const;
   bool operator!=(const DtLocation3D& orig) const
   {
      return !(*this == orig);
   }

   bool isValid() const;

protected:
   DtGeodeticCoord myGeodLocation;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtLocation3D);

DT_DLL_vrfutil std::ostream& operator<<(std::ostream& stream, const DtLocation3D& loc);

class DT_DLL_vrfutil DtVector3D
   : public DtAsciiSerializable
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtVector3D>
#endif
{
public:

   DtVector3D();
   DtVector3D(const DtVector &vect);
   DtVector3D(const DtVector3D& vect);
   virtual ~DtVector3D() override;
   DtVector3D& operator=(const DtVector3D& orig);
   DtVector nedVector() const;

   DtVector3D(const double north, const double east, const double down);

   void setFromGeocentricVector(const DtVector &geocVec, DtLocation3D& origin);

   DtVector3D makeCopy() const;

   //-------------------------------------------

   virtual DtString objectType() const override;

   virtual DtString serialize() override;

   virtual bool deserialize(const DtString& data) override;

   static DtAsciiSerializable* creator();
   //--------------------------------------------

   void setNorthEastDown(const double north, const double east,
      const double down);
   void setBearingInclRange(const double bearing, const double inclination,
      const double range);

   double getBearing(void) const;
   double getInclination(void)const;
   double getRange(void)const;

   double getNorth(void)const;
   double getEast(void) const;
   double getDown(void) const;

   DtVector3D getScaled(const double scale) const;
   DtVector3D getNegated(void) const;
   DtVector3D getUnit(void) const;

   DtVector3D addVector3D(const DtVector3D &vec) const;

   DtVector3D crossVector3D(const DtVector3D &vec) const;

   double dotVector3D(const DtVector3D &vec) const;

   DtVector3D addOffset(const DtVectorOffset3D & offset) const;

   double headingDiff(const DtVector3D &vec) const;
   
   DtVectorGeoc3D makeVectorGeoc3DAtLoc(const DtLocation3D &loc) const;

   bool operator==(const DtVector3D&) const;
   bool operator!=(const DtVector3D& orig) const
   {
      return !(*this == orig);
   }

protected:
   DtVector myNEDVector;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtVector3D);

DT_DLL_vrfutil std::ostream& operator<<(std::ostream& stream, const DtVector3D& vec);

class DT_DLL_vrfutil DtVector2D
   : public DtVector3D
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtVector2D>
#endif
{
public:

   DtVector2D();
   DtVector2D(const DtVector &vect);
   DtVector2D(const DtVector3D& vect);
   virtual ~DtVector2D() override;
   DtVector2D& operator=(const DtVector3D& orig);

   DtVector2D(const double north, const double east);

   virtual DtString objectType() const override;

   static DtAsciiSerializable* creator();

   void setNorth(const double north);
   void setEast(const double east);

   DtVector2D addVector2D(const DtVector3D& vec);

   double crossVector2D(const DtVector3D &vec);

   double dotVector2D(const DtVector3D &vec);

   DtVector2D addOffset2D(const DtVectorOffset3D &vec);

   bool operator==(const DtVector2D&) const;
   bool operator!=(const DtVector2D& orig) const
   {
      return !(*this == orig);
   }
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtVector2D);

DT_DLL_vrfutil std::ostream& operator<<(std::ostream& stream, const DtVector2D& vec);


class DT_DLL_vrfutil DtVectorGeoc3D
   : public DtAsciiSerializable
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtVectorGeoc3D>
#endif
{
public:
   DtVectorGeoc3D(const DtVector &vect);
   DtVectorGeoc3D(const DtVectorGeoc3D& orig);
   virtual ~DtVectorGeoc3D() override;
   DtVectorGeoc3D& operator=(const DtVectorGeoc3D& orig);

   DtVector geocVector() const;

   //-------------------------------------------

   virtual DtString objectType() const override;

   virtual DtString serialize() override;

   virtual bool deserialize(const DtString& data) override;

   static DtAsciiSerializable* creator();
   //--------------------------------------------

   DtVectorGeoc3D makeCopy() const;

   DtVector3D makeVector3DAtLoc(const DtLocation3D loc) const;

   DtVectorGeoc3D getScaled(const double scale) const;
   DtVectorGeoc3D getNegated(void) const;
   DtVectorGeoc3D getUnit(void) const;

   DtVectorGeoc3D crossVectorGeoc3D(const DtVectorGeoc3D &vec) const;

   double dotVectorGeoc3D(const DtVectorGeoc3D &vec) const;
  

   double getLength() const;

   bool operator==(const DtVectorGeoc3D&) const;
   bool operator!=(const DtVectorGeoc3D& orig) const
   {
      return !(*this == orig);
   }

protected:
   DtVector myGeocVector;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtVectorGeoc3D);

DT_DLL_vrfutil std::ostream& operator<<(std::ostream& stream, const DtVectorGeoc3D& vec);


class DT_DLL_vrfutil DtVectorOffset3D
   : public DtAsciiSerializable
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtVectorOffset3D>
#endif
{
public:
   DtVectorOffset3D();
   
   DtVectorOffset3D(const DtVector &vect);
   DtVectorOffset3D(const DtVectorOffset3D& orig);
   virtual ~DtVectorOffset3D() override;
   DtVectorOffset3D& operator=(const DtVectorOffset3D& orig);

   DtVectorOffset3D(double right, double forward, double up);

   void setFromBodyVector(const DtVector &vect);

   DtVectorOffset3D makeCopy() const;

  //-------------------------------------------

   virtual DtString objectType() const override;

   virtual DtString serialize() override;

   virtual bool deserialize(const DtString& data) override;

   static DtAsciiSerializable* creator();
   //--------------------------------------------

   double getRight(void) const;
   void   setRight(const double right);
   double getForward(void) const;
   void   setForward(const double forward);
   double getUp(void) const;
   void   setUp(const double up);

   DtVectorOffset3D getScaled(const double scale) const;
   DtVectorOffset3D getNegated(void) const;
   DtVectorOffset3D getUnit(void) const;

   DtVectorOffset3D addOffset(const DtVectorOffset3D offset) const;

   DtVectorOffset3D crossVectorOffset3D(const DtVectorOffset3D &vec) const;

   double dotVectorOffset3D(const DtVectorOffset3D &vec) const;

   DtVector3D  makeVectorRefToDirection(const DtVector3D dirVect) const;

   DtVector vector() const;

   bool operator==(const DtVectorOffset3D&) const;
   bool operator!=(const DtVectorOffset3D& orig) const
   {
      return !(*this == orig);
   }
protected:
   DtVector myVector;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtVectorOffset3D);

DT_DLL_vrfutil std::ostream& operator<<(std::ostream& stream, const DtVectorOffset3D& vec);