SbBoxd.h

Go to the documentation of this file.

/*
 *
 *  Copyright (C) 2000 Silicon Graphics, Inc.  All Rights Reserved. 
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  Further, this software is distributed without any warranty that it is
 *  free of the rightful claim of any third person regarding infringement
 *  or the like.  Any license provided herein, whether implied or
 *  otherwise, applies only to this software file.  Patent licenses, if
 *  any, provided herein do not apply to combinations of this program with
 *  other software, or any other product whatsoever.
 * 
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *  Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
 *  Mountain View, CA  94043, or:
 * 
 *  http://www.sgi.com 
 * 
 *  For further information regarding this notice, see: 
 * 
 *  http://oss.sgi.com/projects/GenInfo/NoticeExplan/
 *
 */
 
 
/*
 * Copyright (C) 1990,91   Silicon Graphics, Inc.
 *
 _______________________________________________________________________
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 |
 |   $Revision: 1.1.1.1 $
 |
 |   Description:
 |      This file contains definitions of SbBoxes, 2D/3D boxes. A
 |      box has planes parallel to the major axes and can therefore
 |      be specified by two points on a diagonal.  The points with minimum
 |      and maximum x, y, and z coordinates are used.
 |
 |   Author(s)          : originally by Paul S. Strauss, Nick Thompson, David Mott
 |                        adapted for double values by Wolf Spindler
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */
 
#ifndef _SB_BOXD_
#define _SB_BOXD_
 
#include <Inventor/system/SbSystem.h>
#include <Inventor/SbBasic.h>
#include <Inventor/SbLineard.h>
 
 
 
class INVENTOR_API SbBox3d {
  public:
 
    SbBox3d()                                           { makeEmpty(); }
 
    SbBox3d(double xmin, double ymin, double zmin,
            double xmax, double ymax, double zmax)
        { min.setValue(xmin, ymin, zmin); max.setValue(xmax, ymax, zmax); }
 
    SbBox3d(const SbVec3d &min, const SbVec3d &max)
        { this->min = min; this->max = max; }
 
    ~SbBox3d()                                          { }
 
    const SbVec3d &     getMin() const { return min; }
    const SbVec3d &     getMax() const { return max; }
    SbVec3d &           getMin()       { return min; }
    SbVec3d &           getMax()       { return max; }
 
    SbVec3d     getCenter() const;
 
    void        extendBy(const SbVec3d &pt);
 
    void        extendBy(const SbBox3d &bb);
 
    bool        intersect(const SbVec3d &pt) const;
 
    bool        intersect(const SbBox3d &bb) const;
 
    bool        outside(const SbMatrixd &MVP, int &cullBits) const;
 
    void        setBounds(double xmin, double ymin, double zmin,
                          double xmax, double ymax, double zmax)
        { min.setValue(xmin, ymin, zmin); max.setValue(xmax, ymax, zmax); }
 
    void        setBounds(const SbVec3d &_min, const SbVec3d &_max)
        { min = _min; max = _max; }
 
    void        getBounds(double &xmin, double &ymin, double &zmin,
                          double &xmax, double &ymax, double &zmax) const
        { min.getValue(xmin, ymin, zmin); max.getValue(xmax, ymax, zmax); }
 
    void        getBounds(SbVec3d &_min, SbVec3d &_max) const
        { _min = min; _max = max; }
 
    SbVec3d     getClosestPoint(const SbVec3d &point);
 
    void        getOrigin(double &originX,
                          double &originY,
                          double &originZ) const
        { originX = min[0]; originY = min[1]; originZ = min[2]; }
 
    void        getSize(double &sizeX, double &sizeY, double &sizeZ) const
        { sizeX = max[0] - min[0];
          sizeY = max[1] - min[1];
          sizeZ = max[2] - min[2]; }
 
    void        makeEmpty();
 
    bool        isEmpty()  const                { return max[0] < min[0]; }
 
    bool        hasVolume() const
        { return (max[0] > min[0] && max[1] > min[1] && max[2] > min[2] ); }
 
    void        getSpan(const SbVec3d &direction,
                        double &dMin, double &dMax) const;
 
    void        transform(const SbMatrixd &m);
 
    double       getVolume() const;
 
    friend INVENTOR_API bool            operator ==(const SbBox3d &b1, const SbBox3d &b2);
    friend INVENTOR_API bool            operator !=(const SbBox3d &b1, const SbBox3d &b2);
 
  private:
    SbVec3d     min, max;
};
 
INVENTOR_API bool            operator ==(const SbBox3d &b1, const SbBox3d &b2);
inline INVENTOR_API bool     operator !=(const SbBox3d &b1, const SbBox3d &b2)
{ return !(b1 == b2); }
 
 
 
class INVENTOR_API 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);
 
    bool                intersect(const SbVec3d &pt) const;
 
    bool                intersect(const SbBox3d &bb) const
        { return project().intersect(bb); }
 
    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)
        { SbBox3d::getOrigin(originX, originY, originZ); }
 
    void        getSize(double &sizeX, double &sizeY, double &sizeZ)
        { SbBox3d::getSize(sizeX, sizeY, sizeZ); }
 
    double       getVolume() const;
 
    void                makeEmpty()             { SbBox3d::makeEmpty(); }
 
    bool                isEmpty() const { return SbBox3d::isEmpty(); }
 
    bool                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 INVENTOR_API bool            operator ==(const SbXfBox3d &b1, const SbXfBox3d &b2);
    friend INVENTOR_API bool            operator !=(const SbXfBox3d &b1, const SbXfBox3d &b2);
 
  private:
    const SbVec3d &     getMin() const                  { return SbBox3d::getMin(); }
    const SbVec3d &     getMax() const                  { return SbBox3d::getMax(); }
 
    SbMatrixd           xform;
    SbMatrixd           xformInv;
};
 
INVENTOR_API bool            operator ==(const SbXfBox3d &b1, const SbXfBox3d &b2);
inline INVENTOR_API bool     operator !=(const SbXfBox3d &b1, const SbXfBox3d &b2)
{ return !(b1 == b2); }
 
 
 
class INVENTOR_API SbBox2d {
  public:
 
    SbBox2d()                                   { makeEmpty(); };
 
    SbBox2d(double xmin, double ymin, double xmax, double ymax)
        { min.setValue(xmin, ymin); max.setValue(xmax, ymax); }
 
    SbBox2d(const SbVec2d &_min, const SbVec2d &_max)
        { min = _min; max = _max; }
 
    ~SbBox2d()                                          { }
 
    const SbVec2d &     getMin() const                  { return min; }
    const SbVec2d &     getMax() const                  { return max; }
 
    SbVec2d             getCenter() const;
 
    void        extendBy(const SbVec2d &pt);
 
    void        extendBy(const SbBox2d &r);
 
    bool        intersect(const SbVec2d &pt) const;
 
    bool        intersect(const SbBox2d &bb) const;
 
    void        setBounds(double xmin, double ymin, double xmax, double ymax)
        { min.setValue(xmin, ymin); max.setValue(xmax, ymax); }
 
    void        setBounds(const SbVec2d &_min, const SbVec2d &_max)
        { min = _min; max = _max; }
 
    void        getBounds(double &xmin, double &ymin,
                          double &xmax, double &ymax) const
        { min.getValue(xmin, ymin); max.getValue(xmax, ymax); }
 
    void        getBounds(SbVec2d &_min, SbVec2d &_max) const
        { _min = min; _max = max; }
 
    SbVec2d     getClosestPoint(const SbVec2d &point);
 
    void        getOrigin(double &originX, double &originY) const
        { originX = min[0]; originY = min[1]; }
 
    void        getSize(double &sizeX, double &sizeY) const
        { sizeX = max[0] - min[0]; sizeY = max[1] - min[1]; }
 
    double       getAspectRatio() const
        { return (max[0] - min[0]) / (max[1] - min[1]); }
 
    void        makeEmpty();
 
    bool        isEmpty() const         { return max[0] < min[0]; }
 
    bool        hasArea() const
        { return (max[0] > min[0] && max[1] > min[1]); }
 
    friend INVENTOR_API bool            operator ==(const SbBox2d &b1, const SbBox2d &b2);
    friend INVENTOR_API bool            operator !=(const SbBox2d &b1, const SbBox2d &b2);
 
  private:
    SbVec2d     min, max;
};
 
INVENTOR_API bool            operator ==(const SbBox2d &b1, const SbBox2d &b2);
inline INVENTOR_API bool     operator !=(const SbBox2d &b1, const SbBox2d &b2)
{ return !(b1 == b2); }
 
 
#endif /* _SB_BOXD_ */