/* -*- C++ -*- * src/lemon/xy.h - Part of LEMON, a generic C++ optimization library * * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport * (Egervary Combinatorial Optimization Research Group, EGRES). * * Permission to use, modify and distribute this software is granted * provided that this copyright notice appears in all copies. For * precise terms see the accompanying LICENSE file. * * This software is provided "AS IS" with no warranty of any kind, * express or implied, and with no claim as to its suitability for any * purpose. * */ #ifndef LEMON_XY_H #define LEMON_XY_H #include ///\ingroup misc ///\file ///\brief A simple two dimensional vector and a bounding box implementation /// /// The class \ref lemon::xy "xy" implements ///a two dimensional vector with the usual /// operations. /// /// The class \ref lemon::BoundingBox "BoundingBox" can be used to determine /// the rectangular bounding box a set of \ref lemon::xy "xy"'s. /// ///\author Attila Bernath namespace lemon { /// \addtogroup misc /// @{ /// A two dimensional vector (plainvector) implementation /// A two dimensional vector (plainvector) implementation ///with the usual vector /// operators. /// ///\author Attila Bernath template class xy { public: T x,y; ///Default constructor: both coordinates become 0 xy() : x(0), y(0) {} ///Constructing the instance from coordinates xy(T a, T b) : x(a), y(b) { } ///Gives back the square of the norm of the vector T normSquare(){ return x*x+y*y; }; ///Increments the left hand side by u xy& operator +=(const xy& u){ x += u.x; y += u.y; return *this; }; ///Decrements the left hand side by u xy& operator -=(const xy& u){ x -= u.x; y -= u.y; return *this; }; ///Multiplying the left hand side with a scalar xy& operator *=(const T &u){ x *= u; y *= u; return *this; }; ///Dividing the left hand side by a scalar xy& operator /=(const T &u){ x /= u; y /= u; return *this; }; ///Returns the scalar product of two vectors T operator *(const xy& u){ return x*u.x+y*u.y; }; ///Returns the sum of two vectors xy operator+(const xy &u) const { xy b=*this; return b+=u; }; ///Returns the difference of two vectors xy operator-(const xy &u) const { xy b=*this; return b-=u; }; ///Returns a vector multiplied by a scalar xy operator*(const T &u) const { xy b=*this; return b*=u; }; ///Returns a vector divided by a scalar xy operator/(const T &u) const { xy b=*this; return b/=u; }; ///Testing equality bool operator==(const xy &u){ return (x==u.x) && (y==u.y); }; ///Testing inequality bool operator!=(xy u){ return (x!=u.x) || (y!=u.y); }; }; ///Read a plainvector from a stream ///\relates xy /// template inline std::istream& operator>>(std::istream &is, xy &z) { is >> z.x >> z.y; return is; } ///Write a plainvector to a stream ///\relates xy /// template inline std::ostream& operator<<(std::ostream &os, xy z) { os << "(" << z.x << ", " << z.y << ")"; return os; } /// A class to calculate or store the bounding box of plainvectors. /// A class to calculate or store the bounding box of plainvectors. /// ///\author Attila Bernath template class BoundingBox { xy bottom_left, top_right; bool _empty; public: ///Default constructor: an empty bounding box BoundingBox() { _empty = true; } ///Constructing the instance from one point BoundingBox(xy a) { bottom_left=top_right=a; _empty = false; } ///Is there any point added bool empty() const { return _empty; } ///Gives back the bottom left corner (if the bounding box is empty, then the return value is not defined) xy bottomLeft() const { return bottom_left; }; ///Gives back the top right corner (if the bounding box is empty, then the return value is not defined) xy topRight() const { return top_right; }; ///Checks whether a point is inside a bounding box bool inside(const xy& u){ if (_empty) return false; else{ return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 && (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 ); } } ///Increments a bounding box with a point BoundingBox& operator +=(const xy& u){ if (_empty){ bottom_left=top_right=u; _empty = false; } else{ if (bottom_left.x > u.x) bottom_left.x = u.x; if (bottom_left.y > u.y) bottom_left.y = u.y; if (top_right.x < u.x) top_right.x = u.x; if (top_right.y < u.y) top_right.y = u.y; } return *this; }; ///Sums a bounding box and a point BoundingBox operator +(const xy& u){ BoundingBox b = *this; return b += u; }; ///Increments a bounding box with an other bounding box BoundingBox& operator +=(const BoundingBox &u){ if ( !u.empty() ){ *this += u.bottomLeft(); *this += u.topRight(); } return *this; }; ///Sums two bounding boxes BoundingBox operator +(const BoundingBox& u){ BoundingBox b = *this; return b += u; }; };//class Boundingbox /// @} } //namespace lemon #endif //LEMON_XY_H