00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053 #ifndef _SB_BOX_
00054 #define _SB_BOX_
00055
00056 #include <Inventor/SbBase.h>
00057 #include <Inventor/SbVec.h>
00058 #include <Inventor/SbMatrix.h>
00059 #include <Inventor/STL/iostream>
00060
00061 class SbBox3s;
00062 class SbBox3i32;
00063 class SbBox3f;
00064 class SbBox3d;
00065
00066 class SbXfBox3d;
00067 class SbXfBox3f;
00068
00096 class SbBox3i32 {
00097
00098 public:
00102 SbBox3i32()
00103 { makeEmpty(); }
00104
00109 SbBox3i32(int xmin, int ymin, int zmin,
00110 int xmax, int ymax, int zmax)
00111 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00112
00117 SbBox3i32(const SbVec3i32 &_min, const SbVec3i32 &_max)
00118 { m_min = _min; m_max = _max; }
00119
00123 SbBox3i32( const SbBox3s &box );
00124
00128 ~SbBox3i32()
00129 {}
00130
00136 const SbVec3i32 &getMin() const
00137 { return m_min; }
00138
00144 const SbVec3i32 &getMax() const
00145 { return m_max; }
00146
00151 SbVec3i32 &getMin()
00152 { return m_min; }
00153
00158 SbVec3i32 &getMax()
00159 { return m_max; }
00160
00164 SbVec3f getCenter() const;
00165
00169 void extendBy(const SbVec3f &pt);
00170
00174 void extendBy(const SbBox3i32 &bb);
00175
00179 SbBool intersect(const SbVec3f &pt) const;
00180
00184 SbBool intersect(const SbBox3i32 &bb) const;
00185
00189 SbBool intersect(const SbVec3i32 &pt) const;
00190
00195 SbBox3i32 intersection(const SbBox3i32& box) const;
00196
00200 inline SbBool contains(const SbBox3i32 &bb) const
00201 {
00202 SbBool contained = true;
00203 for( int i = 0; i < 3 && contained; i++ )
00204 {
00205 contained &= bb.m_min[i] >= m_min[i] &&
00206 bb.m_min[i] <= m_max[i] &&
00207 bb.m_max[i] <= m_max[i];
00208 }
00209
00210 return contained;
00211 }
00212
00226 SbBool outside(const SbMatrix &MVP, int &cullBits) const;
00227
00231 void setBounds(int xmin, int ymin, int zmin,
00232 int xmax, int ymax, int zmax)
00233 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00234
00238 void setBounds(const SbVec3i32 &_min, const SbVec3i32 &_max)
00239 { m_min = _min; m_max = _max; }
00240
00244 void getBounds(int &xmin, int &ymin, int &zmin,
00245 int &xmax, int &ymax, int &zmax) const
00246 { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
00247
00252 void getBounds(SbVec3i32 &_min, SbVec3i32 &_max) const
00253 { _min = m_min; _max = m_max; }
00254
00259 SbVec3f getClosestPoint(const SbVec3f &point) const;
00260
00264 void getOrigin(int &originX, int &originY, int &originZ) const
00265 { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
00266
00271 void getSize(int &sizeX, int &sizeY, int &sizeZ) const {
00272 if ( m_max[0] < m_min[0] ) {
00273 sizeX = 0;
00274 sizeY = 0;
00275 sizeZ = 0;
00276 }
00277 else {
00278 sizeX = m_max[0] - m_min[0];
00279 sizeY = m_max[1] - m_min[1];
00280 sizeZ = m_max[2] - m_min[2];
00281 }
00282 }
00283
00287 SbVec3i32 getSize() const
00288 {
00289 if ( m_max[0] < m_min[0] )
00290 return SbVec3i32(0, 0, 0);
00291
00292 return m_max-m_min;
00293 }
00294
00298 void makeEmpty();
00299
00305 SbBool isEmpty() const
00306 { return m_max[0] < m_min[0]; }
00307
00312 SbBool hasVolume() const
00313 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2]); }
00314
00322 void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
00323
00327 void transform(const SbMatrix &m);
00328
00332 float getVolume() const;
00333
00337 SbBox3i32 operator = (const SbBox3s &box);
00338
00342 friend inline std::ostream& operator << (std::ostream& os, const SbBox3i32& b);
00343
00347 friend int operator ==(const SbBox3i32 &b1, const SbBox3i32 &b2);
00348
00352 friend int operator !=(const SbBox3i32 &b1, const SbBox3i32 &b2)
00353 { return !(b1 == b2); }
00354
00355 private:
00356
00357 SbVec3i32 m_min, m_max;
00358 };
00359
00383 class SbBox3s {
00384
00385 public:
00389 SbBox3s()
00390 { makeEmpty(); }
00391
00396 SbBox3s(short xmin, short ymin, short zmin,
00397 short xmax, short ymax, short zmax)
00398 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00399
00404 SbBox3s(const SbVec3s &_min, const SbVec3s &_max)
00405 { m_min = _min; m_max = _max; }
00406
00411 SbBox3s(const SbBox3i32 &box);
00412
00416 ~SbBox3s()
00417 {}
00418
00424 const SbVec3s &getMin() const
00425 { return m_min; }
00426
00432 const SbVec3s &getMax() const
00433 { return m_max; }
00434
00439 SbVec3s &getMin()
00440 { return m_min; }
00441
00446 SbVec3s &getMax()
00447 { return m_max; }
00448
00452 SbVec3f getCenter() const;
00453
00457 void extendBy(const SbVec3f &pt);
00458
00462 void extendBy(const SbBox3s &bb);
00463
00467 SbBool intersect(const SbVec3f &pt) const;
00468
00472 SbBool intersect(const SbBox3s &bb) const;
00473
00478 SbBox3s intersection(const SbBox3s& box) const;
00479
00484 inline SbBool contains(const SbBox3s &bb) const
00485 {
00486 SbBool contained = true;
00487 for( int i = 0; i < 3 && contained; i++ )
00488 {
00489 contained &= bb.m_min[i] >= m_min[i] &&
00490 bb.m_min[i] <= m_max[i] &&
00491 bb.m_max[i] <= m_max[i];
00492 }
00493
00494 return contained;
00495 }
00496
00510 SbBool outside(const SbMatrix &MVP, int &cullBits) const;
00511
00515 void setBounds(short xmin, short ymin, short zmin,
00516 short xmax, short ymax, short zmax)
00517 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00518
00522 void setBounds(const SbVec3s &_min, const SbVec3s &_max)
00523 { m_min = _min; m_max = _max; }
00524
00528 void getBounds(short &xmin, short &ymin, short &zmin,
00529 short &xmax, short &ymax, short &zmax) const
00530 { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
00531
00536 void getBounds(SbVec3s &_min, SbVec3s &_max) const
00537 { _min = m_min; _max = m_max; }
00538
00543 SbVec3f getClosestPoint(const SbVec3f &point) const;
00544
00548 void getOrigin(short &originX, short &originY, short &originZ) const
00549 { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
00550
00554 void getSize(short &sizeX, short &sizeY, short &sizeZ) const {
00555 if ( m_max[0] < m_min[0] ) {
00556 sizeX = 0;
00557 sizeY = 0;
00558 sizeZ = 0;
00559 }
00560 else {
00561 sizeX = m_max[0] - m_min[0];
00562 sizeY = m_max[1] - m_min[1];
00563 sizeZ = m_max[2] - m_min[2];
00564 }
00565 }
00566
00570 void makeEmpty();
00571
00575 SbBool isEmpty() const
00576 { return m_max[0] < m_min[0]; }
00577
00582 SbBool hasVolume() const
00583 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2]); }
00584
00592 void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
00593
00597 void transform(const SbMatrix &m);
00598
00602 float getVolume() const;
00603
00608 SbBox3s operator = (const SbBox3i32 &box);
00609
00613 friend int operator ==(const SbBox3s &b1, const SbBox3s &b2);
00614
00618 friend int operator !=(const SbBox3s &b1, const SbBox3s &b2)
00619 { return !(b1 == b2); }
00620
00621 private:
00622
00623 SbVec3s m_min, m_max;
00624 };
00625
00649 class SbBox3f {
00650
00651 public:
00655 SbBox3f()
00656 { makeEmpty(); }
00657
00662 SbBox3f(float xmin, float ymin, float zmin,
00663 float xmax, float ymax, float zmax)
00664 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00665
00670 SbBox3f(const SbVec3f &_min, const SbVec3f &_max)
00671 { m_min = _min; m_max = _max; }
00672
00676 ~SbBox3f()
00677 {}
00678
00684 inline const SbVec3f & getMin() const
00685 { return m_min; }
00686
00691 inline SbVec3f &getMin()
00692 { return m_min; }
00693
00699 inline const SbVec3f & getMax() const
00700 { return m_max; }
00701
00706 inline SbVec3f &getMax()
00707 { return m_max; }
00708
00712 SbVec3f getCenter() const;
00713
00717 inline void extendBy(const SbVec3f &pt)
00718 {
00719 if (pt[0] < m_min[0]) m_min[0] = pt[0];
00720 if (pt[1] < m_min[1]) m_min[1] = pt[1];
00721 if (pt[2] < m_min[2]) m_min[2] = pt[2];
00722 if (pt[0] > m_max[0]) m_max[0] = pt[0];
00723 if (pt[1] > m_max[1]) m_max[1] = pt[1];
00724 if (pt[2] > m_max[2]) m_max[2] = pt[2];
00725 }
00726
00730 void extendBy(const SbBox3f &bb);
00731
00735 SbBool intersect(const SbVec3f &pt) const;
00736
00740 inline SbBool intersect(const SbBox3f &bb) const
00741 {
00742 return ((bb.m_max[0] >= m_min[0]) && (bb.m_min[0] <= m_max[0]) &&
00743 (bb.m_max[1] >= m_min[1]) && (bb.m_min[1] <= m_max[1]) &&
00744 (bb.m_max[2] >= m_min[2]) && (bb.m_min[2] <= m_max[2]));
00745 }
00746
00751 SbBox3f intersection(const SbBox3f& box) const;
00752
00757 inline SbBool contains(const SbBox3f &bb) const
00758 {
00759 SbBool contained = true;
00760 for( int i = 0; i < 3 && contained; i++ )
00761 {
00762 contained &= bb.m_min[i] >= m_min[i] &&
00763 bb.m_min[i] <= m_max[i] &&
00764 bb.m_max[i] <= m_max[i];
00765 }
00766
00767 return contained;
00768 }
00769
00770
00784 SbBool outside(const SbMatrix &MVP, int &cullBits) const;
00785
00789 void setBounds(float xmin, float ymin, float zmin,
00790 float xmax, float ymax, float zmax)
00791 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00792
00796 void setBounds(const SbVec3f &_min, const SbVec3f &_max)
00797 { m_min = _min; m_max = _max; }
00798
00802 void getBounds(float &xmin, float &ymin, float &zmin,
00803 float &xmax, float &ymax, float &zmax) const
00804 { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
00805
00810 void getBounds(SbVec3f &_min, SbVec3f &_max) const
00811 { _min = m_min; _max = m_max; }
00812
00817 SbVec3f getClosestPoint(const SbVec3f &point) const;
00818
00822 void getOrigin(float &originX, float &originY, float &originZ) const
00823 { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
00824
00829 void getSize(float &sizeX, float &sizeY, float &sizeZ) const {
00830 if ( m_max[0] < m_min[0] ) {
00831 sizeX = 0.0f;
00832 sizeY = 0.0f;
00833 sizeZ = 0.0f;
00834 }
00835 else {
00836 sizeX = m_max[0] - m_min[0];
00837 sizeY = m_max[1] - m_min[1];
00838 sizeZ = m_max[2] - m_min[2];
00839 }
00840 }
00841
00845 SbVec3f getSize() const
00846 {
00847 if ( m_max[0] < m_min[0] )
00848 return SbVec3f(0, 0, 0);
00849
00850 return m_max-m_min;
00851 }
00852
00856 inline void makeEmpty()
00857 {
00858 m_min.setValue(FLT_MAX, FLT_MAX, FLT_MAX);
00859 m_max.setValue(- FLT_MAX, - FLT_MAX, - FLT_MAX);
00860 }
00861
00865 inline SbBool isEmpty() const
00866 { return m_max[0] < m_min[0]; }
00867
00872 SbBool hasVolume() const
00873 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2] ); }
00874
00882 void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
00883
00887 void transform(const SbMatrix &m);
00888
00892 float getVolume() const;
00893
00897 friend int operator ==(const SbBox3f &b1, const SbBox3f &b2);
00898
00902 friend int operator !=(const SbBox3f &b1, const SbBox3f &b2)
00903 { return !(b1 == b2); }
00904
00908 friend inline std::ostream& operator << (std::ostream& os, const SbBox3f& b);
00909
00913 template<typename T>
00914 explicit SbBox3f(const T& b)
00915 {
00916 m_min = SbVec3f(b.getMin());
00917 m_max = SbVec3f(b.getMax());
00918 }
00919
00923 float computeMaxDistance2(const SbVec3f& p) const;
00924
00931 SbBool triangleBoxOverlap(const SbVec3f& u0, const SbVec3f& u1, const SbVec3f& u2) const;
00932
00933 private:
00934
00938 SbBool lineSegmentBoxOverlap(const SbVec3f& u0, const SbVec3f& u1) const;
00939
00940 private:
00941
00942 SbVec3f m_min, m_max;
00943 };
00944
00945
00946
00947
00948
00972 class SbBox3d {
00973
00974 public:
00978 SbBox3d()
00979 { makeEmpty(); }
00980
00985 SbBox3d(double xmin, double ymin, double zmin,
00986 double xmax, double ymax, double zmax)
00987 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00988
00993 SbBox3d(const SbVec3d &_min, const SbVec3d &_max)
00994 { m_min = _min; m_max = _max; }
00995
00999 ~SbBox3d()
01000 {}
01001
01007 const SbVec3d & getMin() const
01008 { return m_min; }
01009
01015 const SbVec3d & getMax() const
01016 { return m_max; }
01017
01022 SbVec3d &getMin()
01023 { return m_min; }
01024
01029 SbVec3d &getMax()
01030 { return m_max; }
01031
01035 SbVec3d getCenter() const;
01036
01040 void extendBy(const SbVec3d &pt);
01041
01045 void extendBy(const SbBox3d &bb);
01046
01050 SbBool intersect(const SbVec3d &pt) const;
01051
01055 SbBool intersect(const SbBox3d &bb) const;
01056
01061 SbBox3d intersection(const SbBox3d& box) const;
01062
01067 inline SbBool contains(const SbBox3d &bb) const
01068 {
01069 SbBool contained = true;
01070 for( int i = 0; i < 3 && contained; i++ )
01071 {
01072 contained &= bb.m_min[i] >= m_min[i] &&
01073 bb.m_min[i] <= m_max[i] &&
01074 bb.m_max[i] <= m_max[i];
01075 }
01076
01077 return contained;
01078 }
01079
01093 SbBool outside(const SbMatrixd &MVP, int &cullBits) const;
01094
01098 void setBounds(double xmin, double ymin, double zmin,
01099 double xmax, double ymax, double zmax)
01100 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
01101
01105 void setBounds(const SbVec3d &_min, const SbVec3d &_max)
01106 { m_min = _min; m_max = _max; }
01107
01111 void getBounds(double &xmin, double &ymin, double &zmin,
01112 double &xmax, double &ymax, double &zmax) const
01113 { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
01114
01119 void getBounds(SbVec3d &_min, SbVec3d &_max) const
01120 { _min = m_min; _max = m_max; }
01121
01126 SbVec3d getClosestPoint(const SbVec3d &point) const;
01127
01131 void getOrigin(double &originX, double &originY, double &originZ) const
01132 { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
01133
01137 void getSize(double &sizeX, double &sizeY, double &sizeZ) const {
01138 if ( m_max[0] < m_min[0] ) {
01139 sizeX = 0.0;
01140 sizeY = 0.0;
01141 sizeZ = 0.0;
01142 }
01143 else {
01144 sizeX = m_max[0] - m_min[0];
01145 sizeY = m_max[1] - m_min[1];
01146 sizeZ = m_max[2] - m_min[2];
01147 }
01148 }
01149
01154 SbVec3d getSize() const
01155 {
01156 if ( m_max[0] < m_min[0] )
01157 return SbVec3d(0, 0, 0);
01158
01159 return m_max-m_min;
01160 }
01161
01165 void makeEmpty();
01166
01170 SbBool isEmpty() const
01171 { return m_max[0] < m_min[0]; }
01172
01177 SbBool hasVolume() const
01178 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2] ); }
01179
01187 void getSpan(const SbVec3d &direction, double &dMin, double &dMax) const;
01188
01192 void transform(const SbMatrixd &m);
01193
01197 double getVolume() const;
01198
01202 friend int operator ==(const SbBox3d &b1, const SbBox3d &b2);
01203
01207 friend int operator !=(const SbBox3d &b1, const SbBox3d &b2)
01208 { return !(b1 == b2); }
01209
01213 template<typename T>
01214 explicit SbBox3d(const T& b)
01215 {
01216 m_min = SbVec3d(b.getMin());
01217 m_max = SbVec3d(b.getMax());
01218 }
01219
01220 private:
01221
01222 SbVec3d m_min, m_max;
01223 };
01224
01250 class SbXfBox3f : public SbBox3f {
01251
01252 public:
01256 SbXfBox3f();
01257
01261 SbXfBox3f(const SbVec3f &_min, const SbVec3f &_max);
01262
01266 SbXfBox3f(const SbBox3f &box);
01267
01271 ~SbXfBox3f()
01272 {}
01273
01277 void setTransform(const SbMatrix &m);
01278
01282 const SbMatrix & getTransform() const
01283 { return xform; }
01284
01288 const SbMatrix & getInverse( ) const
01289 { return xformInv; }
01290
01294 SbVec3f getCenter() const;
01295
01334 void extendBy(const SbVec3f &pt);
01335
01341 void extendBy(const SbBox3f &bb)
01342 { extendBy(SbXfBox3f(bb)); }
01343
01347 void extendBy(const SbXfBox3f &bb);
01348
01352 SbBool intersect(const SbVec3f &pt) const;
01353
01357 SbBool intersect(const SbBox3f &bb) const
01358 { return project().intersect(bb); }
01359
01363 SbXfBox3f &setValue(const SbXfBox3d &xfbox3d);
01364
01368 void setBounds(float xmin, float ymin, float zmin,
01369 float xmax, float ymax, float zmax)
01370 { SbBox3f::setBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01371
01375 void setBounds(const SbVec3f &_min, const SbVec3f &_max)
01376 { SbBox3f::setBounds(_min, _max); }
01377
01381 void getBounds(float &xmin, float &ymin, float &zmin,
01382 float &xmax, float &ymax, float &zmax) const
01383 { SbBox3f::getBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01384
01389 void getBounds(SbVec3f &_min, SbVec3f &_max) const
01390 { SbBox3f::getBounds(_min, _max); }
01391
01395 void getOrigin(float &originX, float &originY, float &originZ)
01396 { SbBox3f::getOrigin(originX, originY, originZ); }
01397
01402 void getSize(float &sizeX, float &sizeY, float &sizeZ)
01403 { SbBox3f::getSize(sizeX, sizeY, sizeZ); }
01404
01408 float getVolume() const;
01409
01413 void makeEmpty() { SbBox3f::makeEmpty(); }
01414
01418 SbBool isEmpty() const { return SbBox3f::isEmpty(); }
01419
01423 SbBool hasVolume() const { return SbBox3f::hasVolume(); }
01424
01428 void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const
01429 { project().getSpan(direction, dMin, dMax); }
01430
01434 void transform(const SbMatrix &m);
01435
01439 SbBox3f project() const;
01440
01444 friend int operator ==(const SbXfBox3f &b1, const SbXfBox3f &b2);
01445
01449 friend int operator !=(const SbXfBox3f &b1, const SbXfBox3f &b2)
01450 { return !(b1 == b2); }
01451
01452
01453 private:
01457 inline bool isXFormDegenerate() const
01458 {
01459
01460 return xformInv[0][0] != xformInv[0][0];
01461 }
01462
01463
01464 private:
01465
01466 const SbVec3f &getMin() const
01467 { return SbBox3f::getMin(); }
01468
01469 const SbVec3f &getMax() const
01470 { return SbBox3f::getMax(); }
01471
01472
01473 SbMatrix xform;
01474 SbMatrix xformInv;
01475 };
01476
01502 class SbXfBox3d : public SbBox3d {
01503
01504 public:
01508 SbXfBox3d();
01509
01513 SbXfBox3d(const SbVec3d &_min, const SbVec3d &_max);
01514
01518 SbXfBox3d(const SbBox3d &box);
01519
01523 ~SbXfBox3d()
01524 {}
01525
01529 void setTransform(const SbMatrixd &m);
01530
01534 const SbMatrixd & getTransform() const
01535 { return xform; }
01536
01540 const SbMatrixd & getInverse( ) const
01541 { return xformInv; }
01542
01546 SbVec3d getCenter() const;
01547
01586 void extendBy(const SbVec3d &pt);
01587
01591 void extendBy(const SbBox3d &bb)
01592 { extendBy(SbXfBox3d(bb)); }
01593
01597 void extendBy(const SbXfBox3d &bb);
01598
01602 SbBool intersect(const SbVec3d &pt) const;
01603
01607 SbBool intersect(const SbBox3d &bb) const
01608 { return project().intersect(bb); }
01609
01613 SbXfBox3d &setValue(const SbXfBox3f &xfbox3f);
01614
01618 void setBounds(double xmin, double ymin, double zmin,
01619 double xmax, double ymax, double zmax)
01620 { SbBox3d::setBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01621
01625 void setBounds(const SbVec3d &_min, const SbVec3d &_max)
01626 { SbBox3d::setBounds(_min, _max); }
01627
01631 void getBounds(double &xmin, double &ymin, double &zmin,
01632 double &xmax, double &ymax, double &zmax) const
01633 { SbBox3d::getBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01634
01639 void getBounds(SbVec3d &_min, SbVec3d &_max) const
01640 { SbBox3d::getBounds(_min, _max); }
01641
01645 void getOrigin(double &originX, double &originY, double &originZ) const
01646 { SbBox3d::getOrigin(originX, originY, originZ); }
01647
01651 void getSize(double &sizeX, double &sizeY, double &sizeZ) const
01652 { SbBox3d::getSize(sizeX, sizeY, sizeZ); }
01653
01657 double getVolume() const;
01658
01662 void makeEmpty() { SbBox3d::makeEmpty(); }
01663
01667 SbBool isEmpty() const { return SbBox3d::isEmpty(); }
01668
01672 SbBool hasVolume() const { return SbBox3d::hasVolume(); }
01673
01677 void getSpan(const SbVec3d &direction, double &dMin, double &dMax) const
01678 { project().getSpan(direction, dMin, dMax); }
01679
01683 void transform(const SbMatrixd &m);
01684
01688 SbBox3d project() const;
01689
01693 friend int operator ==(const SbXfBox3d &b1, const SbXfBox3d &b2);
01694
01698 friend int operator !=(const SbXfBox3d &b1, const SbXfBox3d &b2)
01699 { return !(b1 == b2); }
01700
01701 private:
01705 inline bool isXFormDegenerate() const
01706 {
01707
01708 return xformInv[0][0] != xformInv[0][0];
01709 }
01710
01711 private:
01712
01713 const SbVec3d & getMin() const
01714 { return SbBox3d::getMin(); }
01715
01716 const SbVec3d & getMax() const
01717 { return SbBox3d::getMax(); }
01718
01719
01720 SbMatrixd xform;
01721 SbMatrixd xformInv;
01722 };
01723
01724
01725 inline SbXfBox3f &SbXfBox3f::setValue(const SbXfBox3d& xfbox3d)
01726 {
01727
01728 SbMatrixd dtrans = xfbox3d.getTransform();
01729 SbMatrix ftrans;
01730 ftrans.setValue(dtrans);
01731 setTransform(ftrans);
01732
01733
01734 SbVec3d dmin,dmax;
01735 xfbox3d.getBounds(dmin,dmax);
01736 SbVec3f _min,_max;
01737 _min.setValue(dmin);
01738 _max.setValue(dmax);
01739 setBounds((_min),(_max));
01740
01741 return (*this);
01742 }
01743
01744
01745 inline SbXfBox3d &SbXfBox3d::setValue(const SbXfBox3f& xfbox3f)
01746 {
01747
01748 SbMatrix ftrans = xfbox3f.getTransform();
01749 SbMatrixd dtrans;
01750 dtrans.setValue(ftrans);
01751 setTransform(dtrans);
01752
01753
01754 SbVec3f fmin,fmax;
01755 xfbox3f.getBounds(fmin,fmax);
01756 SbVec3d _min,_max;
01757 _min.setValue(fmin);
01758 _max.setValue(fmax);
01759 setBounds((_min),(_max));
01760
01761 return (*this);
01762 }
01763
01764
01787 class SbBox2f {
01788
01789 public:
01793 SbBox2f()
01794 { makeEmpty(); };
01795
01800 SbBox2f(float xmin, float ymin, float xmax, float ymax)
01801 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
01802
01807 SbBox2f(const SbVec2f &_min, const SbVec2f &_max)
01808 { m_min = _min; m_max = _max; }
01809
01813 ~SbBox2f()
01814 {}
01815
01819 const SbVec2f & getMin() const
01820 { return m_min; }
01821
01825 const SbVec2f & getMax() const
01826 { return m_max; }
01827
01831 SbVec2f getCenter() const;
01832
01836 void extendBy(const SbVec2f &pt);
01837
01841 void extendBy(const SbBox2f &r);
01842
01846 SbBool intersect(const SbVec2f &pt) const;
01847
01851 SbBool intersect(const SbBox2f &bb) const;
01852
01857 SbBox2f intersection(const SbBox2f& box) const;
01858
01862 void setBounds(float xmin, float ymin, float xmax, float ymax)
01863 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
01864
01868 void setBounds(const SbVec2f &_min, const SbVec2f &_max)
01869 { m_min = _min; m_max = _max; }
01870
01874 void getBounds(float &xmin, float &ymin,
01875 float &xmax, float &ymax) const
01876 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
01877
01882 void getBounds(SbVec2f &_min, SbVec2f &_max) const
01883 { _min = m_min; _max = m_max; }
01884
01889 SbVec2f getClosestPoint(const SbVec2f &point) const;
01890
01894 void getOrigin(float &originX, float &originY) const
01895 { originX = m_min[0]; originY = m_min[1]; }
01896
01900 void getSize(float &sizeX, float &sizeY) const
01901 {
01902 if ( m_max[0] < m_min[0] ) {
01903 sizeX = 0.0f;
01904 sizeY = 0.0f;
01905 }
01906 else {
01907 sizeX = m_max[0] - m_min[0];
01908 sizeY = m_max[1] - m_min[1];
01909 }
01910 }
01911
01916 SbVec2f getSize() const
01917 {
01918 if ( m_max[0] < m_min[0] )
01919 return SbVec2f(0, 0);
01920
01921 return m_max-m_min;
01922 }
01923
01927 float getAspectRatio() const
01928 { return (m_max[0] - m_min[0]) / (m_max[1] - m_min[1]); }
01929
01933 void makeEmpty();
01934
01938 SbBool isEmpty() const { return m_max[0] < m_min[0]; }
01939
01944 SbBool hasArea() const
01945 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
01946
01950 friend int operator ==(const SbBox2f &b1, const SbBox2f &b2);
01951
01955 friend int operator !=(const SbBox2f &b1, const SbBox2f &b2)
01956 { return !(b1 == b2); }
01957
01958 private:
01959
01960 SbVec2f m_min, m_max;
01961 };
01962
01985 class SbBox2d {
01986
01987 public:
01991 SbBox2d()
01992 { makeEmpty(); };
01993
01998 SbBox2d(double xmin, double ymin, double xmax, double ymax)
01999 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02000
02005 SbBox2d(const SbVec2d &_min, const SbVec2d &_max)
02006 { m_min = _min; m_max = _max; }
02007
02011 ~SbBox2d()
02012 {}
02013
02017 const SbVec2d & getMin() const
02018 { return m_min; }
02019
02023 const SbVec2d & getMax() const
02024 { return m_max; }
02025
02029 SbVec2d getCenter() const;
02030
02034 void extendBy(const SbVec2d &pt);
02035
02039 void extendBy(const SbBox2d &r);
02040
02044 SbBool intersect(const SbVec2d &pt) const;
02045
02049 SbBool intersect(const SbBox2d &bb) const;
02050
02055 SbBox2d intersection(const SbBox2d& box) const;
02056
02060 void setBounds(double xmin, double ymin, double xmax, double ymax)
02061 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02062
02066 void setBounds(const SbVec2d &_min, const SbVec2d &_max)
02067 { m_min = _min; m_max = _max; }
02068
02072 void getBounds(double &xmin, double &ymin,
02073 double &xmax, double &ymax) const
02074 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
02075
02080 void getBounds(SbVec2d &_min, SbVec2d &_max) const
02081 { _min = m_min; _max = m_max; }
02082
02087 SbVec2d getClosestPoint(const SbVec2d &point) const;
02088
02092 void getOrigin(double &originX, double &originY) const
02093 { originX = m_min[0]; originY = m_min[1]; }
02094
02098 void getSize(double &sizeX, double &sizeY) const
02099 {
02100 if ( m_max[0] < m_min[0] ) {
02101 sizeX = 0.0;
02102 sizeY = 0.0;
02103 }
02104 else {
02105 sizeX = m_max[0] - m_min[0];
02106 sizeY = m_max[1] - m_min[1];
02107 }
02108 }
02109
02114 SbVec2d getSize() const
02115 {
02116 if ( m_max[0] < m_min[0] )
02117 return SbVec2d(0, 0);
02118
02119 return m_max-m_min;
02120 }
02121
02125 double getAspectRatio() const
02126 { return (m_max[0] - m_min[0]) / (m_max[1] - m_min[1]); }
02127
02131 void makeEmpty();
02132
02136 SbBool isEmpty() const { return m_max[0] < m_min[0]; }
02137
02142 SbBool hasArea() const
02143 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
02144
02148 friend int operator ==(const SbBox2d &b1, const SbBox2d &b2);
02149
02153 friend int operator !=(const SbBox2d &b1, const SbBox2d &b2)
02154 { return !(b1 == b2); }
02155
02156 private:
02157
02158 SbVec2d m_min, m_max;
02159 };
02160
02183 class SbBox2s {
02184
02185 public:
02189 SbBox2s()
02190 { makeEmpty(); };
02191
02196 SbBox2s(short xmin, short ymin, short xmax, short ymax)
02197 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02198
02203 SbBox2s(const SbVec2s &_min, const SbVec2s &_max)
02204 { m_min = _min; m_max = _max; }
02205
02209 ~SbBox2s()
02210 {}
02211
02215 const SbVec2s & getMin() const
02216 { return m_min; }
02217
02221 const SbVec2s & getMax() const
02222 { return m_max; }
02223
02227 void extendBy(const SbVec2s &pt);
02228
02232 void extendBy(const SbBox2s &r);
02233
02237 SbBool intersect(const SbVec2s &pt) const;
02238
02242 SbBool intersect(const SbBox2s &bb) const;
02243
02248 SbBox2s intersection(const SbBox2s& box) const;
02249
02253 void setBounds(short xmin, short ymin, short xmax, short ymax)
02254 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02255
02259 void setBounds(const SbVec2s &_min, const SbVec2s &_max)
02260 { m_min = _min; m_max = _max; }
02261
02265 void getBounds(short &xmin, short &ymin,
02266 short &xmax, short &ymax) const
02267 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
02268
02273 void getBounds(SbVec2s &_min, SbVec2s &_max) const
02274 { _min = m_min; _max = m_max; }
02275
02279 void getOrigin(short &originX, short &originY) const
02280 { originX = m_min[0]; originY = m_min[1]; }
02281
02285 void getSize(short &sizeX, short &sizeY) const
02286 {
02287 if ( m_max[0] < m_min[0] ) {
02288 sizeX = 0;
02289 sizeY = 0;
02290 }
02291 else {
02292 sizeX = m_max[0] - m_min[0];
02293 sizeY = m_max[1] - m_min[1];
02294 }
02295 }
02296
02301 SbVec2s getSize() const
02302 {
02303 if ( m_max[0] < m_min[0] )
02304 return SbVec2s(0, 0);
02305
02306 return m_max-m_min;
02307 }
02308
02312 float getAspectRatio() const
02313 { return float(m_max[0] - m_min[0]) / float(m_max[1] - m_min[1]); }
02314
02318 void makeEmpty();
02319
02323 SbBool isEmpty() const { return m_max[0] < m_min[0]; }
02324
02329 SbBool hasArea() const
02330 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
02331
02332
02336 friend int operator ==(const SbBox2s &b1, const SbBox2s &b2);
02337
02341 friend int operator !=(const SbBox2s &b1, const SbBox2s &b2)
02342 { return !(b1 == b2); }
02343
02344 private:
02345
02346 SbVec2s m_min, m_max;
02347 };
02348
02372 class SbBox2i32 {
02373
02374 public:
02378 SbBox2i32()
02379 { makeEmpty(); };
02380
02385 SbBox2i32(int xmin, int ymin, int xmax, int ymax)
02386 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02387
02392 SbBox2i32(const SbVec2i32 &_min, const SbVec2i32 &_max)
02393 { m_min = _min; m_max = _max; }
02394
02398 ~SbBox2i32()
02399 {}
02400
02404 const SbVec2i32 & getMin() const
02405 { return m_min; }
02406
02410 const SbVec2i32 & getMax() const
02411 { return m_max; }
02412
02416 void extendBy(const SbVec2i32 &pt);
02417
02421 void extendBy(const SbBox2i32 &r);
02422
02426 SbBool intersect(const SbVec2i32 &pt) const;
02427
02431 SbBool intersect(const SbBox2i32 &bb) const;
02432
02437 SbBox2i32 intersection(const SbBox2i32& box) const;
02438
02442 void setBounds(int xmin, int ymin, int xmax, int ymax)
02443 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02444
02448 void setBounds(const SbVec2i32 &_min, const SbVec2i32 &_max)
02449 { m_min = _min; m_max = _max; }
02450
02454 void getBounds(int &xmin, int &ymin,
02455 int &xmax, int &ymax) const
02456 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
02457
02462 void getBounds(SbVec2i32 &_min, SbVec2i32 &_max) const
02463 { _min = m_min; _max = m_max; }
02464
02468 void getOrigin(int &originX, int &originY) const
02469 { originX = m_min[0]; originY = m_min[1]; }
02470
02474 void getSize(int &sizeX, int &sizeY) const
02475 {
02476 if ( m_max[0] < m_min[0] ) {
02477 sizeX = 0;
02478 sizeY = 0;
02479 }
02480 else {
02481 sizeX = m_max[0] - m_min[0];
02482 sizeY = m_max[1] - m_min[1];
02483 }
02484 }
02485
02490 SbVec2i32 getSize() const
02491 {
02492 if ( m_max[0] < m_min[0] )
02493 return SbVec2i32(0, 0);
02494
02495 return m_max-m_min;
02496 }
02497
02501 float getAspectRatio() const
02502 { return float(m_max[0] - m_min[0]) / float(m_max[1] - m_min[1]); }
02503
02507 void makeEmpty();
02508
02512 friend int operator ==(const SbBox2i32 &b1, const SbBox2i32 &b2);
02513
02517 friend int operator !=(const SbBox2i32 &b1, const SbBox2i32 &b2)
02518 { return !(b1 == b2); }
02519
02520 private:
02521
02522 SbVec2i32 m_min, m_max;
02523 };
02524
02528 inline std::ostream& operator << (std::ostream& os, const SbBox3f& b)
02529 {
02530 return os << b.getMin() << " - " << b.getMax();
02531 }
02532
02536 inline std::ostream& operator << (std::ostream& os, const SbBox3i32& b)
02537 {
02538 return os << b.getMin() << " - " << b.getMax();
02539 }
02540
02544 inline std::ostream& operator << (std::ostream& os, const SbBox2f& b)
02545 {
02546 return os << b.getMin() << " - " << b.getMax();
02547 }
02548
02575 class SbBox4i32 {
02576
02577 public:
02581 SbBox4i32()
02582 {
02583 makeEmpty();
02584 }
02585
02590 SbBox4i32(const SbVec4i32 &_min, const SbVec4i32 &_max)
02591 { m_min = _min; m_max = _max; }
02592
02596 ~SbBox4i32()
02597 {}
02598
02604 const SbVec4i32 &getMin() const
02605 { return m_min; }
02606
02612 const SbVec4i32 &getMax() const
02613 { return m_max; }
02614
02619 SbVec4i32 &getMin()
02620 { return m_min; }
02621
02626 SbVec4i32 &getMax()
02627 { return m_max; }
02628
02632 void extendBy(const SbVec4i32 &pt)
02633 {
02634 for ( int i = 0; i < 4; i++ )
02635 {
02636 if (pt[i] < m_min[i])
02637 m_min[i] = pt[i];
02638 if (pt[i] > m_max[i])
02639 m_max[i] = pt[i];
02640 }
02641 }
02642
02646 SbBool intersect(const SbVec4i32 &pt) const
02647 {
02648 return ((pt[0] >= m_min[0]) &&
02649 (pt[1] >= m_min[1]) &&
02650 (pt[2] >= m_min[2]) &&
02651 (pt[3] >= m_min[3]) &&
02652 (pt[0] <= m_max[0]) &&
02653 (pt[1] <= m_max[1]) &&
02654 (pt[2] <= m_max[2]) &&
02655 (pt[3] <= m_max[3]));
02656 }
02657
02661 SbVec4i32 getSize() const
02662 {
02663 if ( m_max[0] < m_min[0] )
02664 return SbVec4i32(0, 0, 0, 0);
02665
02666 return m_max-m_min + SbVec4i32(1, 1, 1, 1);
02667 }
02668
02672 void makeEmpty();
02673
02677 SbBool isEmpty() const
02678 { return m_max[0] < m_min[0]; }
02679
02683 friend inline std::ostream& operator << (std::ostream& os, const SbBox4i32& b)
02684 {
02685 return os << b.getMin() << " - " << b.getMax();
02686 }
02687
02691 friend int operator ==(const SbBox4i32 &b1, const SbBox4i32 &b2)
02692 {
02693 return ( (b1.m_min == b2.m_min) && (b1.m_max == b2.m_max ) );
02694 }
02695
02699 friend int operator !=(const SbBox4i32 &b1, const SbBox4i32 &b2)
02700 { return !(b1 == b2); }
02701
02702 private:
02703
02704 SbVec4i32 m_min, m_max;
02705 };
02706
02707 #endif
02708
02709
02710