lemon: comparison lemon/dim2.h

equal deleted inserted replaced

-:825b3e2afbd8
+:5908d2eaa672
 ///
 /// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"
 /// can be used to determine
 /// the rectangular bounding box of a set of
 /// \ref lemon::dim2::Point "dim2::Point"'s.
-///
-///\author Attila Bernath
 namespace lemon {
 ///Tools for handling two dimensional coordinates
 public:
 typedef T Value;
-///First co-ordinate
+///First coordinate
 T x;
-///Second co-ordinate
+///Second coordinate
 T y;
 ///Default constructor
 Point() {}
 ///Construct an instance from coordinates
 Point(T a, T b) : x(a), y(b) { }
 ///The dimension of the vector.
-///This class give back always 2.
+///The dimension of the vector.
-///
+///This function always returns 2.
 int size() const { return 2; }
 ///Subscripting operator
 ///\c p[0] is \c p.x and \c p[1] is \c p.y
 Point<T> operator+(const Point<T> &u) const {
 Point<T> b=*this;
 return b+=u;
 }
-///Return the neg of the vectors
+///Return the negative of the vector
 Point<T> operator-() const {
 Point<T> b=*this;
 b.x=-b.x; b.y=-b.y;
 return b;
 }
 return  (x!=u.x) || (y!=u.y);
 }
 };
-///Return an Point
+///Return a Point
-///Return an Point
+///Return a Point.
 ///\relates Point
 template <typename T>
 inline Point<T> makePoint(const T& x, const T& y) {
 return Point<T>(x, y);
 }
 ///Return a vector multiplied by a scalar
-///Return a vector multiplied by a scalar
+///Return a vector multiplied by a scalar.
 ///\relates Point
 template<typename T> Point<T> operator*(const T &u,const Point<T> &x) {
 return x*u;
 }
 ///Read a plainvector from a stream
-///Read a plainvector from a stream
+///Read a plainvector from a stream.
 ///\relates Point
 ///
 template<typename T>
 inline std::istream& operator>>(std::istream &is, Point<T> &z) {
 char c;
 return is;
 }
 ///Write a plainvector to a stream
-///Write a plainvector to a stream
+///Write a plainvector to a stream.
 ///\relates Point
 ///
 template<typename T>
 inline std::ostream& operator<<(std::ostream &os, const Point<T>& z)
 {
 return os;
 }
 ///Rotate by 90 degrees
-///Returns its parameter rotated by 90 degrees in positive direction.
+///Returns the parameter rotated by 90 degrees in positive direction.
 ///\relates Point
 ///
 template<typename T>
 inline Point<T> rot90(const Point<T> &z)
 {
 return Point<T>(-z.y,z.x);
 }
 ///Rotate by 180 degrees
-///Returns its parameter rotated by 180 degrees.
+///Returns the parameter rotated by 180 degrees.
 ///\relates Point
 ///
 template<typename T>
 inline Point<T> rot180(const Point<T> &z)
 {
 return Point<T>(-z.x,-z.y);
 }
 ///Rotate by 270 degrees
-///Returns its parameter rotated by 90 degrees in negative direction.
+///Returns the parameter rotated by 90 degrees in negative direction.
 ///\relates Point
 ///
 template<typename T>
 inline Point<T> rot270(const Point<T> &z)
 {
 /// 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<typename T>
 class BoundingBox {
 Point<T> bottom_left, top_right;
 bool _empty;
 public:
 ///Construct an instance from one point
 BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; }
 ///Construct an instance from two points
-///Construct an instance from two points
+///Construct an instance from two points.
-///\warning The coordinates of the bottom-left corner must be no more
+///\param a The bottom left corner.
-///than those of the top-right one
+///\param b The top right corner.
+///\warning The coordinates of the bottom left corner must be no more
+///than those of the top right one.
 BoundingBox(Point<T> a,Point<T> b)
 {
 	bottom_left=a;
 	top_right=b;
 	_empty = false;
 }
 ///Construct an instance from four numbers
-///Construct an instance from four numbers
+///Construct an instance from four numbers.
-///\warning The coordinates of the bottom-left corner must be no more
+///\param l The left side of the box.
-///than those of the top-right one
+///\param b The bottom of the box.
+///\param r The right side of the box.
+///\param t The top of the box.
+///\warning The left side must be no more than the right side and
+///bottom must be no more than the top.
 BoundingBox(T l,T b,T r,T t)
 {
 	bottom_left=Point<T>(l,b);
 	top_right=Point<T>(r,t);
 	_empty = false;
 }
-///Were any points added?
+///Return \c true if the bounding box is empty.
+///Return \c true if the bounding box is empty (i.e. return \c false
+///if at least one point was added to the box or the coordinates of
+///the box were set).
+///The coordinates of an empty bounding box are not defined.
 bool empty() const {
 return _empty;
 }
 ///Make the BoundingBox empty
 }
 ///Set the bottom left corner
 ///Set the bottom left corner.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void bottomLeft(Point<T> p) {
 	bottom_left = p;
 }
 ///Give back the top right corner
 }
 ///Set the top right corner
 ///Set the top right corner.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void topRight(Point<T> p) {
 	top_right = p;
 }
 ///Give back the bottom right corner
 }
 ///Set the bottom right corner
 ///Set the bottom right corner.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void bottomRight(Point<T> p) {
 	top_right.x = p.x;
 	bottom_left.y = p.y;
 }
 }
 ///Set the top left corner
 ///Set the top left corner.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void topLeft(Point<T> p) {
 	top_right.y = p.y;
 	bottom_left.x = p.x;
 }
 }
 ///Set the bottom of the box
 ///Set the bottom of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void bottom(T t) {
 	bottom_left.y = t;
 }
 ///Give back the top of the box
 }
 ///Set the top of the box
 ///Set the top of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void top(T t) {
 	top_right.y = t;
 }
 ///Give back the left side of the box
 }
 ///Set the left side of the box
 ///Set the left side of the box.
-///It should only bee used for non-empty box
+///It should only be used for non-empty box.
 void left(T t) {
 	bottom_left.x = t;
 }
 /// Give back the right side of the box
 }
 ///Set the right side of the box
 ///Set the right side of the box.
-///It should only bee used for non-empty box
+///It should only be used for non-empty box.
 void right(T t) {
 	top_right.x = t;
 }
 ///Give back the height of the box
 T width() const {
 return top_right.x-bottom_left.x;
 }
 ///Checks whether a point is inside a bounding box
-bool inside(const Point<T>& u){
+bool inside(const Point<T>& u) const {
 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
+///Increments a bounding box with a point.
+///
 BoundingBox& add(const Point<T>& u){
 if (_empty){
 bottom_left=top_right=u;
 _empty = false;
 }
 if (top_right.y < u.y) top_right.y = u.y;
 }
 return *this;
 }
-///Increments a bounding to contain another bounding box
+///Increments a bounding box to contain another bounding box
+///Increments a bounding box to contain another bounding box.
+///
 BoundingBox& add(const BoundingBox &u){
 if ( !u.empty() ){
 this->add(u.bottomLeft());
 	  this->add(u.topRight());
 }
 return *this;
 }
 ///Intersection of two bounding boxes
-BoundingBox operator &(const BoundingBox& u){
+///Intersection of two bounding boxes.
+///
+BoundingBox operator&(const BoundingBox& u) const {
 BoundingBox b;
-	b.bottom_left.x=std::max(this->bottom_left.x,u.bottom_left.x);
+if (this->_empty || u._empty) {
-	b.bottom_left.y=std::max(this->bottom_left.y,u.bottom_left.y);
+	  b._empty = true;
-	b.top_right.x=std::min(this->top_right.x,u.top_right.x);
+	} else {
-	b.top_right.y=std::min(this->top_right.y,u.top_right.y);
+	  b.bottom_left.x = std::max(this->bottom_left.x,u.bottom_left.x);
-	b._empty = this->_empty || u._empty ||
+	  b.bottom_left.y = std::max(this->bottom_left.y,u.bottom_left.y);
-	  b.bottom_left.x>top_right.x && b.bottom_left.y>top_right.y;
+	  b.top_right.x = std::min(this->top_right.x,u.top_right.x);
+	  b.top_right.y = std::min(this->top_right.y,u.top_right.y);
+	  b._empty = b.bottom_left.x > b.top_right.x ||
+	             b.bottom_left.y > b.top_right.y;
+	}
 return b;
 }
 };//class Boundingbox
-///Map of x-coordinates of a dim2::Point<>-map
+///Map of x-coordinates of a \ref Point "Point"-map
 ///\ingroup maps
-///Map of x-coordinates of a dim2::Point<>-map
+///Map of x-coordinates of a \ref Point "Point"-map.
 ///
 template<class M>
 class XMap
 {
 M& _map;
 Value operator[](Key k) const {return _map[k].x;}
 };
 ///Returns a \ref ConstXMap class
-///This function just returns an \ref ConstXMap class.
+///This function just returns a \ref ConstXMap class.
 ///
 ///\ingroup maps
 ///\relates ConstXMap
 template<class M>
 inline ConstXMap<M> xMap(const M &m)
 {
 return ConstXMap<M>(m);
 }
-///Map of y-coordinates of a dim2::Point<>-map
+///Map of y-coordinates of a \ref Point "Point"-map
 ///\ingroup maps
-///Map of y-coordinates of a dim2::Point<>-map
+///Map of y-coordinates of a \ref Point "Point"-map.
 ///
 template<class M>
 class YMap
 {
 M& _map;
 YMap(M& map) : _map(map) {}
 Value operator[](Key k) const {return _map[k].y;}
 void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}
 };
-///Returns an \ref YMap class
+///Returns a \ref YMap class
-///This function just returns an \ref YMap class.
+///This function just returns a \ref YMap class.
 ///
 ///\ingroup maps
 ///\relates YMap
 template<class M>
 inline YMap<M> yMap(M &m)
 Value operator[](Key k) const {return _map[k].y;}
 };
 ///Returns a \ref ConstYMap class
-///This function just returns an \ref ConstYMap class.
+///This function just returns a \ref ConstYMap class.
 ///
 ///\ingroup maps
 ///\relates ConstYMap
 template<class M>
 inline ConstYMap<M> yMap(const M &m)
 return ConstYMap<M>(m);
 }
 ///\brief Map of the \ref Point::normSquare() "normSquare()"
-///of an \ref Point "Point"-map
+///of a \ref Point "Point"-map
 ///
 ///Map of the \ref Point::normSquare() "normSquare()"
-///of an \ref Point "Point"-map
+///of a \ref Point "Point"-map.
 ///\ingroup maps
 ///
 template<class M>
 class NormSquareMap
 {
 Value operator[](Key k) const {return _map[k].normSquare();}
 };
 ///Returns a \ref NormSquareMap class
-///This function just returns an \ref NormSquareMap class.
+///This function just returns a \ref NormSquareMap class.
 ///
 ///\ingroup maps
 ///\relates NormSquareMap
 template<class M>
 inline NormSquareMap<M> normSquareMap(const M &m)

changeset 43	17e76967c49f
parent 8	a1b1d672f37a
child 39	0a01d811071f