Common/vtkMath.h Source File

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

# 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 =========================================================================*/
    00048 #ifndef __vtkMath_h
    00049 #define __vtkMath_h
    00050
    00051 #include "vtkObject.h"
    00052
    00053 class VTK_COMMON_EXPORT vtkMath : public vtkObject
    00054 {
    00055 public:
    00056   static vtkMath *New();
    00057   vtkTypeRevisionMacro(vtkMath,vtkObject);
    00058
    00060
    00061   static float Pi() {return 3.14159265358979f;};
    00062   static float DegreesToRadians() {return 0.017453292f;};
    00063   static float RadiansToDegrees() {return 57.2957795131f;};
    00065
    00067
    00068   static double DoubleDegreesToRadians() {return 0.017453292519943295;};
    00069   static double DoublePi() {return 3.1415926535897932384626;};
    00070   static double DoubleRadiansToDegrees() {return 57.29577951308232;};
    00072
    00074
    00075   static int Round(float f) {
    00076     return static_cast<int>(f + (f >= 0 ? 0.5 : -0.5)); }
    00077   static int Round(double f) {
    00078     return static_cast<int>(f + (f >= 0 ? 0.5 : -0.5)); }
    00080
    00082
    00083   static float Dot(const float x[3], const float y[3]) {
    00084     return (x[0]*y[0] + x[1]*y[1] + x[2]*y[2]);};
    00086
    00088
    00089   static double Dot(const double x[3], const double y[3]) {
    00090     return (x[0]*y[0] + x[1]*y[1] + x[2]*y[2]);};
    00092
    00094   static void Cross(const float x[3], const float y[3], float z[3]);
    00095
    00098   static void Cross(const double x[3], const double y[3], double z[3]);
    00099
    00101   static float Norm(const float* x, int n);
    00102
    00104
    00105   static float Norm(const float x[3]) {
    00106     return static_cast<float> (sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]));};
    00108
    00110
    00111   static double Norm(const double x[3]) {
    00112     return sqrt(x[0]*x[0] + x[1]*x[1] + x[2]*x[2]);};
    00114
    00116   static float Normalize(float x[3]);
    00117
    00120   static double Normalize(double x[3]);
    00121
    00123
    00128   static void Perpendiculars(const double x[3], double y[3], double z[3],
    00129                              double theta);
    00130   static void Perpendiculars(const float x[3], float y[3], float z[3],
    00131                              double theta);
    00133
    00135   static float Distance2BetweenPoints(const float x[3], const float y[3]);
    00136
    00139   static double Distance2BetweenPoints(const double x[3], const double y[3]);
    00140
    00142
    00143   static float Dot2D(const float x[3], const float y[3]) {
    00144     return (x[0]*y[0] + x[1]*y[1]);};
    00146
    00148
    00150   static double Dot2D(const double x[3], const double y[3]) {
    00151     return (x[0]*y[0] + x[1]*y[1]);};
    00153
    00155
    00156   static float Norm2D(const float x[3]) {
    00157     return static_cast<float> (sqrt(x[0]*x[0] + x[1]*x[1]));};
    00159
    00161
    00163   static double Norm2D(const double x[3]) {
    00164     return sqrt(x[0]*x[0] + x[1]*x[1]);};
    00166
    00169   static float Normalize2D(float x[3]);
    00170
    00173   static double Normalize2D(double x[3]);
    00174
    00176
    00177   static float Determinant2x2(const float c1[2], const float c2[2]) {
    00178     return (c1[0]*c2[1] - c2[0]*c1[1]);};
    00180
    00182
    00183   static double Determinant2x2(double a, double b, double c, double d) {
    00184     return (a * d - b * c);};
    00186
    00188
    00190   static void LUFactor3x3(float A[3][3], int index[3]);
    00191   static void LUFactor3x3(double A[3][3], int index[3]);
    00193
    00195
    00197   static void LUSolve3x3(const float A[3][3], const int index[3],
    00198                          float x[3]);
    00199   static void LUSolve3x3(const double A[3][3], const int index[3],
    00200                          double x[3]);
    00202
    00204
    00206   static void LinearSolve3x3(const float A[3][3], const float x[3],
    00207                              float y[3]);
    00208   static void LinearSolve3x3(const double A[3][3], const double x[3],
    00209                              double y[3]);
    00211
    00213
    00214   static void Multiply3x3(const float A[3][3], const float in[3],
    00215                           float out[3]);
    00216   static void Multiply3x3(const double A[3][3], const double in[3],
    00217                           double out[3]);
    00219
    00221
    00222   static void Multiply3x3(const float A[3][3], const float B[3][3],
    00223                           float C[3][3]);
    00224   static void Multiply3x3(const double A[3][3], const double B[3][3],
    00225                           double C[3][3]);
    00227
    00229
    00230   static void Transpose3x3(const float A[3][3], float AT[3][3]);
    00231   static void Transpose3x3(const double A[3][3], double AT[3][3]);
    00233
    00235
    00236   static void Invert3x3(const float A[3][3], float AI[3][3]);
    00237   static void Invert3x3(const double A[3][3], double AI[3][3]);
    00239
    00241
    00242   static void Identity3x3(float A[3][3]);
    00243   static void Identity3x3(double A[3][3]);
    00245
    00247
    00248   static double Determinant3x3(float A[3][3]);
    00249   static double Determinant3x3(double A[3][3]);
    00251
    00253
    00254   static float Determinant3x3(const float c1[3],
    00255                               const float c2[3],
    00256                               const float c3[3]);
    00258
    00260
    00262   static double Determinant3x3(double a1, double a2, double a3,
    00263                                double b1, double b2, double b3,
    00264                                double c1, double c2, double c3);
    00266
    00268
    00270   static void QuaternionToMatrix3x3(const float quat[4], float A[3][3]);
    00271   static void QuaternionToMatrix3x3(const double quat[4], double A[3][3]);
    00273
    00275
    00278   static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4]);
    00279   static void Matrix3x3ToQuaternion(const double A[3][3], double quat[4]);
    00281
    00283
    00286   static void Orthogonalize3x3(const float A[3][3], float B[3][3]);
    00287   static void Orthogonalize3x3(const double A[3][3], double B[3][3]);
    00289
    00291
    00295   static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3]);
    00296   static void Diagonalize3x3(const double A[3][3],double w[3],double V[3][3]);
    00298
    00300
    00307   static void SingularValueDecomposition3x3(const float A[3][3],
    00308                                             float U[3][3], float w[3],
    00309                                             float VT[3][3]);
    00310   static void SingularValueDecomposition3x3(const double A[3][3],
    00311                                             double U[3][3], double w[3],
    00312                                             double VT[3][3]);
    00314
    00319   static int SolveLinearSystem(double **A, double *x, int size);
    00320
    00324   static int InvertMatrix(double **A, double **AI, int size);
    00325
    00327
    00329   static int InvertMatrix(double **A, double **AI, int size,
    00330                           int *tmp1Size, double *tmp2Size);
    00332
    00338   static int LUFactorLinearSystem(double **A, int *index, int size);
    00339
    00341
    00343   static int LUFactorLinearSystem(double **A, int *index, int size,
    00344                                   double *tmpSize);
    00346
    00348
    00354   static void LUSolveLinearSystem(double **A, int *index,
    00355                                   double *x, int size);
    00357
    00365   static double EstimateMatrixCondition(double **A, int size);
    00366
    00372   static void RandomSeed(long s);
    00373
    00376   static float Random();
    00377
    00379   static float Random(float min, float max);
    00380
    00382
    00386   static int Jacobi(float **a, float *w, float **v);
    00387   static int Jacobi(double **a, double *w, double **v);
    00389
    00391
    00396   static int JacobiN(float **a, int n, float *w, float **v);
    00397   static int JacobiN(double **a, int n, double *w, double **v);
    00399
    00406   static double* SolveCubic(double c0, double c1, double c2, double c3);
    00407
    00414   static double* SolveQuadratic(double c0, double c1, double c2);
    00415
    00419   static double* SolveLinear(double c0, double c1);
    00420
    00422
    00433   static int SolveCubic(double c0, double c1, double c2, double c3,
    00434                         double *r1, double *r2, double *r3, int *num_roots);
    00436
    00438
    00442   static int SolveQuadratic(double c0, double c1, double c2,
    00443                             double *r1, double *r2, int *num_roots);
    00445
    00450   static int SolveLinear(double c0, double c1, double *r1, int *num_roots);
    00451
    00452
    00454
    00461   static int SolveLeastSquares(int numberOfSamples, double **xt, int xOrder,
    00462                                double **yt, int yOrder, double **mt);
    00464
    00466
    00468   static void RGBToHSV(float rgb[3], float hsv[3])
    00469     {
    00470     RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2);
    00471     }
    00472   static void RGBToHSV(float r, float g, float b, float *h, float *s, float *v);
    00474
    00476
    00478   static void HSVToRGB(float hsv[3], float rgb[3])
    00479     {
    00480     HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2);
    00481     }
    00482   static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b);
    00484
    00485 protected:
    00486   vtkMath() {};
    00487   ~vtkMath() {};
    00488
    00489   static long Seed;
    00490 private:
    00491   vtkMath(const vtkMath&);  // Not implemented.
    00492   void operator=(const vtkMath&);  // Not implemented.
    00493 };
    00494
    00495 inline float vtkMath::Normalize(float x[3])
    00496 {
    00497   float den;
    00498   if ( (den = vtkMath::Norm(x)) != 0.0 )
    00499     {
    00500     for (int i=0; i < 3; i++)
    00501       {
    00502       x[i] /= den;
    00503       }
    00504     }
    00505   return den;
    00506 }
    00507 inline double vtkMath::Normalize(double x[3])
    00508 {
    00509   double den;
    00510   if ( (den = vtkMath::Norm(x)) != 0.0 )
    00511     {
    00512     for (int i=0; i < 3; i++)
    00513       {
    00514       x[i] /= den;
    00515       }
    00516     }
    00517   return den;
    00518 }
    00519
    00520 inline float vtkMath::Normalize2D(float x[3])
    00521 {
    00522   float 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 double vtkMath::Normalize2D(double x[3])
    00534 {
    00535   double den;
    00536   if ( (den = vtkMath::Norm2D(x)) != 0.0 )
    00537     {
    00538     for (int i=0; i < 2; i++)
    00539       {
    00540       x[i] /= den;
    00541       }
    00542     }
    00543   return den;
    00544 }
    00545
    00546 inline float vtkMath::Determinant3x3(const float c1[3],
    00547                                      const float c2[3],
    00548                                      const float c3[3])
    00549 {
    00550   return c1[0]*c2[1]*c3[2] + c2[0]*c3[1]*c1[2] + c3[0]*c1[1]*c2[2] -
    00551          c1[0]*c3[1]*c2[2] - c2[0]*c1[1]*c3[2] - c3[0]*c2[1]*c1[2];
    00552 }
    00553
    00554 inline double vtkMath::Determinant3x3(double a1, double a2, double a3,
    00555                                       double b1, double b2, double b3,
    00556                                       double c1, double c2, double c3)
    00557 {
    00558     return ( a1 * vtkMath::Determinant2x2( b2, b3, c2, c3 )
    00559            - b1 * vtkMath::Determinant2x2( a2, a3, c2, c3 )
    00560            + c1 * vtkMath::Determinant2x2( a2, a3, b2, b3 ) );
    00561 }
    00562
    00563 inline float vtkMath::Distance2BetweenPoints(const float x[3],
    00564                                              const float y[3])
    00565 {
    00566   return ((x[0]-y[0])*(x[0]-y[0]) + (x[1]-y[1])*(x[1]-y[1]) +
    00567           (x[2]-y[2])*(x[2]-y[2]));
    00568 }
    00569 inline double vtkMath::Distance2BetweenPoints(const double x[3],
    00570                                               const double y[3])
    00571 {
    00572   return ((x[0]-y[0])*(x[0]-y[0]) + (x[1]-y[1])*(x[1]-y[1]) +
    00573           (x[2]-y[2])*(x[2]-y[2]));
    00574 }
    00575
    00576 inline float vtkMath::Random(float min, float max)
    00577 {
    00578   return (min + vtkMath::Random()*(max-min));
    00579 }
    00580
    00581 // Cross product of two 3-vectors. Result vector in z[3].
    00582 inline void vtkMath::Cross(const float x[3], const float y[3], float z[3])
    00583 {
    00584   float Zx = x[1]*y[2] - x[2]*y[1];
    00585   float Zy = x[2]*y[0] - x[0]*y[2];
    00586   float Zz = x[0]*y[1] - x[1]*y[0];
    00587   z[0] = Zx; z[1] = Zy; z[2] = Zz;
    00588 }
    00589
    00590 // Cross product of two 3-vectors. Result vector in z[3].
    00591 inline void vtkMath::Cross(const double x[3], const double y[3], double z[3])
    00592 {
    00593   double Zx = x[1]*y[2] - x[2]*y[1];
    00594   double Zy = x[2]*y[0] - x[0]*y[2];
    00595   double Zz = x[0]*y[1] - x[1]*y[0];
    00596   z[0] = Zx; z[1] = Zy; z[2] = Zz;
    00597 }
    00598
    00599 //BTX
    00600 //----------------------------------------------------------------------------
    00601 template<class T>
    00602 inline double vtkDeterminant3x3(T A[3][3])
    00603 {
    00604   return A[0][0]*A[1][1]*A[2][2] + A[1][0]*A[2][1]*A[0][2] +
    00605          A[2][0]*A[0][1]*A[1][2] - A[0][0]*A[2][1]*A[1][2] -
    00606          A[1][0]*A[0][1]*A[2][2] - A[2][0]*A[1][1]*A[0][2];
    00607 }
    00608 //ETX
    00609
    00610 inline double vtkMath::Determinant3x3(float A[3][3])
    00611 {
    00612   return vtkDeterminant3x3(A);
    00613 }
    00614
    00615 inline double vtkMath::Determinant3x3(double A[3][3])
    00616 {
    00617   return vtkDeterminant3x3(A);
    00618 }
    00619
    00620
    00621 #endif