u3d_point.hpp

/* u3d_point.hpp */
/* $Id: u3d_point.hpp,v 1.11 2008/03/04 16:39:44 guser3 Exp $ */
#ifndef __u3d_point_hpp
#define __u3d_point_hpp

//#include <vector>

#include "u3d_defines.hpp"

//class U3dBox;


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    fX, fY, fZ;
  
};


/* INLINE implementation */

inline U3dPoint::U3dPoint ()
  : fX(0.0), fY(0.0), fZ(0.0)
{
  /* dummy */
}

inline U3dPoint::U3dPoint (const U3dPoint& p)
  : fX(p.getX()), fY(p.getY()), fZ(p.getZ())
{
  /* dummy */
}

inline U3dPoint::U3dPoint (double x, double y, double z)
  : fX(x), fY(y), fZ(z)
{
  /* dummy */
}
/*
  inline U3dPoint::U3dPoint (U3dVertex vertex)
  : fX(vertex.x), fY(vertex.y), fZ(vertex.z)
  {
 
  }*/

inline U3dPoint&
U3dPoint::operator= (const U3dPoint& p)
{
  fX = p.getX();
  fY = p.getY();
  fZ = p.getZ();
  return *this;
}

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

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

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

inline void
U3dPoint::setXYZ (double x, double y, double z)
{
  fX = x;
  fY = y;
  fZ = z;
}

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

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

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

typedef safe_vector<U3dPoint*> U3dPointsAr; 
typedef safe_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 */