DtMatrix3.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2017 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 

#pragma once

#include <vrvMath/DtVector3.h>
#include <vrvMath/DtMath.h>
#include <vrvMath/DtAssert.h>

namespace makVrv {

   template<class T>
   class DtMatrix3
   {
   public:
      DtMatrix3();
      DtMatrix3(const T rhs[3][3]);
      DtMatrix3(T m00, T m01, T m02
         , T m10, T m11, T m12
         , T m20, T m21, T m22);
      DtMatrix3(const T rhs[9]);

      const void* ptr(void) const;

      ~DtMatrix3();

      DtMatrix3 operator*(const DtMatrix3& rhs) const;

      DtVector3<T> operator*(const DtVector3<T>& rhs) const;

      void setZero(void);

      void setIdentity(void);

      DtMatrix3 getTranspose(void) const;

      bool IsEqual(const DtMatrix3& rhs, T tolerance) const;

      const T* operator [](size_t iRow) const;
      T* operator [](size_t iRow);

      static DtMatrix3 theIdentityMatrix;
   private:
      union
      {
         T _m[9];
         T  m[3][3];
      };
   };

   template <class T>
   DtMatrix3<T> DtMatrix3<T>::theIdentityMatrix = DtMatrix3<T>(1,0,0
      , 0,1,0
      , 0,0,1);

   template<class T>
   DtMatrix3<T>::DtMatrix3()
   {

   }

   template<class T>
   DtMatrix3<T>::DtMatrix3(const T rhs[3][3])
   {
      memcpy(_m, rhs, 9*sizeof(T));
   }

   template<class T>
   DtMatrix3<T>::DtMatrix3(T m00, T m01, T m02
      , T m10, T m11, T m12
      , T m20, T m21, T 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;
   }

   template<class T>
   DtMatrix3<T>::DtMatrix3(const T rhs[9])
   {
      memcpy(_m, rhs, 9 * sizeof(T));
   }

   template<class T>
   DtMatrix3<T>::~DtMatrix3()
   {

   }
   template<class T>
   const void* DtMatrix3<T>::ptr(void) const
   {
      return _m;
   }

   template<class T>
   const T* DtMatrix3<T>::operator [](size_t iRow) const
   {
      ASSERT_PREDICATE_RETURN_ZERO(iRow<3);
      return m[iRow];
   }
   template<class T>
   T* DtMatrix3<T>::operator [](size_t iRow)
   {
      ASSERT_PREDICATE_RETURN_ZERO(iRow<3);
      return m[iRow];
   }

   typedef DtMatrix3<float>   Matrix3_32;
   typedef DtMatrix3<double> Matrix3_64;

   template<class T>
   DtMatrix3<T> DtMatrix3<T>::operator*(const DtMatrix3<T>& rhs) const
   {
      /*
      | lhs.00,  lhs.01,  lhs.02 |  | rhs.00,  rhs.01,  rhs.02 |  
      | lhs.10,  lhs.11,  lhs.12 |  | rhs.10,  rhs.11,  rhs.12 |
      | lhs.20,  lhs.21,  lhs.22 |  | rhs.20,  rhs.21,  rhs.22 |
      */
      const DtMatrix3& lhs = *this;

      DtMatrix3 result;

      result.m[0][0] = lhs.m[0][0]*rhs.m[0][0] + lhs.m[0][1]*rhs.m[1][0] + lhs.m[0][2]*rhs.m[2][0];
      result.m[0][1] = lhs.m[0][0]*rhs.m[0][1] + lhs.m[0][1]*rhs.m[1][1] + lhs.m[0][2]*rhs.m[2][1];
      result.m[0][2] = lhs.m[0][0]*rhs.m[0][2] + lhs.m[0][1]*rhs.m[1][2] + lhs.m[0][2]*rhs.m[2][2];

      result.m[1][0] = lhs.m[1][0]*rhs.m[0][0] + lhs.m[1][1]*rhs.m[1][0] + lhs.m[1][2]*rhs.m[2][0];
      result.m[1][1] = lhs.m[1][0]*rhs.m[0][1] + lhs.m[1][1]*rhs.m[1][1] + lhs.m[1][2]*rhs.m[2][1];
      result.m[1][2] = lhs.m[1][0]*rhs.m[0][2] + lhs.m[1][1]*rhs.m[1][2] + lhs.m[1][2]*rhs.m[2][2];

      result.m[2][0] = lhs.m[2][0]*rhs.m[0][0] + lhs.m[2][1]*rhs.m[1][0] + lhs.m[2][2]*rhs.m[2][0];
      result.m[2][1] = lhs.m[2][0]*rhs.m[0][1] + lhs.m[2][1]*rhs.m[1][1] + lhs.m[2][2]*rhs.m[2][1];
      result.m[2][2] = lhs.m[2][0]*rhs.m[0][2] + lhs.m[2][1]*rhs.m[1][2] + lhs.m[2][2]*rhs.m[2][2];

      return result;
   }

   template<class T>
   DtVector3<T> DtMatrix3<T>::operator*(const DtVector3<T>& rhs) const
   {
      /*
      | lhs.00,  lhs.01,  lhs.02 |  | rhs.0 | 
      | lhs.10,  lhs.11,  lhs.12 |  | rhs.1 |
      | lhs.20,  lhs.21,  lhs.22 |  | rhs.2 |
      */
      DtVector3<T> vResult;

      const DtMatrix3& lhs = *this;

      vResult.x = lhs.m[0][0]*rhs.x + lhs.m[0][1]*rhs.y + lhs.m[0][2]*rhs.z;
      vResult.y = lhs.m[1][0]*rhs.x + lhs.m[1][1]*rhs.y + lhs.m[1][2]*rhs.z;
      vResult.z = lhs.m[2][0]*rhs.x + lhs.m[2][1]*rhs.y + lhs.m[2][2]*rhs.z;

      return vResult;
   }

   template<class T>
   void DtMatrix3<T>::setZero(void)
   {
      memset(_m, 0, 9*sizeof(T));
   }

   template<class T>
   void DtMatrix3<T>::setIdentity(void)
   {
      setZero();
      m[0][0] = m[1][1] = m[2][2] = 1;
   }

   template<class T>
   DtMatrix3<T> DtMatrix3<T>::getTranspose(void) const
   {
      return DtMatrix3(
         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]
      );
   }

   template<class T>
   bool DtMatrix3<T>::IsEqual(const DtMatrix3<T>& rhs, T tolerance) const
   {
      const DtMatrix3& lhs = *this;
      for(size_t i = 0; i < 3; ++i)
      {
         for(size_t j = 0; j < 3; ++j)
         {
            if (!DtMath::isEqual(lhs[i][j], rhs[i][j], tolerance))
               return false;
         }
      }
      return true;
   }

} //namespace makVrv