Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Related Pages

dox/Common/vtkMath.h

Go to the documentation of this file.
00001 /*=========================================================================
00002 
00003   Program:   Visualization Toolkit
00004   Module:    $RCSfile: vtkMath.h,v $
00005   Language:  C++
00006 
00007   Copyright (c) 1993-2002 Ken Martin, Will Schroeder, Bill Lorensen 
00008   All rights reserved.
00009   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
00010 
00011      This software is distributed WITHOUT ANY WARRANTY; without even 
00012      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
00013      PURPOSE.  See the above copyright notice for more information.
00014 
00015 =========================================================================*/
00035 #ifndef __vtkMath_h
00036 #define __vtkMath_h
00037 
00038 #include "vtkObject.h"
00039 
00040 class VTK_COMMON_EXPORT vtkMath : public vtkObject
00041 {
00042 public:
00043   static vtkMath *New();
00044   vtkTypeRevisionMacro(vtkMath,vtkObject);
00045   
00047 
00048   static float Pi() {return 3.14159265358979f;};
00049   static float DegreesToRadians() {return 0.017453292f;};
00050   static float RadiansToDegrees() {return 57.2957795131f;};
00052 
00054 
00055   static double DoubleDegreesToRadians() {return 0.017453292519943295;};
00056   static double DoublePi() {return 3.1415926535897932384626;};
00057   static double DoubleRadiansToDegrees() {return 57.29577951308232;};
00059 
00061 
00062   static int Round(float f) {
00063     return static_cast<int>(f + (f >= 0 ? 0.5 : -0.5)); }
00064   static int Round(double f) {
00065     return static_cast<int>(f + (f >= 0 ? 0.5 : -0.5)); }
00067     
00069 
00070   static float Dot(const float x[3], const float y[3]) {
00071     return (x[0]*y[0] + x[1]*y[1] + x[2]*y[2]);};
00073 
00075 
00076   static double Dot(const double x[3], const double y[3]) {
00077     return (x[0]*y[0] + x[1]*y[1] + x[2]*y[2]);};
00079   
00081   static void Cross(const float x[3], const float y[3], float z[3]);
00082 
00085   static void Cross(const double x[3], const double y[3], double z[3]);
00086 
00088   static float Norm(const float* x, int n); 
00089 
00091 
00092   static float Norm(const float x[3]) {
00093     return static_cast<float> (sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]));};
00095   
00097 
00098   static double Norm(const double x[3]) {
00099     return sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);};
00101   
00103   static float Normalize(float x[3]);
00104 
00107   static double Normalize(double x[3]);
00108 
00110 
00115   static void Perpendiculars(const double x[3], double y[3], double z[3], 
00116                              double theta);
00117   static void Perpendiculars(const float x[3], float y[3], float z[3],
00118                              double theta);
00120 
00122   static float Distance2BetweenPoints(const float x[3], const float y[3]);
00123 
00126   static double Distance2BetweenPoints(const double x[3], const double y[3]);
00127 
00129 
00130   static float Dot2D(const float x[3], const float y[3]) {
00131     return (x[0]*y[0] + x[1]*y[1]);};
00133   
00135 
00137   static double Dot2D(const double x[3], const double y[3]) {
00138     return (x[0]*y[0] + x[1]*y[1]);};
00140 
00142 
00143   static float Norm2D(const float x[3]) {
00144     return static_cast<float> (sqrt(x[0]*x[0] + x[1]*x[1]));};
00146 
00148 
00150   static double Norm2D(const double x[3]) {
00151     return sqrt(x[0]*x[0] + x[1]*x[1]);};
00153 
00156   static float Normalize2D(float x[3]);
00157 
00160   static double Normalize2D(double x[3]);
00161 
00163 
00164   static float Determinant2x2(const float c1[2], const float c2[2]) {
00165     return (c1[0]*c2[1] - c2[0]*c1[1]);};
00167 
00169 
00170   static double Determinant2x2(double a, double b, double c, double d) {
00171     return (a * d - b * c);};
00173 
00175 
00177   static void LUFactor3x3(float A[3][3], int index[3]);
00178   static void LUFactor3x3(double A[3][3], int index[3]);
00180 
00182 
00184   static void LUSolve3x3(const float A[3][3], const int index[3], 
00185                          float x[3]);
00186   static void LUSolve3x3(const double A[3][3], const int index[3], 
00187                          double x[3]);
00189 
00191 
00193   static void LinearSolve3x3(const float A[3][3], const float x[3], 
00194                              float y[3]);
00195   static void LinearSolve3x3(const double A[3][3], const double x[3], 
00196                              double y[3]);
00198 
00200 
00201   static void Multiply3x3(const float A[3][3], const float in[3], 
00202                           float out[3]);
00203   static void Multiply3x3(const double A[3][3], const double in[3], 
00204                           double out[3]);
00206   
00208 
00209   static void Multiply3x3(const float A[3][3], const float B[3][3], 
00210                           float C[3][3]);
00211   static void Multiply3x3(const double A[3][3], const double B[3][3], 
00212                           double C[3][3]);
00214 
00216 
00217   static void Transpose3x3(const float A[3][3], float AT[3][3]);
00218   static void Transpose3x3(const double A[3][3], double AT[3][3]);
00220 
00222 
00223   static void Invert3x3(const float A[3][3], float AI[3][3]);
00224   static void Invert3x3(const double A[3][3], double AI[3][3]);
00226 
00228 
00229   static void Identity3x3(float A[3][3]);
00230   static void Identity3x3(double A[3][3]);
00232 
00234 
00235   static double Determinant3x3(float A[3][3]);
00236   static double Determinant3x3(double A[3][3]);
00238 
00240 
00241   static float Determinant3x3(const float c1[3], 
00242                               const float c2[3], 
00243                               const float c3[3]);
00245 
00247 
00249   static double Determinant3x3(double a1, double a2, double a3, 
00250                                double b1, double b2, double b3, 
00251                                double c1, double c2, double c3);
00253 
00255 
00257   static void QuaternionToMatrix3x3(const float quat[4], float A[3][3]); 
00258   static void QuaternionToMatrix3x3(const double quat[4], double A[3][3]); 
00260 
00262 
00265   static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4]);
00266   static void Matrix3x3ToQuaternion(const double A[3][3], double quat[4]);
00268   
00270 
00273   static void Orthogonalize3x3(const float A[3][3], float B[3][3]);
00274   static void Orthogonalize3x3(const double A[3][3], double B[3][3]);
00276 
00278 
00282   static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3]);
00283   static void Diagonalize3x3(const double A[3][3],double w[3],double V[3][3]);
00285 
00287 
00294   static void SingularValueDecomposition3x3(const float A[3][3],
00295                                             float U[3][3], float w[3],
00296                                             float VT[3][3]);
00297   static void SingularValueDecomposition3x3(const double A[3][3],
00298                                             double U[3][3], double w[3],
00299                                             double VT[3][3]);
00301 
00306   static int SolveLinearSystem(double **A, double *x, int size);
00307 
00311   static int InvertMatrix(double **A, double **AI, int size);
00312 
00314 
00316   static int InvertMatrix(double **A, double **AI, int size,
00317                           int *tmp1Size, double *tmp2Size);
00319 
00325   static int LUFactorLinearSystem(double **A, int *index, int size);
00326 
00328 
00330   static int LUFactorLinearSystem(double **A, int *index, int size,
00331                                   double *tmpSize);
00333 
00335 
00341   static void LUSolveLinearSystem(double **A, int *index, 
00342                                   double *x, int size);
00344 
00352   static double EstimateMatrixCondition(double **A, int size);
00353 
00359   static void RandomSeed(long s);  
00360 
00363   static float Random();  
00364 
00366   static float Random(float min, float max);
00367 
00369 
00373   static int Jacobi(float **a, float *w, float **v);
00374   static int Jacobi(double **a, double *w, double **v);
00376 
00378 
00383   static int JacobiN(float **a, int n, float *w, float **v);
00384   static int JacobiN(double **a, int n, double *w, double **v);
00386 
00393   static double* SolveCubic(double c0, double c1, double c2, double c3);
00394 
00401   static double* SolveQuadratic(double c0, double c1, double c2);
00402 
00406   static double* SolveLinear(double c0, double c1);
00407 
00409 
00420   static int SolveCubic(double c0, double c1, double c2, double c3, 
00421                         double *r1, double *r2, double *r3, int *num_roots);
00423 
00425 
00429   static int SolveQuadratic(double c0, double c1, double c2, 
00430                             double *r1, double *r2, int *num_roots);
00432   
00437   static int SolveLinear(double c0, double c1, double *r1, int *num_roots);
00438 
00439 
00441 
00448   static int SolveLeastSquares(int numberOfSamples, double **xt, int xOrder,
00449                                double **yt, int yOrder, double **mt);
00451 
00453 
00455   static void RGBToHSV(float rgb[3], float hsv[3])
00456     { 
00457     RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2);
00458     }
00459   static void RGBToHSV(float r, float g, float b, float *h, float *s, float *v);
00461 
00463 
00465   static void HSVToRGB(float hsv[3], float rgb[3])
00466     { 
00467     HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2);
00468     }
00469   static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b);
00471 
00472 protected:
00473   vtkMath() {};
00474   ~vtkMath() {};
00475   
00476   static long Seed;
00477 private:
00478   vtkMath(const vtkMath&);  // Not implemented.
00479   void operator=(const vtkMath&);  // Not implemented.
00480 };
00481 
00482 inline float vtkMath::Normalize(float x[3])
00483 {
00484   float den; 
00485   if ( (den = vtkMath::Norm(x)) != 0.0 )
00486     {
00487     for (int i=0; i < 3; i++)
00488       {
00489       x[i] /= den;
00490       }
00491     }
00492   return den;
00493 }
00494 inline double vtkMath::Normalize(double x[3])
00495 {
00496   double den; 
00497   if ( (den = vtkMath::Norm(x)) != 0.0 )
00498     {
00499     for (int i=0; i < 3; i++)
00500       {
00501       x[i] /= den;
00502       }
00503     }
00504   return den;
00505 }
00506 
00507 inline float vtkMath::Normalize2D(float x[3])
00508 {
00509   float den; 
00510   if ( (den = vtkMath::Norm2D(x)) != 0.0 )
00511     {
00512     for (int i=0; i < 2; i++)
00513       {
00514       x[i] /= den;
00515       }
00516     }
00517   return den;
00518 }
00519 
00520 inline double vtkMath::Normalize2D(double x[3])
00521 {
00522   double den; 
00523   if ( (den = vtkMath::Norm2D(x)) != 0.0 )
00524     {
00525     for (int i=0; i < 2; i++)
00526       {
00527       x[i] /= den;
00528       }
00529     }
00530   return den;
00531 }
00532 
00533 inline float vtkMath::Determinant3x3(const float c1[3], 
00534                                      const float c2[3], 
00535                                      const float c3[3])
00536 {
00537   return c1[0]*c2[1]*c3[2] + c2[0]*c3[1]*c1[2] + c3[0]*c1[1]*c2[2] -
00538          c1[0]*c3[1]*c2[2] - c2[0]*c1[1]*c3[2] - c3[0]*c2[1]*c1[2];
00539 }
00540 
00541 inline double vtkMath::Determinant3x3(double a1, double a2, double a3, 
00542                                       double b1, double b2, double b3, 
00543                                       double c1, double c2, double c3)
00544 {
00545     return ( a1 * vtkMath::Determinant2x2( b2, b3, c2, c3 )
00546            - b1 * vtkMath::Determinant2x2( a2, a3, c2, c3 )
00547            + c1 * vtkMath::Determinant2x2( a2, a3, b2, b3 ) );
00548 }
00549 
00550 inline float vtkMath::Distance2BetweenPoints(const float x[3], 
00551                                              const float y[3])
00552 {
00553   return ((x[0]-y[0])*(x[0]-y[0]) + (x[1]-y[1])*(x[1]-y[1]) +
00554           (x[2]-y[2])*(x[2]-y[2]));
00555 }
00556 inline double vtkMath::Distance2BetweenPoints(const double x[3], 
00557                                               const double y[3])
00558 {
00559   return ((x[0]-y[0])*(x[0]-y[0]) + (x[1]-y[1])*(x[1]-y[1]) +
00560           (x[2]-y[2])*(x[2]-y[2]));
00561 }
00562 
00563 inline float vtkMath::Random(float min, float max)
00564 {
00565   return (min + vtkMath::Random()*(max-min));
00566 }
00567 
00568 // Cross product of two 3-vectors. Result vector in z[3].
00569 inline void vtkMath::Cross(const float x[3], const float y[3], float z[3])
00570 {
00571   float Zx = x[1]*y[2] - x[2]*y[1]; 
00572   float Zy = x[2]*y[0] - x[0]*y[2];
00573   float Zz = x[0]*y[1] - x[1]*y[0];
00574   z[0] = Zx; z[1] = Zy; z[2] = Zz; 
00575 }
00576 
00577 // Cross product of two 3-vectors. Result vector in z[3].
00578 inline void vtkMath::Cross(const double x[3], const double y[3], double z[3])
00579 {
00580   double Zx = x[1]*y[2] - x[2]*y[1]; 
00581   double Zy = x[2]*y[0] - x[0]*y[2];
00582   double Zz = x[0]*y[1] - x[1]*y[0];
00583   z[0] = Zx; z[1] = Zy; z[2] = Zz; 
00584 }
00585 
00586 //BTX
00587 //----------------------------------------------------------------------------
00588 template<class T>
00589 inline double vtkDeterminant3x3(T A[3][3])
00590 {
00591   return A[0][0]*A[1][1]*A[2][2] + A[1][0]*A[2][1]*A[0][2] + 
00592          A[2][0]*A[0][1]*A[1][2] - A[0][0]*A[2][1]*A[1][2] - 
00593          A[1][0]*A[0][1]*A[2][2] - A[2][0]*A[1][1]*A[0][2];
00594 }
00595 //ETX
00596 
00597 inline double vtkMath::Determinant3x3(float A[3][3])
00598 {
00599   return vtkDeterminant3x3(A);
00600 }
00601 
00602 inline double vtkMath::Determinant3x3(double A[3][3])
00603 {
00604   return vtkDeterminant3x3(A);
00605 }
00606 
00607 
00608 #endif