Point2D.h

Go to the documentation of this file.

/*******************************************************************************
 *  Point2D.h
 *
 *  (C) 2008 AG Aktives Sehen <agas@uni-koblenz.de>
 *           Universitaet Koblenz-Landau
 *
 * $Id: Point2D.h 44313 2011-04-06 22:46:28Z agas $
 *******************************************************************************/

#include <iostream>
#include <sstream>

#include "vec2.h"
#include <float.h>

#ifndef POINT2D_H
#define POINT2D_H

class Point2D
{

  public:

    inline Point2D()
    {
      m_X = 0.0;
      m_Y = 0.0;
    }

    inline Point2D ( double x, double y )
    {
      m_X = x;
      m_Y = y;
    }



    inline Point2D (const Point2D& p){
      m_X = p.x();
      m_Y = p.y();
    }
    
    inline Point2D ( const CVec2& v )
    {
      m_X = v[0];
      m_Y = v[1];
    }

    inline ~Point2D()
    {
    }

    inline double x() const
    {
      return m_X;
    }

    inline double y() const
    {
      return m_Y;
    }

    inline void set ( double x, double y )
    {
      m_X = x;
      m_Y = y;
    }

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

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

    inline Point2D& operator= ( const Point2D& p) {
      m_X = p.x();
      m_Y = p.y(); 
      return *this;
    }

    inline Point2D operator+ ( const CVec2& v ) const
    {
      return Point2D ( m_X + v[0], m_Y + v[1] );
    }

    inline Point2D operator+ ( const Point2D& p ) const
    {
      return Point2D ( m_X + p.x(), m_Y + p.y() );
    }

    inline CVec2 operator- ( const Point2D& p ) const
    {
      return CVec2 ( m_X - p.x(), m_Y - p.y() );
    }

    inline Point2D operator- ( const CVec2& v ) const
    {
      return Point2D ( m_X - v[0], m_Y - v[1] );
    }

    inline Point2D operator* ( double scalar ) const
    {
      return Point2D ( m_X * scalar, m_Y * scalar );
    }

    inline Point2D operator/ ( double scalar ) const
    {
      return Point2D ( m_X / scalar, m_Y / scalar );
    }

    inline Point2D& operator+= ( const CVec2& v )
    {
      m_X += v[0];
      m_Y += v[1];
      return ( *this );
    }

    inline Point2D& operator-= ( const CVec2& v )
    {
      m_X -= v[0];
      m_Y -= v[1];
      return ( *this );
    }

    inline Point2D& operator*= ( double scalar )
    {
      m_X *= scalar;
      m_Y *= scalar;
      return ( *this );
    }

    inline Point2D& operator/= ( double scalar )
    {
      m_X /= scalar;
      m_Y /= scalar;
      return ( *this );
    }

    inline double operator [] ( unsigned int i ) const
    {
      return ( ( double* ) this ) [i];
    }

    inline double& operator [] ( unsigned int i )
    {
      return ( ( double* ) this ) [i];
    }

    inline bool operator== ( const Point2D& point ) const
    {
      return ( fabs(m_X - point.x()) < 0.001 && fabs(m_Y - point.y()) < 0.001 );
    }

    inline bool operator!= ( const Point2D& point ) const
    {
      return !((*this)== point);
    }

    inline double distance ( const Point2D& point ) const
    {
      return sqrt ( ( m_X-point.x() ) * ( m_X-point.x() ) + ( m_Y-point.y() ) * ( m_Y-point.y() ) );
    }

    inline double distance ( ) const
    {
      return sqrt ( m_X * m_X + m_Y * m_Y );
    }

    inline bool equal ( const Point2D& point ) const
    {
      if ( ( *this - point ).magnitude() < 0.0001 )
      {
        return true;
      }
      else
      {
        return false;
      }
    }

    inline CVec2 toVector() const
    {
      return CVec2 ( m_X, m_Y );
    }

    float getPolarAngle () const;

    inline void rotate ( const Point2D& center, float angle )
    {
      double x0=m_X-center.m_X;
      double y0=m_Y-center.m_Y;
      double xRot =  x0*cos ( angle ) - y0*sin ( angle );
      double yRot =  x0*sin ( angle ) + y0*cos ( angle );
      m_X = xRot+center.m_X;
      m_Y = yRot+center.m_Y;
    }

    inline void rotate ( float angle )
    {
      double xRot =  m_X*cos ( angle ) - m_Y*sin ( angle );
      double yRot =  m_X*sin ( angle ) + m_Y*cos ( angle );
      m_X = xRot;
      m_Y = yRot;
    }

    inline std::string toString() const
    {
      std::ostringstream str;
      str << m_X << " " << m_Y;
      return str.str();
    }

    static Point2D invalidPoint() { return Point2D( DBL_MAX, DBL_MAX  ); }

    bool isValid() { return ( ( m_X != DBL_MAX ) || ( m_Y != DBL_MAX ) ); }

  protected:

    double m_X;
    double m_Y;
};

#endif