u3d_point.hpp

/* u3d_point.hpp */
/* $Id: u3d_point.hpp,v 1.4 2008/05/20 08:38:22 sasha Exp $ */
#ifndef __u3d_point_hpp
#define __u3d_point_hpp

#include <vector>
#include <cmath>


#define U3D_EPSILON                    1.e-6
#define EQUAL_REALS(a,b) ( (fabs((a)-(b)) < U3D_EPSILON ? true : false) ) 



class U3dPoint
{
public:
  
  U3dPoint ();
  
  virtual ~U3dPoint(){};
  
  U3dPoint (const U3dPoint& p);
  
  U3dPoint (double x, double y, double z);
  
  /* Create point with given point coordinates. */
  //U3dPoint (U3dVertex vertex);
  
  U3dPoint& operator= (const U3dPoint& p);
  
  bool operator==(const U3dPoint&) const;
  
  bool operator!=(const U3dPoint&) const;
  
  // Point and Vector Operations (always valid) 
  U3dPoint  operator+(U3dPoint) const;      // +translate
  U3dPoint  operator-(U3dPoint) const;      // -translate
  //U3dPoint& operator+=(U3dVector);     // inc translate
  //U3dPoint& operator-=(U3dVector);     // dec translate
  
  // Scalar Multiplication
  friend U3dPoint operator*(int, U3dPoint);
  friend U3dPoint operator*(U3dPoint, int);
  friend U3dPoint operator*(double, U3dPoint);
  friend U3dPoint operator*(U3dPoint, double); 
  
  // Scalar Division
  friend U3dPoint operator/(U3dPoint, int);
  friend U3dPoint operator/(U3dPoint, double);
  
  double    getX () const;
  
  double    getY () const;
  
  double    getZ () const;
 
  /* Check the point is inside given box. */
  //virtual bool isInside (const U3dBox& mbox) const;
  
  void      setXYZ (double x, double y, double z);
  
  void      setX (double x);
  
  void      setY (double y);
  
  void      setZ (double z);
  
  //U3dVertex getVertex();
  
protected:
  
  double    m_X, m_Y, m_Z;
  
};


/* INLINE implementation */

inline U3dPoint::U3dPoint ()
  : m_X(0.0), m_Y(0.0), m_Z(0.0)
{
  /* dummy */
}

inline U3dPoint::U3dPoint (const U3dPoint& p)
  : m_X(p.getX()), m_Y(p.getY()), m_Z(p.getZ())
{
  /* dummy */
}

inline U3dPoint::U3dPoint (double x, double y, double z)
  : m_X(x), m_Y(y), m_Z(z)
{
  /* dummy */
}
/*
  inline U3dPoint::U3dPoint (U3dVertex vertex)
  : m_X(vertex.x), m_Y(vertex.y), m_Z(vertex.z)
  {
 
  }*/

inline U3dPoint&
U3dPoint::operator= (const U3dPoint& p)
{
  m_X = p.getX();
  m_Y = p.getY();
  m_Z = p.getZ();
  return *this;
}

inline double
U3dPoint::getX () const
{
  return m_X;
}   

inline double
U3dPoint::getY () const
{
  return m_Y;
}

inline double
U3dPoint::getZ () const
{
  return m_Z;
}

inline void
U3dPoint::setXYZ (double x, double y, double z)
{
  m_X = x;
  m_Y = y;
  m_Z = z;
}

inline void
U3dPoint::setX (double x)
{
  m_X = x;
}

inline void
U3dPoint::setY (double y)
{
  m_Y = y;
}

inline void
U3dPoint::setZ (double z)
{
  m_Z = z;
}

typedef std::vector<U3dPoint> U3dPoints; 
typedef std::vector<U3dPoint*> U3dPointsAr; 
typedef std::vector<U3dPointsAr> U3dPointsMatrix; 


/*=========================== GLOBAL FUNCTIONS ========================*/

inline double pDistance(U3dPoint p0, U3dPoint p1)
{
  return sqrt ( (p0.getX()-p1.getX())*(p0.getX()-p1.getX()) + 
        (p0.getY()-p1.getY())*(p0.getY()-p1.getY()) + 
        (p0.getZ()-p1.getZ())*(p0.getZ()-p1.getZ()) );
};

int getNeighbour(U3dPoint p, U3dPointsAr p_ar);

  
#endif /* u3d_point.hpp */