Point.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */
#ifndef _BOARD_POINT_H_
#define _BOARD_POINT_H_

#include <cmath>
#include <iostream>
#include <vector>

namespace LibBoard {

struct Point {
  double x;     
  double y;     
  Point():x(0.0),y(0.0) { }

  Point( const Point & other ):x(other.x),y(other.y) { }

  Point( double x, double y ):x(x),y(y) { }

  inline void get( double & x, double & y ) const;

  inline Point & rotate( double angle );

  inline Point rotated( double angle ) const;

  inline Point & rotate( double angle, const Point & center );

  inline Point rotated( double angle, const Point & center ) const;

  inline Point rotatedPI2() const;

  inline Point & operator+=( const Point & other );

  inline Point & operator-=( const Point & other );


  inline Point & operator*=( double s );

  inline Point & operator/=( double s );

  inline Point operator-() const;

  inline double norm() const;

  inline Point & normalise();

  inline Point normalised() const;

  inline double argument() const;

  inline bool isInf() const;

  static Point Infinity;

};

inline void
Point::get( double & x, double & y ) const
{
  x = Point::x;
  y = Point::y;
}

inline Point
operator+( const Point & a, const Point & b )
{
  return Point( a.x + b.x, a.y + b.y );
}

inline Point
operator-( const Point & a, const Point & b )
{
  return Point( a.x - b.x, a.y - b.y );
}

inline double
operator*( const Point & a, const Point & b )
{
  return a.x * b.x + a.y * b.y;
}

inline Point
operator*( const Point & p, double s  )
{
  return Point( p.x * s, p.y * s );
}

inline Point
operator*( double s, const Point & p )
{
  return Point( s * p.x, s * p.y );
}

inline Point
operator/( const Point & p, double s )
{
  return Point( p.x / s, p.y / s );
}

inline Point &
Point::operator+=( const Point & other )
{
  x += other.x;
  y += other.y;
  return *this;
}

inline Point &
Point::operator-=( const Point & other )
{
  x -= other.x;
  y -= other.y;
  return *this;
}

inline Point &
Point::operator*=( double s )
{
  x *= s;
  y *= s;
  return *this;
}

inline Point &
Point::operator/=( double s )
{
  x /= s;
  y /= s;
  return *this;
}

inline bool
operator==( const Point & a, const Point & b )
{
  return ( a.x == b.x ) && ( a.y == b.y ) ;
}

inline bool
operator!=( const Point & a, const Point & b )
{
  return ( a.x != b.x ) || ( a.y != b.y ) ;
}

Point &
Point::rotate( double angle )
{
  double x = cos( angle ) * Point::x - sin( angle ) * Point::y;
  double y = sin( angle ) * Point::x + cos( angle ) * Point::y;
  Point::x = x;
  Point::y = y;
  return *this;
}

Point
Point::rotated( double angle ) const
{
  return Point(*this).rotate( angle );
}

Point &
Point::rotate( double angle, const Point & center )
{
  (*this) -= center;
  (*this).rotate( angle );
  (*this) += center;
  return *this;
}

Point
Point::rotated( double angle, const Point & center ) const
{
  return Point(*this).rotate( angle, center );
}

Point
Point::rotatedPI2() const
{
  return Point(-y,x);
}

double
Point::norm() const
{
  return std::sqrt( x*x + y*y );
}

Point
Point::normalised() const
{
  return (*this) / norm();
}

Point &
Point::normalise()
{
  double n = norm();
  x /= n;
  y /= n;
  return *this;
}

double
Point::argument() const
{
  return std::atan2( y, x );
}

bool
Point::isInf() const
{
  return (*this) == Point::Infinity;
}


Point
Point::operator-() const
{
  return Point( -x, -y );
}

} // mamespace LibBoard

std::ostream & operator<<( std::ostream & out, const LibBoard::Point & p );

#endif // _POINT_H_