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() { vec[0] = 0.f; vec[1] = 0.f; vec[2] = 0.f; }
 
    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);
    friend INVENTOR_API SbVec3f operator /(const SbVec3f &v, float 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 bool               operator ==(const SbVec3f &v1, const SbVec3f &v2);
    friend INVENTOR_API bool               operator !=(const SbVec3f &v1, const SbVec3f &v2);
 
    bool                equals(const SbVec3f v, float tolerance) const;
 
    SbVec3f             getClosestAxis() const;
 
  protected:
    float       vec[3];         
};
 
INVENTOR_API SbVec3f        operator *(const SbVec3f &v, float d);
inline INVENTOR_API SbVec3f operator *(float d, const SbVec3f &v)
{ return v * d; }
inline INVENTOR_API SbVec3f operator /(const SbVec3f &v, float d)
{ return v * (1.0f / d); }
 
INVENTOR_API SbVec3f    operator +(const SbVec3f &v1, const SbVec3f &v2);
INVENTOR_API SbVec3f    operator -(const SbVec3f &v1, const SbVec3f &v2);
INVENTOR_API bool          operator ==(const SbVec3f &v1, const SbVec3f &v2);
inline INVENTOR_API bool operator !=(const SbVec3f &v1, const SbVec3f &v2)
{ return !(v1 == v2); }
 
 
 
 
 
 
class INVENTOR_API SbVec2f {
  public:
 
    SbVec2f() { vec[0] = 0.f; vec[1] = 0.f; }
 
    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);
    friend INVENTOR_API SbVec2f operator /(const SbVec2f &v, float 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 bool               operator ==(const SbVec2f &v1, const SbVec2f &v2);
    friend INVENTOR_API bool               operator !=(const SbVec2f &v1, const SbVec2f &v2);
 
    bool                equals(const SbVec2f v, float tolerance) const;
 
  protected:
    float       vec[2];         
};
 
INVENTOR_API        SbVec2f operator *(const SbVec2f &v, float d);
inline INVENTOR_API SbVec2f operator *(float d, const SbVec2f &v)
{ return v * d; }
inline INVENTOR_API SbVec2f operator /(const SbVec2f &v, float d)
{ return v * (1.0f / d); }
 
INVENTOR_API SbVec2f operator +(const SbVec2f &v1, const SbVec2f &v2);
 
INVENTOR_API SbVec2f operator -(const SbVec2f &v1, const SbVec2f &v2);
 
INVENTOR_API bool               operator ==(const SbVec2f &v1, const SbVec2f &v2);
inline INVENTOR_API bool        operator !=(const SbVec2f &v1, const SbVec2f &v2)
{ return !(v1 == v2); }
 
 
 
 
 
class INVENTOR_API SbVec2s {
  public:
 
    SbVec2s() { vec[0] = 0; vec[1] = 0; }
 
    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);
    friend INVENTOR_API SbVec2s operator *(double d, const SbVec2s &v);
    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 +(const SbVec2s &v1, const SbVec2s &v2);
 
    friend INVENTOR_API SbVec2s operator -(const SbVec2s &v1, const SbVec2s &v2);
 
    friend INVENTOR_API bool               operator ==(const SbVec2s &v1, const SbVec2s &v2);
    friend INVENTOR_API bool               operator !=(const SbVec2s &v1, const SbVec2s &v2);
 
  protected:
    short       vec[2];         
};
 
INVENTOR_API SbVec2s operator *(const SbVec2s &v, int d);
INVENTOR_API SbVec2s operator *(const SbVec2s &v, double d);
inline INVENTOR_API SbVec2s operator *(int d, const SbVec2s &v)
{ return v * d; }
inline INVENTOR_API SbVec2s operator *(double d, const SbVec2s &v)
{ return v * d; }
INVENTOR_API SbVec2s operator /(const SbVec2s &v, int d);
inline INVENTOR_API SbVec2s operator /(const SbVec2s &v, double d)
{ return v * (1.0 / d); }
 
INVENTOR_API SbVec2s operator +(const SbVec2s &v1, const SbVec2s &v2);
INVENTOR_API SbVec2s operator -(const SbVec2s &v1, const SbVec2s &v2);
 
INVENTOR_API bool               operator ==(const SbVec2s &v1, const SbVec2s &v2);
inline INVENTOR_API bool               operator !=(const SbVec2s &v1, const SbVec2s &v2)
{ return !(v1 == v2); }
 
 
class INVENTOR_API SbVec3s {
  public:
 
    SbVec3s() { vec[0] = 0; vec[1] = 0; vec[2] = 0; }
 
    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);
    friend INVENTOR_API SbVec3s operator *(double d, const SbVec3s &v);
    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 +(const SbVec3s &v1, const SbVec3s &v2);
 
    friend INVENTOR_API SbVec3s operator -(const SbVec3s &v1, const SbVec3s &v2);
 
    friend INVENTOR_API bool               operator ==(const SbVec3s &v1, const SbVec3s &v2);
    friend INVENTOR_API bool               operator !=(const SbVec3s &v1, const SbVec3s &v2);
 
  protected:
    short       vec[3];         
};
 
 
INVENTOR_API SbVec3s operator *(const SbVec3s &v, int d);
INVENTOR_API SbVec3s operator *(const SbVec3s &v, double d);
inline INVENTOR_API SbVec3s operator *(int d, const SbVec3s &v)
{ return v * d; }
inline INVENTOR_API SbVec3s operator *(double d, const SbVec3s &v)
{ return v * d; }
INVENTOR_API SbVec3s operator /(const SbVec3s &v, int d);
inline INVENTOR_API SbVec3s operator /(const SbVec3s &v, double d)
{ return v * (1.0 / d); }
 
INVENTOR_API SbVec3s operator +(const SbVec3s &v1, const SbVec3s &v2);
INVENTOR_API SbVec3s operator -(const SbVec3s &v1, const SbVec3s &v2);
 
INVENTOR_API bool               operator ==(const SbVec3s &v1, const SbVec3s &v2);
inline INVENTOR_API bool        operator !=(const SbVec3s &v1, const SbVec3s &v2)
{ return !(v1 == v2); }
 
 
 
 
class INVENTOR_API SbVec4f {
  public:
 
    SbVec4f() { vec[0] = 0.f; vec[1] = 0.f; vec[2] = 0.f; vec[3] = 0.f; }
 
    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;
 
    SbVec3f     getReal() const { SbVec3f tmp; getReal(tmp); return tmp; }
 
    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);
    friend INVENTOR_API SbVec4f operator /(const SbVec4f &v, float 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 bool               operator ==(const SbVec4f &v1, const SbVec4f &v2);
    friend INVENTOR_API bool               operator !=(const SbVec4f &v1, const SbVec4f &v2);
 
    bool                equals(const SbVec4f v, float tolerance) const;
 
  protected:
    float       vec[4];         
};
 
INVENTOR_API SbVec4f operator *(const SbVec4f &v, float d);
inline INVENTOR_API SbVec4f operator *(float d, const SbVec4f &v)
{ return v * d; }
inline INVENTOR_API SbVec4f operator /(const SbVec4f &v, float d)
{ return v * (1.0f / d); }
 
INVENTOR_API SbVec4f operator +(const SbVec4f &v1, const SbVec4f &v2);
 
INVENTOR_API SbVec4f operator -(const SbVec4f &v1, const SbVec4f &v2);
 
INVENTOR_API bool               operator ==(const SbVec4f &v1, const SbVec4f &v2);
inline INVENTOR_API bool        operator !=(const SbVec4f &v1, const SbVec4f &v2)
{ return !(v1 == v2); }
 
 
 
 
 
class INVENTOR_API SbRotation {
  public:
 
    SbRotation()
    { quat[0] = 0.f; quat[1] = 0.f; quat[2] = 0.f; quat[3] = 1.f; }
 
    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;
 
    SbMatrix getMatrix() const;
    
    SbVec3f getAxis() const { SbVec3f axis; float radians; getValue(axis, radians); return axis; }
    float   getAngle() const { SbVec3f axis; float radians; getValue(axis, radians); return radians; }
 
    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 bool       operator ==(const SbRotation &q1, const SbRotation &q2);
    friend INVENTOR_API bool       operator !=(const SbRotation &q1, const SbRotation &q2);
 
    bool                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;
 
    SbVec3f     transformPoint(const SbVec3f &src) const { SbVec3f dst; multVec(src, dst); return dst; }
 
    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();
};
 
INVENTOR_API        bool       operator ==(const SbRotation &q1, const SbRotation &q2);
inline INVENTOR_API bool       operator !=(const SbRotation &q1, const SbRotation &q2)
{ return !(q1 == q2); }
INVENTOR_API SbRotation     operator *(const SbRotation &q1, const SbRotation &q2);
 
 
 
 
 
class INVENTOR_API SbMatrix {
  public:
 
    SbMatrix() {
      makeIdentity();
    }
 
    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;
 
    bool        factor(SbMatrix &r, SbVec3f &s, SbMatrix &u,
                       SbVec3f &t, SbMatrix &proj) const;
 
    SbMatrix    inverse() const;
 
    bool        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
 
    SbVec3f     transformPoint(const SbVec3f &src) const { SbVec3f dst; multVecMatrix(src, dst); return dst; }
    SbVec4f     transformPoint(const SbVec4f &src) const { SbVec4f dst; multVecMatrix(src, dst); return dst; }
 
    SbVec3f     transformDirection(const SbVec3f &src) const { SbVec3f dst; multDirMatrix(src, dst); return dst; }
 
    SbLine     transformLine(const SbLine &src) const;
 
    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 bool               operator ==(const SbMatrix &m1, const SbMatrix &m2);
    friend INVENTOR_API bool               operator !=(const SbMatrix &m1, const SbMatrix &m2);
 
    bool                equals(const SbMatrix &m, float tolerance) const;
 
  private:
    SbMat       matrix;         
 
    void        jacobi3(float evalues[3], SbVec3f evectors[3], int &rots) const;
 
    bool affine_inverse(const SbMatrix &in, SbMatrix &out) const;
};
 
INVENTOR_API SbMatrix        operator *(const SbMatrix &m1, const SbMatrix &m2);
 
INVENTOR_API        bool               operator ==(const SbMatrix &m1, const SbMatrix &m2);
inline INVENTOR_API bool               operator !=(const SbMatrix &m1, const SbMatrix &m2)
{ return !(m1 == m2); }
 
 
 
 
class INVENTOR_API SbViewVolume {
  public:
 
    SbViewVolume();
    ~SbViewVolume()                            {}
 
    void                getMatrices(SbMatrix &affine, SbMatrix &proj) const;
 
    SbMatrix            getViewingMatrix() const { SbMatrix affine; SbMatrix proj; getMatrices(affine, proj); return affine; }
 
    SbMatrix            getProjectionMatrix() const { SbMatrix affine; SbMatrix proj; getMatrices(affine, proj); return proj; }
 
    SbMatrix            getMatrix() const;
 
    SbMatrix            getCameraSpaceMatrix() const;
 
    void                projectPointToLine(const SbVec2f &pt,
                                        SbLine &line) const;
    void                projectPointToLine(const SbVec2f &pt,
                                       SbVec3f &line0, SbVec3f &line1) const;
    SbLine              projectPointToLine(const SbVec2f &pt) const;
    
    void                projectToScreen(const SbVec3f &src,
                                        SbVec3f &dst) const;
 
    SbVec3f              projectToScreen(const SbVec3f &src) const { SbVec3f dst; projectToScreen(src, dst); return dst; }
 
    SbPlane             getPlane(float distFromEye) const;
 
    SbVec3f             getSightPoint(float distFromEye) const;
 
    SbVec3f             getPlanePoint(float distFromEye,
                                      const SbVec2f &normPoint) const;
 
    SbRotation          getAlignRotation(bool 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               getFarDist() const        { return nearDist + nearToFar; }
 
    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);
 
    bool        intersect(const SbVec3f &point) const;
 
    bool        intersect(const SbVec3f &p0, const SbVec3f &p1,
                          SbVec3f &closestPoint) const;
 
    bool        intersect(const SbBox3f &box) const;
 
    bool        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);
 
    bool                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:
    bool                intersect( const SbBox3f &box,
                                   SbVec3f &enter, SbVec3f &exit ) const;
    bool                intersect( float angle, const SbBox3f &box ) const;
    bool                intersect( float angle, const SbVec3f &point ) const;
    bool                intersect( float angle, const SbVec3f &v0,
                                   const SbVec3f &v1, SbVec3f &pt ) const;
    bool                intersect( const SbVec3f &v0,
                                  const SbVec3f &v1,
                                  const SbVec3f &v2,
                                  SbVec3f &pt, SbVec3f &barycentric,
                                  bool &front ) const;
 
  private:
    SbVec3f     pos;
    SbVec3f     dir;
};
 
 
 
 
 
class INVENTOR_API SbPlane {
  public:
    SbPlane() { distance = 0.f; }
 
    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);
 
    bool                intersect(const SbLine &l,
                                  SbVec3f &intersection) const;
 
    void                transform(const SbMatrix &matrix);
 
    bool                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 bool               operator ==(const SbPlane &p1, const SbPlane &p2);
    friend INVENTOR_API bool               operator !=(const SbPlane &p1, const SbPlane &p2);
 
  private:
 
    SbVec3f     normalVec;
 
    float       distance;
};
 
INVENTOR_API        bool               operator ==(const SbPlane &p1, const SbPlane &p2);
inline INVENTOR_API bool               operator !=(const SbPlane &p1, const SbPlane &p2)
{ return !(p1 == p2); }
 
 
 
 
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; }
 
    bool        intersect(const SbLine &l, SbVec3f &intersection) const;
    bool        intersect(const SbLine &l,
                          SbVec3f &enter, SbVec3f &exit) const;
 
  private:
    SbLine      axis;
    float       radius;
 
    static bool         unitCylinderIntersect(const SbLine &l,
                                              SbVec3f &in, SbVec3f &out);
};
 
 
 
 
 
 
class INVENTOR_API SbSphere {
  public:
 
    SbSphere() { radius = 0.f; }
 
    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);
 
    bool        intersect(const SbLine &l, SbVec3f &intersection) const;
    bool        intersect(const SbLine &l, SbVec3f &enter, SbVec3f &exit) const;
 
  private:
    SbVec3f     center;
    float       radius;
};
 
#endif /* _SB_LINEAR_ */