开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
matrix4.hpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：12k
源码类别：

生物技术

开发平台：

C/C++

matrix4.hpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: matrix4.hpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 19:48:55  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. #ifndef GUI_MATH___MATRIX4___HPP
  11. #define GUI_MATH___MATRIX4___HPP
  13. /*  $Id: matrix4.hpp,v 1000.2 2004/06/01 19:48:55 gouriano Exp $
  14.  * ===========================================================================
  15.  *
  16.  *                            PUBLIC DOMAIN NOTICE
  17.  *               National Center for Biotechnology Information
  18.  *
  19.  *  This software / database is a "United States Government Work" under the
  20.  *  terms of the United States Copyright Act.  It was written as part of
  21.  *  the author's official duties as a United States Government employee and
  22.  *  thus cannot be copyrighted.  This software / database is freely available
  23.  *  to the public for use. The National Library of Medicine and the U.S.
  24.  *  Government have not placed any restriction on its use or reproduction.
  25.  *
  26.  *  Although all reasonable efforts have been taken to ensure the accuracy
  27.  *  and reliability of the software and data, the NLM and the U.S.
  28.  *  Government do not and cannot warrant the performance or results that
  29.  *  may be obtained by using this software or data. The NLM and the U.S.
  30.  *  Government disclaim all warranties, express or implied, including
  31.  *  warranties of performance, merchantability or fitness for any particular
  32.  *  purpose.
  33.  *
  34.  *  Please cite the author in any work or product based on this material.
  35.  *
  36.  * ===========================================================================
  37.  *
  38.  * Authors:  Mike DiCuccio
  39.  *
  40.  * File Description:
  41.  *
  42.  */
  45. #include <corelib/ncbistd.hpp>
  46. #include <gui/math/vect4.hpp>
  48. /** @addtogroup GUI_MATH
  49.  *
  50.  * @{
  51.  */
  53. BEGIN_NCBI_SCOPE
  56. template <class T>
  57. class CMatrix4
  58. {
  59. public:
  60.     // ctors
  61.     CMatrix4();
  62.     CMatrix4 (T val);
  63.     CMatrix4 (T,T,T,T, T,T,T,T, T,T,T,T, T,T,T,T);
  64.     CMatrix4 (T[16]);
  65.     CMatrix4 (T[4][4]);
  67.     //
  68.     // operators
  69.     //
  71.     // operator: index
  72.     const T&    operator() (int i, int j) const { return m_Data[i * 4+j]; }
  73.     T&          operator() (int i, int j)       { return m_Data[i * 4+j]; }
  75.     // operator: index
  76.     const T&    operator[] (int i) const        { return m_Data[i]; }
  77.     T&          operator[] (int i)              { return m_Data[i]; }
  80.     // operator: addition
  81.     CMatrix4<T>& operator+= (T);
  82.     CMatrix4<T>& operator+= (const CMatrix4<T>&);
  84.     // operator: subtraction
  85.     CMatrix4<T>& operator-= (T);
  86.     CMatrix4<T>& operator-= (const CMatrix4<T>&);
  88.     // operator: multiplication
  89.     CMatrix4<T>& operator*= (T);
  90.     CMatrix4<T>& operator*= (const CMatrix4<T>&);
  92.     // operator: division
  93.     CMatrix4<T>& operator/= (T);
  95.     //
  96.     // named functions
  99.     // transpose the current matrix
  100.     void        Transpose();
  102.     // make the current matrix an identity matrix
  103.     void        Identity();
  105.     // clear the current matrix to a given value
  106.     void        Clear(T x = (T)0);
  108.     // return the determinant of the current matrix
  109.     T           Determinant() const;
  111.     // data accessor
  112.     const T*    GetData() const    { return m_Data; }
  114.     // return a vector representing a row
  115.     CVect4<T>   Row(int) const;
  117.     // return a vector representing a column
  118.     CVect4<T>   Column(int) const;
  120. private:
  121.     T m_Data[16];
  123. };
  126. END_NCBI_SCOPE
  128. //
  129. // global operations
  130. // this is included after the class declaration
  131. #include <gui/math/globals.hpp>
  133. BEGIN_NCBI_SCOPE
  136. //
  137. // default ctor
  138. template <class T> inline
  139. CMatrix4<T>::CMatrix4()
  140. {
  141.     Clear(T(0));
  142. }
  144. //
  145. // conversion ctors
  146. template <class T> inline
  147. CMatrix4<T>::CMatrix4(T val)
  148. {
  149.     Clear(val);
  150. }
  153. template <class T> inline
  154. CMatrix4<T>::CMatrix4(T m1,  T m2,  T m3,  T m4,
  155.                       T m5,  T m6,  T m7,  T m8,
  156.                       T m9,  T m10, T m11, T m12,
  157.                       T m13, T m14, T m15, T m16)
  158. {
  159.     m_Data[ 0] = m1;  m_Data[ 1] = m2;  m_Data[ 2] = m3;  m_Data[ 3] = m4;
  160.     m_Data[ 4] = m5;  m_Data[ 5] = m6;  m_Data[ 6] = m7;  m_Data[ 7] = m8;
  161.     m_Data[ 8] = m9;  m_Data[ 9] = m10; m_Data[10] = m11; m_Data[11] = m12;
  162.     m_Data[12] = m13; m_Data[13] = m14; m_Data[14] = m15; m_Data[15] = m16;
  163. }
  166. template <class T> inline
  167. CMatrix4<T>::CMatrix4(T m[16])
  168. {
  169.     for (int i = 0;  i < 16;  ++i) {
  170.         m_Data[i] = m[i];
  171.     }
  172. }
  175. template <class T> inline
  176. CMatrix4<T>::CMatrix4(T m[4][4])
  177. {
  178.     m_Data[ 0] = m[0][0];
  179.     m_Data[ 1] = m[0][1];
  180.     m_Data[ 2] = m[0][2];
  181.     m_Data[ 3] = m[0][3];
  183.     m_Data[ 4] = m[1][0];
  184.     m_Data[ 5] = m[1][1];
  185.     m_Data[ 6] = m[1][2];
  186.     m_Data[ 7] = m[1][3];
  188.     m_Data[ 8] = m[2][0];
  189.     m_Data[ 9] = m[2][1];
  190.     m_Data[10] = m[2][2];
  191.     m_Data[11] = m[2][3];
  193.     m_Data[12] = m[3][0];
  194.     m_Data[13] = m[3][1];
  195.     m_Data[14] = m[3][2];
  196.     m_Data[15] = m[3][3];
  197. }
  200. //
  201. // addition: scalar
  202. template <class T> inline CMatrix4<T>&
  203. CMatrix4<T>::operator+= (T scalar)
  204. {
  205.     for (int i = 0;  i < 16;  ++i) {
  206.         m_Data[i] += scalar;
  207.     }
  209.     return *this;
  210. }
  212. //
  213. // addition: matrix
  214. template <class T> inline CMatrix4<T>&
  215. CMatrix4<T>::operator+= (const CMatrix4<T>& m)
  216. {
  217.     for (int i = 0;  i < 16;  ++i) {
  218.         m_Data[i] += m[i];
  219.     }
  221.     return *this;
  222. }
  224. //
  225. // subtraction: scalar
  226. template <class T> inline CMatrix4<T>&
  227. CMatrix4<T>::operator-= (T scalar)
  228. {
  229.     for (int i = 0;  i < 16;  ++i) {
  230.         m_Data[i] -= scalar;
  231.     }
  233.     return *this;
  234. }
  236. //
  237. // subtraction: matrix
  238. template <class T> inline CMatrix4<T>&
  239. CMatrix4<T>::operator-= (const CMatrix4<T>& m)
  240. {
  241.     for (int i = 0;  i < 16;  ++i) {
  242.         m_Data[i] -= m[i];
  243.     }
  245.     return *this;
  246. }
  249. //
  250. // multiplication: scalar
  251. template <class T> inline CMatrix4<T>&
  252. CMatrix4<T>::operator*= (T scalar)
  253. {
  254.     for (int i = 0;  i < 16;  ++i) {
  255.         m_Data[i] *= scalar;
  256.     }
  258.     return *this;
  259. }
  261. //
  262. // multiplication: matrix
  263. template <class T> inline CMatrix4<T>&
  264. CMatrix4<T>::operator*= (const CMatrix4<T>& m)
  265. {
  266.     // given
  267.     // 
  268.     // a b c   1 2 3
  269.     // d e f   4 5 6
  270.     // g h i   7 8 9
  271.     // 
  272.     // result is:
  273.     //  (a1 + b4 + c7)  (a2 + b5 + c8)  (a3 + b6 + c9)
  274.     //  (d1 + e4 + f7)  (d2 + e5 + f8)  (d3 + e6 + f9)
  275.     //  (g1 + h4 + i7)  (g2 + h5 + i8)  (g3 + h6 + i9)
  277.     T t0;
  278.     T t1;
  279.     T t2;
  280.     T t3;
  282.     t0 = m_Data[ 0] * m[ 0] + m_Data[ 1] * m[ 4] +
  283.         m_Data[ 2] * m[ 8] + m_Data[ 3] * m[12];
  284.     t1 = m_Data[ 0] * m[ 1] + m_Data[ 1] * m[ 5] +
  285.         m_Data[ 2] * m[ 9] + m_Data[ 3] * m[13];
  286.     t2 = m_Data[ 0] * m[ 2] + m_Data[ 1] * m[ 6] +
  287.         m_Data[ 2] * m[10] + m_Data[ 3] * m[14];
  288.     t3 = m_Data[ 0] * m[ 3] + m_Data[ 1] * m[ 7] +
  289.         m_Data[ 2] * m[11] + m_Data[ 3] * m[15];
  290.     m_Data[0] = t0;
  291.     m_Data[1] = t1;
  292.     m_Data[2] = t2;
  293.     m_Data[3] = t3;
  295.     t0 = m_Data[ 4] * m[ 0] + m_Data[ 5] * m[ 4] +
  296.         m_Data[ 6] * m[ 8] + m_Data[ 7] * m[12];
  297.     t1 = m_Data[ 4] * m[ 1] + m_Data[ 5] * m[ 5] +
  298.         m_Data[ 6] * m[ 9] + m_Data[ 7] * m[13];
  299.     t2 = m_Data[ 4] * m[ 2] + m_Data[ 5] * m[ 6] +
  300.         m_Data[ 6] * m[10] + m_Data[ 7] * m[14];
  301.     t3 = m_Data[ 4] * m[ 3] + m_Data[ 5] * m[ 7] +
  302.         m_Data[ 6] * m[11] + m_Data[ 7] * m[15];
  303.     m_Data[4] = t0;
  304.     m_Data[5] = t1;
  305.     m_Data[6] = t2;
  306.     m_Data[7] = t3;
  308.     t0 = m_Data[ 8] * m[ 0] + m_Data[ 9] * m[ 4] +
  309.         m_Data[10] * m[ 8] + m_Data[11] * m[12];
  310.     t1 = m_Data[ 8] * m[ 1] + m_Data[ 9] * m[ 5] +
  311.         m_Data[10] * m[ 9] + m_Data[11] * m[13];
  312.     t2 = m_Data[ 8] * m[ 2] + m_Data[ 9] * m[ 6] +
  313.         m_Data[10] * m[10] + m_Data[11] * m[14];
  314.     t3 = m_Data[ 8] * m[ 3] + m_Data[ 9] * m[ 7] +
  315.         m_Data[10] * m[11] + m_Data[11] * m[15];
  316.     m_Data[ 8] = t0;
  317.     m_Data[ 9] = t1;
  318.     m_Data[10] = t2;
  319.     m_Data[11] = t3;
  321.     t0 = m_Data[12] * m[ 0] + m_Data[13] * m[ 4] +
  322.         m_Data[14] * m[ 8] + m_Data[15] * m[12];
  323.     t1 = m_Data[12] * m[ 1] + m_Data[13] * m[ 5] +
  324.         m_Data[14] * m[ 9] + m_Data[15] * m[13];
  325.     t2 = m_Data[12] * m[ 2] + m_Data[13] * m[ 6] +
  326.         m_Data[14] * m[10] + m_Data[15] * m[14];
  327.     t3 = m_Data[12] * m[ 3] + m_Data[13] * m[ 7] +
  328.         m_Data[14] * m[11] + m_Data[15] * m[15];
  329.     m_Data[12] = t0;
  330.     m_Data[13] = t1;
  331.     m_Data[14] = t2;
  332.     m_Data[15] = t3;
  334.     return *this;
  335. }
  337. //
  338. // division: scalar
  339. template <class T> inline CMatrix4<T>&
  340. CMatrix4<T>::operator/= (T scalar)
  341. {
  342.     scalar = T(1) / scalar;
  344.     for (int i = 0;  i < 16;  ++i) {
  345.         m_Data[i] *= scalar;
  346.     }
  348.     return *this;
  349. }
  352. //
  353. // transpose a matrix
  354. template <class T> inline void
  355. CMatrix4<T>::Transpose()
  356. {
  357.     // given
  358.     //   a b c d
  359.     //   e f g h
  360.     //   i j k l
  361.     //   m n o p
  362.     //   
  363.     // result is
  364.     //   a e i m
  365.     //   b f j n
  366.     //   c g k o
  367.     //   d h l p
  370.     std::swap(m_Data[ 1], m_Data[ 4]);
  371.     std::swap(m_Data[ 2], m_Data[ 8]);
  372.     std::swap(m_Data[ 3], m_Data[12]);
  373.     std::swap(m_Data[ 6], m_Data[ 9]);
  374.     std::swap(m_Data[ 7], m_Data[13]);
  375.     std::swap(m_Data[11], m_Data[14]);
  376. }
  378. //
  379. // create a unit matrix
  380. template <class T> inline void
  381. CMatrix4<T>::Identity()
  382. {
  383.     Clear((T)0);
  384.     m_Data[ 0] = 1;
  385.     m_Data[ 5] = 1;
  386.     m_Data[10] = 1;
  387.     m_Data[15] = 1;
  388. }
  390. //
  391. // clear a matrix so that all its values are the passed value
  392. template <class T> inline void
  393. CMatrix4<T>::Clear(T value)
  394. {
  395.     for (int i = 0;  i < 16;  ++i) {
  396.         m_Data[i] = value;
  397.     }
  398. }
  401. //
  402. // return a row as a vector
  403. template <class T> inline CVect4<T>
  404. CMatrix4<T>::Row(int i) const
  405. {
  406.     return CVect4<T> (m_Data[i<<2    ],
  407.                       m_Data[i<<2 + 1],
  408.                       m_Data[i<<2 + 2] ,
  409.                       m_Data[i<<2 + 3]);
  410. }
  413. //
  414. // return a column as a vector
  415. template <class T> inline CVect4<T>
  416. CMatrix4<T>::Column(int j) const
  417. {
  418.     return CVect4<T> (m_Data[     j],
  419.                       m_Data[ 4 + j],
  420.                       m_Data[ 8 + j],
  421.                       m_Data[12 + j]);
  422. }
  425. //
  426. // return the determinant of a 3x3 matrix
  427. template <class T> inline T
  428. CMatrix4<T>::Determinant() const
  429. {
  430.     // given
  431.     //  a b c d
  432.     //  e f g h
  433.     //  i j k l
  434.     //  m n o p
  435.     // 
  436.     // determinant is
  437.     // 
  438.     // + a[ f(kp - lo) - g(jp - ln) + h(jo - kn) ]
  439.     // - b[ e(kp - lo) - g(ip - lm) + h(io - km) ]
  440.     // + c[ e(jp - ln) - f(ip - lm) + h(in - jm) ]
  441.     // - d[ e(jo - kn) - f(io - km) + g(in - jm) ]
  443.     T det;
  445.     T kp = m_Data[10]*m_Data[15];
  446.     T lo = m_Data[11]*m_Data[14];
  447.     T jp = m_Data[ 9]*m_Data[15];
  448.     T ln = m_Data[11]*m_Data[13];
  449.     T jo = m_Data[ 9]*m_Data[14];
  450.     T kn = m_Data[10]*m_Data[13];
  452.     det = m_Data[0] * ( m_Data[5]*(kp - lo)
  453.                         - m_Data[6]*(jp - ln)
  454.                         + m_Data[7]*(jo - kn) );
  456.     T ip = m_Data[ 8]*m_Data[15];
  457.     T lm = m_Data[11]*m_Data[12];
  458.     T io = m_Data[ 8]*m_Data[14];
  459.     T km = m_Data[10]*m_Data[12];
  461.     det -= m_Data[1] * ( m_Data[4]*(kp - lo)
  462.                          - m_Data[6]*(ip - lm)
  463.                          + m_Data[7]*(io - km) );
  465.     T in = m_Data[ 8]*m_Data[13];
  466.     T jm = m_Data[ 9]*m_Data[12];
  468.     det += m_Data[3] * ( m_Data[4]*(jp - ln)
  469.                          - m_Data[5]*(ip - lm)
  470.                          + m_Data[7]*(in - jm) );
  472.     det -= m_Data[4] * ( m_Data[4]*(jo - kn)
  473.                          - m_Data[5]*(io - km)
  474.                          + m_Data[6]*(in - jm) );
  476.     return det;
  477. }
  480. END_NCBI_SCOPE
  482. /* @} */
  485. /*
  486.  * ===========================================================================
  487.  * $Log: matrix4.hpp,v $
  488.  * Revision 1000.2  2004/06/01 19:48:55  gouriano
  489.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
  490.  *
  491.  * Revision 1.6  2004/05/11 18:53:50  dicuccio
  492.  * Added doxygen modules info
  493.  *
  494.  * Revision 1.5  2004/05/03 13:10:01  dicuccio
  495.  * Removed gui/gui.hpp --> not necessary for math projects
  496.  *
  497.  * Revision 1.4  2004/05/03 12:43:35  dicuccio
  498.  * Added #include for gui/gui.hpp
  499.  *
  500.  * Revision 1.3  2004/04/26 17:28:18  ucko
  501.  * Add a missing type declaration in matrix += scalar code.
  502.  *
  503.  * Revision 1.2  2004/03/11 17:17:07  dicuccio
  504.  * FIxed include guards
  505.  *
  506.  * Revision 1.1  2003/06/09 19:30:50  dicuccio
  507.  * Initial revision
  508.  *
  509.  * ===========================================================================
  510.  */
  512. #endif // GUI_MATH___MATRIX4___HPP