IceMatrix3x3.h
Go to the documentation of this file.
00001 
00002 
00008 
00009 
00011 // Include Guard
00012 #ifndef __ICEMATRIX3X3_H__
00013 #define __ICEMATRIX3X3_H__
00014 
00015         // Forward declarations
00016         class Quat;
00017 
00018         #define MATRIX3X3_EPSILON               (1.0e-7f)
00019 
00020         class ICEMATHS_API Matrix3x3
00021         {
00022                 public:
00024                 inline_                                 Matrix3x3()                                                                     {}
00026                 inline_                                 Matrix3x3(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)
00027                                                                 {
00028                                                                         m[0][0] = m00;  m[0][1] = m01;  m[0][2] = m02;
00029                                                                         m[1][0] = m10;  m[1][1] = m11;  m[1][2] = m12;
00030                                                                         m[2][0] = m20;  m[2][1] = m21;  m[2][2] = m22;
00031                                                                 }
00033                 inline_                                 Matrix3x3(const Matrix3x3& mat)                         { CopyMemory(m, &mat.m, 9*sizeof(float));       }
00035                 inline_                                 ~Matrix3x3()                                                            {}
00036 
00038                 inline_ void                    Set(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)
00039                                                                 {
00040                                                                         m[0][0] = m00;  m[0][1] = m01;  m[0][2] = m02;
00041                                                                         m[1][0] = m10;  m[1][1] = m11;  m[1][2] = m12;
00042                                                                         m[2][0] = m20;  m[2][1] = m21;  m[2][2] = m22;
00043                                                                 }
00044 
00046                 inline_ void                    SetScale(const Point& p)                                        { m[0][0] = p.x;        m[1][1] = p.y;  m[2][2] = p.z;  }
00047 
00049                 inline_ void                    SetScale(float sx, float sy, float sz)          { m[0][0] = sx;         m[1][1] = sy;   m[2][2] = sz;   }
00050 
00052                 inline_ void                    Scale(const Point& p)
00053                                                                 {
00054                                                                         m[0][0] *= p.x; m[0][1] *= p.x; m[0][2] *= p.x;
00055                                                                         m[1][0] *= p.y; m[1][1] *= p.y; m[1][2] *= p.y;
00056                                                                         m[2][0] *= p.z; m[2][1] *= p.z; m[2][2] *= p.z;
00057                                                                 }
00058 
00060                 inline_ void                    Scale(float sx, float sy, float sz)
00061                                                                 {
00062                                                                         m[0][0] *= sx;  m[0][1] *= sx;  m[0][2] *= sx;
00063                                                                         m[1][0] *= sy;  m[1][1] *= sy;  m[1][2] *= sy;
00064                                                                         m[2][0] *= sz;  m[2][1] *= sz;  m[2][2] *= sz;
00065                                                                 }
00066 
00068                 inline_ void                    Copy(const Matrix3x3& source)                           { CopyMemory(m, source.m, 9*sizeof(float));                     }
00069 
00070                 // Row-column access
00072                 inline_ void                    GetRow(const udword r, Point& p)        const   { p.x = m[r][0];        p.y = m[r][1];  p.z = m[r][2];  }
00074                 inline_ const Point&    GetRow(const udword r)                          const   { return *(const Point*)&m[r][0];       }
00076                 inline_ Point&                  GetRow(const udword r)                                          { return *(Point*)&m[r][0];                     }
00078                 inline_ void                    SetRow(const udword r, const Point& p)          { m[r][0] = p.x;        m[r][1] = p.y;  m[r][2] = p.z;  }
00080                 inline_ void                    GetCol(const udword c, Point& p)        const   { p.x = m[0][c];        p.y = m[1][c];  p.z = m[2][c];  }
00082                 inline_ void                    SetCol(const udword c, const Point& p)          { m[0][c] = p.x;        m[1][c] = p.y;  m[2][c] = p.z;  }
00083 
00085                 inline_ float                   Trace()                                 const                           { return m[0][0] + m[1][1] + m[2][2];                           }
00087                 inline_ void                    Zero()                                                                          { ZeroMemory(&m, sizeof(m));                                            }
00089                 inline_ void                    Identity()                                                                      { Zero(); m[0][0] = m[1][1] = m[2][2] = 1.0f;           }
00091                 inline_ bool                    IsIdentity()                    const
00092                                                                 {
00093                                                                         if(IR(m[0][0])!=IEEE_1_0)       return false;
00094                                                                         if(IR(m[0][1])!=0)                      return false;
00095                                                                         if(IR(m[0][2])!=0)                      return false;
00096 
00097                                                                         if(IR(m[1][0])!=0)                      return false;
00098                                                                         if(IR(m[1][1])!=IEEE_1_0)       return false;
00099                                                                         if(IR(m[1][2])!=0)                      return false;
00100 
00101                                                                         if(IR(m[2][0])!=0)                      return false;
00102                                                                         if(IR(m[2][1])!=0)                      return false;
00103                                                                         if(IR(m[2][2])!=IEEE_1_0)       return false;
00104 
00105                                                                         return true;
00106                                                                 }
00107 
00109                 inline_ BOOL                    IsValid()                               const
00110                                                                 {
00111                                                                         for(udword j=0;j<3;j++)
00112                                                                         {
00113                                                                                 for(udword i=0;i<3;i++)
00114                                                                                 {
00115                                                                                         if(!IsValidFloat(m[j][i]))      return FALSE;
00116                                                                                 }
00117                                                                         }
00118                                                                         return TRUE;
00119                                                                 }
00120 
00127                 inline_ void                    SkewSymmetric(const Point& a)
00128                                                                 {
00129                                                                         m[0][0] = 0.0f;
00130                                                                         m[0][1] = -a.z;
00131                                                                         m[0][2] = a.y;
00132 
00133                                                                         m[1][0] = a.z;
00134                                                                         m[1][1] = 0.0f;
00135                                                                         m[1][2] = -a.x;
00136 
00137                                                                         m[2][0] = -a.y;
00138                                                                         m[2][1] = a.x;
00139                                                                         m[2][2] = 0.0f;
00140                                                                 }
00141 
00143                 inline_ void                    Neg()
00144                                                                 {
00145                                                                         m[0][0] = -m[0][0];     m[0][1] = -m[0][1];     m[0][2] = -m[0][2];
00146                                                                         m[1][0] = -m[1][0];     m[1][1] = -m[1][1];     m[1][2] = -m[1][2];
00147                                                                         m[2][0] = -m[2][0];     m[2][1] = -m[2][1];     m[2][2] = -m[2][2];
00148                                                                 }
00149 
00151                 inline_ void                    Neg(const Matrix3x3& mat)
00152                                                                 {
00153                                                                         m[0][0] = -mat.m[0][0]; m[0][1] = -mat.m[0][1]; m[0][2] = -mat.m[0][2];
00154                                                                         m[1][0] = -mat.m[1][0]; m[1][1] = -mat.m[1][1]; m[1][2] = -mat.m[1][2];
00155                                                                         m[2][0] = -mat.m[2][0]; m[2][1] = -mat.m[2][1]; m[2][2] = -mat.m[2][2];
00156                                                                 }
00157 
00159                 inline_ void                    Add(const Matrix3x3& mat)
00160                                                                 {
00161                                                                         m[0][0] += mat.m[0][0]; m[0][1] += mat.m[0][1]; m[0][2] += mat.m[0][2];
00162                                                                         m[1][0] += mat.m[1][0]; m[1][1] += mat.m[1][1]; m[1][2] += mat.m[1][2];
00163                                                                         m[2][0] += mat.m[2][0]; m[2][1] += mat.m[2][1]; m[2][2] += mat.m[2][2];
00164                                                                 }
00165 
00167                 inline_ void                    Sub(const Matrix3x3& mat)
00168                                                                 {
00169                                                                         m[0][0] -= mat.m[0][0]; m[0][1] -= mat.m[0][1]; m[0][2] -= mat.m[0][2];
00170                                                                         m[1][0] -= mat.m[1][0]; m[1][1] -= mat.m[1][1]; m[1][2] -= mat.m[1][2];
00171                                                                         m[2][0] -= mat.m[2][0]; m[2][1] -= mat.m[2][1]; m[2][2] -= mat.m[2][2];
00172                                                                 }
00174                 inline_ void                    Mac(const Matrix3x3& a, const Matrix3x3& b, float s)
00175                                                                 {
00176                                                                         m[0][0] = a.m[0][0] + b.m[0][0] * s;
00177                                                                         m[0][1] = a.m[0][1] + b.m[0][1] * s;
00178                                                                         m[0][2] = a.m[0][2] + b.m[0][2] * s;
00179 
00180                                                                         m[1][0] = a.m[1][0] + b.m[1][0] * s;
00181                                                                         m[1][1] = a.m[1][1] + b.m[1][1] * s;
00182                                                                         m[1][2] = a.m[1][2] + b.m[1][2] * s;
00183 
00184                                                                         m[2][0] = a.m[2][0] + b.m[2][0] * s;
00185                                                                         m[2][1] = a.m[2][1] + b.m[2][1] * s;
00186                                                                         m[2][2] = a.m[2][2] + b.m[2][2] * s;
00187                                                                 }
00189                 inline_ void                    Mac(const Matrix3x3& a, float s)
00190                                                                 {
00191                                                                         m[0][0] += a.m[0][0] * s;       m[0][1] += a.m[0][1] * s;       m[0][2] += a.m[0][2] * s;
00192                                                                         m[1][0] += a.m[1][0] * s;       m[1][1] += a.m[1][1] * s;       m[1][2] += a.m[1][2] * s;
00193                                                                         m[2][0] += a.m[2][0] * s;       m[2][1] += a.m[2][1] * s;       m[2][2] += a.m[2][2] * s;
00194                                                                 }
00195 
00197                 inline_ void                    Mult(const Matrix3x3& a, float s)
00198                                                                 {
00199                                                                         m[0][0] = a.m[0][0] * s;        m[0][1] = a.m[0][1] * s;        m[0][2] = a.m[0][2] * s;
00200                                                                         m[1][0] = a.m[1][0] * s;        m[1][1] = a.m[1][1] * s;        m[1][2] = a.m[1][2] * s;
00201                                                                         m[2][0] = a.m[2][0] * s;        m[2][1] = a.m[2][1] * s;        m[2][2] = a.m[2][2] * s;
00202                                                                 }
00203 
00204                 inline_ void                    Add(const Matrix3x3& a, const Matrix3x3& b)
00205                                                                 {
00206                                                                         m[0][0] = a.m[0][0] + b.m[0][0];        m[0][1] = a.m[0][1] + b.m[0][1];        m[0][2] = a.m[0][2] + b.m[0][2];
00207                                                                         m[1][0] = a.m[1][0] + b.m[1][0];        m[1][1] = a.m[1][1] + b.m[1][1];        m[1][2] = a.m[1][2] + b.m[1][2];
00208                                                                         m[2][0] = a.m[2][0] + b.m[2][0];        m[2][1] = a.m[2][1] + b.m[2][1];        m[2][2] = a.m[2][2] + b.m[2][2];
00209                                                                 }
00210 
00211                 inline_ void                    Sub(const Matrix3x3& a, const Matrix3x3& b)
00212                                                                 {
00213                                                                         m[0][0] = a.m[0][0] - b.m[0][0];        m[0][1] = a.m[0][1] - b.m[0][1];        m[0][2] = a.m[0][2] - b.m[0][2];
00214                                                                         m[1][0] = a.m[1][0] - b.m[1][0];        m[1][1] = a.m[1][1] - b.m[1][1];        m[1][2] = a.m[1][2] - b.m[1][2];
00215                                                                         m[2][0] = a.m[2][0] - b.m[2][0];        m[2][1] = a.m[2][1] - b.m[2][1];        m[2][2] = a.m[2][2] - b.m[2][2];
00216                                                                 }
00217 
00219                 inline_ void                    Mult(const Matrix3x3& a, const Matrix3x3& b)
00220                                                                 {
00221                                                                         m[0][0] = a.m[0][0] * b.m[0][0] + a.m[0][1] * b.m[1][0] + a.m[0][2] * b.m[2][0];
00222                                                                         m[0][1] = a.m[0][0] * b.m[0][1] + a.m[0][1] * b.m[1][1] + a.m[0][2] * b.m[2][1];
00223                                                                         m[0][2] = a.m[0][0] * b.m[0][2] + a.m[0][1] * b.m[1][2] + a.m[0][2] * b.m[2][2];
00224                                                                         m[1][0] = a.m[1][0] * b.m[0][0] + a.m[1][1] * b.m[1][0] + a.m[1][2] * b.m[2][0];
00225                                                                         m[1][1] = a.m[1][0] * b.m[0][1] + a.m[1][1] * b.m[1][1] + a.m[1][2] * b.m[2][1];
00226                                                                         m[1][2] = a.m[1][0] * b.m[0][2] + a.m[1][1] * b.m[1][2] + a.m[1][2] * b.m[2][2];
00227                                                                         m[2][0] = a.m[2][0] * b.m[0][0] + a.m[2][1] * b.m[1][0] + a.m[2][2] * b.m[2][0];
00228                                                                         m[2][1] = a.m[2][0] * b.m[0][1] + a.m[2][1] * b.m[1][1] + a.m[2][2] * b.m[2][1];
00229                                                                         m[2][2] = a.m[2][0] * b.m[0][2] + a.m[2][1] * b.m[1][2] + a.m[2][2] * b.m[2][2];
00230                                                                 }
00231 
00233                 inline_ void                    MultAtB(const Matrix3x3& a, const Matrix3x3& b)
00234                                                                 {
00235                                                                         m[0][0] = a.m[0][0] * b.m[0][0] + a.m[1][0] * b.m[1][0] + a.m[2][0] * b.m[2][0];
00236                                                                         m[0][1] = a.m[0][0] * b.m[0][1] + a.m[1][0] * b.m[1][1] + a.m[2][0] * b.m[2][1];
00237                                                                         m[0][2] = a.m[0][0] * b.m[0][2] + a.m[1][0] * b.m[1][2] + a.m[2][0] * b.m[2][2];
00238                                                                         m[1][0] = a.m[0][1] * b.m[0][0] + a.m[1][1] * b.m[1][0] + a.m[2][1] * b.m[2][0];
00239                                                                         m[1][1] = a.m[0][1] * b.m[0][1] + a.m[1][1] * b.m[1][1] + a.m[2][1] * b.m[2][1];
00240                                                                         m[1][2] = a.m[0][1] * b.m[0][2] + a.m[1][1] * b.m[1][2] + a.m[2][1] * b.m[2][2];
00241                                                                         m[2][0] = a.m[0][2] * b.m[0][0] + a.m[1][2] * b.m[1][0] + a.m[2][2] * b.m[2][0];
00242                                                                         m[2][1] = a.m[0][2] * b.m[0][1] + a.m[1][2] * b.m[1][1] + a.m[2][2] * b.m[2][1];
00243                                                                         m[2][2] = a.m[0][2] * b.m[0][2] + a.m[1][2] * b.m[1][2] + a.m[2][2] * b.m[2][2];
00244                                                                 }
00245 
00247                 inline_ void                    MultABt(const Matrix3x3& a, const Matrix3x3& b)
00248                                                                 {
00249                                                                         m[0][0] = a.m[0][0] * b.m[0][0] + a.m[0][1] * b.m[0][1] + a.m[0][2] * b.m[0][2];
00250                                                                         m[0][1] = a.m[0][0] * b.m[1][0] + a.m[0][1] * b.m[1][1] + a.m[0][2] * b.m[1][2];
00251                                                                         m[0][2] = a.m[0][0] * b.m[2][0] + a.m[0][1] * b.m[2][1] + a.m[0][2] * b.m[2][2];
00252                                                                         m[1][0] = a.m[1][0] * b.m[0][0] + a.m[1][1] * b.m[0][1] + a.m[1][2] * b.m[0][2];
00253                                                                         m[1][1] = a.m[1][0] * b.m[1][0] + a.m[1][1] * b.m[1][1] + a.m[1][2] * b.m[1][2];
00254                                                                         m[1][2] = a.m[1][0] * b.m[2][0] + a.m[1][1] * b.m[2][1] + a.m[1][2] * b.m[2][2];
00255                                                                         m[2][0] = a.m[2][0] * b.m[0][0] + a.m[2][1] * b.m[0][1] + a.m[2][2] * b.m[0][2];
00256                                                                         m[2][1] = a.m[2][0] * b.m[1][0] + a.m[2][1] * b.m[1][1] + a.m[2][2] * b.m[1][2];
00257                                                                         m[2][2] = a.m[2][0] * b.m[2][0] + a.m[2][1] * b.m[2][1] + a.m[2][2] * b.m[2][2];
00258                                                                 }
00259 
00261                                 Matrix3x3&              FromTo(const Point& from, const Point& to);
00262 
00267                                 void                    RotX(float angle);
00272                                 void                    RotY(float angle);
00277                                 void                    RotZ(float angle);
00281                                 void                    RotYX(float y, float x);
00282 
00284                                 Matrix3x3&              Rot(float angle, const Point& axis);
00285 
00287                                 void                    Transpose()
00288                                                                 {
00289                                                                         IR(m[1][0]) ^= IR(m[0][1]);     IR(m[0][1]) ^= IR(m[1][0]);     IR(m[1][0]) ^= IR(m[0][1]);
00290                                                                         IR(m[2][0]) ^= IR(m[0][2]);     IR(m[0][2]) ^= IR(m[2][0]);     IR(m[2][0]) ^= IR(m[0][2]);
00291                                                                         IR(m[2][1]) ^= IR(m[1][2]);     IR(m[1][2]) ^= IR(m[2][1]);     IR(m[2][1]) ^= IR(m[1][2]);
00292                                                                 }
00293 
00295                                 void                    Transpose(const Matrix3x3& a)
00296                                                                 {
00297                                                                         m[0][0] = a.m[0][0];    m[0][1] = a.m[1][0];    m[0][2] = a.m[2][0];
00298                                                                         m[1][0] = a.m[0][1];    m[1][1] = a.m[1][1];    m[1][2] = a.m[2][1];
00299                                                                         m[2][0] = a.m[0][2];    m[2][1] = a.m[1][2];    m[2][2] = a.m[2][2];
00300                                                                 }
00301 
00303                                 float                   Determinant()                                   const
00304                                                                 {
00305                                                                         return (m[0][0]*m[1][1]*m[2][2] + m[0][1]*m[1][2]*m[2][0] + m[0][2]*m[1][0]*m[2][1])
00306                                                                                 -  (m[2][0]*m[1][1]*m[0][2] + m[2][1]*m[1][2]*m[0][0] + m[2][2]*m[1][0]*m[0][1]);
00307                                                                 }
00308 /*
00310                                 float                   CoFactor(ubyte row, ubyte column)       const
00311                                 {
00312                                         static sdword gIndex[3+2] = { 0, 1, 2, 0, 1 };
00313                                         return  (m[gIndex[row+1]][gIndex[column+1]]*m[gIndex[row+2]][gIndex[column+2]] - m[gIndex[row+2]][gIndex[column+1]]*m[gIndex[row+1]][gIndex[column+2]]);
00314                                 }
00315 */
00317                                 Matrix3x3&              Invert()
00318                                                                 {
00319                                                                         float Det = Determinant();      // Must be !=0
00320                                                                         float OneOverDet = 1.0f / Det;
00321 
00322                                                                         Matrix3x3 Temp;
00323                                                                         Temp.m[0][0] = +(m[1][1] * m[2][2] - m[2][1] * m[1][2]) * OneOverDet;
00324                                                                         Temp.m[1][0] = -(m[1][0] * m[2][2] - m[2][0] * m[1][2]) * OneOverDet;
00325                                                                         Temp.m[2][0] = +(m[1][0] * m[2][1] - m[2][0] * m[1][1]) * OneOverDet;
00326                                                                         Temp.m[0][1] = -(m[0][1] * m[2][2] - m[2][1] * m[0][2]) * OneOverDet;
00327                                                                         Temp.m[1][1] = +(m[0][0] * m[2][2] - m[2][0] * m[0][2]) * OneOverDet;
00328                                                                         Temp.m[2][1] = -(m[0][0] * m[2][1] - m[2][0] * m[0][1]) * OneOverDet;
00329                                                                         Temp.m[0][2] = +(m[0][1] * m[1][2] - m[1][1] * m[0][2]) * OneOverDet;
00330                                                                         Temp.m[1][2] = -(m[0][0] * m[1][2] - m[1][0] * m[0][2]) * OneOverDet;
00331                                                                         Temp.m[2][2] = +(m[0][0] * m[1][1] - m[1][0] * m[0][1]) * OneOverDet;
00332 
00333                                                                         *this = Temp;
00334 
00335                                                                         return  *this;
00336                                                                 }
00337 
00338                                 Matrix3x3&              Normalize();
00339 
00341                                 Matrix3x3&              Exp(const Matrix3x3& a);
00342 
00343 void FromQuat(const Quat &q);
00344 void FromQuatL2(const Quat &q, float l2);
00345 
00346                 // Arithmetic operators
00348                 inline_ Matrix3x3               operator+(const Matrix3x3& mat) const
00349                                                                 {
00350                                                                         return Matrix3x3(
00351                                                                         m[0][0] + mat.m[0][0],  m[0][1] + mat.m[0][1],  m[0][2] + mat.m[0][2],
00352                                                                         m[1][0] + mat.m[1][0],  m[1][1] + mat.m[1][1],  m[1][2] + mat.m[1][2],
00353                                                                         m[2][0] + mat.m[2][0],  m[2][1] + mat.m[2][1],  m[2][2] + mat.m[2][2]);
00354                                                                 }
00355 
00357                 inline_ Matrix3x3               operator-(const Matrix3x3& mat) const
00358                                                                 {
00359                                                                         return Matrix3x3(
00360                                                                         m[0][0] - mat.m[0][0],  m[0][1] - mat.m[0][1],  m[0][2] - mat.m[0][2],
00361                                                                         m[1][0] - mat.m[1][0],  m[1][1] - mat.m[1][1],  m[1][2] - mat.m[1][2],
00362                                                                         m[2][0] - mat.m[2][0],  m[2][1] - mat.m[2][1],  m[2][2] - mat.m[2][2]);
00363                                                                 }
00364 
00366                 inline_ Matrix3x3               operator*(const Matrix3x3& mat) const
00367                                                                 {
00368                                                                         return Matrix3x3(
00369                                                                         m[0][0]*mat.m[0][0] + m[0][1]*mat.m[1][0] + m[0][2]*mat.m[2][0],
00370                                                                         m[0][0]*mat.m[0][1] + m[0][1]*mat.m[1][1] + m[0][2]*mat.m[2][1],
00371                                                                         m[0][0]*mat.m[0][2] + m[0][1]*mat.m[1][2] + m[0][2]*mat.m[2][2],
00372 
00373                                                                         m[1][0]*mat.m[0][0] + m[1][1]*mat.m[1][0] + m[1][2]*mat.m[2][0],
00374                                                                         m[1][0]*mat.m[0][1] + m[1][1]*mat.m[1][1] + m[1][2]*mat.m[2][1],
00375                                                                         m[1][0]*mat.m[0][2] + m[1][1]*mat.m[1][2] + m[1][2]*mat.m[2][2],
00376 
00377                                                                         m[2][0]*mat.m[0][0] + m[2][1]*mat.m[1][0] + m[2][2]*mat.m[2][0],
00378                                                                         m[2][0]*mat.m[0][1] + m[2][1]*mat.m[1][1] + m[2][2]*mat.m[2][1],
00379                                                                         m[2][0]*mat.m[0][2] + m[2][1]*mat.m[1][2] + m[2][2]*mat.m[2][2]);
00380                                                                 }
00381 
00383                 inline_ Point                   operator*(const Point& v)               const           { return Point(GetRow(0)|v, GetRow(1)|v, GetRow(2)|v); }
00384 
00386                 inline_ Matrix3x3               operator*(float s)                              const
00387                                                                 {
00388                                                                         return Matrix3x3(
00389                                                                         m[0][0]*s,      m[0][1]*s,      m[0][2]*s,
00390                                                                         m[1][0]*s,      m[1][1]*s,      m[1][2]*s,
00391                                                                         m[2][0]*s,      m[2][1]*s,      m[2][2]*s);
00392                                                                 }
00393 
00395                 inline_ friend Matrix3x3 operator*(float s, const Matrix3x3& mat)
00396                                                                 {
00397                                                                         return Matrix3x3(
00398                                                                         s*mat.m[0][0],  s*mat.m[0][1],  s*mat.m[0][2],
00399                                                                         s*mat.m[1][0],  s*mat.m[1][1],  s*mat.m[1][2],
00400                                                                         s*mat.m[2][0],  s*mat.m[2][1],  s*mat.m[2][2]);
00401                                                                 }
00402 
00404                 inline_ Matrix3x3               operator/(float s)                              const
00405                                                                 {
00406                                                                         if (s)  s = 1.0f / s;
00407                                                                         return Matrix3x3(
00408                                                                         m[0][0]*s,      m[0][1]*s,      m[0][2]*s,
00409                                                                         m[1][0]*s,      m[1][1]*s,      m[1][2]*s,
00410                                                                         m[2][0]*s,      m[2][1]*s,      m[2][2]*s);
00411                                                                 }
00412 
00414                 inline_ friend Matrix3x3 operator/(float s, const Matrix3x3& mat)
00415                                                                 {
00416                                                                         return Matrix3x3(
00417                                                                         s/mat.m[0][0],  s/mat.m[0][1],  s/mat.m[0][2],
00418                                                                         s/mat.m[1][0],  s/mat.m[1][1],  s/mat.m[1][2],
00419                                                                         s/mat.m[2][0],  s/mat.m[2][1],  s/mat.m[2][2]);
00420                                                                 }
00421 
00423                 inline_ Matrix3x3&              operator+=(const Matrix3x3& mat)
00424                                                                 {
00425                                                                         m[0][0] += mat.m[0][0];         m[0][1] += mat.m[0][1];         m[0][2] += mat.m[0][2];
00426                                                                         m[1][0] += mat.m[1][0];         m[1][1] += mat.m[1][1];         m[1][2] += mat.m[1][2];
00427                                                                         m[2][0] += mat.m[2][0];         m[2][1] += mat.m[2][1];         m[2][2] += mat.m[2][2];
00428                                                                         return  *this;
00429                                                                 }
00430 
00432                 inline_ Matrix3x3&              operator-=(const Matrix3x3& mat)
00433                                                                 {
00434                                                                         m[0][0] -= mat.m[0][0];         m[0][1] -= mat.m[0][1];         m[0][2] -= mat.m[0][2];
00435                                                                         m[1][0] -= mat.m[1][0];         m[1][1] -= mat.m[1][1];         m[1][2] -= mat.m[1][2];
00436                                                                         m[2][0] -= mat.m[2][0];         m[2][1] -= mat.m[2][1];         m[2][2] -= mat.m[2][2];
00437                                                                         return  *this;
00438                                                                 }
00439 
00441                 inline_ Matrix3x3&              operator*=(const Matrix3x3& mat)
00442                                                                 {
00443                                                                         Point TempRow;
00444 
00445                                                                         GetRow(0, TempRow);
00446                                                                         m[0][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
00447                                                                         m[0][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
00448                                                                         m[0][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];
00449 
00450                                                                         GetRow(1, TempRow);
00451                                                                         m[1][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
00452                                                                         m[1][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
00453                                                                         m[1][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];
00454 
00455                                                                         GetRow(2, TempRow);
00456                                                                         m[2][0] = TempRow.x*mat.m[0][0] + TempRow.y*mat.m[1][0] + TempRow.z*mat.m[2][0];
00457                                                                         m[2][1] = TempRow.x*mat.m[0][1] + TempRow.y*mat.m[1][1] + TempRow.z*mat.m[2][1];
00458                                                                         m[2][2] = TempRow.x*mat.m[0][2] + TempRow.y*mat.m[1][2] + TempRow.z*mat.m[2][2];
00459                                                                         return  *this;
00460                                                                 }
00461 
00463                 inline_ Matrix3x3&              operator*=(float s)
00464                                                                 {
00465                                                                         m[0][0] *= s;   m[0][1] *= s;   m[0][2] *= s;
00466                                                                         m[1][0] *= s;   m[1][1] *= s;   m[1][2] *= s;
00467                                                                         m[2][0] *= s;   m[2][1] *= s;   m[2][2] *= s;
00468                                                                         return  *this;
00469                                                                 }
00470 
00472                 inline_ Matrix3x3&              operator/=(float s)
00473                                                                 {
00474                                                                         if (s)  s = 1.0f / s;
00475                                                                         m[0][0] *= s;   m[0][1] *= s;   m[0][2] *= s;
00476                                                                         m[1][0] *= s;   m[1][1] *= s;   m[1][2] *= s;
00477                                                                         m[2][0] *= s;   m[2][1] *= s;   m[2][2] *= s;
00478                                                                         return  *this;
00479                                                                 }
00480 
00481                 // Cast operators
00483                                                                 operator Matrix4x4()    const;
00485                                                                 operator Quat()                 const;
00486 
00487                 inline_ const Point&    operator[](int row)             const   { return *(const Point*)&m[row][0];     }
00488                 inline_ Point&                  operator[](int row)                             { return *(Point*)&m[row][0];           }
00489 
00490                 public:
00491 
00492                                 float                   m[3][3];
00493         };
00494 
00495 #endif // __ICEMATRIX3X3_H__
00496 


openhrp3
Author(s): AIST, General Robotix Inc., Nakamura Lab of Dept. of Mechano Informatics at University of Tokyo
autogenerated on Sun Apr 2 2017 03:43:54