FaceGen 3 SDKs Reference
Loading...
Searching...
No Matches
matrixCT.hpp
1//
2// Copyright (c) Singular Inversions Inc. 2000.
3//
4// File: matrixCT.hpp
5// Description: FR2MatrixCTC (constant size matrix) template class
6// Authors: John Leung
7// Created: January 24, 2000.
8//
9// This class replaces FR2MatrixTC (double only matrix). This class
10// allows you to have float matrix, int matrix, etc.
11//
12
13#ifndef FR2_MATRIX_CT_HPP
14#define FR2_MATRIX_CT_HPP
15
16#include <string>
17#include <cmath>
18#include <cfloat>
19#include "vect2.hpp"
20#include "vect3.hpp"
21
22namespace Fg {
23
24// Note that operator[] references to data[] are slower since there is an
25// extra pointer dereference, thus data[] is public if fast access is needed.
26//
27template <class T, const int nrows, const int ncols>
28struct FR2MatrixCTC
29{
30 T data[nrows][ncols];
31
32 inline T* operator[](size_t i) { return data[i]; }
33 inline T const* operator[](size_t i) const { return data[i]; }
34
35 FR2MatrixCTC<T,nrows,nrows> operator*(
36 const FR2MatrixCTC<T,ncols,nrows>&) const;
37 FR2MatrixCTC operator*(T const&) const;
38 FR2MatrixCTC operator+(const FR2MatrixCTC&) const;
39 FR2MatrixCTC operator-(const FR2MatrixCTC&) const;
40 FR2MatrixCTC operator-() const; // Unary - operator
41 FR2MatrixCTC& operator*=(const FR2MatrixCTC&); // sq. matrix only
42 FR2MatrixCTC& operator*=(T const&);
43 FR2MatrixCTC& operator+=(const FR2MatrixCTC&);
44 FR2MatrixCTC& operator-=(const FR2MatrixCTC&);
45 bool operator==(const FR2MatrixCTC&) const;
46
47 inline int numRows() const { return nrows; }
48 inline int numCols() const { return ncols; }
49 inline void setZero() { memset(data,0,nrows*ncols*sizeof(T)); }
50 void setOne();
51 void setIdentity();
52 FR2MatrixCTC<T,ncols,nrows> transpose() const;
53};
54
55//***********************************************************************
56// Aliases
57//***********************************************************************
58//
59typedef FR2MatrixCTC<float,2,2> FutMatrix22FC; // Square matrices
60typedef FR2MatrixCTC<double,2,2> FutMatrix22DC;
61typedef FR2MatrixCTC<float,3,3> FutMatrix33FC;
62typedef FR2MatrixCTC<double,3,3> FutMatrix33DC;
63typedef FR2MatrixCTC<float,4,4> FutMatrix44FC;
64typedef FR2MatrixCTC<double,4,4> FutMatrix44DC;
65
66typedef FR2MatrixCTC<float,2,1> FutMatrix21FC; // Column vectors
67typedef FR2MatrixCTC<double,2,1> FutMatrix21DC;
68typedef FR2MatrixCTC<float,3,1> FutMatrix31FC;
69typedef FR2MatrixCTC<double,3,1> FutMatrix31DC;
70typedef FR2MatrixCTC<float,4,1> FutMatrix41FC;
71typedef FR2MatrixCTC<double,4,1> FutMatrix41DC;
72
73typedef FR2MatrixCTC<float,1,2> FutMatrix12FC; // Row vectors
74typedef FR2MatrixCTC<double,1,2> FutMatrix12DC;
75typedef FR2MatrixCTC<float,1,3> FutMatrix13FC;
76typedef FR2MatrixCTC<double,1,3> FutMatrix13DC;
77typedef FR2MatrixCTC<float,1,4> FutMatrix14FC;
78typedef FR2MatrixCTC<double,1,4> FutMatrix14DC;
79
80typedef FR2MatrixCTC<float,2,3> FutMatrix23FC; // 3D to 2D matrices.
81typedef FR2MatrixCTC<double,2,3> FutMatrix23DC;
82
83//***********************************************************************
84// RELATED GLOBAL FUNCTIONS
85//***********************************************************************
86//
87//***********************************************************************
88// Rotation matrices
89//***********************************************************************
90//
91template <class T>
92FR2MatrixCTC<T,3,3> rotMatrixXCT(T angle)
93{
94 T ct = (T)cos(angle);
95 T st = (T)sin(angle);
96
97 FR2MatrixCTC<T,3,3> mat;
98 mat[0][0]=1.0; mat[0][1]=0.0; mat[0][2]=0.0;
99 mat[1][0]=0.0; mat[1][1]=ct; mat[1][2]=-st;
100 mat[2][0]=0.0; mat[2][1]=st; mat[2][2]=ct;
101
102 return mat;
103}
104
105
106template <class T>
107FR2MatrixCTC<T,3,3> rotMatrixYCT(T angle)
108{
109 T ct = (T)cos(angle);
110 T st = (T)sin(angle);
111
112 FR2MatrixCTC<T,3,3> mat;
113 mat[0][0]=ct; mat[0][1]=0.0; mat[0][2]=st;
114 mat[1][0]=0.0; mat[1][1]=1.0; mat[1][2]=0.0;
115 mat[2][0]=-st; mat[2][1]=0.0; mat[2][2]=ct;
116
117 return mat;
118}
119
120
121template <class T>
122FR2MatrixCTC<T,3,3> rotMatrixZCT(T angle)
123{
124 T ct = (T)cos(angle);
125 T st = (T)sin(angle);
126
127 FR2MatrixCTC<T,3,3> mat;
128 mat[0][0]=ct; mat[0][1]=-st; mat[0][2]=0.0;
129 mat[1][0]=st; mat[1][1]=ct; mat[1][2]=0.0;
130 mat[2][0]=0.0; mat[2][1]=0.0; mat[2][2]=1.0;
131
132 return mat;
133}
134
135
136template <class T>
137FR2MatrixCTC<T,3,3> rotMatrixKCT(T angle, const FR2Vect3TC<T> &k)
138{
139 T ct = (T)cos(angle);
140 T st = (T)sin(angle);
141 T vt = T(1.0-ct);
142
143 FR2MatrixCTC<T,3,3> mat;
144 mat[0][0] = k.x1*k.x1*vt + ct;
145 mat[0][1] = k.x1*k.x2*vt - k.x3*st;
146 mat[0][2] = k.x1*k.x3*vt + k.x2*st;
147
148 mat[1][0] = k.x1*k.x2*vt + k.x3*st;
149 mat[1][1] = k.x2*k.x2*vt + ct;
150 mat[1][2] = k.x2*k.x3*vt - k.x1*st;
151
152 mat[2][0] = k.x1*k.x3*vt - k.x2*st;
153 mat[2][1] = k.x2*k.x3*vt + k.x1*st;
154 mat[2][2] = k.x3*k.x3*vt + ct;
155
156 return mat;
157}
158
159
160//***********************************************************************
161// rowVector
162//***********************************************************************
163template <class T>
164inline FR2MatrixCTC<T,1,2> rowVector2T(const FR2Vect2TC<T>& v)
165{
166 FR2MatrixCTC<T,1,2> mat;
167 mat[0][0] = v.x1;
168 mat[0][1] = v.x2;
169 return mat;
170}
171
172
173template <class T>
174inline FR2MatrixCTC<T,1,3> rowVector3T(const FR2Vect3TC<T>& v)
175{
176 FR2MatrixCTC<T,1,3> mat;
177 mat[0][0] = v.x1;
178 mat[0][1] = v.x2;
179 mat[0][2] = v.x3;
180 return mat;
181}
182
183
184template <class T, const int ncols>
185inline FR2MatrixCTC<T,1,ncols> rowVectorCT(T const v[])
186{
187 FR2MatrixCTC<T,1,ncols> mat;
188 for (int ii=0; ii<ncols; ii++)
189 mat[0][ii] = v[ii];
190 return mat;
191}
192
193
194//***********************************************************************
195// columnVector
196//***********************************************************************
197template <class T>
198inline FR2MatrixCTC<T,2,1> columnVector2T(const FR2Vect2TC<T>& v)
199{
200 FR2MatrixCTC<T,2,1> mat;
201 mat[0][0] = v.x1;
202 mat[1][0] = v.x2;
203 return mat;
204}
205
206
207template <class T>
208inline FR2MatrixCTC<T,3,1> columnVector3T(const FR2Vect3TC<T>& v)
209{
210 FR2MatrixCTC<T,3,1> mat;
211 mat[0][0] = v.x1;
212 mat[1][0] = v.x2;
213 mat[2][0] = v.x3;
214 return mat;
215}
216
217
218template <class T, const int nrows>
219inline FR2MatrixCTC<T,nrows,1> columnVectorCT(T const v[])
220{
221 FR2MatrixCTC<T,nrows,1> mat;
222 for (int ii=0; ii<nrows; ii++)
223 mat[ii][0] = v[ii];
224 return mat;
225}
226
227
228//***********************************************************************
229// diagMatrix
230//***********************************************************************
231template <class T>
232inline FR2MatrixCTC<T,2,2> diagMatrix2T(const FR2Vect2TC<T> &v)
233{
234 FR2MatrixCTC<T,2,2> mat;
235
236 mat.setZero();
237 mat[0][0] = v[0];
238 mat[1][1] = v[1];
239
240 return mat;
241}
242
243template <class T>
244inline FR2MatrixCTC<T,3,3> diagMatrix3T(const FR2Vect3TC<T> &v)
245{
246 FR2MatrixCTC<T,3,3> mat;
247
248 mat.setZero();
249 mat[0][0] = v[0];
250 mat[1][1] = v[1];
251 mat[2][2] = v[2];
252
253 return mat;
254}
255
256template <class T, const int nrows>
257inline FR2MatrixCTC<T,nrows,nrows> diagMatrixCT(T const v[nrows])
258{
259 FR2MatrixCTC<T,nrows,nrows> mat;
260
261 mat.setZero();
262 for (int ii=0; ii<nrows; ii++)
263 mat[ii][ii] = v[ii];
264
265 return mat;
266}
267
268//***********************************************************************
269// operator* Functions
270//***********************************************************************
271template <class T>
272FR2Vect3TC<T> operator*(const FR2MatrixCTC<T,3,3> &m, const FR2Vect3TC<T> &v)
273{
274 FR2Vect3TC<T> v2;
275
276 v2.x1 = m[0][0] * v.x1 + m[0][1] * v.x2 + m[0][2] * v.x3;
277 v2.x2 = m[1][0] * v.x1 + m[1][1] * v.x2 + m[1][2] * v.x3;
278 v2.x3 = m[2][0] * v.x1 + m[2][1] * v.x2 + m[2][2] * v.x3;
279
280 return v2;
281}
282
283template <class T>
284FR2Vect2TC<T> operator*(const FR2MatrixCTC<T,2,3> &m, const FR2Vect3TC<T> &v)
285{
286 FR2Vect2TC<T> v2;
287
288 v2.x1 = m[0][0] * v.x1 + m[0][1] * v.x2 + m[0][2] * v.x3;
289 v2.x2 = m[1][0] * v.x1 + m[1][1] * v.x2 + m[1][2] * v.x3;
290
291 return v2;
292}
293
294template <class T>
295FR2Vect2TC<T> operator*(const FR2MatrixCTC<T,2,2> &m, const FR2Vect2TC<T> &v)
296{
297 FR2Vect2TC<T> v2;
298
299 v2.x1 = m[0][0] * v.x1 + m[0][1] * v.x2;
300 v2.x2 = m[1][0] * v.x1 + m[1][1] * v.x2;
301
302 return v2;
303}
304
305//***********************************************************************
306// fr2MatMulCT --- [m x n] * [n x k]
307//***********************************************************************
308template <class T, const int nrows, const int ncols, const int ncols2>
309FR2MatrixCTC<T,nrows,ncols2> fr2MatMulCT(
310 const FR2MatrixCTC<T,nrows,ncols>& m1,
311 const FR2MatrixCTC<T,ncols,ncols2>& m2)
312{
313 FR2MatrixCTC<T,nrows,ncols2> newMat;
314
315 for (int ii=0; ii<nrows; ii++)
316 for (int jj=0; jj<ncols2; jj++)
317 {
318 newMat[ii][jj] = 0.0;
319 for (int kk=0; kk<ncols; kk++)
320 newMat[ii][jj] += m1[ii][kk] * m2[kk][jj];
321 }
322
323 return newMat;
324}
325
326
327//***********************************************************************
328// MEMBER FUNCTIONS
329//***********************************************************************
330//
331//***********************************************************************
332// operator* --- [m x n] * [n x m]
333//***********************************************************************
334template <class T, const int nrows, const int ncols>
335FR2MatrixCTC<T,nrows,nrows> FR2MatrixCTC<T,nrows,ncols>::operator*(
336 const FR2MatrixCTC<T,ncols,nrows>& m) const
337{
338 FR2MatrixCTC<T,nrows,nrows> newMat;
339
340 for (int ii=0; ii<nrows; ii++)
341 for (int jj=0; jj<nrows; jj++)
342 {
343 newMat[ii][jj] = T(0);
344 for (int kk=0; kk<ncols; kk++)
345 newMat[ii][jj] += data[ii][kk] * m[kk][jj];
346 }
347
348 return newMat;
349}
350
351
352//***********************************************************************
353// operator* --- [m x n] * scalar
354//***********************************************************************
355template <class T,const int nrows, const int ncols>
356inline FR2MatrixCTC<T,nrows,ncols> FR2MatrixCTC<T,nrows,ncols>::operator*(
357 T const &v) const
358{
359 FR2MatrixCTC<T,nrows,ncols> newMat;
360
361 for (int ii=0; ii<nrows; ii++)
362 for (int jj=0; jj<ncols; jj++)
363 newMat.data[ii][jj] = data[ii][jj] * v;
364
365 return newMat;
366}
367
368
369//***********************************************************************
370// operator+
371//***********************************************************************
372template <class T,const int nrows, const int ncols>
373inline FR2MatrixCTC<T,nrows,ncols> FR2MatrixCTC<T,nrows,ncols>::operator+(
374 const FR2MatrixCTC<T,nrows,ncols>& m) const
375{
376 FR2MatrixCTC<T,nrows,ncols> newMat;
377
378 for (int ii=0; ii<nrows; ii++)
379 for (int jj=0; jj<ncols; jj++)
380 newMat.data[ii][jj] = data[ii][jj] + m.data[ii][jj];
381
382 return newMat;
383}
384
385
386//***********************************************************************
387// operator-
388//***********************************************************************
389template <class T,const int nrows, const int ncols>
390inline FR2MatrixCTC<T,nrows,ncols> FR2MatrixCTC<T,nrows,ncols>::operator-(
391 const FR2MatrixCTC<T,nrows,ncols>& m) const
392{
393 FR2MatrixCTC<T,nrows,ncols> newMat;
394
395 for (int ii=0; ii<nrows; ii++)
396 for (int jj=0; jj<ncols; jj++)
397 newMat.data[ii][jj] = data[ii][jj] - m.data[ii][jj];
398
399 return newMat;
400}
401
402template <class T,const int nrows,const int ncols>
403inline FR2MatrixCTC<T,nrows,ncols> FR2MatrixCTC<T,nrows,ncols>::operator-() const
404{
405 FR2MatrixCTC<T,nrows,ncols> retval;
406
407 for (int ii=0; ii<nrows; ii++)
408 for (int jj=0; jj<ncols; jj++)
409 retval.data[ii][jj] = - data[ii][jj];
410
411 return retval;
412}
413
414//***********************************************************************
415// operator*= -- [m x n] * scalar
416//***********************************************************************
417template <class T,const int nrows, const int ncols>
418inline FR2MatrixCTC<T,nrows,ncols>& FR2MatrixCTC<T,nrows,ncols>::operator*=(
419 T const &v)
420{
421 for (int ii=0; ii<nrows; ii++)
422 for (int jj=0; jj<ncols; jj++)
423 data[ii][jj] *= v;
424
425 return *this;
426}
427
428
429//***********************************************************************
430// operator+=
431//***********************************************************************
432template <class T,const int nrows, const int ncols>
433inline FR2MatrixCTC<T,nrows,ncols>& FR2MatrixCTC<T,nrows,ncols>::operator+=(
434 const FR2MatrixCTC<T,nrows,ncols>& m)
435{
436 for (int ii=0; ii<nrows; ii++)
437 for (int jj=0; jj<ncols; jj++)
438 data[ii][jj] += m.data[ii][jj];
439
440 return *this;
441}
442
443
444//***********************************************************************
445// operator-=
446//***********************************************************************
447template <class T,const int nrows, const int ncols>
448inline FR2MatrixCTC<T,nrows,ncols>& FR2MatrixCTC<T,nrows,ncols>::operator-=(
449 const FR2MatrixCTC<T,nrows,ncols>& m)
450{
451 for (int ii=0; ii<nrows; ii++)
452 for (int jj=0; jj<ncols; jj++)
453 data[ii][jj] -= m.data[ii][jj];
454
455 return *this;
456}
457
458//***********************************************************************
459// operator==
460//***********************************************************************
461template <class T,const int nrows, const int ncols>
462inline bool FR2MatrixCTC<T,nrows,ncols>::operator==(
463
464 const FR2MatrixCTC& v)
465 const
466{
467 bool retval(true);
468 for (uint row=0; row<nrows; row++)
469 {
470 for (uint col=0; col<ncols; col++)
471 retval = retval && (data[row][col] == v.data[row][col]);
472 }
473 return retval;
474}
475
476//***********************************************************************
477// setOne
478//***********************************************************************
479template <class T,const int nrows, const int ncols>
480inline void FR2MatrixCTC<T,nrows,ncols>::setOne()
481{
482 for (int ii=0; ii<nrows; ii++)
483 for (int jj=0; jj<ncols; jj++)
484 data[ii][jj] = T(1);
485}
486
487
488//***********************************************************************
489// setIdentity
490//***********************************************************************
491template <class T,const int nrows, const int ncols>
492inline void FR2MatrixCTC<T,nrows,ncols>::setIdentity()
493{
494 setZero();
495 int nn = (nrows < ncols) ? nrows : ncols;
496 for (int ii=0; ii<nn; ii++)
497 data[ii][ii] = T(1);
498}
499
500
501//***********************************************************************
502// transpose
503//***********************************************************************
504template <class T,const int nrows, const int ncols>
505inline FR2MatrixCTC<T,ncols,nrows> FR2MatrixCTC<T,nrows,ncols>::transpose()
506const
507{
508 FR2MatrixCTC<T,ncols,nrows> tMat;
509
510 for (int ii=0; ii<nrows; ii++)
511 for (int jj=0; jj<ncols; jj++)
512 tMat[jj][ii] = data[ii][jj];
513
514 return tMat;
515}
516
517
518//***********************************************************************
519// futMatInverse22
520//***********************************************************************
521template <class T>
522static FR2MatrixCTC<T,2,2> futMatInverse22(
523
524 const FR2MatrixCTC<T,2,2>& m)
525{
526 FR2MatrixCTC<T,2,2> retval;
527
528 T fac = (m.data[0][0] * m.data[1][1] - m.data[0][1] * m.data[1][0]);
529 FGASSERT_FAST(fac != T(0));
530 fac = T(1) / fac;
531
532 retval.data[0][0] = m.data[1][1] * fac;
533 retval.data[0][1] = - m.data[0][1] * fac;
534 retval.data[1][0] = - m.data[1][0] * fac;
535 retval.data[1][1] = m.data[0][0] * fac;
536
537 return retval;
538}
539
540
541//***********************************************************************
542// futMatInverse<T,2,2>
543//***********************************************************************
544inline FR2MatrixCTC<float,2,2> futMatInverse(const FR2MatrixCTC<float,2,2>& m)
545 { return futMatInverse22<float>(m);}
546
547inline FR2MatrixCTC<double,2,2> futMatInverse(const FR2MatrixCTC<double,2,2>& m)
548 { return futMatInverse22<double>(m);}
549
550
551//***********************************************************************
552// Output Stream
553//***********************************************************************
554//
555template <class T,const int r,const int c>
556std::ostream& operator<<(std::ostream& s,FR2MatrixCTC<T,r,c> m)
557{
558 for (int i=0; i<r; i++)
559 {
560 for (int j=0; j<c; j++)
561 {
562 s << m[i][j] << " ";
563 }
564 s << "\n";
565 }
566 return s;
567}
568
569}
570
571#endif
Generated on Fri Nov 8 2024 08:25:14 for FaceGen 3 SDKs Reference by doxygen 1.9.7