home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / include / k3d / k3dsdk / bounding_box3.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-01-23  |  4.3 KB  |  153 lines
  1. #ifndef K3DSDK_BOUNDING_BOX3_H
  2. #define K3DSDK_BOUNDING_BOX3_H
  3.  
  4. // K-3D
  5. // Copyright (c) 1995-2006, Timothy M. Shead
  6. //
  7. // Contact: tshead@k-3d.com
  8. //
  9. // This program is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. //
  14. // This program is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. // General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public
  20. // License along with this program; if not, write to the Free Software
  21. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22.  
  23. /** \file
  24.     \author Tim Shead (tshead@k-3d.com)
  25.     \author Anders Dahnielson (anders@dahnielson.com)
  26. */
  27.  
  28. #include "point3.h"
  29.  
  30. #include <algorithm>
  31. #include <cassert>
  32. #include <cmath>
  33. #include <iosfwd>
  34. #include <limits>
  35.  
  36. namespace k3d
  37. {
  38.  
  39. class matrix4;
  40.  
  41. /// Stores an axis-aligned bounding-box in three space
  42. class bounding_box3
  43. {
  44. public:
  45.     /// Initializes an "empty" bounding box (note: "empty" means "undefined" - it's not the same as having all values zero)
  46.     explicit bounding_box3() :
  47.         px(-std::numeric_limits<double>::max()),
  48.         nx(std::numeric_limits<double>::max()),
  49.         py(-std::numeric_limits<double>::max()),
  50.         ny(std::numeric_limits<double>::max()),
  51.         pz(-std::numeric_limits<double>::max()),
  52.         nz(std::numeric_limits<double>::max())
  53.     {
  54.     }
  55.  
  56.     bounding_box3(double PX, double NX, double PY, double NY, double PZ, double NZ) :
  57.         px(std::max(PX, NX)),
  58.         nx(std::min(PX, NX)),
  59.         py(std::max(PY, NY)),
  60.         ny(std::min(PY, NY)),
  61.         pz(std::max(PZ, NZ)),
  62.         nz(std::min(PZ, NZ))
  63.     {
  64.     }
  65.  
  66.     /// Grows the bounding box as needed to contain the given point
  67.     void insert(const point3& Point)
  68.     {
  69.         px = std::max(px, Point[0]);
  70.         nx = std::min(nx, Point[0]);
  71.         py = std::max(py, Point[1]);
  72.         ny = std::min(ny, Point[1]);
  73.         pz = std::max(pz, Point[2]);
  74.         nz = std::min(nz, Point[2]);
  75.     }
  76.  
  77.     /// Grows the bounding box as needed to contain the given bounding box
  78.     void insert(const bounding_box3& Box)
  79.     {
  80.         px = std::max(px, Box.px);
  81.         nx = std::min(nx, Box.nx);
  82.         py = std::max(py, Box.py);
  83.         ny = std::min(ny, Box.ny);
  84.         pz = std::max(pz, Box.pz);
  85.         nz = std::min(nz, Box.nz);
  86.     }
  87.  
  88.     /// Returns true iff the bounding box contains the given point
  89.     bool contains(const point3& Point) const
  90.     {
  91.         return nx <= Point[0] && Point[0] <= px && ny <= Point[1] && Point[1] <= py && nz <= Point[2] && Point[2] <= pz;
  92.     }
  93.  
  94.     /// Returns true iff the box is empty (undefined)
  95.     bool empty() const
  96.     {
  97.         return px < nx || py < ny || pz < nz;
  98.     }
  99.  
  100.     /// Returns the width of the bounding box, or zero if the box is empty
  101.     double width() const
  102.     {
  103.         return empty() ? 0.0 : px-nx;
  104.     }
  105.  
  106.     /// Returns the height of the bounding box, or zero if the box is empty
  107.     double height() const
  108.     {
  109.         return empty() ? 0.0 : py-ny;
  110.     }
  111.  
  112.     /// Returns the depth of the bounding box, or zero if the box is empty
  113.     double depth() const
  114.     {
  115.         return empty() ? 0.0 : pz-nz;
  116.     }
  117.  
  118.     /// Returns the center of the bounding box, asserts if the box is empty
  119.     const point3 center() const
  120.     {
  121.         assert(!empty());
  122.         return point3((px + nx) / 2, (py + ny) / 2, (pz + nz) / 2);
  123.     }
  124.  
  125.     bounding_box3& operator*=(const matrix4 Transformation);
  126.  
  127.     /// Stores the maximum x value (not necessarily positive)
  128.     double px;
  129.     /// Stores the minimum x value (not necessarily negative)
  130.     double nx;
  131.     /// Stores the maximum y value (not necessarily positive)
  132.     double py;
  133.     /// Stores the minimum y value (not necessarily negative)
  134.     double ny;
  135.     /// Stores the maximum z value (not necessarily positive)
  136.     double pz;
  137.     /// Stores the minimum z value (not necessarily negative)
  138.     double nz;
  139. };
  140.  
  141. bounding_box3 operator*(const bounding_box3& BBox, const matrix4& Transformation);
  142. bounding_box3 operator*(const matrix4& Transformation, const bounding_box3& BBox);
  143. bool operator==(const bounding_box3& LHS, const bounding_box3& RHS);
  144. bool operator!=(const bounding_box3& LHS, const bounding_box3& RHS);
  145.  
  146. std::ostream& operator<<(std::ostream& Stream, const bounding_box3& RHS);
  147. std::istream& operator>>(std::istream& Stream, bounding_box3& RHS);
  148.  
  149. } // namespace k3d
  150.  
  151. #endif // !K3DSDK_BOUNDING_BOX3_H
  152.  
  153.