Changeset 209:765619b7cbb2 in lemon1.0 for lemon/dim2.h
 Timestamp:
 07/13/08 20:51:02 (13 years ago)
 Branch:
 default
 Phase:
 public
 File:

 1 edited
Legend:
 Unmodified
 Added
 Removed

lemon/dim2.h
r49 r209 1 /* * C++*1 /* * mode: C++; indenttabsmode: nil; * 2 2 * 3 * This file is a part of LEMON, a generic C++ optimization library 3 * This file is a part of LEMON, a generic C++ optimization library. 4 4 * 5 5 * Copyright (C) 20032008 … … 25 25 ///\ingroup misc 26 26 ///\file 27 ///\brief A simple two dimensional vector and a bounding box implementation 27 ///\brief A simple two dimensional vector and a bounding box implementation 28 28 /// 29 29 /// The class \ref lemon::dim2::Point "dim2::Point" implements … … 60 60 T x; 61 61 ///Second coordinate 62 T y; 63 62 T y; 63 64 64 ///Default constructor 65 65 Point() {} … … 71 71 72 72 ///The dimension of the vector. 73 ///This function always returns 2. 73 ///This function always returns 2. 74 74 int size() const { return 2; } 75 75 … … 93 93 return x*x+y*y; 94 94 } 95 95 96 96 ///Increment the left hand side by \c u 97 97 Point<T>& operator +=(const Point<T>& u) { … … 100 100 return *this; 101 101 } 102 102 103 103 ///Decrement the left hand side by \c u 104 104 Point<T>& operator =(const Point<T>& u) { … … 121 121 return *this; 122 122 } 123 123 124 124 ///Return the scalar product of two vectors 125 125 T operator *(const Point<T>& u) const { 126 126 return x*u.x+y*u.y; 127 127 } 128 128 129 129 ///Return the sum of two vectors 130 130 Point<T> operator+(const Point<T> &u) const { … … 170 170 }; 171 171 172 ///Return a Point 172 ///Return a Point 173 173 174 174 ///Return a Point. … … 260 260 } 261 261 262 262 263 263 264 264 /// A class to calculate or store the bounding box of plainvectors. … … 271 271 bool _empty; 272 272 public: 273 273 274 274 ///Default constructor: creates an empty bounding box 275 275 BoundingBox() { _empty = true; } … … 277 277 ///Construct an instance from one point 278 278 BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; } 279 279 280 280 ///Construct an instance from two points 281 281 282 282 ///Construct an instance from two points. 283 283 ///\param a The bottom left corner. … … 287 287 BoundingBox(Point<T> a,Point<T> b) 288 288 { 289 290 291 292 } 293 289 bottom_left=a; 290 top_right=b; 291 _empty = false; 292 } 293 294 294 ///Construct an instance from four numbers 295 295 … … 300 300 ///\param t The top of the box. 301 301 ///\warning The left side must be no more than the right side and 302 ///bottom must be no more than the top. 302 ///bottom must be no more than the top. 303 303 BoundingBox(T l,T b,T r,T t) 304 304 { 305 306 307 308 } 309 305 bottom_left=Point<T>(l,b); 306 top_right=Point<T>(r,t); 307 _empty = false; 308 } 309 310 310 ///Return \c true if the bounding box is empty. 311 311 312 312 ///Return \c true if the bounding box is empty (i.e. return \c false 313 313 ///if at least one point was added to the box or the coordinates of 314 314 ///the box were set). 315 315 /// 316 ///The coordinates of an empty bounding box are not defined. 316 ///The coordinates of an empty bounding box are not defined. 317 317 bool empty() const { 318 318 return _empty; 319 319 } 320 320 321 321 ///Make the BoundingBox empty 322 322 void clear() { … … 337 337 ///It should only be used for nonempty box. 338 338 void bottomLeft(Point<T> p) { 339 339 bottom_left = p; 340 340 } 341 341 … … 353 353 ///It should only be used for nonempty box. 354 354 void topRight(Point<T> p) { 355 355 top_right = p; 356 356 } 357 357 … … 369 369 ///It should only be used for nonempty box. 370 370 void bottomRight(Point<T> p) { 371 372 373 } 374 371 top_right.x = p.x; 372 bottom_left.y = p.y; 373 } 374 375 375 ///Give back the top left corner of the box 376 376 … … 386 386 ///It should only be used for nonempty box. 387 387 void topLeft(Point<T> p) { 388 389 388 top_right.y = p.y; 389 bottom_left.x = p.x; 390 390 } 391 391 … … 403 403 ///It should only be used for nonempty box. 404 404 void bottom(T t) { 405 405 bottom_left.y = t; 406 406 } 407 407 … … 419 419 ///It should only be used for nonempty box. 420 420 void top(T t) { 421 421 top_right.y = t; 422 422 } 423 423 … … 429 429 return bottom_left.x; 430 430 } 431 431 432 432 ///Set the left side of the box 433 433 … … 435 435 ///It should only be used for nonempty box. 436 436 void left(T t) { 437 437 bottom_left.x = t; 438 438 } 439 439 … … 451 451 ///It should only be used for nonempty box. 452 452 void right(T t) { 453 453 top_right.x = t; 454 454 } 455 455 … … 479 479 } 480 480 } 481 481 482 482 ///Increments a bounding box with a point 483 483 … … 497 497 return *this; 498 498 } 499 499 500 500 ///Increments a bounding box to contain another bounding box 501 501 502 502 ///Increments a bounding box to contain another bounding box. 503 503 /// … … 505 505 if ( !u.empty() ){ 506 506 this>add(u.bottomLeft()); 507 507 this>add(u.topRight()); 508 508 } 509 509 return *this; 510 510 } 511 511 512 512 ///Intersection of two bounding boxes 513 513 … … 517 517 BoundingBox b; 518 518 if (this>_empty  u._empty) { 519 520 521 522 523 524 525 526 527 } 519 b._empty = true; 520 } 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; 527 } 528 528 return b; 529 529 } … … 538 538 /// 539 539 template<class M> 540 class XMap 540 class XMap 541 541 { 542 542 M& _map; … … 550 550 void set(Key k,Value v) {_map.set(k,typename M::Value(v,_map[k].y));} 551 551 }; 552 552 553 553 ///Returns an \ref XMap class 554 554 … … 557 557 ///\ingroup maps 558 558 ///\relates XMap 559 template<class M> 560 inline XMap<M> xMap(M &m) 559 template<class M> 560 inline XMap<M> xMap(M &m) 561 561 { 562 562 return XMap<M>(m); 563 563 } 564 564 565 template<class M> 566 inline XMap<M> xMap(const M &m) 565 template<class M> 566 inline XMap<M> xMap(const M &m) 567 567 { 568 568 return XMap<M>(m); … … 575 575 /// 576 576 template<class M> 577 class ConstXMap 577 class ConstXMap 578 578 { 579 579 const M& _map; … … 586 586 Value operator[](Key k) const {return _map[k].x;} 587 587 }; 588 588 589 589 ///Returns a \ref ConstXMap class 590 590 … … 593 593 ///\ingroup maps 594 594 ///\relates ConstXMap 595 template<class M> 596 inline ConstXMap<M> xMap(const M &m) 595 template<class M> 596 inline ConstXMap<M> xMap(const M &m) 597 597 { 598 598 return ConstXMap<M>(m); … … 600 600 601 601 ///Map of ycoordinates of a \ref Point "Point"map 602 602 603 603 ///\ingroup maps 604 604 ///Map of ycoordinates of a \ref Point "Point"map. 605 605 /// 606 606 template<class M> 607 class YMap 607 class YMap 608 608 { 609 609 M& _map; … … 624 624 ///\ingroup maps 625 625 ///\relates YMap 626 template<class M> 627 inline YMap<M> yMap(M &m) 626 template<class M> 627 inline YMap<M> yMap(M &m) 628 628 { 629 629 return YMap<M>(m); 630 630 } 631 631 632 template<class M> 633 inline YMap<M> yMap(const M &m) 632 template<class M> 633 inline YMap<M> yMap(const M &m) 634 634 { 635 635 return YMap<M>(m); … … 642 642 /// 643 643 template<class M> 644 class ConstYMap 644 class ConstYMap 645 645 { 646 646 const M& _map; … … 653 653 Value operator[](Key k) const {return _map[k].y;} 654 654 }; 655 655 656 656 ///Returns a \ref ConstYMap class 657 657 … … 660 660 ///\ingroup maps 661 661 ///\relates ConstYMap 662 template<class M> 663 inline ConstYMap<M> yMap(const M &m) 662 template<class M> 663 inline ConstYMap<M> yMap(const M &m) 664 664 { 665 665 return ConstYMap<M>(m); … … 674 674 ///\ingroup maps 675 675 template<class M> 676 class NormSquareMap 676 class NormSquareMap 677 677 { 678 678 const M& _map; … … 685 685 Value operator[](Key k) const {return _map[k].normSquare();} 686 686 }; 687 687 688 688 ///Returns a \ref NormSquareMap class 689 689 … … 692 692 ///\ingroup maps 693 693 ///\relates NormSquareMap 694 template<class M> 695 inline NormSquareMap<M> normSquareMap(const M &m) 694 template<class M> 695 inline NormSquareMap<M> normSquareMap(const M &m) 696 696 { 697 697 return NormSquareMap<M>(m); … … 701 701 702 702 } //namespce dim2 703 703 704 704 } //namespace lemon 705 705
Note: See TracChangeset
for help on using the changeset viewer.