Matrix3f.h

Go to the documentation of this file.

//    Copyright 2004, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    H3D API 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 General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//

#ifndef __MATRIX3F_H__
#define __MATRIX3F_H__

#include "H3DApi.h"
#include "H3DBasicTypes.h"
#include "Vec3f.h"
#include "Exception.h"

namespace H3D {
  namespace ArithmeticTypes {
    class Quaternion;
    class Rotation;
    class Matrix3d;

    class H3DAPI_API Matrix3f {
    public:
      H3D_API_EXCEPTION( SingularMatrix3f );

      inline Matrix3f() {
        setToIdentity();
      }

      inline Matrix3f( H3DFloat m00, H3DFloat m01, H3DFloat m02,
                       H3DFloat m10, H3DFloat m11, H3DFloat m12,
                       H3DFloat m20, H3DFloat m21, H3DFloat m22 ) {
        m[0][0] = m00; m[0][1] = m01; m[0][2] = m02; 
        m[1][0] = m10; m[1][1] = m11; m[1][2] = m12; 
        m[2][0] = m20; m[2][1] = m21; m[2][2] = m22; 
      }

      Matrix3f( const Rotation &r );

      Matrix3f( const Quaternion &q );

      explicit Matrix3f( const Matrix3d &v );

      inline void setToIdentity() {
        m[0][0] = 1; m[0][1] = 0; m[0][2] = 0;
        m[1][0] = 0; m[1][1] = 1; m[1][2] = 0;
        m[2][0] = 0; m[2][1] = 0; m[2][2] = 1;
      }
                                
      inline Matrix3f transpose() const {
        return Matrix3f( m[0][0], m[1][0], m[2][0],
                                                                                                 m[0][1], m[1][1], m[2][1],
                                                                                                 m[0][2], m[1][2], m[2][2] );
      };

      Matrix3f inverse() const;

      inline H3DFloat* operator[]( int i ) { return m[i]; }

      inline const H3DFloat* operator[]( int i ) const { return m[i]; }

      inline Vec3f getRow( int i ) const { 
        return Vec3f( m[i][0], m[i][1], m[i][2] ); 
      }

      inline H3DFloat getElement( int i, int j ) const { 
        return m[i][j];
      }

      inline void setElement( int i, int j, H3DFloat v ) { 
        m[i][j] = v;
      }

      Vec3f getScalePart() const;

      Vec3f toEulerAngles();

      inline Vec3f getColumn( int i ) const { 
        return Vec3f( m[0][i], m[1][i], m[2][i] ); 
      }

    private:
      H3DFloat m[3][3];
    };
    
                                
    inline Matrix3f operator*( const Matrix3f &m1, const Matrix3f &m2 ) {
      return Matrix3f( 
                      m1[0][0]*m2[0][0] + m1[0][1]*m2[1][0] + m1[0][2]*m2[2][0],
                      m1[0][0]*m2[0][1] + m1[0][1]*m2[1][1] + m1[0][2]*m2[2][1],
                      m1[0][0]*m2[0][2] + m1[0][1]*m2[1][2] + m1[0][2]*m2[2][2],
                      m1[1][0]*m2[0][0] + m1[1][1]*m2[1][0] + m1[1][2]*m2[2][0],
                      m1[1][0]*m2[0][1] + m1[1][1]*m2[1][1] + m1[1][2]*m2[2][1],
                      m1[1][0]*m2[0][2] + m1[1][1]*m2[1][2] + m1[1][2]*m2[2][2],
                      m1[2][0]*m2[0][0] + m1[2][1]*m2[1][0] + m1[2][2]*m2[2][0],
                      m1[2][0]*m2[0][1] + m1[2][1]*m2[1][1] + m1[2][2]*m2[2][1],
                      m1[2][0]*m2[0][2] + m1[2][1]*m2[1][2] + m1[2][2]*m2[2][2] );
    }
    
    inline Matrix3f operator+( const Matrix3f &m1, const Matrix3f &m2 ) {
      return Matrix3f( 
                      m1[0][0]+m2[0][0], m1[0][1]+m2[0][1], m1[0][2]+m2[0][2],
                      m1[1][0]+m2[1][0], m1[1][1]+m2[1][1], m1[1][2]+m2[1][2],
                      m1[2][0]+m2[2][0], m1[2][1]+m2[2][1], m1[2][2]+m2[2][2] );
    }
                
    inline Matrix3f operator*( const Matrix3f &m, const float &f ) {
      return Matrix3f( m[0][0]*f, m[0][1]*f, m[0][2]*f,
                       m[1][0]*f, m[1][1]*f, m[1][2]*f,
                       m[2][0]*f, m[2][1]*f, m[2][2]*f );
    }

    inline Matrix3f operator*( const Matrix3f &m, const double &d ) {
      return Matrix3f( 
   (H3DFloat)(m[0][0]*d), (H3DFloat)(m[0][1]*d), (H3DFloat)(m[0][2]*d),
   (H3DFloat)(m[1][0]*d), (H3DFloat)(m[1][1]*d), (H3DFloat)(m[1][2]*d),
   (H3DFloat)(m[2][0]*d), (H3DFloat)(m[2][1]*d), (H3DFloat)(m[2][2]*d ));
    }

    inline Matrix3f operator*( const Matrix3f &m, const int &f ) {
      return Matrix3f( m[0][0]*f, m[0][1]*f, m[0][2]*f,
                       m[1][0]*f, m[1][1]*f, m[1][2]*f,
                       m[2][0]*f, m[2][1]*f, m[2][2]*f );
    }

    inline Matrix3f operator*( const Matrix3f &m, const long &f ) {
      return Matrix3f( m[0][0]*f, m[0][1]*f, m[0][2]*f,
                       m[1][0]*f, m[1][1]*f, m[1][2]*f,
                       m[2][0]*f, m[2][1]*f, m[2][2]*f );
    }

    inline bool operator==( const Matrix3f &m1, const Matrix3f &m2 ) {
      return (
         m1[0][0]==m2[0][0] && m1[0][1]==m2[0][1] && m1[0][2]==m2[0][2] &&
         m1[1][0]==m2[1][0] && m1[1][1]==m2[1][1] && m1[1][2]==m2[1][2] && 
         m1[2][0]==m2[2][0] && m1[2][1]==m2[2][1] && m1[2][2]==m2[2][2] 
         );
     }

          H3DAPI_API ostream& operator<<( ostream &os, const Matrix3f &m );

    inline Matrix3f operator*( const float &a, const Matrix3f &b ) { return b * a; }

    inline Matrix3f operator*( const double &a, const Matrix3f &b ) { return b * a; }

    inline Matrix3f operator*( const int &a, const Matrix3f &b ) { return b * a; }

    inline Matrix3f operator*( const long &a, const Matrix3f &b ) { return b * a; }
    
    inline Matrix3f operator-( const Matrix3f &m ) { return m * -1; }
    
    inline Matrix3f operator-( const Matrix3f &a, const Matrix3f &b ) 
        { return a + (-b); }

  }
}

#endif

---