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
00384 class SbBox3s {
00385
00386 public:
00390 SbBox3s()
00391 { makeEmpty(); }
00392
00397 SbBox3s(short xmin, short ymin, short zmin,
00398 short xmax, short ymax, short zmax)
00399 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00400
00405 SbBox3s(const SbVec3s &_min, const SbVec3s &_max)
00406 { m_min = _min; m_max = _max; }
00407
00412 SbBox3s(const SbBox3i32 &box);
00413
00417 ~SbBox3s()
00418 {}
00419
00425 const SbVec3s &getMin() const
00426 { return m_min; }
00427
00433 const SbVec3s &getMax() const
00434 { return m_max; }
00435
00440 SbVec3s &getMin()
00441 { return m_min; }
00442
00447 SbVec3s &getMax()
00448 { return m_max; }
00449
00453 SbVec3f getCenter() const;
00454
00458 void extendBy(const SbVec3f &pt);
00459
00463 void extendBy(const SbBox3s &bb);
00464
00468 SbBool intersect(const SbVec3f &pt) const;
00469
00473 SbBool intersect(const SbBox3s &bb) const;
00474
00479 SbBox3s intersection(const SbBox3s& box) const;
00480
00485 inline SbBool contains(const SbBox3s &bb) const
00486 {
00487 SbBool contained = true;
00488 for( int i = 0; i < 3 && contained; i++ )
00489 {
00490 contained &= bb.m_min[i] >= m_min[i] &&
00491 bb.m_min[i] <= m_max[i] &&
00492 bb.m_max[i] <= m_max[i];
00493 }
00494
00495 return contained;
00496 }
00497
00511 SbBool outside(const SbMatrix &MVP, int &cullBits) const;
00512
00516 void setBounds(short xmin, short ymin, short zmin,
00517 short xmax, short ymax, short zmax)
00518 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00519
00523 void setBounds(const SbVec3s &_min, const SbVec3s &_max)
00524 { m_min = _min; m_max = _max; }
00525
00529 void getBounds(short &xmin, short &ymin, short &zmin,
00530 short &xmax, short &ymax, short &zmax) const
00531 { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
00532
00537 void getBounds(SbVec3s &_min, SbVec3s &_max) const
00538 { _min = m_min; _max = m_max; }
00539
00544 SbVec3f getClosestPoint(const SbVec3f &point) const;
00545
00549 void getOrigin(short &originX, short &originY, short &originZ) const
00550 { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
00551
00555 void getSize(short &sizeX, short &sizeY, short &sizeZ) const {
00556 if ( m_max[0] < m_min[0] ) {
00557 sizeX = 0;
00558 sizeY = 0;
00559 sizeZ = 0;
00560 }
00561 else {
00562 sizeX = m_max[0] - m_min[0];
00563 sizeY = m_max[1] - m_min[1];
00564 sizeZ = m_max[2] - m_min[2];
00565 }
00566 }
00567
00571 void makeEmpty();
00572
00576 SbBool isEmpty() const
00577 { return m_max[0] < m_min[0]; }
00578
00583 SbBool hasVolume() const
00584 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2]); }
00585
00593 void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
00594
00598 void transform(const SbMatrix &m);
00599
00603 float getVolume() const;
00604
00609 SbBox3s operator = (const SbBox3i32 &box);
00610
00614 friend int operator ==(const SbBox3s &b1, const SbBox3s &b2);
00615
00619 friend int operator !=(const SbBox3s &b1, const SbBox3s &b2)
00620 { return !(b1 == b2); }
00621
00622 private:
00623
00624 SbVec3s m_min, m_max;
00625 };
00626
00651 class SbBox3f {
00652
00653 public:
00657 SbBox3f()
00658 { makeEmpty(); }
00659
00664 SbBox3f(float xmin, float ymin, float zmin,
00665 float xmax, float ymax, float zmax)
00666 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00667
00672 SbBox3f(const SbVec3f &_min, const SbVec3f &_max)
00673 { m_min = _min; m_max = _max; }
00674
00678 ~SbBox3f()
00679 {}
00680
00686 inline const SbVec3f & getMin() const
00687 { return m_min; }
00688
00693 inline SbVec3f &getMin()
00694 { return m_min; }
00695
00701 inline const SbVec3f & getMax() const
00702 { return m_max; }
00703
00708 inline SbVec3f &getMax()
00709 { return m_max; }
00710
00714 SbVec3f getCenter() const;
00715
00719 inline void extendBy(const SbVec3f &pt)
00720 {
00721 if (pt[0] < m_min[0]) m_min[0] = pt[0];
00722 if (pt[1] < m_min[1]) m_min[1] = pt[1];
00723 if (pt[2] < m_min[2]) m_min[2] = pt[2];
00724 if (pt[0] > m_max[0]) m_max[0] = pt[0];
00725 if (pt[1] > m_max[1]) m_max[1] = pt[1];
00726 if (pt[2] > m_max[2]) m_max[2] = pt[2];
00727 }
00728
00732 void extendBy(const SbBox3f &bb);
00733
00737 SbBool intersect(const SbVec3f &pt) const;
00738
00742 inline SbBool intersect(const SbBox3f &bb) const
00743 {
00744 return ((bb.m_max[0] >= m_min[0]) && (bb.m_min[0] <= m_max[0]) &&
00745 (bb.m_max[1] >= m_min[1]) && (bb.m_min[1] <= m_max[1]) &&
00746 (bb.m_max[2] >= m_min[2]) && (bb.m_min[2] <= m_max[2]));
00747 }
00748
00753 SbBox3f intersection(const SbBox3f& box) const;
00754
00759 inline SbBool contains(const SbBox3f &bb) const
00760 {
00761 SbBool contained = true;
00762 for( int i = 0; i < 3 && contained; i++ )
00763 {
00764 contained &= bb.m_min[i] >= m_min[i] &&
00765 bb.m_min[i] <= m_max[i] &&
00766 bb.m_max[i] <= m_max[i];
00767 }
00768
00769 return contained;
00770 }
00771
00772
00786 SbBool outside(const SbMatrix &MVP, int &cullBits) const;
00787
00791 void setBounds(float xmin, float ymin, float zmin,
00792 float xmax, float ymax, float zmax)
00793 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00794
00798 void setBounds(const SbVec3f &_min, const SbVec3f &_max)
00799 { m_min = _min; m_max = _max; }
00800
00804 void getBounds(float &xmin, float &ymin, float &zmin,
00805 float &xmax, float &ymax, float &zmax) const
00806 { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
00807
00812 void getBounds(SbVec3f &_min, SbVec3f &_max) const
00813 { _min = m_min; _max = m_max; }
00814
00819 SbVec3f getClosestPoint(const SbVec3f &point) const;
00820
00824 void getOrigin(float &originX, float &originY, float &originZ) const
00825 { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
00826
00831 void getSize(float &sizeX, float &sizeY, float &sizeZ) const {
00832 if ( m_max[0] < m_min[0] ) {
00833 sizeX = 0.0f;
00834 sizeY = 0.0f;
00835 sizeZ = 0.0f;
00836 }
00837 else {
00838 sizeX = m_max[0] - m_min[0];
00839 sizeY = m_max[1] - m_min[1];
00840 sizeZ = m_max[2] - m_min[2];
00841 }
00842 }
00843
00847 SbVec3f getSize() const
00848 {
00849 if ( m_max[0] < m_min[0] )
00850 return SbVec3f(0, 0, 0);
00851
00852 return m_max-m_min;
00853 }
00854
00858 inline void makeEmpty()
00859 {
00860 m_min.setValue(FLT_MAX, FLT_MAX, FLT_MAX);
00861 m_max.setValue(- FLT_MAX, - FLT_MAX, - FLT_MAX);
00862 }
00863
00867 inline SbBool isEmpty() const
00868 { return m_max[0] < m_min[0]; }
00869
00874 SbBool hasVolume() const
00875 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2] ); }
00876
00884 void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
00885
00889 void transform(const SbMatrix &m);
00890
00894 float getVolume() const;
00895
00899 friend int operator ==(const SbBox3f &b1, const SbBox3f &b2);
00900
00904 friend int operator !=(const SbBox3f &b1, const SbBox3f &b2)
00905 { return !(b1 == b2); }
00906
00910 friend inline std::ostream& operator << (std::ostream& os, const SbBox3f& b);
00911
00915 template<typename T>
00916 explicit SbBox3f(const T& b)
00917 {
00918 m_min = SbVec3f(b.getMin());
00919 m_max = SbVec3f(b.getMax());
00920 }
00921
00925 float computeMaxDistance2(const SbVec3f& p) const;
00926
00933 SbBool triangleBoxOverlap(const SbVec3f& u0, const SbVec3f& u1, const SbVec3f& u2) const;
00934
00935 private:
00936
00940 SbBool lineSegmentBoxOverlap(const SbVec3f& u0, const SbVec3f& u1) const;
00941
00942 private:
00943
00944 SbVec3f m_min, m_max;
00945 };
00946
00947
00948
00949
00950
00975 class SbBox3d {
00976
00977 public:
00981 SbBox3d()
00982 { makeEmpty(); }
00983
00988 SbBox3d(double xmin, double ymin, double zmin,
00989 double xmax, double ymax, double zmax)
00990 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
00991
00996 SbBox3d(const SbVec3d &_min, const SbVec3d &_max)
00997 { m_min = _min; m_max = _max; }
00998
01002 ~SbBox3d()
01003 {}
01004
01010 const SbVec3d & getMin() const
01011 { return m_min; }
01012
01018 const SbVec3d & getMax() const
01019 { return m_max; }
01020
01025 SbVec3d &getMin()
01026 { return m_min; }
01027
01032 SbVec3d &getMax()
01033 { return m_max; }
01034
01038 SbVec3d getCenter() const;
01039
01043 void extendBy(const SbVec3d &pt);
01044
01048 void extendBy(const SbBox3d &bb);
01049
01053 SbBool intersect(const SbVec3d &pt) const;
01054
01058 SbBool intersect(const SbBox3d &bb) const;
01059
01064 SbBox3d intersection(const SbBox3d& box) const;
01065
01070 inline SbBool contains(const SbBox3d &bb) const
01071 {
01072 SbBool contained = true;
01073 for( int i = 0; i < 3 && contained; i++ )
01074 {
01075 contained &= bb.m_min[i] >= m_min[i] &&
01076 bb.m_min[i] <= m_max[i] &&
01077 bb.m_max[i] <= m_max[i];
01078 }
01079
01080 return contained;
01081 }
01082
01096 SbBool outside(const SbMatrixd &MVP, int &cullBits) const;
01097
01101 void setBounds(double xmin, double ymin, double zmin,
01102 double xmax, double ymax, double zmax)
01103 { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
01104
01108 void setBounds(const SbVec3d &_min, const SbVec3d &_max)
01109 { m_min = _min; m_max = _max; }
01110
01114 void getBounds(double &xmin, double &ymin, double &zmin,
01115 double &xmax, double &ymax, double &zmax) const
01116 { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
01117
01122 void getBounds(SbVec3d &_min, SbVec3d &_max) const
01123 { _min = m_min; _max = m_max; }
01124
01129 SbVec3d getClosestPoint(const SbVec3d &point) const;
01130
01134 void getOrigin(double &originX, double &originY, double &originZ) const
01135 { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
01136
01140 void getSize(double &sizeX, double &sizeY, double &sizeZ) const {
01141 if ( m_max[0] < m_min[0] ) {
01142 sizeX = 0.0;
01143 sizeY = 0.0;
01144 sizeZ = 0.0;
01145 }
01146 else {
01147 sizeX = m_max[0] - m_min[0];
01148 sizeY = m_max[1] - m_min[1];
01149 sizeZ = m_max[2] - m_min[2];
01150 }
01151 }
01152
01157 SbVec3d getSize() const
01158 {
01159 if ( m_max[0] < m_min[0] )
01160 return SbVec3d(0, 0, 0);
01161
01162 return m_max-m_min;
01163 }
01164
01168 void makeEmpty();
01169
01173 SbBool isEmpty() const
01174 { return m_max[0] < m_min[0]; }
01175
01180 SbBool hasVolume() const
01181 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2] ); }
01182
01190 void getSpan(const SbVec3d &direction, double &dMin, double &dMax) const;
01191
01195 void transform(const SbMatrixd &m);
01196
01200 double getVolume() const;
01201
01205 friend int operator ==(const SbBox3d &b1, const SbBox3d &b2);
01206
01210 friend int operator !=(const SbBox3d &b1, const SbBox3d &b2)
01211 { return !(b1 == b2); }
01212
01216 template<typename T>
01217 explicit SbBox3d(const T& b)
01218 {
01219 m_min = SbVec3d(b.getMin());
01220 m_max = SbVec3d(b.getMax());
01221 }
01222
01223 private:
01224
01225 SbVec3d m_min, m_max;
01226 };
01227
01254 class SbXfBox3f : public SbBox3f {
01255
01256 public:
01260 SbXfBox3f();
01261
01265 SbXfBox3f(const SbVec3f &_min, const SbVec3f &_max);
01266
01270 SbXfBox3f(const SbBox3f &box);
01271
01275 ~SbXfBox3f()
01276 {}
01277
01281 void setTransform(const SbMatrix &m);
01282
01286 const SbMatrix & getTransform() const
01287 { return xform; }
01288
01292 const SbMatrix & getInverse( ) const
01293 { return xformInv; }
01294
01298 SbVec3f getCenter() const;
01299
01338 void extendBy(const SbVec3f &pt);
01339
01345 void extendBy(const SbBox3f &bb)
01346 { extendBy(SbXfBox3f(bb)); }
01347
01351 void extendBy(const SbXfBox3f &bb);
01352
01356 SbBool intersect(const SbVec3f &pt) const;
01357
01361 SbBool intersect(const SbBox3f &bb) const
01362 { return project().intersect(bb); }
01363
01367 SbXfBox3f &setValue(const SbXfBox3d &xfbox3d);
01368
01372 void setBounds(float xmin, float ymin, float zmin,
01373 float xmax, float ymax, float zmax)
01374 { SbBox3f::setBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01375
01379 void setBounds(const SbVec3f &_min, const SbVec3f &_max)
01380 { SbBox3f::setBounds(_min, _max); }
01381
01385 void getBounds(float &xmin, float &ymin, float &zmin,
01386 float &xmax, float &ymax, float &zmax) const
01387 { SbBox3f::getBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01388
01393 void getBounds(SbVec3f &_min, SbVec3f &_max) const
01394 { SbBox3f::getBounds(_min, _max); }
01395
01399 void getOrigin(float &originX, float &originY, float &originZ)
01400 { SbBox3f::getOrigin(originX, originY, originZ); }
01401
01406 void getSize(float &sizeX, float &sizeY, float &sizeZ)
01407 { SbBox3f::getSize(sizeX, sizeY, sizeZ); }
01408
01412 float getVolume() const;
01413
01417 void makeEmpty() { SbBox3f::makeEmpty(); }
01418
01422 SbBool isEmpty() const { return SbBox3f::isEmpty(); }
01423
01427 SbBool hasVolume() const { return SbBox3f::hasVolume(); }
01428
01432 void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const
01433 { project().getSpan(direction, dMin, dMax); }
01434
01438 void transform(const SbMatrix &m);
01439
01443 SbBox3f project() const;
01444
01448 friend int operator ==(const SbXfBox3f &b1, const SbXfBox3f &b2);
01449
01453 friend int operator !=(const SbXfBox3f &b1, const SbXfBox3f &b2)
01454 { return !(b1 == b2); }
01455
01456
01457 private:
01461 inline bool isXFormDegenerate() const
01462 {
01463
01464 return xformInv[0][0] != xformInv[0][0];
01465 }
01466
01467
01468 private:
01469
01470 const SbVec3f &getMin() const
01471 { return SbBox3f::getMin(); }
01472
01473 const SbVec3f &getMax() const
01474 { return SbBox3f::getMax(); }
01475
01476
01477 SbMatrix xform;
01478 SbMatrix xformInv;
01479 };
01480
01507 class SbXfBox3d : public SbBox3d {
01508
01509 public:
01513 SbXfBox3d();
01514
01518 SbXfBox3d(const SbVec3d &_min, const SbVec3d &_max);
01519
01523 SbXfBox3d(const SbBox3d &box);
01524
01528 ~SbXfBox3d()
01529 {}
01530
01534 void setTransform(const SbMatrixd &m);
01535
01539 const SbMatrixd & getTransform() const
01540 { return xform; }
01541
01545 const SbMatrixd & getInverse( ) const
01546 { return xformInv; }
01547
01551 SbVec3d getCenter() const;
01552
01591 void extendBy(const SbVec3d &pt);
01592
01596 void extendBy(const SbBox3d &bb)
01597 { extendBy(SbXfBox3d(bb)); }
01598
01602 void extendBy(const SbXfBox3d &bb);
01603
01607 SbBool intersect(const SbVec3d &pt) const;
01608
01612 SbBool intersect(const SbBox3d &bb) const
01613 { return project().intersect(bb); }
01614
01618 SbXfBox3d &setValue(const SbXfBox3f &xfbox3f);
01619
01623 void setBounds(double xmin, double ymin, double zmin,
01624 double xmax, double ymax, double zmax)
01625 { SbBox3d::setBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01626
01630 void setBounds(const SbVec3d &_min, const SbVec3d &_max)
01631 { SbBox3d::setBounds(_min, _max); }
01632
01636 void getBounds(double &xmin, double &ymin, double &zmin,
01637 double &xmax, double &ymax, double &zmax) const
01638 { SbBox3d::getBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
01639
01644 void getBounds(SbVec3d &_min, SbVec3d &_max) const
01645 { SbBox3d::getBounds(_min, _max); }
01646
01650 void getOrigin(double &originX, double &originY, double &originZ) const
01651 { SbBox3d::getOrigin(originX, originY, originZ); }
01652
01656 void getSize(double &sizeX, double &sizeY, double &sizeZ) const
01657 { SbBox3d::getSize(sizeX, sizeY, sizeZ); }
01658
01662 double getVolume() const;
01663
01667 void makeEmpty() { SbBox3d::makeEmpty(); }
01668
01672 SbBool isEmpty() const { return SbBox3d::isEmpty(); }
01673
01677 SbBool hasVolume() const { return SbBox3d::hasVolume(); }
01678
01682 void getSpan(const SbVec3d &direction, double &dMin, double &dMax) const
01683 { project().getSpan(direction, dMin, dMax); }
01684
01688 void transform(const SbMatrixd &m);
01689
01693 SbBox3d project() const;
01694
01698 friend int operator ==(const SbXfBox3d &b1, const SbXfBox3d &b2);
01699
01703 friend int operator !=(const SbXfBox3d &b1, const SbXfBox3d &b2)
01704 { return !(b1 == b2); }
01705
01706 private:
01710 inline bool isXFormDegenerate() const
01711 {
01712
01713 return xformInv[0][0] != xformInv[0][0];
01714 }
01715
01716 private:
01717
01718 const SbVec3d & getMin() const
01719 { return SbBox3d::getMin(); }
01720
01721 const SbVec3d & getMax() const
01722 { return SbBox3d::getMax(); }
01723
01724
01725 SbMatrixd xform;
01726 SbMatrixd xformInv;
01727 };
01728
01729
01730 inline SbXfBox3f &SbXfBox3f::setValue(const SbXfBox3d& xfbox3d)
01731 {
01732
01733 SbMatrixd dtrans = xfbox3d.getTransform();
01734 SbMatrix ftrans;
01735 ftrans.setValue(dtrans);
01736 setTransform(ftrans);
01737
01738
01739 SbVec3d dmin,dmax;
01740 xfbox3d.getBounds(dmin,dmax);
01741 SbVec3f _min,_max;
01742 _min.setValue(dmin);
01743 _max.setValue(dmax);
01744 setBounds((_min),(_max));
01745
01746 return (*this);
01747 }
01748
01749
01750 inline SbXfBox3d &SbXfBox3d::setValue(const SbXfBox3f& xfbox3f)
01751 {
01752
01753 SbMatrix ftrans = xfbox3f.getTransform();
01754 SbMatrixd dtrans;
01755 dtrans.setValue(ftrans);
01756 setTransform(dtrans);
01757
01758
01759 SbVec3f fmin,fmax;
01760 xfbox3f.getBounds(fmin,fmax);
01761 SbVec3d _min,_max;
01762 _min.setValue(fmin);
01763 _max.setValue(fmax);
01764 setBounds((_min),(_max));
01765
01766 return (*this);
01767 }
01768
01769
01793 class SbBox2f {
01794
01795 public:
01799 SbBox2f()
01800 { makeEmpty(); };
01801
01806 SbBox2f(float xmin, float ymin, float xmax, float ymax)
01807 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
01808
01813 SbBox2f(const SbVec2f &_min, const SbVec2f &_max)
01814 { m_min = _min; m_max = _max; }
01815
01819 ~SbBox2f()
01820 {}
01821
01825 const SbVec2f & getMin() const
01826 { return m_min; }
01827
01831 const SbVec2f & getMax() const
01832 { return m_max; }
01833
01837 SbVec2f getCenter() const;
01838
01842 void extendBy(const SbVec2f &pt);
01843
01847 void extendBy(const SbBox2f &r);
01848
01852 SbBool intersect(const SbVec2f &pt) const;
01853
01857 SbBool intersect(const SbBox2f &bb) const;
01858
01863 SbBox2f intersection(const SbBox2f& box) const;
01864
01868 void setBounds(float xmin, float ymin, float xmax, float ymax)
01869 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
01870
01874 void setBounds(const SbVec2f &_min, const SbVec2f &_max)
01875 { m_min = _min; m_max = _max; }
01876
01880 void getBounds(float &xmin, float &ymin,
01881 float &xmax, float &ymax) const
01882 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
01883
01888 void getBounds(SbVec2f &_min, SbVec2f &_max) const
01889 { _min = m_min; _max = m_max; }
01890
01895 SbVec2f getClosestPoint(const SbVec2f &point) const;
01896
01900 void getOrigin(float &originX, float &originY) const
01901 { originX = m_min[0]; originY = m_min[1]; }
01902
01906 void getSize(float &sizeX, float &sizeY) const
01907 {
01908 if ( m_max[0] < m_min[0] ) {
01909 sizeX = 0.0f;
01910 sizeY = 0.0f;
01911 }
01912 else {
01913 sizeX = m_max[0] - m_min[0];
01914 sizeY = m_max[1] - m_min[1];
01915 }
01916 }
01917
01922 SbVec2f getSize() const
01923 {
01924 if ( m_max[0] < m_min[0] )
01925 return SbVec2f(0, 0);
01926
01927 return m_max-m_min;
01928 }
01929
01933 float getAspectRatio() const
01934 { return (m_max[0] - m_min[0]) / (m_max[1] - m_min[1]); }
01935
01939 void makeEmpty();
01940
01944 SbBool isEmpty() const { return m_max[0] < m_min[0]; }
01945
01950 SbBool hasArea() const
01951 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
01952
01956 friend int operator ==(const SbBox2f &b1, const SbBox2f &b2);
01957
01961 friend int operator !=(const SbBox2f &b1, const SbBox2f &b2)
01962 { return !(b1 == b2); }
01963
01964 private:
01965
01966 SbVec2f m_min, m_max;
01967 };
01968
01992 class SbBox2d {
01993
01994 public:
01998 SbBox2d()
01999 { makeEmpty(); };
02000
02005 SbBox2d(double xmin, double ymin, double xmax, double ymax)
02006 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02007
02012 SbBox2d(const SbVec2d &_min, const SbVec2d &_max)
02013 { m_min = _min; m_max = _max; }
02014
02018 ~SbBox2d()
02019 {}
02020
02024 const SbVec2d & getMin() const
02025 { return m_min; }
02026
02030 const SbVec2d & getMax() const
02031 { return m_max; }
02032
02036 SbVec2d getCenter() const;
02037
02041 void extendBy(const SbVec2d &pt);
02042
02046 void extendBy(const SbBox2d &r);
02047
02051 SbBool intersect(const SbVec2d &pt) const;
02052
02056 SbBool intersect(const SbBox2d &bb) const;
02057
02062 SbBox2d intersection(const SbBox2d& box) const;
02063
02067 void setBounds(double xmin, double ymin, double xmax, double ymax)
02068 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02069
02073 void setBounds(const SbVec2d &_min, const SbVec2d &_max)
02074 { m_min = _min; m_max = _max; }
02075
02079 void getBounds(double &xmin, double &ymin,
02080 double &xmax, double &ymax) const
02081 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
02082
02087 void getBounds(SbVec2d &_min, SbVec2d &_max) const
02088 { _min = m_min; _max = m_max; }
02089
02094 SbVec2d getClosestPoint(const SbVec2d &point) const;
02095
02099 void getOrigin(double &originX, double &originY) const
02100 { originX = m_min[0]; originY = m_min[1]; }
02101
02105 void getSize(double &sizeX, double &sizeY) const
02106 {
02107 if ( m_max[0] < m_min[0] ) {
02108 sizeX = 0.0;
02109 sizeY = 0.0;
02110 }
02111 else {
02112 sizeX = m_max[0] - m_min[0];
02113 sizeY = m_max[1] - m_min[1];
02114 }
02115 }
02116
02121 SbVec2d getSize() const
02122 {
02123 if ( m_max[0] < m_min[0] )
02124 return SbVec2d(0, 0);
02125
02126 return m_max-m_min;
02127 }
02128
02132 double getAspectRatio() const
02133 { return (m_max[0] - m_min[0]) / (m_max[1] - m_min[1]); }
02134
02138 void makeEmpty();
02139
02143 SbBool isEmpty() const { return m_max[0] < m_min[0]; }
02144
02149 SbBool hasArea() const
02150 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
02151
02155 friend int operator ==(const SbBox2d &b1, const SbBox2d &b2);
02156
02160 friend int operator !=(const SbBox2d &b1, const SbBox2d &b2)
02161 { return !(b1 == b2); }
02162
02163 private:
02164
02165 SbVec2d m_min, m_max;
02166 };
02167
02191 class SbBox2s {
02192
02193 public:
02197 SbBox2s()
02198 { makeEmpty(); };
02199
02204 SbBox2s(short xmin, short ymin, short xmax, short ymax)
02205 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02206
02211 SbBox2s(const SbVec2s &_min, const SbVec2s &_max)
02212 { m_min = _min; m_max = _max; }
02213
02217 ~SbBox2s()
02218 {}
02219
02223 const SbVec2s & getMin() const
02224 { return m_min; }
02225
02229 const SbVec2s & getMax() const
02230 { return m_max; }
02231
02235 void extendBy(const SbVec2s &pt);
02236
02240 void extendBy(const SbBox2s &r);
02241
02245 SbBool intersect(const SbVec2s &pt) const;
02246
02250 SbBool intersect(const SbBox2s &bb) const;
02251
02256 SbBox2s intersection(const SbBox2s& box) const;
02257
02261 void setBounds(short xmin, short ymin, short xmax, short ymax)
02262 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02263
02267 void setBounds(const SbVec2s &_min, const SbVec2s &_max)
02268 { m_min = _min; m_max = _max; }
02269
02273 void getBounds(short &xmin, short &ymin,
02274 short &xmax, short &ymax) const
02275 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
02276
02281 void getBounds(SbVec2s &_min, SbVec2s &_max) const
02282 { _min = m_min; _max = m_max; }
02283
02287 void getOrigin(short &originX, short &originY) const
02288 { originX = m_min[0]; originY = m_min[1]; }
02289
02293 void getSize(short &sizeX, short &sizeY) const
02294 {
02295 if ( m_max[0] < m_min[0] ) {
02296 sizeX = 0;
02297 sizeY = 0;
02298 }
02299 else {
02300 sizeX = m_max[0] - m_min[0];
02301 sizeY = m_max[1] - m_min[1];
02302 }
02303 }
02304
02309 SbVec2s getSize() const
02310 {
02311 if ( m_max[0] < m_min[0] )
02312 return SbVec2s(0, 0);
02313
02314 return m_max-m_min;
02315 }
02316
02320 float getAspectRatio() const
02321 { return float(m_max[0] - m_min[0]) / float(m_max[1] - m_min[1]); }
02322
02326 void makeEmpty();
02327
02331 SbBool isEmpty() const { return m_max[0] < m_min[0]; }
02332
02337 SbBool hasArea() const
02338 { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
02339
02340
02344 friend int operator ==(const SbBox2s &b1, const SbBox2s &b2);
02345
02349 friend int operator !=(const SbBox2s &b1, const SbBox2s &b2)
02350 { return !(b1 == b2); }
02351
02352 private:
02353
02354 SbVec2s m_min, m_max;
02355 };
02356
02381 class SbBox2i32 {
02382
02383 public:
02387 SbBox2i32()
02388 { makeEmpty(); };
02389
02394 SbBox2i32(int xmin, int ymin, int xmax, int ymax)
02395 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02396
02401 SbBox2i32(const SbVec2i32 &_min, const SbVec2i32 &_max)
02402 { m_min = _min; m_max = _max; }
02403
02407 ~SbBox2i32()
02408 {}
02409
02413 const SbVec2i32 & getMin() const
02414 { return m_min; }
02415
02419 const SbVec2i32 & getMax() const
02420 { return m_max; }
02421
02425 void extendBy(const SbVec2i32 &pt);
02426
02430 void extendBy(const SbBox2i32 &r);
02431
02435 SbBool intersect(const SbVec2i32 &pt) const;
02436
02440 SbBool intersect(const SbBox2i32 &bb) const;
02441
02446 SbBox2i32 intersection(const SbBox2i32& box) const;
02447
02451 void setBounds(int xmin, int ymin, int xmax, int ymax)
02452 { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
02453
02457 void setBounds(const SbVec2i32 &_min, const SbVec2i32 &_max)
02458 { m_min = _min; m_max = _max; }
02459
02463 void getBounds(int &xmin, int &ymin,
02464 int &xmax, int &ymax) const
02465 { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
02466
02471 void getBounds(SbVec2i32 &_min, SbVec2i32 &_max) const
02472 { _min = m_min; _max = m_max; }
02473
02477 void getOrigin(int &originX, int &originY) const
02478 { originX = m_min[0]; originY = m_min[1]; }
02479
02483 void getSize(int &sizeX, int &sizeY) const
02484 {
02485 if ( m_max[0] < m_min[0] ) {
02486 sizeX = 0;
02487 sizeY = 0;
02488 }
02489 else {
02490 sizeX = m_max[0] - m_min[0];
02491 sizeY = m_max[1] - m_min[1];
02492 }
02493 }
02494
02499 SbVec2i32 getSize() const
02500 {
02501 if ( m_max[0] < m_min[0] )
02502 return SbVec2i32(0, 0);
02503
02504 return m_max-m_min;
02505 }
02506
02510 float getAspectRatio() const
02511 { return float(m_max[0] - m_min[0]) / float(m_max[1] - m_min[1]); }
02512
02516 void makeEmpty();
02517
02521 friend int operator ==(const SbBox2i32 &b1, const SbBox2i32 &b2);
02522
02526 friend int operator !=(const SbBox2i32 &b1, const SbBox2i32 &b2)
02527 { return !(b1 == b2); }
02528
02529 private:
02530
02531 SbVec2i32 m_min, m_max;
02532 };
02533
02537 inline std::ostream& operator << (std::ostream& os, const SbBox3f& b)
02538 {
02539 return os << b.getMin() << " - " << b.getMax();
02540 }
02541
02545 inline std::ostream& operator << (std::ostream& os, const SbBox3i32& b)
02546 {
02547 return os << b.getMin() << " - " << b.getMax();
02548 }
02549
02553 inline std::ostream& operator << (std::ostream& os, const SbBox2f& b)
02554 {
02555 return os << b.getMin() << " - " << b.getMax();
02556 }
02557
02584 class SbBox4i32 {
02585
02586 public:
02590 SbBox4i32()
02591 {
02592 makeEmpty();
02593 }
02594
02599 SbBox4i32(const SbVec4i32 &_min, const SbVec4i32 &_max)
02600 { m_min = _min; m_max = _max; }
02601
02605 ~SbBox4i32()
02606 {}
02607
02613 const SbVec4i32 &getMin() const
02614 { return m_min; }
02615
02621 const SbVec4i32 &getMax() const
02622 { return m_max; }
02623
02628 SbVec4i32 &getMin()
02629 { return m_min; }
02630
02635 SbVec4i32 &getMax()
02636 { return m_max; }
02637
02641 void extendBy(const SbVec4i32 &pt)
02642 {
02643 for ( int i = 0; i < 4; i++ )
02644 {
02645 if (pt[i] < m_min[i])
02646 m_min[i] = pt[i];
02647 if (pt[i] > m_max[i])
02648 m_max[i] = pt[i];
02649 }
02650 }
02651
02655 SbBool intersect(const SbVec4i32 &pt) const
02656 {
02657 return ((pt[0] >= m_min[0]) &&
02658 (pt[1] >= m_min[1]) &&
02659 (pt[2] >= m_min[2]) &&
02660 (pt[3] >= m_min[3]) &&
02661 (pt[0] <= m_max[0]) &&
02662 (pt[1] <= m_max[1]) &&
02663 (pt[2] <= m_max[2]) &&
02664 (pt[3] <= m_max[3]));
02665 }
02666
02670 SbVec4i32 getSize() const
02671 {
02672 if ( m_max[0] < m_min[0] )
02673 return SbVec4i32(0, 0, 0, 0);
02674
02675 return m_max-m_min + SbVec4i32(1, 1, 1, 1);
02676 }
02677
02681 void makeEmpty();
02682
02686 SbBool isEmpty() const
02687 { return m_max[0] < m_min[0]; }
02688
02692 friend inline std::ostream& operator << (std::ostream& os, const SbBox4i32& b)
02693 {
02694 return os << b.getMin() << " - " << b.getMax();
02695 }
02696
02700 friend int operator ==(const SbBox4i32 &b1, const SbBox4i32 &b2)
02701 {
02702 return ( (b1.m_min == b2.m_min) && (b1.m_max == b2.m_max ) );
02703 }
02704
02708 friend int operator !=(const SbBox4i32 &b1, const SbBox4i32 &b2)
02709 { return !(b1 == b2); }
02710
02711 private:
02712
02713 SbVec4i32 m_min, m_max;
02714 };
02715
02716 #endif
02717
02718
02719