MeVis/ThirdParty/Sources/Inventor/inventor/lib/database/include/Inventor/SbLinear.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.3 $
 |
 |   Description:
 |      This file contains definitions of various linear algebra classes,
 |      such as vectors, coordinates, etc..
 |
 |   Classes:
 |      SbVec3f
 |      SbVec2f
 |      SbVec2s
 |      SbVec3s         //!< Extension to SGI OIV 2.1
 |      SbVec4f
 |      SbRotation
 |      SbMatrix
 |      SbViewVolume
 |
 |      SbLine
 |      SbPlane
 |      SbSphere
 |
 |   Author(s)          : Paul S. Strauss, Nick Thompson, 
 |                        David Mott, Alain Dumesny
 |
 ______________  S I L I C O N   G R A P H I C S   I N C .  ____________
 _______________________________________________________________________
 */

#ifndef _SB_LINEAR_
#define _SB_LINEAR_

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


typedef float SbMat[4][4];


class SbVec3f;
class SbVec2f;
class SbVec2s;
class SbVec4f;
class SbRotation;
class SbMatrix;

class SbLine;
class SbPlane;
class SbCylinder;
class SbSphere;

class SbBox3f;







class INVENTOR_API SbVec3f {
  public:

    SbVec3f()                                           { }

    SbVec3f(const float v[3])
         { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; }

    SbVec3f(float x, float y, float z)
         { vec[0] = x; vec[1] = y; vec[2] = z; }

    SbVec3f(SbPlane &p0, SbPlane &p1, SbPlane &p2);

    SbVec3f     cross(const SbVec3f &v) const;

    float       dot(const SbVec3f &v) const;

    const float *getValue() const                       { return vec; }

    void        getValue(float &x, float &y, float &z) const;

    float       length() const;

    float       normalize();

    void        negate();

    SbVec3f &   setValue(const float v[3])
         { vec[0] = v[0]; vec[1] = v[1]; vec[2] = v[2]; return *this; }

    SbVec3f &   setValue(float x, float y, float z)
         { vec[0] = x; vec[1] = y; vec[2] = z; return *this; }

    SbVec3f &   setValue(const SbVec3f &barycentic,
                const SbVec3f &v0, const SbVec3f &v1, const SbVec3f &v2);

    float &       operator [](int i)            { return (vec[i]); }
    const float & operator [](int i) const      { return (vec[i]); }

    SbVec3f &   operator *=(float d);

    SbVec3f &   operator /=(float d)
        { return *this *= (1.0f / d); }

    SbVec3f &   operator +=(SbVec3f v);
    SbVec3f &   operator -=(SbVec3f v);

    SbVec3f     operator -() const;

    friend INVENTOR_API SbVec3f operator *(const SbVec3f &v, float d);
    friend INVENTOR_API SbVec3f operator *(float d, const SbVec3f &v)
        { return v * d; }
    friend INVENTOR_API SbVec3f operator /(const SbVec3f &v, float d)
        { return v * (1.0f / d); }

    friend INVENTOR_API SbVec3f operator +(const SbVec3f &v1, const SbVec3f &v2);

    friend INVENTOR_API SbVec3f operator -(const SbVec3f &v1, const SbVec3f &v2);

    friend INVENTOR_API int             operator ==(const SbVec3f &v1, const SbVec3f &v2);
    friend INVENTOR_API int             operator !=(const SbVec3f &v1, const SbVec3f &v2)
        { return !(v1 == v2); }

    SbBool              equals(const SbVec3f v, float tolerance) const;

    SbVec3f             getClosestAxis() const;

  protected:
    float       vec[3];         
};







class INVENTOR_API SbVec2f {
  public:

    SbVec2f()                                           { }

    SbVec2f(const float v[2])                           { setValue(v); }

    SbVec2f(float x, float y)                           { setValue(x, y); }

    float       dot(const SbVec2f &v) const;

    const float *getValue() const                       { return vec; }

    void        getValue(float &x, float &y) const;

    float       length() const;

    void        negate();

    float       normalize();

    SbVec2f &   setValue(const float v[2]);

    SbVec2f &   setValue(float x, float y);

    float &       operator [](int i)            { return (vec[i]); }
    const float & operator [](int i) const      { return (vec[i]); }

    SbVec2f &   operator *=(float d);

    SbVec2f &   operator /=(float d)
        { return *this *= (1.0f / d); }

    SbVec2f &   operator +=(const SbVec2f &u);
    SbVec2f &   operator -=(const SbVec2f &u);

    SbVec2f     operator -() const;

    friend INVENTOR_API SbVec2f operator *(const SbVec2f &v, float d);
    friend INVENTOR_API SbVec2f operator *(float d, const SbVec2f &v)
        { return v * d; }
    friend INVENTOR_API SbVec2f operator /(const SbVec2f &v, float d)
        { return v * (1.0f / d); }

    friend INVENTOR_API SbVec2f operator +(const SbVec2f &v1, const SbVec2f &v2);

    friend INVENTOR_API SbVec2f operator -(const SbVec2f &v1, const SbVec2f &v2);

    friend INVENTOR_API int             operator ==(const SbVec2f &v1, const SbVec2f &v2);
    friend INVENTOR_API int             operator !=(const SbVec2f &v1, const SbVec2f &v2)
        { return !(v1 == v2); }

    SbBool              equals(const SbVec2f v, float tolerance) const;

  protected:
    float       vec[2];         
};







class INVENTOR_API SbVec2s {
  public:

    SbVec2s()                                           { }

    SbVec2s(const short v[2])                           { setValue(v); }

    SbVec2s(short x, short y)                           { setValue(x, y); }

    int32_t     dot(const SbVec2s &v) const;

    const short *getValue() const                       { return vec; }

    void        getValue(short &x, short &y) const;

    void        negate();

    SbVec2s &   setValue(const short v[2]);

    SbVec2s &   setValue(short x, short y);

    short &       operator [](int i)            { return (vec[i]); }
    const short & operator [](int i) const      { return (vec[i]); }

    SbVec2s &   operator *=(int d);
    SbVec2s &   operator *=(double d);

    SbVec2s &   operator /=(int d);
    SbVec2s &   operator /=(double d)
        { return *this *= (1.0 / d); }

    SbVec2s &   operator +=(const SbVec2s &u);
    SbVec2s &   operator -=(const SbVec2s &u);

    SbVec2s     operator -() const;

    friend INVENTOR_API SbVec2s operator *(const SbVec2s &v, int d);
    friend INVENTOR_API SbVec2s operator *(const SbVec2s &v, double d);
    friend INVENTOR_API SbVec2s operator *(int d, const SbVec2s &v)
        { return v * d; }
    friend INVENTOR_API SbVec2s operator *(double d, const SbVec2s &v)
        { return v * d; }
    friend INVENTOR_API SbVec2s operator /(const SbVec2s &v, int d);
    friend INVENTOR_API SbVec2s operator /(const SbVec2s &v, double d)
        { return v * (1.0 / d); }

    friend INVENTOR_API SbVec2s operator +(const SbVec2s &v1, const SbVec2s &v2);

    friend INVENTOR_API SbVec2s operator -(const SbVec2s &v1, const SbVec2s &v2);

    friend INVENTOR_API int             operator ==(const SbVec2s &v1, const SbVec2s &v2);
    friend INVENTOR_API int             operator !=(const SbVec2s &v1, const SbVec2s &v2)
        { return !(v1 == v2); }

  protected:
    short       vec[2];         
};


class INVENTOR_API SbVec3s {
  public:

    SbVec3s()                                           { }

    SbVec3s(const short v[3])                           { setValue(v); }

    SbVec3s(short x, short y, short z)                  { setValue(x, y, z); }

    int32_t     dot(const SbVec3s &v) const;

    const short *getValue() const                       { return vec; }

    void        getValue(short &x, short &y, short &z) const;

    void        negate();

    SbVec3s &   setValue(const short v[3]);

    SbVec3s &   setValue(short x, short y, short z);

    short &       operator [](int i)            { return (vec[i]); }
    const short & operator [](int i) const      { return (vec[i]); }

    SbVec3s &   operator *=(int d);
    SbVec3s &   operator *=(double d);

    SbVec3s &   operator /=(int d);
    SbVec3s &   operator /=(double d)
        { return *this *= (1.0 / d); }

    SbVec3s &   operator +=(const SbVec3s &u);
    SbVec3s &   operator -=(const SbVec3s &u);

    SbVec3s     operator -() const;

    friend INVENTOR_API SbVec3s operator *(const SbVec3s &v, int d);
    friend INVENTOR_API SbVec3s operator *(const SbVec3s &v, double d);
    friend INVENTOR_API SbVec3s operator *(int d, const SbVec3s &v)
        { return v * d; }
    friend INVENTOR_API SbVec3s operator *(double d, const SbVec3s &v)
        { return v * d; }
    friend INVENTOR_API SbVec3s operator /(const SbVec3s &v, int d);
    friend INVENTOR_API SbVec3s operator /(const SbVec3s &v, double d)
        { return v * (1.0 / d); }

    friend INVENTOR_API SbVec3s operator +(const SbVec3s &v1, const SbVec3s &v2);

    friend INVENTOR_API SbVec3s operator -(const SbVec3s &v1, const SbVec3s &v2);

    friend INVENTOR_API int             operator ==(const SbVec3s &v1, const SbVec3s &v2);
    friend INVENTOR_API int             operator !=(const SbVec3s &v1, const SbVec3s &v2)
        { return !(v1 == v2); }

  protected:
    short       vec[3];         
};







class INVENTOR_API SbVec4f {
  public:

    SbVec4f()                                           { }

    SbVec4f(const float v[4])                           { setValue(v); }

    SbVec4f(float x, float y, float z, float w)       { setValue(x, y, z, w); }

    float       dot(const SbVec4f &v) const;

    void        getReal(SbVec3f &v) const;

    const float *getValue() const                       { return vec; }

    void        getValue(float &x, float &y, float &z, float &w) const;

    float       length() const;

    void        negate();

    float       normalize();

    SbVec4f &   setValue(const float v[4]);

    SbVec4f &   setValue(float x, float y, float z, float w);

    float &       operator [](int i)            { return (vec[i]); }
    const float & operator [](int i) const      { return (vec[i]); }

    SbVec4f &   operator *=(float d);

    SbVec4f &   operator /=(float d)
        { return *this *= (1.0f / d); }

    SbVec4f &   operator +=(const SbVec4f &u);
    SbVec4f &   operator -=(const SbVec4f &u);

    SbVec4f     operator -() const;

    friend INVENTOR_API SbVec4f operator *(const SbVec4f &v, float d);
    friend INVENTOR_API SbVec4f operator *(float d, const SbVec4f &v)
        { return v * d; }
    friend INVENTOR_API SbVec4f operator /(const SbVec4f &v, float d)
        { return v * (1.0f / d); }

    friend INVENTOR_API SbVec4f operator +(const SbVec4f &v1, const SbVec4f &v2);

    friend INVENTOR_API SbVec4f operator -(const SbVec4f &v1, const SbVec4f &v2);

    friend INVENTOR_API int             operator ==(const SbVec4f &v1, const SbVec4f &v2);
    friend INVENTOR_API int             operator !=(const SbVec4f &v1, const SbVec4f &v2)
        { return !(v1 == v2); }

    SbBool              equals(const SbVec4f v, float tolerance) const;

  protected:
    float       vec[4];         
};







class INVENTOR_API SbRotation {
  public:

    SbRotation()
        {}

    SbRotation(const float v[4])
        { setValue(v); }

    SbRotation(float q0, float q1, float q2, float q3)
        { setValue(q0, q1, q2, q3); }

    SbRotation(const SbMatrix &m)
        { setValue(m); }

    SbRotation(const SbVec3f &axis, float radians)
        { setValue(axis, radians); }

    SbRotation(const SbVec3f &rotateFrom, const SbVec3f &rotateTo)
        { setValue(rotateFrom, rotateTo); }

    const float *       getValue() const
        { return (quat); }

    void                getValue(float &q0, float &q1,
                                 float &q2, float &q3) const;

    void                getValue(SbVec3f &axis, float &radians) const;

    void                getValue(SbMatrix &matrix) const;

    SbRotation &        invert();

    SbRotation          inverse() const
        { SbRotation q = *this; return q.invert(); }

    SbRotation &        setValue(const float q[4]);

    SbRotation &        setValue(float q0, float q1, float q2, float q3);

    SbRotation &        setValue(const SbMatrix &m);

    SbRotation &        setValue(const SbVec3f &axis, float radians);

    SbRotation &        setValue(const SbVec3f &rotateFrom,
                                 const SbVec3f &rotateTo);

    SbRotation &         operator *=(const SbRotation &q);

    friend INVENTOR_API int     operator ==(const SbRotation &q1, const SbRotation &q2);
    friend INVENTOR_API int     operator !=(const SbRotation &q1, const SbRotation &q2)
        { return !(q1 == q2); }

    SbBool              equals(const SbRotation &r, float tolerance) const;

    friend INVENTOR_API SbRotation      operator *(const SbRotation &q1, const SbRotation &q2);

    void        multVec(const SbVec3f &src, SbVec3f &dst) const;

    void scaleAngle( float scaleFactor );

    static SbRotation   slerp(const SbRotation &rot0,
                              const SbRotation &rot1, float t);

    static SbRotation   identity()
        { return SbRotation(0.0, 0.0, 0.0, 1.0); }

  private:
    float       quat[4];        

    float       norm() const;

    void        normalize();
};







class INVENTOR_API SbMatrix {
  public:

    SbMatrix()                                          { }

    SbMatrix(float a11, float a12, float a13, float a14,
             float a21, float a22, float a23, float a24, 
             float a31, float a32, float a33, float a34, 
             float a41, float a42, float a43, float a44);

    SbMatrix(const SbMat &m);

    void        setValue(const SbMat &m);

    void        setValue(const float* data);

    public:

    void        makeIdentity();

    static SbMatrix     identity();

    void        setRotate(const SbRotation &q);

    void        setScale(float s);

    void        setScale(const SbVec3f &s);

    void        setTranslate(const SbVec3f &t);

    void        setTransform(
                        const SbVec3f &translation,
                        const SbRotation &rotation,
                        const SbVec3f &scaleFactor,
                        const SbRotation &scaleOrientation,
                        const SbVec3f &center);
    void        setTransform(const SbVec3f &t, const SbRotation &r,
                             const SbVec3f &s)
                { setTransform(t, r, s,
                               SbRotation(0,0,0,1), SbVec3f(0,0,0)); }
    void        setTransform(const SbVec3f &t, const SbRotation &r,
                             const SbVec3f &s, const SbRotation &so)
                { setTransform(t, r, s, so, SbVec3f(0,0,0)); }

    void        getTransform(SbVec3f &translation,
                          SbRotation &rotation,
                          SbVec3f &scaleFactor,
                          SbRotation &scaleOrientation,
                          const SbVec3f &center) const;
    void        getTransform(SbVec3f &t, SbRotation &r,
                          SbVec3f &s, SbRotation &so) const
                { getTransform(t, r, s, so, SbVec3f(0,0,0)); }



    void        getValue(SbMat &m) const;
    const SbMat &       getValue() const { return matrix; }

    float       det3(int r1, int r2, int r3, int c1, int c2, int c3) const;

    float       det3() const { return det3(0, 1, 2, 0, 1, 2); }

    float       det4() const;

    SbBool      factor(SbMatrix &r, SbVec3f &s, SbMatrix &u,
                       SbVec3f &t, SbMatrix &proj) const;

    SbMatrix    inverse() const;

    SbBool      LUDecomposition(int index[4], float &d);

    void        LUBackSubstitution(int index[4], float b[4]) const;

    SbMatrix    transpose() const;

    SbMatrix &  multRight(const SbMatrix &m);   // this = this * m
    SbMatrix &  multLeft(const SbMatrix &m);    // this = m * this

    void        multMatrixVec(const SbVec3f &src, SbVec3f &dst) const;

    void        multVecMatrix(const SbVec3f &src, SbVec3f &dst) const;
    void        multVecMatrix(const SbVec4f &src, SbVec4f &dst) const;
    void        multVecMatrix(const SbVec3f &src, SbVec4f &dst) const;

    void        multDirMatrix(const SbVec3f &src, SbVec3f &dst) const;

    void        multLineMatrix(const SbLine &src, SbLine &dst) const;

    void        print(FILE *fp) const;

    operator float *()          { return &matrix[0][0]; }

    operator SbMat &()          { return matrix; }

    float *       operator [](int i)        { return &matrix[i][0]; }
    const float * operator [](int i) const  { return &matrix[i][0]; }

    SbMatrix &  operator =(const SbMat &m);

    SbMatrix &  operator =(const SbMatrix &m);

    SbMatrix &  operator =(const SbRotation &q) { setRotate(q); return *this; }

    SbMatrix &  operator *=(const SbMatrix &m)  { return multRight(m); }

    friend INVENTOR_API SbMatrix        operator *(const SbMatrix &m1, const SbMatrix &m2);

    friend INVENTOR_API int             operator ==(const SbMatrix &m1, const SbMatrix &m2);
    friend INVENTOR_API int             operator !=(const SbMatrix &m1, const SbMatrix &m2)
        { return !(m1 == m2); }

    SbBool              equals(const SbMatrix &m, float tolerance) const;

  private:
    SbMat       matrix;         

    void        jacobi3(float evalues[3], SbVec3f evectors[3], int &rots) const;

    SbBool affine_inverse(const SbMatrix &in, SbMatrix &out) const;
};






class INVENTOR_API SbViewVolume {
  public:

    SbViewVolume();
    ~SbViewVolume()                            {}

    void                getMatrices(SbMatrix &affine, SbMatrix &proj) const;

    SbMatrix            getMatrix() const;

    SbMatrix            getCameraSpaceMatrix() const;

    void                projectPointToLine(const SbVec2f &pt,
                                        SbLine &line) const;
    void                projectPointToLine(const SbVec2f &pt,
                                       SbVec3f &line0, SbVec3f &line1) const;

    void                projectToScreen(const SbVec3f &src,
                                        SbVec3f &dst) const;

    SbPlane             getPlane(float distFromEye) const;

    SbVec3f             getSightPoint(float distFromEye) const;

    SbVec3f             getPlanePoint(float distFromEye,
                                      const SbVec2f &normPoint) const;

    SbRotation          getAlignRotation(SbBool rightAngleOnly = FALSE) const;

    float               getWorldToScreenScale(const SbVec3f &worldCenter,
                                              float normRadius) const;

    SbVec2f             projectBox(const SbBox3f &box) const;

    SbViewVolume        narrow(float left,  float bottom,
                               float right, float top) const;

    SbViewVolume        narrow(const SbBox3f &box) const;

    void                ortho(float left,   float right,
                              float bottom, float top,
                              float nearVal,   float farVal);

    void                perspective(float fovy, float aspect,
                                    float nearVal, float farVal);

    void                rotateCamera(const SbRotation &q);

    void                translateCamera(const SbVec3f &v);

    SbVec3f             zVector() const;

    SbViewVolume        zNarrow(float nearVal, float farVal) const;

    void                scale(float factor);

    void                scaleWidth(float ratio);
    void                scaleHeight(float ratio);

    enum ProjectionType { 
        ORTHOGRAPHIC, 
        PERSPECTIVE 
    };

    ProjectionType      getProjectionType() const  { return type; }

    const SbVec3f &     getProjectionPoint() const { return projPoint; }

    const SbVec3f &     getProjectionDirection() const   { return projDir; }

    float               getNearDist() const        { return nearDist; }

    float               getWidth() const      { return (lrfO-llfO).length(); }
    float               getHeight() const     { return (ulfO-llfO).length(); }
    float               getDepth() const      { return nearToFar; }

  SoINTERNAL public:
    ProjectionType type;

    SbVec3f     projPoint;              
    SbVec3f     projDir;
    float       nearDist;               
    float       nearToFar;              
    SbVec3f     llf;
    SbVec3f     lrf;
    SbVec3f     ulf;

    void        transform(const SbMatrix &matrix);

    SbBool      intersect(const SbVec3f &point) const;

    SbBool      intersect(const SbVec3f &p0, const SbVec3f &p1,
                          SbVec3f &closestPoint) const;

    SbBool      intersect(const SbBox3f &box) const;

    SbBool      outsideTest(const SbPlane &p,
                        const SbVec3f &min, const SbVec3f &max) const;

  private:
    SbVec3f     llfO;                   
    SbVec3f     lrfO;                   
    SbVec3f     ulfO;                   
};






class INVENTOR_API SbLine {
  public:
    SbLine()    {}

    SbLine(const SbVec3f &p0, const SbVec3f &p1);

    void                setValue(const SbVec3f &p0, const SbVec3f &p1);

    SbBool              getClosestPoints(const SbLine  &line2,
                                         SbVec3f &ptOnThis,
                                         SbVec3f &ptOnLine2 ) const;

    SbVec3f             getClosestPoint(const SbVec3f &point) const;

    const SbVec3f &     getPosition() const     { return pos; }
    const SbVec3f &     getDirection() const    { return dir; }


  SoINTERNAL public:
    SbBool              intersect( const SbBox3f &box,
                                   SbVec3f &enter, SbVec3f &exit ) const;
    SbBool              intersect( float angle, const SbBox3f &box ) const;
    SbBool              intersect( float angle, const SbVec3f &point ) const;
    SbBool              intersect( float angle, const SbVec3f &v0,
                                   const SbVec3f &v1, SbVec3f &pt ) const;
    SbBool              intersect( const SbVec3f &v0,
                                  const SbVec3f &v1,
                                  const SbVec3f &v2,
                                  SbVec3f &pt, SbVec3f &barycentric,
                                  SbBool &front ) const;

  private:
    SbVec3f     pos;
    SbVec3f     dir;
};






class INVENTOR_API SbPlane {
  public:
    SbPlane()   {}

    SbPlane(const SbVec3f &p0, const SbVec3f &p1, const SbVec3f &p2);

    SbPlane(const SbVec3f &n, float d);

    SbPlane(const SbVec3f &n, const SbVec3f &p);

    void                offset(float d);

    SbBool              intersect(const SbLine &l,
                                  SbVec3f &intersection) const;

    void                transform(const SbMatrix &matrix);

    SbBool              isInHalfSpace(const SbVec3f &point) const;

    float getDistance(const SbVec3f &point) const;

    const SbVec3f &     getNormal() const               { return normalVec; }
    float               getDistanceFromOrigin() const   { return distance; }

    friend INVENTOR_API int             operator ==(const SbPlane &p1, const SbPlane &p2);
    friend INVENTOR_API int             operator !=(const SbPlane &p1, const SbPlane &p2)
        { return !(p1 == p2); }

  private:

    SbVec3f     normalVec;

    float       distance;
};





class INVENTOR_API SbCylinder {
  public:

    SbCylinder();

    SbCylinder(const SbLine &a, float r);

    void        setValue(const SbLine &a, float r);

    void        setAxis(const SbLine &a);
    void        setRadius(float r);

    const SbLine &      getAxis() const                 { return axis; }
    float               getRadius() const               { return radius; }

    SbBool      intersect(const SbLine &l, SbVec3f &intersection) const;
    SbBool      intersect(const SbLine &l,
                          SbVec3f &enter, SbVec3f &exit) const;

  private:
    SbLine      axis;
    float       radius;

    static SbBool       unitCylinderIntersect(const SbLine &l,
                                              SbVec3f &in, SbVec3f &out);
};







class INVENTOR_API SbSphere {
  public:

    SbSphere()  {}

    SbSphere(const SbVec3f &c, float r);

    void        setValue(const SbVec3f &c, float r);

    void        setCenter(const SbVec3f &c);
    void        setRadius(float r);

    const SbVec3f &     getCenter() const               { return center; }
    float               getRadius() const               { return radius; }

    void        circumscribe(const SbBox3f &box);

    SbBool      intersect(const SbLine &l, SbVec3f &intersection) const;
    SbBool      intersect(const SbLine &l, SbVec3f &enter, SbVec3f &exit) const;

  private:
    SbVec3f     center;
    float       radius;
};

#endif /* _SB_LINEAR_ */