SbBox.h

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Paul S. Strauss (MMM yyyy)
** Modified by : Nick Thompson (MMM yyyy)
** Modified by : David Mott (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2023 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
 
#ifndef _SB_BOX_
#define _SB_BOX_
 
#include <Inventor/SbBase.h>
#include <Inventor/SbVec.h>
#include <Inventor/SbMatrix.h>
#include <Inventor/STL/iostream>
 
class SbBox3s;
class SbBox3i32;
class SbBox3f;
class SbBox3d;
 
class SbXfBox3d;
class SbXfBox3f;
 
class  SbBox3i32 {
 
 public:
  SbBox3i32()
    { makeEmpty(); }
 
  SbBox3i32(int xmin, int ymin, int zmin,
          int xmax, int ymax, int zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  SbBox3i32(const SbVec3i32 &_min, const SbVec3i32 &_max)
    { m_min = _min; m_max = _max; }
 
  SbBox3i32( const SbBox3s &box );
 
  ~SbBox3i32()
    {}
 
  const SbVec3i32 &getMin() const
    { return m_min; }
 
  const SbVec3i32 &getMax() const
    { return m_max; }
 
  SbVec3i32 &getMin()
    { return m_min; }
 
  SbVec3i32 &getMax()
    { return m_max; }
 
  SbVec3f getCenter() const;
 
  void extendBy(const SbVec3f &pt);
 
  void extendBy(const SbBox3i32 &bb);
 
  SbBool intersect(const SbVec3f &pt) const;
 
  SbBool intersect(const SbBox3i32 &bb) const;
 
  SbBool intersect(const SbVec3i32 &pt) const;
 
  SbBox3i32 intersection(const SbBox3i32& box) const;
 
  inline SbBool contains(const SbBox3i32 &bb) const
  {
    SbBool contained = true;
    for( int i = 0; i < 3 && contained; i++ )
    {
      contained &= bb.m_min[i] >= m_min[i] &&
                   bb.m_min[i] <= m_max[i] &&
                   bb.m_max[i] <= m_max[i];
    }
 
    return contained;
  }
 
  SbBool outside(const SbMatrix &MVP, int &cullBits) const;
 
  void setBounds(int xmin, int ymin, int zmin,
                 int xmax, int ymax, int zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  void setBounds(const SbVec3i32 &_min, const SbVec3i32 &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(int &xmin, int &ymin, int &zmin,
                 int &xmax, int &ymax, int &zmax) const
    { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
 
  void getBounds(SbVec3i32 &_min, SbVec3i32 &_max) const
    { _min = m_min; _max = m_max; }
 
  SbVec3f getClosestPoint(const SbVec3f &point) const;
 
  void getOrigin(int &originX, int &originY, int &originZ) const
    { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
 
  void getSize(int &sizeX, int &sizeY, int &sizeZ) const {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0;
      sizeY = 0;
      sizeZ = 0;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
      sizeZ = m_max[2] - m_min[2];
    }
  }
 
  SbVec3i32 getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec3i32(0, 0, 0);
 
    return m_max-m_min;
  }
 
  void makeEmpty();
 
  SbBool isEmpty() const
    { return m_max[0] < m_min[0]; }
 
  SbBool hasVolume() const
    { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2]); }
 
  void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
 
  void transform(const SbMatrix &m);
 
  float getVolume() const;
 
  SbBox3i32 operator = (const SbBox3s &box);
 
   friend inline std::ostream& operator << (std::ostream& os, const SbBox3i32& b);
 
   friend int operator ==(const SbBox3i32 &b1, const SbBox3i32 &b2);
 
   friend int operator !=(const SbBox3i32 &b1, const SbBox3i32 &b2)
  { return !(b1 == b2); }
 
 private:
  // Minimum and maximum points
  SbVec3i32 m_min, m_max;
};
 
class  SbBox3s {
 
 public:
  SbBox3s()
    { makeEmpty(); }
 
  SbBox3s(short xmin, short ymin, short zmin,
          short xmax, short ymax, short zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  SbBox3s(const SbVec3s &_min, const SbVec3s &_max)
    { m_min = _min; m_max = _max; }
 
  SbBox3s(const SbBox3i32 &box);
 
  ~SbBox3s()
    {}
 
  const SbVec3s &getMin() const
    { return m_min; }
 
  const SbVec3s &getMax() const
    { return m_max; }
 
  SbVec3s &getMin()
    { return m_min; }
 
  SbVec3s &getMax()
    { return m_max; }
 
  SbVec3f getCenter() const;
 
  void extendBy(const SbVec3f &pt);
 
  void extendBy(const SbBox3s &bb);
 
  SbBool intersect(const SbVec3f &pt) const;
 
  SbBool intersect(const SbBox3s &bb) const;
 
  SbBox3s intersection(const SbBox3s& box) const;
 
  inline SbBool contains(const SbBox3s &bb) const
  {
    SbBool contained = true;
    for( int i = 0; i < 3 && contained; i++ )
    {
      contained &= bb.m_min[i] >= m_min[i] &&
                   bb.m_min[i] <= m_max[i] &&
                   bb.m_max[i] <= m_max[i];
    }
 
    return contained;
  }
 
  SbBool outside(const SbMatrix &MVP, int &cullBits) const;
 
  void setBounds(short xmin, short ymin, short zmin,
                 short xmax, short ymax, short zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  void setBounds(const SbVec3s &_min, const SbVec3s &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(short &xmin, short &ymin, short &zmin,
                 short &xmax, short &ymax, short &zmax) const
    { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
 
  void getBounds(SbVec3s &_min, SbVec3s &_max) const
    { _min = m_min; _max = m_max; }
 
  SbVec3f getClosestPoint(const SbVec3f &point) const;
 
  void getOrigin(short &originX, short &originY, short &originZ) const
    { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
 
  void getSize(short &sizeX, short &sizeY, short &sizeZ) const {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0;
      sizeY = 0;
      sizeZ = 0;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
      sizeZ = m_max[2] - m_min[2];
    }
  }
 
  void makeEmpty();
 
  SbBool isEmpty() const
    { return m_max[0] < m_min[0]; }
 
  SbBool hasVolume() const
    { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2]); }
 
  void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
 
  void transform(const SbMatrix &m);
 
  float getVolume() const;
 
  SbBox3s operator = (const SbBox3i32 &box);
 
   friend int operator ==(const SbBox3s &b1, const SbBox3s &b2);
 
   friend int operator !=(const SbBox3s &b1, const SbBox3s &b2)
  { return !(b1 == b2); }
 
 private:
  // Minimum and maximum points
  SbVec3s m_min, m_max;
};
 
class  SbBox3f {
 
 public:
  SbBox3f()
    { makeEmpty(); }
 
  SbBox3f(float xmin, float ymin, float zmin,
          float xmax, float ymax, float zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  SbBox3f(const SbVec3f &_min, const SbVec3f &_max)
    { m_min = _min; m_max = _max; }
 
  ~SbBox3f()
    {}
 
  inline const SbVec3f & getMin() const
    { return m_min; }
 
  inline SbVec3f &getMin()
    { return m_min; }
 
  inline const SbVec3f & getMax() const
    { return m_max; }
 
  inline SbVec3f &getMax()
    { return m_max; }
 
  SbVec3f getCenter() const;
 
  inline void extendBy(const SbVec3f &pt)
  {
    if (pt[0] < m_min[0]) m_min[0] = pt[0];
    if (pt[1] < m_min[1]) m_min[1] = pt[1];
    if (pt[2] < m_min[2]) m_min[2] = pt[2];
    if (pt[0] > m_max[0]) m_max[0] = pt[0];
    if (pt[1] > m_max[1]) m_max[1] = pt[1];
    if (pt[2] > m_max[2]) m_max[2] = pt[2];
  }
 
  void extendBy(const SbBox3f &bb);
 
  SbBool intersect(const SbVec3f &pt) const;
 
  inline SbBool intersect(const SbBox3f &bb) const
  {
    return ((bb.m_max[0] >= m_min[0]) && (bb.m_min[0] <= m_max[0]) &&
        (bb.m_max[1] >= m_min[1]) && (bb.m_min[1] <= m_max[1]) &&
        (bb.m_max[2] >= m_min[2]) && (bb.m_min[2] <= m_max[2]));
  }
 
  SbBox3f intersection(const SbBox3f& box) const;
 
  inline SbBool contains(const SbBox3f &bb) const
  {
    SbBool contained = true;
    for( int i = 0; i < 3 && contained; i++ )
    {
      contained &= bb.m_min[i] >= m_min[i] &&
                   bb.m_min[i] <= m_max[i] &&
                   bb.m_max[i] <= m_max[i];
    }
 
    return contained;
  }
 
 
  SbBool outside(const SbMatrix &MVP, int &cullBits) const;
 
  void setBounds(float xmin, float ymin, float zmin,
                 float xmax, float ymax, float zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  void setBounds(const SbVec3f &_min, const SbVec3f &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(float &xmin, float &ymin, float &zmin,
                 float &xmax, float &ymax, float &zmax) const
    { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
 
  void getBounds(SbVec3f &_min, SbVec3f &_max) const
    { _min = m_min; _max = m_max; }
 
  SbVec3f getClosestPoint(const SbVec3f &point) const;
 
  void getOrigin(float &originX, float &originY, float &originZ) const
    { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
 
  void getSize(float &sizeX, float &sizeY, float &sizeZ) const {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0.0f;
      sizeY = 0.0f;
      sizeZ = 0.0f;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
      sizeZ = m_max[2] - m_min[2];
    }
  }
 
  SbVec3f getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec3f(0, 0, 0);
 
    return m_max-m_min;
  }
 
  inline void makeEmpty()
  {
    m_min.setValue(FLT_MAX, FLT_MAX, FLT_MAX);
    m_max.setValue(- FLT_MAX, - FLT_MAX, - FLT_MAX);
  }
 
  inline SbBool isEmpty() const
    { return m_max[0] < m_min[0]; }
 
  SbBool hasVolume() const
    { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2] ); }
 
  void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const;
 
  void transform(const SbMatrix &m);
 
  float getVolume() const;
 
   friend int operator ==(const SbBox3f &b1, const SbBox3f &b2);
 
   friend int operator !=(const SbBox3f &b1, const SbBox3f &b2)
  { return !(b1 == b2); }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbBox3f& b);
 
  template<typename T>
  explicit SbBox3f(const T& b)
  {
    m_min = SbVec3f(b.getMin());
    m_max = SbVec3f(b.getMax());
  }
 
  float computeMaxDistance2(const SbVec3f& p) const;
 
  SbBool triangleBoxOverlap(const SbVec3f& u0, const SbVec3f& u1, const SbVec3f& u2) const;
 
  private:
 
  SbBool lineSegmentBoxOverlap(const SbVec3f& u0, const SbVec3f& u1) const;
 
private:
  // Minimum and maximum points
  SbVec3f m_min, m_max;
};
 
 
// P.Vigneras Adding support for double precision bounding box 3
// Feb 15 2000
 
class  SbBox3d {
 
 public:
  SbBox3d()
    { makeEmpty(); }
 
  SbBox3d(double xmin, double ymin, double zmin,
          double xmax, double ymax, double zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  SbBox3d(const SbVec3d &_min, const SbVec3d &_max)
    { m_min = _min; m_max = _max; }
 
  ~SbBox3d()
    {}
 
  const SbVec3d & getMin() const
    { return m_min; }
 
  const SbVec3d & getMax() const
    { return m_max; }
 
  SbVec3d &getMin()
    { return m_min; }
 
  SbVec3d &getMax()
    { return m_max; }
 
  SbVec3d getCenter() const;
 
  void extendBy(const SbVec3d &pt);
 
  void extendBy(const SbBox3d &bb);
 
  SbBool intersect(const SbVec3d &pt) const;
 
  SbBool intersect(const SbBox3d &bb) const;
 
  SbBox3d intersection(const SbBox3d& box) const;
 
  inline SbBool contains(const SbBox3d &bb) const
  {
    SbBool contained = true;
    for( int i = 0; i < 3 && contained; i++ )
    {
      contained &= bb.m_min[i] >= m_min[i] &&
                   bb.m_min[i] <= m_max[i] &&
                   bb.m_max[i] <= m_max[i];
    }
 
    return contained;
  }
 
  SbBool outside(const SbMatrixd &MVP, int &cullBits) const;
 
  void setBounds(double xmin, double ymin, double zmin,
                 double xmax, double ymax, double zmax)
    { m_min.setValue(xmin, ymin, zmin); m_max.setValue(xmax, ymax, zmax); }
 
  void setBounds(const SbVec3d &_min, const SbVec3d &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(double &xmin, double &ymin, double &zmin,
                 double &xmax, double &ymax, double &zmax) const
    { m_min.getValue(xmin, ymin, zmin); m_max.getValue(xmax, ymax, zmax); }
 
  void getBounds(SbVec3d &_min, SbVec3d &_max) const
    { _min = m_min; _max = m_max; }
 
  SbVec3d getClosestPoint(const SbVec3d &point) const;
 
  void getOrigin(double &originX, double &originY, double &originZ) const
    { originX = m_min[0]; originY = m_min[1]; originZ = m_min[2]; }
 
  void getSize(double &sizeX, double &sizeY, double &sizeZ) const {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0.0;
      sizeY = 0.0;
      sizeZ = 0.0;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
      sizeZ = m_max[2] - m_min[2];
    }
  }
 
  SbVec3d getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec3d(0, 0, 0);
 
    return m_max-m_min;
  }
 
  void makeEmpty();
 
  SbBool isEmpty() const
    { return m_max[0] < m_min[0]; }
 
  SbBool hasVolume() const
    { return (m_max[0] > m_min[0] && m_max[1] > m_min[1] && m_max[2] > m_min[2] ); }
 
  void getSpan(const SbVec3d &direction, double &dMin, double &dMax) const;
 
  void transform(const SbMatrixd &m);
 
  double getVolume() const;
 
   friend int operator ==(const SbBox3d &b1, const SbBox3d &b2);
 
   friend int operator !=(const SbBox3d &b1, const SbBox3d &b2)
  { return !(b1 == b2); }
 
  template<typename T>
  explicit SbBox3d(const T& b)
  {
    m_min = SbVec3d(b.getMin());
    m_max = SbVec3d(b.getMax());
  }
 
 private:
  // Minimum and maximum points
  SbVec3d m_min, m_max;
};
 
class  SbXfBox3f : public SbBox3f {
 
 public:
  SbXfBox3f();
 
  SbXfBox3f(const SbVec3f &_min, const SbVec3f &_max);
 
  SbXfBox3f(const SbBox3f &box);
 
  ~SbXfBox3f()
    {}
 
  void setTransform(const SbMatrix &m);
 
  const SbMatrix & getTransform() const
    { return xform; }
 
  const SbMatrix & getInverse( ) const
    { return xformInv; }
 
  SbVec3f getCenter() const;
 
  void extendBy(const SbVec3f &pt);
 
  void extendBy(const SbBox3f &bb)
    { extendBy(SbXfBox3f(bb)); }
 
  void extendBy(const SbXfBox3f &bb);
 
  SbBool intersect(const SbVec3f &pt) const;
 
  SbBool intersect(const SbBox3f &bb) const
    { return project().intersect(bb); }
 
  SbXfBox3f &setValue(const SbXfBox3d &xfbox3d);
 
  void setBounds(float xmin, float ymin, float zmin,
                 float xmax, float ymax, float zmax)
    { SbBox3f::setBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
 
  void setBounds(const SbVec3f &_min, const SbVec3f &_max)
    { SbBox3f::setBounds(_min, _max); }
 
  void getBounds(float &xmin, float &ymin, float &zmin,
                 float &xmax, float &ymax, float &zmax) const
    { SbBox3f::getBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
 
  void getBounds(SbVec3f &_min, SbVec3f &_max) const
    { SbBox3f::getBounds(_min, _max); }
 
  void getOrigin(float &originX, float &originY, float &originZ)
    { SbBox3f::getOrigin(originX, originY, originZ); }
 
  void getSize(float &sizeX, float &sizeY, float &sizeZ)
    { SbBox3f::getSize(sizeX, sizeY, sizeZ); }
 
  float getVolume() const;
 
  void makeEmpty() { SbBox3f::makeEmpty(); }
 
  SbBool isEmpty() const { return SbBox3f::isEmpty(); }
 
  SbBool hasVolume() const { return SbBox3f::hasVolume(); }
 
  void getSpan(const SbVec3f &direction, float &dMin, float &dMax) const
    { project().getSpan(direction, dMin, dMax); }
 
  void transform(const SbMatrix &m);
 
  SbBox3f project() const;
 
  SbVec3f getClosestPoint(const SbVec3f& point) const;
 
  float computeMaxDistance2(const SbVec3f& p) const;
 
   friend int operator ==(const SbXfBox3f &b1, const SbXfBox3f &b2);
 
   friend int operator !=(const SbXfBox3f &b1, const SbXfBox3f &b2)
  { return !(b1 == b2); }
 
 
 private:
  inline bool isXFormDegenerate() const
  { 
    // test whether first item in matrix is a signalingNaN
    return xformInv[0][0] != xformInv[0][0]; 
  }
 
 
 private:
  // These are incorrect for SbXfBox3f, so we hide them
  const SbVec3f &getMin() const
    { return SbBox3f::getMin(); }
 
  const SbVec3f &getMax() const
    { return SbBox3f::getMax(); }
 
  // The box is transformed by this xform
  SbMatrix xform;
  SbMatrix xformInv;
};
 
class  SbXfBox3d : public SbBox3d {
 
 public:
  SbXfBox3d();
 
  SbXfBox3d(const SbVec3d &_min, const SbVec3d &_max);
 
  SbXfBox3d(const SbBox3d &box);
 
  ~SbXfBox3d()
    {}
 
  void setTransform(const SbMatrixd &m);
 
  const SbMatrixd & getTransform() const
    { return xform; }
  
  const SbMatrixd & getInverse( ) const
    { return xformInv; }
 
  SbVec3d getCenter() const;
 
  void extendBy(const SbVec3d &pt);
 
  void extendBy(const SbBox3d &bb)
    { extendBy(SbXfBox3d(bb)); }
 
  void extendBy(const SbXfBox3d &bb);
 
  SbBool intersect(const SbVec3d &pt) const;
 
  SbBool intersect(const SbBox3d &bb) const
    { return project().intersect(bb); }
 
  SbXfBox3d &setValue(const SbXfBox3f &xfbox3f);
 
  void setBounds(double xmin, double ymin, double zmin,
                 double xmax, double ymax, double zmax)
    { SbBox3d::setBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
 
  void setBounds(const SbVec3d &_min, const SbVec3d &_max)
    { SbBox3d::setBounds(_min, _max); }
 
  void getBounds(double &xmin, double &ymin, double &zmin,
                 double &xmax, double &ymax, double &zmax) const
    { SbBox3d::getBounds(xmin, ymin, zmin, xmax, ymax, zmax); }
 
  void getBounds(SbVec3d &_min, SbVec3d &_max) const
    { SbBox3d::getBounds(_min, _max); }
 
  void getOrigin(double &originX, double &originY, double &originZ) const
    { SbBox3d::getOrigin(originX, originY, originZ); }
 
  void getSize(double &sizeX, double &sizeY, double &sizeZ) const
    { SbBox3d::getSize(sizeX, sizeY, sizeZ); }
 
  double getVolume() const;
 
  void makeEmpty() { SbBox3d::makeEmpty(); }
 
  SbBool isEmpty() const { return SbBox3d::isEmpty(); }
 
  SbBool hasVolume() const { return SbBox3d::hasVolume(); }
 
  void getSpan(const SbVec3d &direction, double &dMin, double &dMax) const
    { project().getSpan(direction, dMin, dMax); }
 
  void transform(const SbMatrixd &m);
 
  SbBox3d project() const;
 
   friend int operator ==(const SbXfBox3d &b1, const SbXfBox3d &b2);
 
   friend int operator !=(const SbXfBox3d &b1, const SbXfBox3d &b2)
  { return !(b1 == b2); }
 
 private:
  inline bool isXFormDegenerate() const
  { 
    // test whether first item in matrix is a signalingNaN
    return xformInv[0][0] != xformInv[0][0]; 
  }
 
 private:
  // These are incorrect for SbXfBox3d, so we hide them
  const SbVec3d & getMin() const
    { return SbBox3d::getMin(); }
 
  const SbVec3d & getMax() const
    { return SbBox3d::getMax(); }
 
  // The box is transformed by this xform
  SbMatrixd xform;
  SbMatrixd xformInv;
};
 
// Note: This implementation must appear after the declaration of SbXfBox3d!
inline SbXfBox3f &SbXfBox3f::setValue(const SbXfBox3d& xfbox3d)
{
  // set float transform
  SbMatrixd dtrans = xfbox3d.getTransform();
  SbMatrix ftrans;
  ftrans.setValue(dtrans);
  setTransform(ftrans);
 
  // set float bounds
  SbVec3d dmin,dmax;
  xfbox3d.getBounds(dmin,dmax);
  SbVec3f _min,_max;
  _min.setValue(dmin);
  _max.setValue(dmax);
  setBounds((_min),(_max));
 
    return (*this);
}
 
// Note: This implementation must appear after the declaration of SbXfBox3d!
inline SbXfBox3d &SbXfBox3d::setValue(const SbXfBox3f& xfbox3f)
{
  // set float transform
  SbMatrix ftrans = xfbox3f.getTransform();
  SbMatrixd dtrans;
  dtrans.setValue(ftrans);
  setTransform(dtrans);
 
  // set float bounds
  SbVec3f fmin,fmax;
  xfbox3f.getBounds(fmin,fmax);
  SbVec3d _min,_max;
  _min.setValue(fmin);
  _max.setValue(fmax);
  setBounds((_min),(_max));
 
    return (*this);
}
 
 
class  SbBox2f {
 
 public:
  SbBox2f()
    { makeEmpty(); };
 
  SbBox2f(float xmin, float ymin, float xmax, float ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  SbBox2f(const SbVec2f &_min, const SbVec2f &_max)
    { m_min = _min; m_max = _max; }
 
  ~SbBox2f()
    {}
 
  const SbVec2f & getMin() const
    { return m_min; }
 
  const SbVec2f & getMax() const
    { return m_max; }
 
  SbVec2f getCenter() const;
 
  void extendBy(const SbVec2f &pt);
 
  void extendBy(const SbBox2f &r);
 
  SbBool intersect(const SbVec2f &pt) const;
 
  SbBool intersect(const SbBox2f &bb) const;
 
  SbBox2f intersection(const SbBox2f& box) const;
 
  void setBounds(float xmin, float ymin, float xmax, float ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  void setBounds(const SbVec2f &_min, const SbVec2f &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(float &xmin, float &ymin,
                 float &xmax, float &ymax) const
    { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
 
  void getBounds(SbVec2f &_min, SbVec2f &_max) const
    { _min = m_min; _max = m_max; }
 
  SbVec2f getClosestPoint(const SbVec2f &point) const;
 
  void getOrigin(float &originX, float &originY) const
    { originX = m_min[0]; originY = m_min[1]; }
 
  void getSize(float &sizeX, float &sizeY) const
    {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0.0f;
      sizeY = 0.0f;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
    }
  }
 
  SbVec2f getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec2f(0, 0);
 
    return m_max-m_min;
  }
 
  float getAspectRatio() const
    { return (m_max[0] - m_min[0]) / (m_max[1] - m_min[1]); }
 
  void makeEmpty();
 
  SbBool isEmpty() const { return m_max[0] < m_min[0]; }
 
  SbBool hasArea() const
    { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
 
   friend int operator ==(const SbBox2f &b1, const SbBox2f &b2);
 
   friend int operator !=(const SbBox2f &b1, const SbBox2f &b2)
  { return !(b1 == b2); }
 
 private:
  // Minimum and maximum points
  SbVec2f m_min, m_max;
};
 
class  SbBox2d {
 
 public:
  SbBox2d()
    { makeEmpty(); };
 
  SbBox2d(double xmin, double ymin, double xmax, double ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  SbBox2d(const SbVec2d &_min, const SbVec2d &_max)
    { m_min = _min; m_max = _max; }
 
  ~SbBox2d()
    {}
 
  const SbVec2d & getMin() const
    { return m_min; }
 
  const SbVec2d & getMax() const
    { return m_max; }
 
  SbVec2d getCenter() const;
 
  void extendBy(const SbVec2d &pt);
 
  void extendBy(const SbBox2d &r);
 
  SbBool intersect(const SbVec2d &pt) const;
 
  SbBool intersect(const SbBox2d &bb) const;
 
  SbBox2d intersection(const SbBox2d& box) const;
 
  void setBounds(double xmin, double ymin, double xmax, double ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  void setBounds(const SbVec2d &_min, const SbVec2d &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(double &xmin, double &ymin,
                 double &xmax, double &ymax) const
    { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
 
  void getBounds(SbVec2d &_min, SbVec2d &_max) const
    { _min = m_min; _max = m_max; }
 
  SbVec2d getClosestPoint(const SbVec2d &point) const;
 
  void getOrigin(double &originX, double &originY) const
    { originX = m_min[0]; originY = m_min[1]; }
 
  void getSize(double &sizeX, double &sizeY) const
    {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0.0;
      sizeY = 0.0;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
    }  
  }
 
  SbVec2d getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec2d(0, 0);
 
    return m_max-m_min;
  }
 
  double getAspectRatio() const
    { return (m_max[0] - m_min[0]) / (m_max[1] - m_min[1]); }
 
  void makeEmpty();
 
  SbBool isEmpty() const { return m_max[0] < m_min[0]; }
 
  SbBool hasArea() const
    { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
 
   friend int operator ==(const SbBox2d &b1, const SbBox2d &b2);
 
   friend int operator !=(const SbBox2d &b1, const SbBox2d &b2)
  { return !(b1 == b2); }
 
 private:
  // Minimum and maximum points
  SbVec2d m_min, m_max;
};
 
class  SbBox2s {
 
 public:
  SbBox2s()
    { makeEmpty(); };
 
  SbBox2s(short xmin, short ymin, short xmax, short ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  SbBox2s(const SbVec2s &_min, const SbVec2s &_max)
    { m_min = _min; m_max = _max; }
 
  ~SbBox2s()
    {}
 
  const SbVec2s & getMin() const
    { return m_min; }
 
  const SbVec2s & getMax() const
    { return m_max; }
 
  void extendBy(const SbVec2s &pt);
 
  void extendBy(const SbBox2s &r);
 
  SbBool intersect(const SbVec2s &pt) const;
 
  SbBool intersect(const SbBox2s &bb) const;
 
  SbBox2s intersection(const SbBox2s& box) const;
 
  void setBounds(short xmin, short ymin, short xmax, short ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  void setBounds(const SbVec2s &_min, const SbVec2s &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(short &xmin, short &ymin,
                 short &xmax, short &ymax) const
    { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
 
  void getBounds(SbVec2s &_min, SbVec2s &_max) const
    { _min = m_min; _max = m_max; }
 
  void getOrigin(short &originX, short &originY) const
    { originX = m_min[0]; originY = m_min[1]; }
 
  void getSize(short &sizeX, short &sizeY) const
    {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0;
      sizeY = 0;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
    }
  }
 
  SbVec2s getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec2s(0, 0);
 
    return m_max-m_min;
  }
 
  float getAspectRatio() const
    { return float(m_max[0] - m_min[0]) / float(m_max[1] - m_min[1]); }
 
  void makeEmpty();
 
  SbBool isEmpty() const { return m_max[0] < m_min[0]; }
 
  SbBool hasArea() const
    { return (m_max[0] > m_min[0] && m_max[1] > m_min[1]); }
 
 
   friend int operator ==(const SbBox2s &b1, const SbBox2s &b2);
 
   friend int operator !=(const SbBox2s &b1, const SbBox2s &b2)
  { return !(b1 == b2); }
 
 private:
  // Minimum and maximum points
  SbVec2s m_min, m_max;
};
 
class  SbBox2i32 {
 
 public:
  SbBox2i32()
    { makeEmpty(); };
 
  SbBox2i32(int xmin, int ymin, int xmax, int ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  SbBox2i32(const SbVec2i32 &_min, const SbVec2i32 &_max)
    { m_min = _min; m_max = _max; }
 
  ~SbBox2i32()
    {}
 
  const SbVec2i32 & getMin() const
    { return m_min; }
 
  const SbVec2i32 & getMax() const
    { return m_max; }
 
  void extendBy(const SbVec2i32 &pt);
 
  void extendBy(const SbBox2i32 &r);
 
  SbBool intersect(const SbVec2i32 &pt) const;
 
  SbBool intersect(const SbBox2i32 &bb) const;
 
  SbBox2i32 intersection(const SbBox2i32& box) const;
 
  void setBounds(int xmin, int ymin, int xmax, int ymax)
    { m_min.setValue(xmin, ymin); m_max.setValue(xmax, ymax); }
 
  void setBounds(const SbVec2i32 &_min, const SbVec2i32 &_max)
    { m_min = _min; m_max = _max; }
 
  void getBounds(int &xmin, int &ymin,
                 int &xmax, int &ymax) const
    { m_min.getValue(xmin, ymin); m_max.getValue(xmax, ymax); }
 
  void getBounds(SbVec2i32 &_min, SbVec2i32 &_max) const
    { _min = m_min; _max = m_max; }
 
  void getOrigin(int &originX, int &originY) const
    { originX = m_min[0]; originY = m_min[1]; }
 
  void getSize(int &sizeX, int &sizeY) const
    {
    if ( m_max[0] < m_min[0] ) {
      sizeX = 0;
      sizeY = 0;
    }
    else {
      sizeX = m_max[0] - m_min[0];
      sizeY = m_max[1] - m_min[1];
    }
  }
 
  SbVec2i32 getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec2i32(0, 0);
 
    return m_max-m_min;
  }
 
  float getAspectRatio() const
    { return float(m_max[0] - m_min[0]) / float(m_max[1] - m_min[1]); }
 
  void makeEmpty();
 
   friend int operator ==(const SbBox2i32 &b1, const SbBox2i32 &b2);
 
   friend int operator !=(const SbBox2i32 &b1, const SbBox2i32 &b2)
  { return !(b1 == b2); }
 
 private:
  // Minimum and maximum points
  SbVec2i32 m_min, m_max;
};
 
inline std::ostream& operator << (std::ostream& os, const SbBox3f& b)
{
  return os << b.getMin() << " - " << b.getMax();
}
 
inline std::ostream& operator << (std::ostream& os, const SbBox3i32& b)
{
  return os << b.getMin() << " - " << b.getMax();
}
 
inline std::ostream& operator << (std::ostream& os, const SbBox2f& b)
{
  return os << b.getMin() << " - " << b.getMax();
}
 
class  SbBox4i32 {
 
 public:
  SbBox4i32()
  {
    makeEmpty();
  }
 
  SbBox4i32(const SbVec4i32 &_min, const SbVec4i32 &_max)
    { m_min = _min; m_max = _max; }
 
  ~SbBox4i32()
    {}
 
  const SbVec4i32 &getMin() const
    { return m_min; }
 
  const SbVec4i32 &getMax() const
    { return m_max; }
 
  SbVec4i32 &getMin()
    { return m_min; }
 
  SbVec4i32 &getMax()
    { return m_max; }
 
  void extendBy(const SbVec4i32 &pt)
  {
    for ( int i = 0; i < 4; i++ )
    {
      if (pt[i] < m_min[i])
        m_min[i] = pt[i];
      if (pt[i] > m_max[i])
        m_max[i] = pt[i];
    }
  }
 
  SbBool intersect(const SbVec4i32 &pt) const
  {
    return ((pt[0] >= m_min[0]) &&
            (pt[1] >= m_min[1]) &&
            (pt[2] >= m_min[2]) &&
            (pt[3] >= m_min[3]) &&
            (pt[0] <= m_max[0]) &&
            (pt[1] <= m_max[1]) &&
            (pt[2] <= m_max[2]) &&
            (pt[3] <= m_max[3]));
  }
 
  SbVec4i32 getSize() const
  {
    if ( m_max[0] < m_min[0] )
      return SbVec4i32(0, 0, 0, 0);
 
    return m_max-m_min + SbVec4i32(1, 1, 1, 1);
  }
 
  void makeEmpty();
 
  SbBool isEmpty() const
    { return m_max[0] < m_min[0]; }
 
   friend inline std::ostream& operator << (std::ostream& os, const SbBox4i32& b)
  {
    return os << b.getMin() << " - " << b.getMax();
  }
 
   friend int operator ==(const SbBox4i32 &b1, const SbBox4i32 &b2)
  {
    return ( (b1.m_min == b2.m_min) && (b1.m_max == b2.m_max ) );
  }
 
   friend int operator !=(const SbBox4i32 &b1, const SbBox4i32 &b2)
  { return !(b1 == b2); }
 
 private:
  // Minimum and maximum points
  SbVec4i32 m_min, m_max;
};
 
#endif /* _SB_BOX_ */