Point.h

Go to the documentation of this file.

/* -*- mode: c++ -*- */
#ifndef BOARD_POINT_H
#define BOARD_POINT_H
 
#include <cmath>
#include <iostream>
#include <limits>
#include <vector>
#include <board/Tools.h>
 
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) {}
 
  inline Point & operator=(const Point & other);
 
  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 & translate(double dx, double dy);
 
  inline Point translated(double dx, double dy) const;
 
  inline Point & scale(double sx, double sy);
 
  inline Point scaled(double sx, double sy);
 
  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;
};
 
Point mix(const Point & a, const Point & b, double t);
 
bool orthogonal(const Point & a, const Point & b);
 
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 bool operator==(const Point & a, const Point & b)
{
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wfloat-equal"
  return (a.x == b.x) && (a.y == b.y);
#pragma clang diagnostic pop
}
 
inline bool operator!=(const Point & a, const Point & b)
{
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wfloat-equal"
  return (a.x != b.x) || (a.y != b.y);
#pragma clang diagnostic push
}
 
inline bool almostEqual(const Point & a, const Point & b)
{
  return Tools::almostEqual((a - b).norm(), 0.0);
}
 
// Inline methods
 
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;
}
 
Point & Point::operator=(const Point & other)
{
  x = other.x;
  y = other.y;
  return *this;
}
 
void Point::get(double & x, double & y) const
{
  x = Point::x;
  y = Point::y;
}
 
Point & Point::rotate(double angle)
{
  const double x = cos(angle) * Point::x - sin(angle) * Point::y;
  const 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);
}
 
Point & Point::translate(double dx, double dy)
{
  x += dx;
  y += dy;
  return *this;
}
 
Point Point::translated(double dx, double dy) const
{
  return Point(x + dx, y + dy);
}
 
Point & Point::scale(double sx, double sy)
{
  x *= sx;
  y *= sy;
  return *this;
}
 
Point Point::scaled(double sx, double sy)
{
  return Point(*this).scale(sx, sy);
}
 
double Point::norm() const
{
  return std::hypot(x, 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);
}
 
} // namespace LibBoard
 
std::ostream & operator<<(std::ostream & out, const LibBoard::Point &);
 
std::ostream & operator<<(std::ostream & out, const std::vector<LibBoard::Point> &);
 
#endif // BOARD_POINT_H