COIN-OR::LEMON - Graph Library

Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • lemon/dim2.h

    r220 r241  
    2121
    2222#include <iostream>
    23 #include <lemon/core.h>
    2423
    2524///\ingroup misc
     
    4645  /// @{
    4746
    48   /// A simple two dimensional vector (plainvector) implementation
    49 
    50   /// A simple two dimensional vector (plainvector) implementation
     47  /// A simple two dimensional vector (plain vector) implementation
     48
     49  /// A simple two dimensional vector (plain vector) implementation
    5150  /// with the usual vector operations.
    5251  template<typename T>
     
    187186  }
    188187
    189   ///Read a plainvector from a stream
    190 
    191   ///Read a plainvector from a stream.
     188  ///Read a plain vector from a stream
     189
     190  ///Read a plain vector from a stream.
    192191  ///\relates Point
    193192  ///
     
    215214  }
    216215
    217   ///Write a plainvector to a stream
    218 
    219   ///Write a plainvector to a stream.
     216  ///Write a plain vector to a stream
     217
     218  ///Write a plain vector to a stream.
    220219  ///\relates Point
    221220  ///
     
    262261
    263262
    264   /// A class to calculate or store the bounding box of plainvectors.
    265 
    266   /// A class to calculate or store the bounding box of plainvectors.
    267   ///
     263    /// A class to calculate or store the bounding box of plain vectors.
     264
     265    /// A class to calculate or store the bounding box of plain vectors.
     266    ///
    268267    template<typename T>
    269268    class BoundingBox {
    270       Point<T> bottom_left, top_right;
     269      Point<T> _bottom_left, _top_right;
    271270      bool _empty;
    272271    public:
     
    276275
    277276      ///Construct an instance from one point
    278       BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; }
     277      BoundingBox(Point<T> a) {
     278        _bottom_left = _top_right = a;
     279        _empty = false;
     280      }
    279281
    280282      ///Construct an instance from two points
     
    287289      BoundingBox(Point<T> a,Point<T> b)
    288290      {
    289         bottom_left=a;
    290         top_right=b;
     291        _bottom_left = a;
     292        _top_right = b;
    291293        _empty = false;
    292294      }
     
    303305      BoundingBox(T l,T b,T r,T t)
    304306      {
    305         bottom_left=Point<T>(l,b);
    306         top_right=Point<T>(r,t);
     307        _bottom_left=Point<T>(l,b);
     308        _top_right=Point<T>(r,t);
    307309        _empty = false;
    308310      }
     
    321323      ///Make the BoundingBox empty
    322324      void clear() {
    323         _empty=1;
     325        _empty = true;
    324326      }
    325327
     
    329331      ///If the bounding box is empty, then the return value is not defined.
    330332      Point<T> bottomLeft() const {
    331         return bottom_left;
     333        return _bottom_left;
    332334      }
    333335
     
    335337
    336338      ///Set the bottom left corner of the box.
    337       ///It should only be used for non-empty box.
     339      ///\pre The box must not be empty.
    338340      void bottomLeft(Point<T> p) {
    339         bottom_left = p;
     341        _bottom_left = p;
    340342      }
    341343
     
    345347      ///If the bounding box is empty, then the return value is not defined.
    346348      Point<T> topRight() const {
    347         return top_right;
     349        return _top_right;
    348350      }
    349351
     
    351353
    352354      ///Set the top right corner of the box.
    353       ///It should only be used for non-empty box.
     355      ///\pre The box must not be empty.
    354356      void topRight(Point<T> p) {
    355         top_right = p;
     357        _top_right = p;
    356358      }
    357359
     
    361363      ///If the bounding box is empty, then the return value is not defined.
    362364      Point<T> bottomRight() const {
    363         return Point<T>(top_right.x,bottom_left.y);
     365        return Point<T>(_top_right.x,_bottom_left.y);
    364366      }
    365367
     
    367369
    368370      ///Set the bottom right corner of the box.
    369       ///It should only be used for non-empty box.
     371      ///\pre The box must not be empty.
    370372      void bottomRight(Point<T> p) {
    371         top_right.x = p.x;
    372         bottom_left.y = p.y;
     373        _top_right.x = p.x;
     374        _bottom_left.y = p.y;
    373375      }
    374376
     
    378380      ///If the bounding box is empty, then the return value is not defined.
    379381      Point<T> topLeft() const {
    380         return Point<T>(bottom_left.x,top_right.y);
     382        return Point<T>(_bottom_left.x,_top_right.y);
    381383      }
    382384
     
    384386
    385387      ///Set the top left corner of the box.
    386       ///It should only be used for non-empty box.
     388      ///\pre The box must not be empty.
    387389      void topLeft(Point<T> p) {
    388         top_right.y = p.y;
    389         bottom_left.x = p.x;
     390        _top_right.y = p.y;
     391        _bottom_left.x = p.x;
    390392      }
    391393
     
    395397      ///If the bounding box is empty, then the return value is not defined.
    396398      T bottom() const {
    397         return bottom_left.y;
     399        return _bottom_left.y;
    398400      }
    399401
     
    401403
    402404      ///Set the bottom of the box.
    403       ///It should only be used for non-empty box.
     405      ///\pre The box must not be empty.
    404406      void bottom(T t) {
    405         bottom_left.y = t;
     407        _bottom_left.y = t;
    406408      }
    407409
     
    411413      ///If the bounding box is empty, then the return value is not defined.
    412414      T top() const {
    413         return top_right.y;
     415        return _top_right.y;
    414416      }
    415417
     
    417419
    418420      ///Set the top of the box.
    419       ///It should only be used for non-empty box.
     421      ///\pre The box must not be empty.
    420422      void top(T t) {
    421         top_right.y = t;
     423        _top_right.y = t;
    422424      }
    423425
     
    427429      ///If the bounding box is empty, then the return value is not defined.
    428430      T left() const {
    429         return bottom_left.x;
     431        return _bottom_left.x;
    430432      }
    431433
     
    433435
    434436      ///Set the left side of the box.
    435       ///It should only be used for non-empty box.
     437      ///\pre The box must not be empty.
    436438      void left(T t) {
    437         bottom_left.x = t;
     439        _bottom_left.x = t;
    438440      }
    439441
     
    443445      ///If the bounding box is empty, then the return value is not defined.
    444446      T right() const {
    445         return top_right.x;
     447        return _top_right.x;
    446448      }
    447449
     
    449451
    450452      ///Set the right side of the box.
    451       ///It should only be used for non-empty box.
     453      ///\pre The box must not be empty.
    452454      void right(T t) {
    453         top_right.x = t;
     455        _top_right.x = t;
    454456      }
    455457
     
    459461      ///If the bounding box is empty, then the return value is not defined.
    460462      T height() const {
    461         return top_right.y-bottom_left.y;
     463        return _top_right.y-_bottom_left.y;
    462464      }
    463465
     
    467469      ///If the bounding box is empty, then the return value is not defined.
    468470      T width() const {
    469         return top_right.x-bottom_left.x;
     471        return _top_right.x-_bottom_left.x;
    470472      }
    471473
     
    474476        if (_empty)
    475477          return false;
    476         else{
    477           return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
    478               (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
     478        else {
     479          return ( (u.x-_bottom_left.x)*(_top_right.x-u.x) >= 0 &&
     480                   (u.y-_bottom_left.y)*(_top_right.y-u.y) >= 0 );
    479481        }
    480482      }
     
    485487      ///
    486488      BoundingBox& add(const Point<T>& u){
    487         if (_empty){
    488           bottom_left=top_right=u;
     489        if (_empty) {
     490          _bottom_left = _top_right = u;
    489491          _empty = false;
    490492        }
    491         else{
    492           if (bottom_left.x > u.x) bottom_left.x = u.x;
    493           if (bottom_left.y > u.y) bottom_left.y = u.y;
    494           if (top_right.x < u.x) top_right.x = u.x;
    495           if (top_right.y < u.y) top_right.y = u.y;
     493        else {
     494          if (_bottom_left.x > u.x) _bottom_left.x = u.x;
     495          if (_bottom_left.y > u.y) _bottom_left.y = u.y;
     496          if (_top_right.x < u.x) _top_right.x = u.x;
     497          if (_top_right.y < u.y) _top_right.y = u.y;
    496498        }
    497499        return *this;
     
    504506      BoundingBox& add(const BoundingBox &u){
    505507        if ( !u.empty() ){
    506           this->add(u.bottomLeft());
    507           this->add(u.topRight());
     508          add(u._bottom_left);
     509          add(u._top_right);
    508510        }
    509511        return *this;
     
    516518      BoundingBox operator&(const BoundingBox& u) const {
    517519        BoundingBox b;
    518         if (this->_empty || u._empty) {
     520        if (_empty || u._empty) {
    519521          b._empty = true;
    520522        } else {
    521           b.bottom_left.x = std::max(this->bottom_left.x,u.bottom_left.x);
    522           b.bottom_left.y = std::max(this->bottom_left.y,u.bottom_left.y);
    523           b.top_right.x = std::min(this->top_right.x,u.top_right.x);
    524           b.top_right.y = std::min(this->top_right.y,u.top_right.y);
    525           b._empty = b.bottom_left.x > b.top_right.x ||
    526                      b.bottom_left.y > b.top_right.y;
     523          b._bottom_left.x = std::max(_bottom_left.x, u._bottom_left.x);
     524          b._bottom_left.y = std::max(_bottom_left.y, u._bottom_left.y);
     525          b._top_right.x = std::min(_top_right.x, u._top_right.x);
     526          b._top_right.y = std::min(_top_right.y, u._top_right.y);
     527          b._empty = b._bottom_left.x > b._top_right.x ||
     528                     b._bottom_left.y > b._top_right.y;
    527529        }
    528530        return b;
Note: See TracChangeset for help on using the changeset viewer.