point.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2003 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: point.h,v $ $Revision: 1.27 $ $State: Exp $
*******************************************************************************/

#ifndef point_H_
#define point_H_

#ifndef NO_VRLINK
#include <vlutil/vlConfig.h>
#include <vlutil/vlString.h>
#include <vlutil/vlUtil.h>
#include <matrix/vlVector.h>
#endif

#include <stdio.h>
#include <iostream>
#include "geometry/geometryDefines.h"

class Dt4dPoint;
class DtPoint;

typedef DtPoint DtVertex;

// DtPoint represents points in 3-space. 
// DtPoint may rely on vrlink (for things like DtString and DtVector).
// This class has no virtual functions, in order to minimize its run-time 
// size.  (A terrain database can have millions of DtPoints, so the 
// vtable ptr can matter).

class DT_DLL_geometry DtPoint
{

public:
//   friend std::ostream& operator<<(std::ostream& os, const DtPoint& point);
//   friend std::istream& operator>>(std::istream& is, DtPoint& point);


   DtPoint(
      const double& x = 0.0,
      const double& y = 0.0,
      const double& z = 0.0);

   enum DtPointIndex {
      DtPX = 0,
      DtPY = 1,
      DtPZ = 2,
      DtMAXPointIndex
   };

   DtPoint(const DtPoint& orig);
   DtPoint(const DtVector& orig);
   DtPoint(const Dt4dPoint& orig);

   virtual ~DtPoint();

   DtPoint& operator=(const DtPoint& rhs);
   DtPoint& operator=(const DtVector& rhs);
   DtPoint& operator=(const Dt4dPoint& rhs);

   const double& operator[](const int& index) const;
   double& operator[](const int& index);

   const double& operator[](const DtPointIndex& index) const;
   double& operator[](const DtPointIndex& index);

   bool operator==(const DtPoint& rhs) const;
   bool operator!=(const DtPoint& rhs) const;

   DtPoint operator*(const double& rhs) const;
   DtPoint& operator*=(const double& rhs);

   DtPoint operator/(const double& rhs) const;
   DtPoint& operator/=(const double& rhs);

   DtPoint operator+(const DtPoint& rhs) const;
   DtPoint& operator+=(const DtPoint& rhs);

   DtPoint operator+(const DtVector& rhs) const;
   DtPoint& operator+=(const DtVector& rhs);

   DtPoint operator-(const DtPoint& rhs) const;
   DtPoint& operator-=(const DtPoint& rhs);

   DtPoint operator-(const DtVector& rhs) const;
   DtPoint& operator-=(const DtVector& rhs);

   // compares two points and returns true if the distance between them
   // is within the tolerance value.
   bool approxEq(const DtPoint& p, const double& tolerance) const;

   const double& x() const;
   const double& y() const;
   const double& z() const;

   void set( const double& x, const double& y, const double& z);
   void setX(const double& x);
   void setY(const double& y);
   void setZ(const double& z);

   // Distance from this point to end point.
   double distanceTo(const DtPoint & end) const;
   double distanceSquaredTo(const DtPoint & end) const;

   // Distance from this point to end point.  Ignores Z values.
   double xyDistanceTo(const DtPoint & end) const;
   double xyDistanceSquaredTo(const DtPoint & end) const;

   // Distance from this point to line defined by points A and B. Ignores Z.
   double xyDistanceToLine(const DtPoint& pointA, const DtPoint& pointB) const;
   double xyDistanceToLineSquared(const DtPoint& pointA, const DtPoint& pointB) const;

   // Assuming that this point is the end point of a vector
   // starting at (0,0,0), This function normalizes that
   // vector and sets this point to the normalized end point.
   void normalize();

   // Distance from this point to the origin (0,0,0) point.
   double magnitudeSquared() const;

   DtVector difference(const DtPoint& p) const;

#ifndef NO_VRLINK
   DtString string() const;  
#endif

   bool readFrom(FILE* fp);
   bool writeTo(FILE* fp);

   void dump(const char* label) const;

protected:
   double myRep[3]; 
};

DT_DLL_geometry std::ostream& operator<<(std::ostream& os, const DtPoint& point);
DT_DLL_geometry std::istream& operator>>(std::istream& is, DtPoint& point);

inline DtPoint::DtPoint(const double& x, const double& y, const double& z)
{
   myRep[DtPX] = x;
   myRep[DtPY] = y;
   myRep[DtPZ] = z;
}

inline DtPoint::~DtPoint()
{
}

inline const double& DtPoint::operator[](const int& index) const
{
   return myRep[index];
}

inline double& DtPoint::operator[](const int& index) 
{ 
   return myRep[index];
}

inline const double& DtPoint::operator[](const DtPointIndex& index) const 
{
   return myRep[index];
}

inline double& DtPoint::operator[](const DtPointIndex& index) 
{ 
   return myRep[index];
}

inline void DtPoint::set( const double& x, const double& y, const double& z)
{ 
   myRep[DtPX] = x;
   myRep[DtPY] = y;
   myRep[DtPZ] = z;
}

inline const double& DtPoint::x() const
{
   return myRep[DtPX];
}

inline void DtPoint::setX(const double& x)
{
   myRep[DtPX] = x;
}

inline const double& DtPoint::y() const
{
   return myRep[DtPY];
}

inline void DtPoint::setY(const double& y)
{
   myRep[DtPY] = y;
}

inline const double& DtPoint::z() const
{
   return myRep[DtPZ];
}

inline void DtPoint::setZ(const double& z)
{
   myRep[DtPZ] = z;
}

#endif