u2d_point.hpp

/* u2d_point.hpp */
/* $Id: u2d_point.hpp,v 1.2 2008/05/27 09:38:22 sasha Exp $ */
#ifndef __u2d_point_hpp
#define __u2d_point_hpp

#include <vector>
#include <math.h>

class U2dPoint
{
public:
  
  U2dPoint ();
  
  virtual ~U2dPoint(){};
  
  U2dPoint (const U2dPoint& p);
  
  U2dPoint (double x, double z);
  
  U2dPoint& operator= (const U2dPoint& p);
  
  bool operator==(const U2dPoint&) const;
  
  bool operator!=(const U2dPoint&) const;
  
  // Point and Vector Operations (always valid) 
  U2dPoint  operator+(U2dPoint);      // +translate
  U2dPoint  operator-(U2dPoint);      // -translate
  
  // Scalar Multiplication
  friend U2dPoint operator*(int, U2dPoint);
  friend U2dPoint operator*(U2dPoint, int);
  friend U2dPoint operator*(double, U2dPoint);
  friend U2dPoint operator*(U2dPoint, double); 
  
  // Scalar Division
  friend U2dPoint operator/(U2dPoint, int);
  friend U2dPoint operator/(U2dPoint, double);
  
  
  static bool x_asc(const U2dPoint& p1, const U2dPoint& p2) { return p1.m_X < p2.m_X; }
  
  static bool z_asc(const U2dPoint& p1, const U2dPoint& p2) { return p1.m_Z < p2.m_Z; }
  
  static bool x_desc(const U2dPoint& p1, const U2dPoint& p2) { return p1.m_X > p2.m_X; }
  
  static bool z_desc(const U2dPoint& p1, const U2dPoint& p2) { return p1.m_Z > p2.m_Z; }
  
  static double pDistance(const U2dPoint& p0, const U2dPoint& p1);
  
  static int getNeighbour(const U2dPoint& p, std::vector<U2dPoint*>& p_ar);
  static int getNeighbour(const U2dPoint& p, std::vector<U2dPoint>& p_ar);
  
  
  
  double    getX () const;
  
  double    getZ () const;
  
  void  setXZ (double x, double z);
  
  void        setX (double x);
  
  void  setZ (double z);
  
  
protected:
  
  double    m_X, m_Z;
  
};


/* INLINE implementation */

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

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

inline U2dPoint::U2dPoint (double x, double z)
  : m_X(x), m_Z(z)
{
  /* dummy */
}


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

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

inline double
U2dPoint::getZ () const
{
  return m_Z;
}
  
inline void
U2dPoint::setXZ (double x, double z)
{
  m_X = x;
  m_Z = z;
}

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

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


typedef std::vector<U2dPoint> U2dPoints;
typedef std::vector<U2dPoint*> U2dPointsAr;
typedef std::vector<U2dPointsAr> U2dPointsMatrix;


struct U2dRayPoint
{
  U2dPoint p;
  double f;
  double t;
};



#endif /* u2d_point.hpp */