MeVis/ThirdParty/Sources/Inventor/inventor/lib/database/include/Inventor/SbBox.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)          : Paul S. Strauss, Nick Thompson, David Mott
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */

#ifndef _SB_BOX_
#define _SB_BOX_

#include <Inventor/system/SbSystem.h>
#include <Inventor/SbBasic.h>
#include <Inventor/SbLinear.h>




class INVENTOR_API SbBox3f {
  public:

    SbBox3f()                                           { makeEmpty(); }

    SbBox3f(float xmin, float ymin, float zmin,
            float xmax, float ymax, float zmax)
        { min.setValue(xmin, ymin, zmin); max.setValue(xmax, ymax, zmax); }

    SbBox3f(const SbVec3f &min, const SbVec3f &max)
        { this->min = min; this->max = max; }

    ~SbBox3f()                                          { }

    const SbVec3f &     getMin() const { return min; }
    const SbVec3f &     getMax() const { return max; }
    SbVec3f &           getMin()       { return min; }
    SbVec3f &           getMax()       { return max; }

    SbVec3f     getCenter() const;

    void        extendBy(const SbVec3f &pt);

    void        extendBy(const SbBox3f &bb);

    SbBool      intersect(const SbVec3f &pt) const;

    SbBool      intersect(const SbBox3f &bb) const;

    SbBool      outside(const SbMatrix &MVP, int &cullBits) const;

    void        setBounds(float xmin, float ymin, float zmin,
                          float xmax, float ymax, float zmax)
        { min.setValue(xmin, ymin, zmin); max.setValue(xmax, ymax, zmax); }

    void        setBounds(const SbVec3f &_min, const SbVec3f &_max)
        { min = _min; max = _max; }

    void        getBounds(float &xmin, float &ymin, float &zmin,
                          float &xmax, float &ymax, float &zmax) const
        { min.getValue(xmin, ymin, zmin); max.getValue(xmax, ymax, zmax); }

    void        getBounds(SbVec3f &_min, SbVec3f &_max) const
        { _min = min; _max = max; }

    SbVec3f     getClosestPoint(const SbVec3f &point);

    void        getOrigin(float &originX,
                          float &originY,
                          float &originZ) const
        { originX = min[0]; originY = min[1]; originZ = min[2]; }

    void        getSize(float &sizeX, float &sizeY, float &sizeZ) const
        { sizeX = max[0] - min[0];
          sizeY = max[1] - min[1];
          sizeZ = max[2] - min[2]; }

    void        makeEmpty();

    SbBool      isEmpty()  const                { return max[0] < min[0]; }

    SbBool      hasVolume() const
        { return (max[0] > min[0] && max[1] > min[1] && max[2] > min[2] ); }

    void        getSpan(const SbVec3f &direction,
                        float &dMin, float &dMax) const;

    void        transform(const SbMatrix &m);

    float       getVolume() const;

    friend INVENTOR_API int          operator ==(const SbBox3f &b1, const SbBox3f &b2);
    friend INVENTOR_API int          operator !=(const SbBox3f &b1, const SbBox3f &b2)
        { return !(b1 == b2); }

  private:
    SbVec3f     min, max;
};




class INVENTOR_API 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); }

    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;

    friend INVENTOR_API int          operator ==(const SbXfBox3f &b1, const SbXfBox3f &b2);
    friend INVENTOR_API int          operator !=(const SbXfBox3f &b1, const SbXfBox3f &b2)
        { return !(b1 == b2); }

  private:
    const SbVec3f &     getMin() const                  { return SbBox3f::getMin(); }
    const SbVec3f &     getMax() const                  { return SbBox3f::getMax(); }

    SbMatrix            xform;
    SbMatrix            xformInv;
};




class INVENTOR_API SbBox2f {
  public:

    SbBox2f()                                   { makeEmpty(); };

    SbBox2f(float xmin, float ymin, float xmax, float ymax)
        { min.setValue(xmin, ymin); max.setValue(xmax, ymax); }

    SbBox2f(const SbVec2f &_min, const SbVec2f &_max)
        { min = _min; max = _max; }

    ~SbBox2f()                                          { }

    const SbVec2f &     getMin() const                  { return min; }
    const SbVec2f &     getMax() const                  { return 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;

    void        setBounds(float xmin, float ymin, float xmax, float ymax)
        { min.setValue(xmin, ymin); max.setValue(xmax, ymax); }

    void        setBounds(const SbVec2f &_min, const SbVec2f &_max)
        { min = _min; max = _max; }

    void        getBounds(float &xmin, float &ymin,
                          float &xmax, float &ymax) const
        { min.getValue(xmin, ymin); max.getValue(xmax, ymax); }

    void        getBounds(SbVec2f &_min, SbVec2f &_max) const
        { _min = min; _max = max; }

    SbVec2f     getClosestPoint(const SbVec2f &point);

    void        getOrigin(float &originX, float &originY) const
        { originX = min[0]; originY = min[1]; }

    void        getSize(float &sizeX, float &sizeY) const
        { sizeX = max[0] - min[0]; sizeY = max[1] - min[1]; }

    float       getAspectRatio() const
        { return (max[0] - min[0]) / (max[1] - min[1]); }

    void        makeEmpty();

    SbBool      isEmpty() const         { return max[0] < min[0]; }

    SbBool      hasArea() const
        { return (max[0] > min[0] && max[1] > min[1]); }

    friend INVENTOR_API int          operator ==(const SbBox2f &b1, const SbBox2f &b2);
    friend INVENTOR_API int          operator !=(const SbBox2f &b1, const SbBox2f &b2)
        { return !(b1 == b2); }

  private:
    SbVec2f     min, max;
};




class INVENTOR_API SbBox2s {
  public:

    SbBox2s()                                   { makeEmpty(); };

    SbBox2s(short xmin, short ymin, short xmax, short ymax)
        { min.setValue(xmin, ymin); max.setValue(xmax, ymax); }

    SbBox2s(const SbVec2s &min, const SbVec2s &max)
        { this->min = min; this->max = max; }

    ~SbBox2s()                                          { }

    const SbVec2s &     getMin() const                  { return min; }
    const SbVec2s &     getMax() const                  { return max; }

    void        extendBy(const SbVec2s &pt);

    void        extendBy(const SbBox2s &r);

    SbBool      intersect(const SbVec2s &pt) const;

    SbBool      intersect(const SbBox2s &bb) const;

    void        setBounds(short xmin, short ymin, short xmax, short ymax)
        { min.setValue(xmin, ymin); max.setValue(xmax, ymax); }

    void        setBounds(const SbVec2s &_min, const SbVec2s &_max)
        { min = _min; max = _max; }

    void        getBounds(short &xmin, short &ymin,
                          short &xmax, short &ymax) const
        { min.getValue(xmin, ymin); max.getValue(xmax, ymax); }

    void        getBounds(SbVec2s &_min, SbVec2s &_max) const
        { _min = min; _max = max; }

    void        getOrigin(short &originX, short &originY) const
        { originX = min[0]; originY = min[1]; }

    void        getSize(short &sizeX, short &sizeY) const
        { sizeX = max[0] - min[0]; sizeY = max[1] - min[1]; }

    float       getAspectRatio() const
        { return float(max[0] - min[0]) / float(max[1] - min[1]); }

    void        makeEmpty();

    friend INVENTOR_API int          operator ==(const SbBox2s &b1, const SbBox2s &b2);
    friend INVENTOR_API int          operator !=(const SbBox2s &b1, const SbBox2s &b2)
        { return !(b1 == b2); }

  private:
    SbVec2s     min, max;
};

#endif /* _SB_BOX_ */