VTK  9.1.0
vtkBoundingBox.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3 Program: Visualization Toolkit
4 Module: vtkBoundingBox.h
5 
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
28 #ifndef vtkBoundingBox_h
29 #define vtkBoundingBox_h
30 #include "vtkCommonDataModelModule.h" // For export macro
31 #include "vtkSystemIncludes.h"
32 #include <atomic> // For threaded bounding box computation
33 
34 class vtkPoints;
35 
36 class VTKCOMMONDATAMODEL_EXPORT vtkBoundingBox
37 {
38 public:
40 
45  vtkBoundingBox(const double bounds[6]);
46  vtkBoundingBox(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax);
48 
52  vtkBoundingBox(const vtkBoundingBox& bbox);
53 
57  vtkBoundingBox& operator=(const vtkBoundingBox& bbox);
58 
60 
63  bool operator==(const vtkBoundingBox& bbox) const;
64  bool operator!=(const vtkBoundingBox& bbox) const;
66 
68 
72  void SetBounds(const double bounds[6]);
73  void SetBounds(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax);
75 
77 
84  static void ComputeBounds(vtkPoints* pts, double bounds[6]);
85  static void ComputeBounds(vtkPoints* pts, const unsigned char* ptUses, double bounds[6]);
86  static void ComputeBounds(
87  vtkPoints* pts, const std::atomic<unsigned char>* ptUses, double bounds[6]);
88  void ComputeBounds(vtkPoints* pts) { this->ComputeBounds(pts, (unsigned char*)nullptr); }
89  void ComputeBounds(vtkPoints* pts, unsigned char* ptUses)
90  {
91  double bds[6];
92  vtkBoundingBox::ComputeBounds(pts, ptUses, bds);
93  this->MinPnt[0] = bds[0];
94  this->MinPnt[1] = bds[2];
95  this->MinPnt[2] = bds[4];
96  this->MaxPnt[0] = bds[1];
97  this->MaxPnt[1] = bds[3];
98  this->MaxPnt[2] = bds[5];
99  }
101 
103 
107  static void ComputeLocalBounds(
108  vtkPoints* points, double u[3], double v[3], double w[3], double outputBounds[6]);
110 
112 
116  void SetMinPoint(double x, double y, double z);
117  void SetMinPoint(double p[3]);
119 
121 
125  void SetMaxPoint(double x, double y, double z);
126  void SetMaxPoint(double p[3]);
128 
130 
134  int IsValid() const;
135  static int IsValid(const double bounds[6]);
137 
139 
143  void AddPoint(double p[3]);
144  void AddPoint(double px, double py, double pz);
146 
151  void AddBox(const vtkBoundingBox& bbox);
152 
157  void AddBounds(const double bounds[]);
158 
162  bool IsSubsetOf(const vtkBoundingBox& bbox) const;
163 
169  int IntersectBox(const vtkBoundingBox& bbox);
170 
174  int Intersects(const vtkBoundingBox& bbox) const;
175 
181  bool IntersectPlane(double origin[3], double normal[3]);
182 
187  bool IntersectsSphere(double center[3], double squaredRadius) const;
188 
193  bool IntersectsLine(const double p1[3], const double p2[3]) const;
194 
199 
204  int Contains(const vtkBoundingBox& bbox) const;
205 
207 
210  void GetBounds(double bounds[6]) const;
211  void GetBounds(
212  double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax) const;
214 
218  double GetBound(int i) const;
219 
221 
224  const double* GetMinPoint() const VTK_SIZEHINT(3);
225  void GetMinPoint(double& x, double& y, double& z) const;
226  void GetMinPoint(double x[3]) const;
228 
230 
233  const double* GetMaxPoint() const VTK_SIZEHINT(3);
234  void GetMaxPoint(double& x, double& y, double& z) const;
235  void GetMaxPoint(double x[3]) const;
237 
242  void GetCorner(int corner, double p[3]) const;
243 
245 
248  vtkTypeBool ContainsPoint(const double p[3]) const;
249  vtkTypeBool ContainsPoint(double px, double py, double pz) const;
250  template <class PointT>
251  bool ContainsPoint(const PointT& p) const;
253 
257  void GetCenter(double center[3]) const;
258 
262  void GetLengths(double lengths[3]) const;
263 
267  double GetLength(int i) const;
268 
272  double GetMaxLength() const;
273 
278  double GetDiagonalLength() const;
279 
281 
289  void Inflate(double delta);
290  void Inflate(double deltaX, double deltaY, double deltaZ);
291  void Inflate();
293 
295 
301  void Scale(double s[3]);
302  void Scale(double sx, double sy, double sz);
304 
306 
311  void ScaleAboutCenter(double s);
312  void ScaleAboutCenter(double s[3]);
313  void ScaleAboutCenter(double sx, double sy, double sz);
315 
326  vtkIdType ComputeDivisions(vtkIdType totalBins, double bounds[6], int divs[3]) const;
327 
332  static void ClampDivisions(vtkIdType targetBins, int divs[3]);
333 
337  void Reset();
338 
339 protected:
340  double MinPnt[3], MaxPnt[3];
341 };
342 
343 inline void vtkBoundingBox::Reset()
344 {
345  this->MinPnt[0] = this->MinPnt[1] = this->MinPnt[2] = VTK_DOUBLE_MAX;
346  this->MaxPnt[0] = this->MaxPnt[1] = this->MaxPnt[2] = VTK_DOUBLE_MIN;
347 }
348 
350  double& xMin, double& xMax, double& yMin, double& yMax, double& zMin, double& zMax) const
351 {
352  xMin = this->MinPnt[0];
353  xMax = this->MaxPnt[0];
354  yMin = this->MinPnt[1];
355  yMax = this->MaxPnt[1];
356  zMin = this->MinPnt[2];
357  zMax = this->MaxPnt[2];
358 }
359 
360 inline double vtkBoundingBox::GetBound(int i) const
361 {
362  // If i is odd then when are returning a part of the max bounds
363  // else part of the min bounds is requested. The exact component
364  // needed is i /2 (or i right shifted by 1
365  return ((i & 0x1) ? this->MaxPnt[i >> 1] : this->MinPnt[i >> 1]);
366 }
367 
368 inline const double* vtkBoundingBox::GetMinPoint() const
369 {
370  return this->MinPnt;
371 }
372 
373 inline void vtkBoundingBox::GetMinPoint(double x[3]) const
374 {
375  x[0] = this->MinPnt[0];
376  x[1] = this->MinPnt[1];
377  x[2] = this->MinPnt[2];
378 }
379 
380 inline const double* vtkBoundingBox::GetMaxPoint() const
381 {
382  return this->MaxPnt;
383 }
384 
385 inline void vtkBoundingBox::GetMaxPoint(double x[3]) const
386 {
387  x[0] = this->MaxPnt[0];
388  x[1] = this->MaxPnt[1];
389  x[2] = this->MaxPnt[2];
390 }
391 
392 inline int vtkBoundingBox::IsValid() const
393 {
394  return ((this->MinPnt[0] <= this->MaxPnt[0]) && (this->MinPnt[1] <= this->MaxPnt[1]) &&
395  (this->MinPnt[2] <= this->MaxPnt[2]));
396 }
397 
398 inline int vtkBoundingBox::IsValid(const double bounds[6])
399 {
400  return (bounds[0] <= bounds[1] && bounds[2] <= bounds[3] && bounds[4] <= bounds[5]);
401 }
402 
403 inline double vtkBoundingBox::GetLength(int i) const
404 {
405  return this->MaxPnt[i] - this->MinPnt[i];
406 }
407 
408 inline void vtkBoundingBox::GetLengths(double lengths[3]) const
409 {
410  lengths[0] = this->GetLength(0);
411  lengths[1] = this->GetLength(1);
412  lengths[2] = this->GetLength(2);
413 }
414 
415 inline void vtkBoundingBox::GetCenter(double center[3]) const
416 {
417  center[0] = 0.5 * (this->MaxPnt[0] + this->MinPnt[0]);
418  center[1] = 0.5 * (this->MaxPnt[1] + this->MinPnt[1]);
419  center[2] = 0.5 * (this->MaxPnt[2] + this->MinPnt[2]);
420 }
421 
422 inline bool vtkBoundingBox::IsSubsetOf(const vtkBoundingBox& bbox) const
423 {
424  const double* bboxMaxPnt = bbox.GetMaxPoint();
425  const double* bboxMinPnt = bbox.GetMinPoint();
426  return this->MaxPnt[0] < bboxMaxPnt[0] && this->MinPnt[0] > bboxMinPnt[0] &&
427  this->MaxPnt[1] < bboxMaxPnt[1] && this->MinPnt[1] > bboxMinPnt[1] &&
428  this->MaxPnt[2] < bboxMaxPnt[2] && this->MinPnt[2] > bboxMinPnt[2];
429 }
430 
431 inline void vtkBoundingBox::SetBounds(const double bounds[6])
432 {
433  this->SetBounds(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]);
434 }
435 
436 inline void vtkBoundingBox::GetBounds(double bounds[6]) const
437 {
438  this->GetBounds(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]);
439 }
440 
442 {
443  this->Reset();
444 }
445 
446 inline vtkBoundingBox::vtkBoundingBox(const double bounds[6])
447 {
448  this->Reset();
449  this->SetBounds(bounds);
450 }
451 
453  double xMin, double xMax, double yMin, double yMax, double zMin, double zMax)
454 {
455  this->Reset();
456  this->SetBounds(xMin, xMax, yMin, yMax, zMin, zMax);
457 }
458 
460 {
461  this->MinPnt[0] = bbox.MinPnt[0];
462  this->MinPnt[1] = bbox.MinPnt[1];
463  this->MinPnt[2] = bbox.MinPnt[2];
464 
465  this->MaxPnt[0] = bbox.MaxPnt[0];
466  this->MaxPnt[1] = bbox.MaxPnt[1];
467  this->MaxPnt[2] = bbox.MaxPnt[2];
468 }
469 
471 {
472  this->MinPnt[0] = bbox.MinPnt[0];
473  this->MinPnt[1] = bbox.MinPnt[1];
474  this->MinPnt[2] = bbox.MinPnt[2];
475 
476  this->MaxPnt[0] = bbox.MaxPnt[0];
477  this->MaxPnt[1] = bbox.MaxPnt[1];
478  this->MaxPnt[2] = bbox.MaxPnt[2];
479  return *this;
480 }
481 
482 inline bool vtkBoundingBox::operator==(const vtkBoundingBox& bbox) const
483 {
484  return ((this->MinPnt[0] == bbox.MinPnt[0]) && (this->MinPnt[1] == bbox.MinPnt[1]) &&
485  (this->MinPnt[2] == bbox.MinPnt[2]) && (this->MaxPnt[0] == bbox.MaxPnt[0]) &&
486  (this->MaxPnt[1] == bbox.MaxPnt[1]) && (this->MaxPnt[2] == bbox.MaxPnt[2]));
487 }
488 
489 inline bool vtkBoundingBox::operator!=(const vtkBoundingBox& bbox) const
490 {
491  return !((*this) == bbox);
492 }
493 
494 inline void vtkBoundingBox::SetMinPoint(double p[3])
495 {
496  this->SetMinPoint(p[0], p[1], p[2]);
497 }
498 
499 inline void vtkBoundingBox::SetMaxPoint(double p[3])
500 {
501  this->SetMaxPoint(p[0], p[1], p[2]);
502 }
503 
504 inline void vtkBoundingBox::GetMinPoint(double& x, double& y, double& z) const
505 {
506  x = this->MinPnt[0];
507  y = this->MinPnt[1];
508  z = this->MinPnt[2];
509 }
510 
511 inline void vtkBoundingBox::GetMaxPoint(double& x, double& y, double& z) const
512 {
513  x = this->MaxPnt[0];
514  y = this->MaxPnt[1];
515  z = this->MaxPnt[2];
516 }
517 
518 inline vtkTypeBool vtkBoundingBox::ContainsPoint(double px, double py, double pz) const
519 {
520  if ((px < this->MinPnt[0]) || (px > this->MaxPnt[0]))
521  {
522  return 0;
523  }
524  if ((py < this->MinPnt[1]) || (py > this->MaxPnt[1]))
525  {
526  return 0;
527  }
528  if ((pz < this->MinPnt[2]) || (pz > this->MaxPnt[2]))
529  {
530  return 0;
531  }
532  return 1;
533 }
534 
535 inline vtkTypeBool vtkBoundingBox::ContainsPoint(const double p[3]) const
536 {
537  return this->ContainsPoint(p[0], p[1], p[2]);
538 }
539 
540 template <class PointT>
541 inline bool vtkBoundingBox::ContainsPoint(const PointT& p) const
542 {
543  return this->ContainsPoint(p[0], p[1], p[2]);
544 }
545 
546 inline void vtkBoundingBox::GetCorner(int corner, double p[3]) const
547 {
548  if ((corner < 0) || (corner > 7))
549  {
550  p[0] = VTK_DOUBLE_MAX;
551  p[1] = VTK_DOUBLE_MAX;
552  p[2] = VTK_DOUBLE_MAX;
553  return; // out of bounds
554  }
555 
556  int ix = (corner & 1) ? 1 : 0; // 0,1,0,1,0,1,0,1
557  int iy = ((corner >> 1) & 1) ? 1 : 0; // 0,0,1,1,0,0,1,1
558  int iz = (corner >> 2) ? 1 : 0; // 0,0,0,0,1,1,1,1
559 
560  const double* pts[2] = { this->MinPnt, this->MaxPnt };
561  p[0] = pts[ix][0];
562  p[1] = pts[iy][1];
563  p[2] = pts[iz][2];
564 }
565 
566 #endif
567 // VTK-HeaderTest-Exclude: vtkBoundingBox.h
Fast, simple class for representing and operating on 3D bounds.
int IntersectBox(const vtkBoundingBox &bbox)
Intersect this box with bbox.
const double * GetMinPoint() const
Get the minimum point of the bounding box.
void SetBounds(double xMin, double xMax, double yMin, double yMax, double zMin, double zMax)
Set the bounds explicitly of the box (using the VTK convention for representing a bounding box).
void AddBox(const vtkBoundingBox &bbox)
Change the bounding box to be the union of itself and the specified bbox.
void AddBounds(const double bounds[])
Adjust the bounding box so it contains the specified bounds (defined by the VTK representation (xmin,...
int Contains(const vtkBoundingBox &bbox) const
Returns 1 if the min and max points of bbox are contained within the bounds of the specified box,...
int IsValid() const
Returns 1 if the bounds have been set and 0 if the box is in its initialized state which is an invert...
int Intersects(const vtkBoundingBox &bbox) const
Returns 1 if the boxes intersect else returns 0.
bool operator!=(const vtkBoundingBox &bbox) const
Equality operator.
void AddPoint(double px, double py, double pz)
Change bounding box so it includes the point p.
int ComputeInnerDimension() const
Returns the inner dimension of the bounding box.
void GetCorner(int corner, double p[3]) const
Get the ith corner of the bounding box.
void ComputeBounds(vtkPoints *pts)
Compute the bounding box from an array of vtkPoints.
bool IsSubsetOf(const vtkBoundingBox &bbox) const
Returns true if this instance is entirely contained by bbox.
static void ComputeBounds(vtkPoints *pts, double bounds[6])
Compute the bounding box from an array of vtkPoints.
bool IntersectsSphere(double center[3], double squaredRadius) const
Intersect this box with a sphere.
void SetMaxPoint(double x, double y, double z)
Set the maximum point of the bounding box - if the max point is less than the min point then the min ...
bool IntersectPlane(double origin[3], double normal[3])
Intersect this box with the half space defined by plane.
bool IntersectsLine(const double p1[3], const double p2[3]) const
Returns true if any part of segment [p1,p2] lies inside the bounding box, as well as on its boundarie...
static void ComputeLocalBounds(vtkPoints *points, double u[3], double v[3], double w[3], double outputBounds[6])
Compute local bounds.
void GetCenter(double center[3]) const
Get the center of the bounding box.
void AddPoint(double p[3])
Change bounding box so it includes the point p.
double GetLength(int i) const
Return the length of the bounding box in the ith direction.
bool operator==(const vtkBoundingBox &bbox) const
Equality operator.
vtkTypeBool ContainsPoint(const double p[3]) const
Returns 1 if the point is contained in the box else 0.
vtkBoundingBox()
Construct a bounding box with the min point set to VTK_DOUBLE_MAX and the max point set to VTK_DOUBLE...
double MinPnt[3]
double MaxPnt[3]
void GetLengths(double lengths[3]) const
Get the length of each side of the box.
void ComputeBounds(vtkPoints *pts, unsigned char *ptUses)
Compute the bounding box from an array of vtkPoints.
static void ComputeBounds(vtkPoints *pts, const unsigned char *ptUses, double bounds[6])
Compute the bounding box from an array of vtkPoints.
void SetBounds(const double bounds[6])
Set the bounds explicitly of the box (using the VTK convention for representing a bounding box).
const double * GetMaxPoint() const
Get the maximum point of the bounding box.
double GetBound(int i) const
Return the ith bounds of the box (defined by VTK style).
static void ComputeBounds(vtkPoints *pts, const std::atomic< unsigned char > *ptUses, double bounds[6])
Compute the bounding box from an array of vtkPoints.
void GetBounds(double bounds[6]) const
Get the bounds of the box (defined by VTK style).
void SetMinPoint(double x, double y, double z)
Set the minimum point of the bounding box - if the min point is greater than the max point then the m...
vtkBoundingBox & operator=(const vtkBoundingBox &bbox)
Assignment Operator.
represent and manipulate 3D points
Definition: vtkPoints.h:34
void GetBounds(T a, double bds[6])
@ points
Definition: vtkX3D.h:452
@ center
Definition: vtkX3D.h:236
int vtkTypeBool
Definition: vtkABI.h:69
int vtkIdType
Definition: vtkType.h:332
#define VTK_DOUBLE_MIN
Definition: vtkType.h:164
#define VTK_DOUBLE_MAX
Definition: vtkType.h:165
VTKCOMMONCORE_EXPORT bool operator!=(const vtkUnicodeString &lhs, const vtkUnicodeString &rhs)
VTKCOMMONCORE_EXPORT bool operator==(const vtkUnicodeString &lhs, const vtkUnicodeString &rhs)
#define VTK_SIZEHINT(...)