RhodeCode

/// can be used to determine

/// the rectangular bounding box of a set of

/// \ref lemon::dim2::Point "dim2::Point"'s.

namespace lemon {

      typedef T Value;

      T x;

      T y;     

      ///Default constructor

      ///The dimension of the vector.

      int size() const { return 2; }

      ///Subscripting operator

        return b+=u;

      }

      Point<T> operator-() const {

        Point<T> b=*this;

        b.x=-b.x; b.y=-b.y;

    };

  ///\relates Point

  template <typename T>

  inline Point<T> makePoint(const T& x, const T& y) {

  ///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

  ///\relates Point

  ///

  template<typename T>

  ///Write a plainvector to a stream

  ///\relates Point

  ///

  template<typename T>

  ///Rotate by 90 degrees

  ///\relates Point

  ///

  template<typename T>

  ///Rotate by 180 degrees

  ///\relates Point

  ///

  template<typename T>

  ///Rotate by 270 degrees

  ///\relates Point

  ///

  template<typename T>

  /// A class to calculate or store the bounding box of plainvectors.

  ///

    template<typename T>

    class BoundingBox {

      Point<T> bottom_left, top_right;

      ///Construct an instance from two points

      BoundingBox(Point<T> a,Point<T> b)

      {

	bottom_left=a;

      ///Construct an instance from four numbers

      BoundingBox(T l,T b,T r,T t)

      {

	bottom_left=Point<T>(l,b);

	_empty = false;

      }

      bool empty() const {

        return _empty;

      }

      ///Set the bottom left corner

      ///Set the bottom left corner.

      void bottomLeft(Point<T> p) {

	bottom_left = p;

      }

      ///Set the top right corner

      ///Set the top right corner.

      void topRight(Point<T> p) {

	top_right = p;

      }

      ///Set the bottom right corner

      ///Set the bottom right corner.

      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.

      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.

      void bottom(T t) {

	bottom_left.y = t;

      }

      ///Set the top of the box

      ///Set the top of the box.

      void top(T t) {

	top_right.y = t;

      }

      ///Set the left side of the box

      ///Set the left side of the box.

      void left(T t) {

	bottom_left.x = t;

      }

      ///Set the right side of the box

      ///Set the right side of the box.

      void right(T t) {

	top_right.x = t;

      }

      }

      ///Checks whether a point is inside a bounding box

        if (_empty)

          return false;

        else{

      }

      ///Increments a bounding box with a point

      BoundingBox& add(const Point<T>& u){

        if (_empty){

          bottom_left=top_right=u;

        return *this;

      }

      BoundingBox& add(const BoundingBox &u){

        if ( !u.empty() ){

          this->add(u.bottomLeft());

      }

      ///Intersection of two bounding boxes

        BoundingBox b;

	b.bottom_left.x=std::max(this->bottom_left.x,u.bottom_left.x);

	b.bottom_left.y=std::max(this->bottom_left.y,u.bottom_left.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);

        return b;

      }

    };//class Boundingbox

  ///\ingroup maps

  ///

  template<class M>

  class XMap 

  ///Returns a \ref ConstXMap class

  ///

  ///\ingroup maps

  ///\relates ConstXMap

    return ConstXMap<M>(m);

  }

  ///\ingroup maps

  ///

  template<class M>

  class YMap 

    void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}

  };

  ///

  ///\ingroup maps

  ///\relates YMap

  ///Returns a \ref ConstYMap class

  ///

  ///\ingroup maps

  ///\relates ConstYMap

    ///\brief Map of the \ref Point::normSquare() "normSquare()"

    ///

    ///Map of the \ref Point::normSquare() "normSquare()"

    ///\ingroup maps

    ///

  template<class M>

  ///Returns a \ref NormSquareMap class

  ///

  ///\ingroup maps

  ///\relates NormSquareMap