osg::TransformationMatrix< ValueTypeT > Class Template Reference

00092 {
00093     for(UInt32 i = 0; i < 4; i++)
00094     {
00095         _matrix[i][i] = TypeTraits<ValueType>::getOneElement();
00096     }
00097 }

00102 {
00103     for(UInt32 i = 0; i < 4; i++)
00104     {
00105         _matrix[i] = source._matrix[i];
00106     }
00107 }

00114 {
00115     _matrix[0].setValue(vector1);
00116     _matrix[1].setValue(vector2);
00117     _matrix[2].setValue(vector3);
00118 }

00126 {
00127     _matrix[0].setValue(vector1);
00128     _matrix[1].setValue(vector2);
00129     _matrix[2].setValue(vector3);
00130     _matrix[3].setValue(vector4);
00131 }

00154 {
00155     _matrix[0].setValues(rVal00, rVal01, rVal02, rVal03);
00156     _matrix[1].setValues(rVal10, rVal11, rVal12, rVal13);
00157     _matrix[2].setValues(rVal20, rVal21, rVal22, rVal23);
00158     _matrix[3].setValues(rVal30, rVal31, rVal32, rVal33);
00159 }

00166 {
00167 }

02090 {
02091     _matrix[0][0] += matrix._matrix[0][0];
02092     _matrix[0][1] += matrix._matrix[0][1];
02093     _matrix[0][2] += matrix._matrix[0][2];
02094     _matrix[0][3] += matrix._matrix[0][3];
02095 
02096     _matrix[1][0] += matrix._matrix[1][0];
02097     _matrix[1][1] += matrix._matrix[1][1];
02098     _matrix[1][2] += matrix._matrix[1][2];
02099     _matrix[1][3] += matrix._matrix[1][3];
02100 
02101     _matrix[2][0] += matrix._matrix[2][0];
02102     _matrix[2][1] += matrix._matrix[2][1];
02103     _matrix[2][2] += matrix._matrix[2][2];
02104     _matrix[2][3] += matrix._matrix[2][3];
02105 
02106     _matrix[3][0] += matrix._matrix[3][0];
02107     _matrix[3][1] += matrix._matrix[3][1];
02108     _matrix[3][2] += matrix._matrix[3][2];
02109     _matrix[3][3] += matrix._matrix[3][3];
02110 }

02144 {
02145     _matrix[0][0] += s*matrix._matrix[0][0];
02146     _matrix[0][1] += s*matrix._matrix[0][1];
02147     _matrix[0][2] += s*matrix._matrix[0][2];
02148     _matrix[0][3] += s*matrix._matrix[0][3];
02149 
02150     _matrix[1][0] += s*matrix._matrix[1][0];
02151     _matrix[1][1] += s*matrix._matrix[1][1];
02152     _matrix[1][2] += s*matrix._matrix[1][2];
02153     _matrix[1][3] += s*matrix._matrix[1][3];
02154 
02155     _matrix[2][0] += s*matrix._matrix[2][0];
02156     _matrix[2][1] += s*matrix._matrix[2][1];
02157     _matrix[2][2] += s*matrix._matrix[2][2];
02158     _matrix[2][3] += s*matrix._matrix[2][3];
02159 
02160     _matrix[3][0] += s*matrix._matrix[3][0];
02161     _matrix[3][1] += s*matrix._matrix[3][1];
02162     _matrix[3][2] += s*matrix._matrix[3][2];
02163     _matrix[3][3] += s*matrix._matrix[3][3];
02164 }

01444 {
01445     ValueTypeT
01446         a1, a2, a3, a4,
01447         b1, b2, b3, b4,
01448         c1, c2, c3, c4,
01449         d1, d2, d3, d4;
01450 
01451     a1 = _matrix[0][0];
01452     b1 = _matrix[1][0];
01453     c1 = _matrix[2][0];
01454     d1 = _matrix[3][0];
01455 
01456     a2 = _matrix[0][1];
01457     b2 = _matrix[1][1];
01458     c2 = _matrix[2][1];
01459     d2 = _matrix[3][1];
01460 
01461     a3 = _matrix[0][2];
01462     b3 = _matrix[1][2];
01463     c3 = _matrix[2][2];
01464     d3 = _matrix[3][2];
01465 
01466     a4 = _matrix[0][3];
01467     b4 = _matrix[1][3];
01468     c4 = _matrix[2][3];
01469     d4 = _matrix[3][3];
01470 
01471     return(   a1 * det3(b2, b3, b4, c2, c3, c4, d2, d3, d4)
01472             - b1 * det3(a2, a3, a4, c2, c3, c4, d2, d3, d4)
01473             + c1 * det3(a2, a3, a4, b2, b3, b4, d2, d3, d4)
01474             - d1 * det3(a2, a3, a4, b2, b3, b4, c2, c3, c4));
01475 
01476 }

00441 {
00442     return (a1 * b2) - (a2 * b1);
00443 }

00456 {
00457     return
00458         (a1 * b2 * c3) + (a2 * b3 * c1) + (a3 * b1 * c2) -
00459         (a1 * b3 * c2) - (a2 * b1 * c3) - (a3 * b2 * c1);
00460 }

01431 {
01432     return (_matrix[0][0] * _matrix[1][1] * _matrix[2][2] +
01433             _matrix[0][1] * _matrix[1][2] * _matrix[2][0] +
01434             _matrix[0][2] * _matrix[1][0] * _matrix[2][1] -
01435             _matrix[0][2] * _matrix[1][1] * _matrix[2][0] -
01436             _matrix[0][1] * _matrix[1][0] * _matrix[2][2] -
01437             _matrix[0][0] * _matrix[1][2] * _matrix[2][1]);
01438 }

01412 {
01413     UInt32 i;
01414     bool returnValue = true;
01415 
01416     for(i = 0; i < 4; i++)
01417     {
01418         returnValue &= _matrix[i].equals(matrix._matrix[i], tolerance);
01419 
01420         if(returnValue == false)
01421             break;
01422     }
01423 
01424     return returnValue;
01425 }

02543 {
02544     const Int32                q = 6;
02545 
02546           TransformationMatrix A(*this);
02547           TransformationMatrix D;
02548           TransformationMatrix N;
02549 
02550           Int32                j = 1;
02551           Int32                k;
02552 
02553           ValueTypeT           c(1.0);
02554 
02555     j += Int32(osgLog(A.normInfinity() / 0.693));
02556 
02557     if(j < 0) 
02558         j = 0;
02559 
02560     A.scale(ValueTypeT(1.0f / (1 << j)));
02561 
02562     result.setIdentity();
02563 
02564     for(k = 1; k <= q; k++)
02565     {
02566         c *= ValueTypeT(q - k + 1) / ValueTypeT(k * (2 * q - k + 1));
02567 
02568         result.multLeft(A);
02569 
02570         N.addScaled(result, c);
02571 
02572         if(k % 2) 
02573         {
02574             D.addScaled(result, -c);
02575         }
02576         else
02577         {
02578             D.addScaled(result,  c);
02579         }
02580     }
02581 
02582     result.invertFrom(D);
02583     result.mult      (N);
02584 
02585     for(k = 0; k < j; k++)
02586         result.mult(result);
02587 
02588     // ToDo: return value
02589     return true;
02590 }

02598 {
02599     const Int32                q = 6;
02600 
02601           TransformationMatrix A(matrix);
02602           TransformationMatrix D;
02603           TransformationMatrix N;
02604 
02605           Int32                j = 1;
02606           Int32                k;
02607 
02608           ValueTypeT           c(1.0);
02609 
02610     j += int(osgLog(A.normInfinity() / 0.693));
02611 
02612     if(j < 0) 
02613         j = 0;
02614 
02615     A.scale(1.0 / (ValueTypeT(1 << j)));
02616 
02617     setIdentity();
02618 
02619     for(k = 1; k <= q; k++)
02620     {
02621         c *= ValueTypeT(q - k + 1) / ValueTypeT(k * (2 *q - k + 1));
02622 
02623         multLeft(A);
02624 
02625         N.addScaled(*this,c);
02626 
02627         if(k % 2) 
02628         {
02629             D.addScaled(*this, -c);
02630         }
02631         else 
02632         {
02633             D.addScaled(*this,  c);
02634         }
02635     }
02636 
02637     invertFrom(D);
02638     mult      (N);
02639 
02640     for(k = 0; k < j; k++)
02641         mult(*this);
02642 
02643     // ToDo: return value
02644     return true;
02645 }

01030 {
01031     Real64               det;       
01032     Real64               det_sign;   
01033     Real64               scratch;
01034     Int32                i;
01035     Int32                j;
01036     Int32                junk;
01037     TransformationMatrix a;
01038     TransformationMatrix aT;
01039     TransformationMatrix rT;
01040     TransformationMatrix b;
01041     TransformationMatrix si;
01042     ValueTypeT           evalues [3];
01043     VectorType3f         evectors[3];
01044     
01045     a = *this;
01046 
01047     proj.setIdentity();
01048 
01049     scratch = 1.0;
01050     
01051     for (i = 0; i < 3; i++) 
01052     {
01053         for (j = 0; j < 3; j++) 
01054         {
01055             a._matrix[i][j] *= ValueTypeT(scratch);
01056         }
01057 
01058         t[i] = _matrix[3][i] * ValueTypeT(scratch);
01059 
01060         a._matrix[3][i] = a._matrix[i][3] = 0.0;
01061     }
01062 
01063     a._matrix[3][3] = 1.0;
01064     
01065     /* (3) Compute det A. If negative, set sign = -1, else sign = 1 */
01066 
01067     det      = a.det3();
01068 
01069     det_sign = (det < 0.0 ? -1.0 : 1.0);
01070 
01071     if(det_sign * det < 1e-12)
01072         return false;      // singular
01073     
01074     /* (4) B = A * A^  (here A^ means A transpose) */
01075