VTK
vtkMath.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkMath.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================
15  Copyright 2011 Sandia Corporation.
16  Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
17  license for use of this work by or on behalf of the
18  U.S. Government. Redistribution and use in source and binary forms, with
19  or without modification, are permitted provided that this Notice and any
20  statement of authorship are reproduced on all copies.
21 
22  Contact: pppebay@sandia.gov,dcthomp@sandia.gov
23 
24 =========================================================================*/
45 #ifndef vtkMath_h
46 #define vtkMath_h
47 
48 #include "vtkCommonCoreModule.h" // For export macro
49 #include "vtkObject.h"
50 #include "vtkTypeTraits.h" // For type traits
51 #include "vtkSmartPointer.h" // For vtkSmartPointer.
52 
53 #include "vtkMathConfigure.h" // For <cmath> and VTK_HAS_ISNAN etc.
54 
55 #include <cassert> // assert() in inline implementations.
56 
57 #ifndef DBL_MIN
58 # define VTK_DBL_MIN 2.2250738585072014e-308
59 #else // DBL_MIN
60 # define VTK_DBL_MIN DBL_MIN
61 #endif // DBL_MIN
62 
63 #ifndef DBL_EPSILON
64 # define VTK_DBL_EPSILON 2.2204460492503131e-16
65 #else // DBL_EPSILON
66 # define VTK_DBL_EPSILON DBL_EPSILON
67 #endif // DBL_EPSILON
68 
69 #ifndef VTK_DBL_EPSILON
70 # ifndef DBL_EPSILON
71 # define VTK_DBL_EPSILON 2.2204460492503131e-16
72 # else // DBL_EPSILON
73 # define VTK_DBL_EPSILON DBL_EPSILON
74 # endif // DBL_EPSILON
75 #endif // VTK_DBL_EPSILON
76 
77 class vtkDataArray;
78 class vtkPoints;
79 class vtkMathInternal;
82 
83 namespace vtk_detail
84 {
85 // forward declaration
86 template <typename OutT>
87 void RoundDoubleToIntegralIfNecessary(double val, OutT* ret);
88 } // end namespace vtk_detail
89 
90 class VTKCOMMONCORE_EXPORT vtkMath : public vtkObject
91 {
92 public:
93  static vtkMath *New();
94  vtkTypeMacro(vtkMath,vtkObject);
95  void PrintSelf(ostream& os, vtkIndent indent) override;
96 
100  static double Pi() { return 3.141592653589793; };
101 
103 
106  static float RadiansFromDegrees( float degrees);
107  static double RadiansFromDegrees( double degrees);
109 
111 
114  static float DegreesFromRadians( float radians);
115  static double DegreesFromRadians( double radians);
117 
121  static int Round(float f) {
122  return static_cast<int>( f + ( f >= 0.0 ? 0.5 : -0.5 ) ); }
123  static int Round(double f) {
124  return static_cast<int>( f + ( f >= 0.0 ? 0.5 : -0.5 ) ); }
125 
130  template <typename OutT>
131  static void RoundDoubleToIntegralIfNecessary(double val, OutT* ret)
132  {
133  // Can't specialize template methods in a template class, so we move the
134  // implementations to a external namespace.
136  }
137 
143  static int Floor(double x);
144 
150  static int Ceil(double x);
151 
157  static int CeilLog2(vtkTypeUInt64 x);
158 
162  template<class T>
163  static T Min(const T & a, const T & b);
164 
168  template<class T>
169  static T Max(const T & a, const T & b);
170 
174  static bool IsPowerOfTwo(vtkTypeUInt64 x);
175 
181  static int NearestPowerOfTwo(int x);
182 
187  static vtkTypeInt64 Factorial( int N );
188 
194  static vtkTypeInt64 Binomial( int m, int n );
195 
206  static int* BeginCombination( int m, int n );
207 
218  static int NextCombination( int m, int n, int* combination );
219 
223  static void FreeCombination( int* combination);
224 
240  static void RandomSeed(int s);
241 
253  static int GetSeed();
254 
268  static double Random();
269 
282  static double Random( double min, double max );
283 
296  static double Gaussian();
297 
310  static double Gaussian( double mean, double std );
311 
315  static void Add(const float a[3], const float b[3], float c[3]) {
316  for (int i = 0; i < 3; ++i)
317  c[i] = a[i] + b[i];
318  }
319 
323  static void Add(const double a[3], const double b[3], double c[3]) {
324  for (int i = 0; i < 3; ++i)
325  c[i] = a[i] + b[i];
326  }
327 
331  static void Subtract(const float a[3], const float b[3], float c[3]) {
332  for (int i = 0; i < 3; ++i)
333  c[i] = a[i] - b[i];
334  }
335 
339  static void Subtract(const double a[3], const double b[3], double c[3]) {
340  for (int i = 0; i < 3; ++i)
341  c[i] = a[i] - b[i];
342  }
343 
348  static void MultiplyScalar(float a[3], float s) {
349  for (int i = 0; i < 3; ++i)
350  a[i] *= s;
351  }
352 
357  static void MultiplyScalar2D(float a[2], float s) {
358  for (int i = 0; i < 2; ++i)
359  a[i] *= s;
360  }
361 
366  static void MultiplyScalar(double a[3], double s) {
367  for (int i = 0; i < 3; ++i)
368  a[i] *= s;
369  }
370 
375  static void MultiplyScalar2D(double a[2], double s) {
376  for (int i = 0; i < 2; ++i)
377  a[i] *= s;
378  }
379 
383  static float Dot(const float a[3], const float b[3]) {
384  return ( a[0] * b[0] + a[1] * b[1] + a[2] * b[2] );};
385 
389  static double Dot(const double a[3], const double b[3]) {
390  return ( a[0] * b[0] + a[1] * b[1] + a[2] * b[2] );};
391 
395  static void Outer(const float a[3], const float b[3], float C[3][3]) {
396  for (int i=0; i < 3; i++)
397  for (int j=0; j < 3; j++)
398  C[i][j] = a[i] * b[j];
399  }
403  static void Outer(const double a[3], const double b[3], double C[3][3]) {
404  for (int i=0; i < 3; i++)
405  for (int j=0; j < 3; j++)
406  C[i][j] = a[i] * b[j];
407  }
408 
412  static void Cross(const float a[3], const float b[3], float c[3]);
413 
418  static void Cross(const double a[3], const double b[3], double c[3]);
419 
421 
424  static float Norm(const float* x, int n);
425  static double Norm(const double* x, int n);
427 
431  static float Norm(const float v[3]) {
432  return static_cast<float> (sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] ) );};
433 
437  static double Norm(const double v[3]) {
438  return sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] );};
439 
443  static float Normalize(float v[3]);
444 
449  static double Normalize(double v[3]);
450 
452 
459  static void Perpendiculars(const double v1[3], double v2[3], double v3[3],
460  double theta);
461  static void Perpendiculars(const float v1[3], float v2[3], float v3[3],
462  double theta);
464 
466 
471  static bool ProjectVector(const float a[3], const float b[3], float projection[3]);
472  static bool ProjectVector(const double a[3], const double b[3], double projection[3]);
474 
476 
482  static bool ProjectVector2D(const float a[2], const float b[2], float projection[2]);
483  static bool ProjectVector2D(const double a[2], const double b[2], double projection[2]);
485 
489  static float Distance2BetweenPoints(const float p1[3], const float p2[3]);
490 
495  static double Distance2BetweenPoints(const double p1[3], const double p2[3]);
496 
500  static double AngleBetweenVectors(const double v1[3], const double v2[3]);
501 
506  static double GaussianAmplitude(const double variance, const double distanceFromMean);
507 
512  static double GaussianAmplitude(const double mean, const double variance, const double position);
513 
519  static double GaussianWeight(const double variance, const double distanceFromMean);
520 
526  static double GaussianWeight(const double mean, const double variance, const double position);
527 
531  static float Dot2D(const float x[2], const float y[2]) {
532  return ( x[0] * y[0] + x[1] * y[1] );};
533 
537  static double Dot2D(const double x[2], const double y[2]) {
538  return ( x[0] * y[0] + x[1] * y[1] );};
539 
543  static void Outer2D(const float x[2], const float y[2], float A[2][2])
544  {
545  for (int i=0; i < 2; i++)
546  {
547  for (int j=0; j < 2; j++)
548  {
549  A[i][j] = x[i] * y[j];
550  }
551  }
552  }
556  static void Outer2D(const double x[2], const double y[2], double A[2][2])
557  {
558  for (int i=0; i < 2; i++)
559  {
560  for (int j=0; j < 2; j++)
561  {
562  A[i][j] = x[i] * y[j];
563  }
564  }
565  }
566 
570  static float Norm2D(const float x[2]) {
571  return static_cast<float> (sqrt( x[0] * x[0] + x[1] * x[1] ) );};
572 
577  static double Norm2D(const double x[2]) {
578  return sqrt( x[0] * x[0] + x[1] * x[1] );};
579 
583  static float Normalize2D(float v[2]);
584 
589  static double Normalize2D(double v[2]);
590 
594  static float Determinant2x2(const float c1[2], const float c2[2]) {
595  return (c1[0] * c2[1] - c2[0] * c1[1] );};
596 
598 
601  static double Determinant2x2(double a, double b, double c, double d) {
602  return (a * d - b * c);};
603  static double Determinant2x2(const double c1[2], const double c2[2]) {
604  return (c1[0] * c2[1] - c2[0] * c1[1] );};
606 
608 
611  static void LUFactor3x3(float A[3][3], int index[3]);
612  static void LUFactor3x3(double A[3][3], int index[3]);
614 
616 
619  static void LUSolve3x3(const float A[3][3], const int index[3],
620  float x[3]);
621  static void LUSolve3x3(const double A[3][3], const int index[3],
622  double x[3]);
624 
626 
630  static void LinearSolve3x3(const float A[3][3], const float x[3],
631  float y[3]);
632  static void LinearSolve3x3(const double A[3][3], const double x[3],
633  double y[3]);
635 
637 
640  static void Multiply3x3(const float A[3][3], const float in[3],
641  float out[3]);
642  static void Multiply3x3(const double A[3][3], const double in[3],
643  double out[3]);
645 
647 
650  static void Multiply3x3(const float A[3][3], const float B[3][3],
651  float C[3][3]);
652  static void Multiply3x3(const double A[3][3], const double B[3][3],
653  double C[3][3]);
655 
661  static void MultiplyMatrix(double **A, double **B,
662  unsigned int rowA, unsigned int colA,
663  unsigned int rowB, unsigned int colB,
664  double **C);
665 
667 
671  static void Transpose3x3(const float A[3][3], float AT[3][3]);
672  static void Transpose3x3(const double A[3][3], double AT[3][3]);
674 
676 
680  static void Invert3x3(const float A[3][3], float AI[3][3]);
681  static void Invert3x3(const double A[3][3], double AI[3][3]);
683 
685 
688  static void Identity3x3(float A[3][3]);
689  static void Identity3x3(double A[3][3]);
691 
693 
696  static double Determinant3x3(float A[3][3]);
697  static double Determinant3x3(double A[3][3]);
699 
703  static float Determinant3x3(const float c1[3],
704  const float c2[3],
705  const float c3[3]);
706 
710  static double Determinant3x3(const double c1[3],
711  const double c2[3],
712  const double c3[3]);
713 
720  static double Determinant3x3(double a1, double a2, double a3,
721  double b1, double b2, double b3,
722  double c1, double c2, double c3);
723 
725 
732  static void QuaternionToMatrix3x3(const float quat[4], float A[3][3]);
733  static void QuaternionToMatrix3x3(const double quat[4], double A[3][3]);
735 
737 
745  static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4]);
746  static void Matrix3x3ToQuaternion(const double A[3][3], double quat[4]);
748 
750 
756  static void MultiplyQuaternion( const float q1[4], const float q2[4], float q[4] );
757  static void MultiplyQuaternion( const double q1[4], const double q2[4], double q[4] );
759 
761 
765  static void RotateVectorByNormalizedQuaternion(const float v[3], const float q[4], float r[3]);
766  static void RotateVectorByNormalizedQuaternion(const double v[3], const double q[4], double r[3]);
768 
770 
774  static void RotateVectorByWXYZ(const float v[3], const float q[4], float r[3]);
775  static void RotateVectorByWXYZ(const double v[3], const double q[4], double r[3]);
777 
779 
784  static void Orthogonalize3x3(const float A[3][3], float B[3][3]);
785  static void Orthogonalize3x3(const double A[3][3], double B[3][3]);
787 
789 
795  static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3]);
796  static void Diagonalize3x3(const double A[3][3],double w[3],double V[3][3]);
798 
800 
809  static void SingularValueDecomposition3x3(const float A[3][3],
810  float U[3][3], float w[3],
811  float VT[3][3]);
812  static void SingularValueDecomposition3x3(const double A[3][3],
813  double U[3][3], double w[3],
814  double VT[3][3]);
816 
823  static int SolveLinearSystem(double **A, double *x, int size);
824 
831  static int InvertMatrix(double **A, double **AI, int size);
832 
838  static int InvertMatrix(double **A, double **AI, int size,
839  int *tmp1Size, double *tmp2Size);
840 
863  static int LUFactorLinearSystem(double **A, int *index, int size);
864 
870  static int LUFactorLinearSystem(double **A, int *index, int size,
871  double *tmpSize);
872 
881  static void LUSolveLinearSystem(double **A, int *index,
882  double *x, int size);
883 
892  static double EstimateMatrixCondition(double **A, int size);
893 
895 
903  static int Jacobi(float **a, float *w, float **v);
904  static int Jacobi(double **a, double *w, double **v);
906 
908 
917  static int JacobiN(float **a, int n, float *w, float **v);
918  static int JacobiN(double **a, int n, double *w, double **v);
920 
934  static int SolveHomogeneousLeastSquares(int numberOfSamples, double **xt, int xOrder,
935  double **mt);
936 
951  static int SolveLeastSquares(int numberOfSamples, double **xt, int xOrder,
952  double **yt, int yOrder, double **mt, int checkHomogeneous=1);
953 
955 
962  static void RGBToHSV(const float rgb[3], float hsv[3])
963  { RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); }
964  static void RGBToHSV(float r, float g, float b, float *h, float *s, float *v);
965  static double* RGBToHSV(const double rgb[3]);
966  static double* RGBToHSV(double r, double g, double b);
967  static void RGBToHSV(const double rgb[3], double hsv[3])
968  { RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); }
969  static void RGBToHSV(double r, double g, double b, double *h, double *s, double *v);
971 
973 
980  static void HSVToRGB(const float hsv[3], float rgb[3])
981  { HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); }
982  static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b);
983  static double* HSVToRGB(const double hsv[3]);
984  static double* HSVToRGB(double h, double s, double v);
985  static void HSVToRGB(const double hsv[3], double rgb[3])
986  { HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); }
987  static void HSVToRGB(double h, double s, double v, double *r, double *g, double *b);
989 
991 
994  static void LabToXYZ(const double lab[3], double xyz[3]) {
995  LabToXYZ(lab[0], lab[1], lab[2], xyz+0, xyz+1, xyz+2);
996  }
997  static void LabToXYZ(double L, double a, double b,
998  double *x, double *y, double *z);
999  static double *LabToXYZ(const double lab[3]);
1001 
1003 
1006  static void XYZToLab(const double xyz[3], double lab[3]) {
1007  XYZToLab(xyz[0], xyz[1], xyz[2], lab+0, lab+1, lab+2);
1008  }
1009  static void XYZToLab(double x, double y, double z,
1010  double *L, double *a, double *b);
1011  static double *XYZToLab(const double xyz[3]);
1013 
1015 
1018  static void XYZToRGB(const double xyz[3], double rgb[3]) {
1019  XYZToRGB(xyz[0], xyz[1], xyz[2], rgb+0, rgb+1, rgb+2);
1020  }
1021  static void XYZToRGB(double x, double y, double z,
1022  double *r, double *g, double *b);
1023  static double *XYZToRGB(const double xyz[3]);
1025 
1027 
1030  static void RGBToXYZ(const double rgb[3], double xyz[3]) {
1031  RGBToXYZ(rgb[0], rgb[1], rgb[2], xyz+0, xyz+1, xyz+2);
1032  }
1033  static void RGBToXYZ(double r, double g, double b,
1034  double *x, double *y, double *z);
1035  static double *RGBToXYZ(const double rgb[3]);
1037 
1039 
1045  static void RGBToLab(const double rgb[3], double lab[3]) {
1046  RGBToLab(rgb[0], rgb[1], rgb[2], lab+0, lab+1, lab+2);
1047  }
1048  static void RGBToLab(double red, double green, double blue,
1049  double *L, double *a, double *b);
1050  static double *RGBToLab(const double rgb[3]);
1052 
1054 
1057  static void LabToRGB(const double lab[3], double rgb[3]) {
1058  LabToRGB(lab[0], lab[1], lab[2], rgb+0, rgb+1, rgb+2);
1059  }
1060  static void LabToRGB(double L, double a, double b,
1061  double *red, double *green, double *blue);
1062  static double *LabToRGB(const double lab[3]);
1064 
1066 
1069  static void UninitializeBounds(double bounds[6]){
1070  bounds[0] = 1.0;
1071  bounds[1] = -1.0;
1072  bounds[2] = 1.0;
1073  bounds[3] = -1.0;
1074  bounds[4] = 1.0;
1075  bounds[5] = -1.0;
1076  }
1078 
1080 
1083  static vtkTypeBool AreBoundsInitialized(const double bounds[6]){
1084  if ( bounds[1]-bounds[0]<0.0 )
1085  {
1086  return 0;
1087  }
1088  return 1;
1089  }
1091 
1096  template<class T>
1097  static T ClampValue(const T & value, const T & min, const T & max);
1098 
1100 
1104  static void ClampValue(double *value, const double range[2]);
1105  static void ClampValue(double value, const double range[2], double *clamped_value);
1106  static void ClampValues(
1107  double *values, int nb_values, const double range[2]);
1108  static void ClampValues(
1109  const double *values, int nb_values, const double range[2], double *clamped_values);
1111 
1118  static double ClampAndNormalizeValue(double value,
1119  const double range[2]);
1120 
1125  template<class T1, class T2>
1126  static void TensorFromSymmetricTensor(T1 symmTensor[6], T2 tensor[9]);
1127 
1133  template<class T>
1134  static void TensorFromSymmetricTensor(T tensor[9]);
1135 
1144  static int GetScalarTypeFittingRange(
1145  double range_min, double range_max,
1146  double scale = 1.0, double shift = 0.0);
1147 
1156  static int GetAdjustedScalarRange(
1157  vtkDataArray *array, int comp, double range[2]);
1158 
1163  static vtkTypeBool ExtentIsWithinOtherExtent(int extent1[6], int extent2[6]);
1164 
1170  static vtkTypeBool BoundsIsWithinOtherBounds(double bounds1[6], double bounds2[6], double delta[3]);
1171 
1177  static vtkTypeBool PointIsWithinBounds(double point[3], double bounds[6], double delta[3]);
1178 
1188  static int PlaneIntersectsAABB(double const bounds[6], double const normal[3],
1189  double const point[3]);
1190 
1200  static double Solve3PointCircle(const double p1[3], const double p2[3], const double p3[3], double center[3]);
1201 
1205  static double Inf();
1206 
1210  static double NegInf();
1211 
1215  static double Nan();
1216 
1220  static vtkTypeBool IsInf(double x);
1221 
1225  static vtkTypeBool IsNan(double x);
1226 
1230  static bool IsFinite(double x);
1231 protected:
1232  vtkMath() {}
1233  ~vtkMath() override {}
1234 
1236 private:
1237  vtkMath(const vtkMath&) = delete;
1238  void operator=(const vtkMath&) = delete;
1239 };
1240 
1241 //----------------------------------------------------------------------------
1242 inline float vtkMath::RadiansFromDegrees( float x )
1243 {
1244  return x * 0.017453292f;
1245 }
1246 
1247 //----------------------------------------------------------------------------
1248 inline double vtkMath::RadiansFromDegrees( double x )
1249 {
1250  return x * 0.017453292519943295;
1251 }
1252 
1253 //----------------------------------------------------------------------------
1254 inline float vtkMath::DegreesFromRadians( float x )
1255 {
1256  return x * 57.2957795131f;
1257 }
1258 
1259 //----------------------------------------------------------------------------
1260 inline double vtkMath::DegreesFromRadians( double x )
1261 {
1262  return x * 57.29577951308232;
1263 }
1264 
1265 //----------------------------------------------------------------------------
1266 inline bool vtkMath::IsPowerOfTwo(vtkTypeUInt64 x)
1267 {
1268  return ((x != 0) & ((x & (x - 1)) == 0));
1269 }
1270 
1271 //----------------------------------------------------------------------------
1272 // Credit goes to Peter Hart and William Lewis on comp.lang.python 1997
1274 {
1275  unsigned int z = ((x > 0) ? x - 1 : 0);
1276  z |= z >> 1;
1277  z |= z >> 2;
1278  z |= z >> 4;
1279  z |= z >> 8;
1280  z |= z >> 16;
1281  return static_cast<int>(z + 1);
1282 }
1283 
1284 //----------------------------------------------------------------------------
1285 // Modify the trunc() operation provided by static_cast<int>() to get floor(),
1286 // Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1287 inline int vtkMath::Floor(double x)
1288 {
1289  int i = static_cast<int>(x);
1290  return i - ( i > x );
1291 }
1292 
1293 //----------------------------------------------------------------------------
1294 // Modify the trunc() operation provided by static_cast<int>() to get ceil(),
1295 // Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1296 inline int vtkMath::Ceil(double x)
1297 {
1298  int i = static_cast<int>(x);
1299  return i + ( i < x );
1300 }
1301 
1302 //----------------------------------------------------------------------------
1303 template<class T>
1304 inline T vtkMath::Min(const T & a, const T & b)
1305 {
1306  return (a < b ? a : b);
1307 }
1308 
1309 //----------------------------------------------------------------------------
1310 template<class T>
1311 inline T vtkMath::Max(const T & a, const T & b)
1312 {
1313  return (a > b ? a : b);
1314 }
1315 
1316 //----------------------------------------------------------------------------
1317 inline float vtkMath::Normalize(float v[3])
1318 {
1319  float den = vtkMath::Norm( v );
1320  if ( den != 0.0 )
1321  {
1322  for (int i=0; i < 3; i++)
1323  {
1324  v[i] /= den;
1325  }
1326  }
1327  return den;
1328 }
1329 
1330 //----------------------------------------------------------------------------
1331 inline double vtkMath::Normalize(double v[3])
1332 {
1333  double den = vtkMath::Norm( v );
1334  if ( den != 0.0 )
1335  {
1336  for (int i=0; i < 3; i++)
1337  {
1338  v[i] /= den;
1339  }
1340  }
1341  return den;
1342 }
1343 
1344 //----------------------------------------------------------------------------
1345 inline float vtkMath::Normalize2D(float v[3])
1346 {
1347  float den = vtkMath::Norm2D( v );
1348  if ( den != 0.0 )
1349  {
1350  for (int i=0; i < 2; i++)
1351  {
1352  v[i] /= den;
1353  }
1354  }
1355  return den;
1356 }
1357 
1358 //----------------------------------------------------------------------------
1359 inline double vtkMath::Normalize2D(double v[3])
1360 {
1361  double den = vtkMath::Norm2D( v );
1362  if ( den != 0.0 )
1363  {
1364  for (int i=0; i < 2; i++)
1365  {
1366  v[i] /= den;
1367  }
1368  }
1369  return den;
1370 }
1371 
1372 //----------------------------------------------------------------------------
1373 inline float vtkMath::Determinant3x3(const float c1[3],
1374  const float c2[3],
1375  const float c3[3])
1376 {
1377  return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1378  c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1379 }
1380 
1381 //----------------------------------------------------------------------------
1382 inline double vtkMath::Determinant3x3(const double c1[3],
1383  const double c2[3],
1384  const double c3[3])
1385 {
1386  return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1387  c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1388 }
1389 
1390 //----------------------------------------------------------------------------
1391 inline double vtkMath::Determinant3x3(double a1, double a2, double a3,
1392  double b1, double b2, double b3,
1393  double c1, double c2, double c3)
1394 {
1395  return ( a1 * vtkMath::Determinant2x2( b2, b3, c2, c3 )
1396  - b1 * vtkMath::Determinant2x2( a2, a3, c2, c3 )
1397  + c1 * vtkMath::Determinant2x2( a2, a3, b2, b3 ) );
1398 }
1399 
1400 //----------------------------------------------------------------------------
1401 inline float vtkMath::Distance2BetweenPoints(const float p1[3],
1402  const float p2[3])
1403 {
1404  return ( ( p1[0] - p2[0] ) * ( p1[0] - p2[0] )
1405  + ( p1[1] - p2[1] ) * ( p1[1] - p2[1] )
1406  + ( p1[2] - p2[2] ) * ( p1[2] - p2[2] ) );
1407 }
1408 
1409 //----------------------------------------------------------------------------
1410 inline double vtkMath::Distance2BetweenPoints(const double p1[3],
1411  const double p2[3])
1412 {
1413  return ( ( p1[0] - p2[0] ) * ( p1[0] - p2[0] )
1414  + ( p1[1] - p2[1] ) * ( p1[1] - p2[1] )
1415  + ( p1[2] - p2[2] ) * ( p1[2] - p2[2] ) );
1416 }
1417 
1418 //----------------------------------------------------------------------------
1419 // Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1420 inline void vtkMath::Cross(const float a[3], const float b[3], float c[3])
1421 {
1422  float Cx = a[1] * b[2] - a[2] * b[1];
1423  float Cy = a[2] * b[0] - a[0] * b[2];
1424  float Cz = a[0] * b[1] - a[1] * b[0];
1425  c[0] = Cx; c[1] = Cy; c[2] = Cz;
1426 }
1427 
1428 //----------------------------------------------------------------------------
1429 // Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1430 inline void vtkMath::Cross(const double a[3], const double b[3], double c[3])
1431 {
1432  double Cx = a[1] * b[2] - a[2] * b[1];
1433  double Cy = a[2] * b[0] - a[0] * b[2];
1434  double Cz = a[0] * b[1] - a[1] * b[0];
1435  c[0] = Cx; c[1] = Cy; c[2] = Cz;
1436 }
1437 
1438 //----------------------------------------------------------------------------
1439 template<class T>
1440 inline double vtkDeterminant3x3(T A[3][3])
1441 {
1442  return A[0][0] * A[1][1] * A[2][2] + A[1][0] * A[2][1] * A[0][2] +
1443  A[2][0] * A[0][1] * A[1][2] - A[0][0] * A[2][1] * A[1][2] -
1444  A[1][0] * A[0][1] * A[2][2] - A[2][0] * A[1][1] * A[0][2];
1445 }
1446 
1447 //----------------------------------------------------------------------------
1448 inline double vtkMath::Determinant3x3(float A[3][3])
1449 {
1450  return vtkDeterminant3x3( A );
1451 }
1452 
1453 //----------------------------------------------------------------------------
1454 inline double vtkMath::Determinant3x3(double A[3][3])
1455 {
1456  return vtkDeterminant3x3( A );
1457 }
1458 
1459 //----------------------------------------------------------------------------
1460 template<class T>
1461 inline T vtkMath::ClampValue(const T & value, const T & min, const T & max)
1462 {
1463  assert("pre: valid_range" && min<=max);
1464 
1465  if (value < min)
1466  {
1467  return min;
1468  }
1469 
1470  if (value > max)
1471  {
1472  return max;
1473  }
1474 
1475  return value;
1476 }
1477 
1478 //----------------------------------------------------------------------------
1479 inline void vtkMath::ClampValue(double *value, const double range[2])
1480 {
1481  if (value && range)
1482  {
1483  assert("pre: valid_range" && range[0]<=range[1]);
1484 
1485  if (*value < range[0])
1486  {
1487  *value = range[0];
1488  }
1489  else if (*value > range[1])
1490  {
1491  *value = range[1];
1492  }
1493  }
1494 }
1495 
1496 //----------------------------------------------------------------------------
1498  double value, const double range[2], double *clamped_value)
1499 {
1500  if (range && clamped_value)
1501  {
1502  assert("pre: valid_range" && range[0]<=range[1]);
1503 
1504  if (value < range[0])
1505  {
1506  *clamped_value = range[0];
1507  }
1508  else if (value > range[1])
1509  {
1510  *clamped_value = range[1];
1511  }
1512  else
1513  {
1514  *clamped_value = value;
1515  }
1516  }
1517 }
1518 
1519 // ---------------------------------------------------------------------------
1521  const double range[2])
1522 {
1523  assert("pre: valid_range" && range[0]<=range[1]);
1524 
1525  double result;
1526  if(range[0]==range[1])
1527  {
1528  result=0.0;
1529  }
1530  else
1531  {
1532  // clamp
1533  if(value<range[0])
1534  {
1535  result=range[0];
1536  }
1537  else
1538  {
1539  if(value>range[1])
1540  {
1541  result=range[1];
1542  }
1543  else
1544  {
1545  result=value;
1546  }
1547  }
1548 
1549  // normalize
1550  result=( result - range[0] ) / ( range[1] - range[0] );
1551  }
1552 
1553  assert("post: valid_result" && result>=0.0 && result<=1.0);
1554 
1555  return result;
1556 }
1557 
1558 //-----------------------------------------------------------------------------
1559 template<class T1, class T2>
1560 inline void vtkMath::TensorFromSymmetricTensor(T1 symmTensor[9], T2 tensor[9])
1561 {
1562  for (int i = 0; i < 3; i++)
1563  {
1564  tensor[4*i] = symmTensor[i];
1565  }
1566  tensor[1] = tensor[3] = symmTensor[3];
1567  tensor[2] = tensor[6] = symmTensor[5];
1568  tensor[5] = tensor[7] = symmTensor[4];
1569 }
1570 
1571 //-----------------------------------------------------------------------------
1572 template<class T>
1573 inline void vtkMath::TensorFromSymmetricTensor(T tensor[9])
1574 {
1575  tensor[6] = tensor[5]; // XZ
1576  tensor[7] = tensor[4]; // YZ
1577  tensor[8] = tensor[2]; // ZZ
1578  tensor[4] = tensor[1]; // YY
1579  tensor[5] = tensor[7]; // YZ
1580  tensor[2] = tensor[6]; // XZ
1581  tensor[1] = tensor[3]; // XY
1582 }
1583 
1584 namespace vtk_detail
1585 {
1586 // Can't specialize templates inside a template class, so we move the impl here.
1587 template <typename OutT>
1588 void RoundDoubleToIntegralIfNecessary(double val, OutT* ret)
1589 { // OutT is integral -- clamp and round
1590  val = vtkMath::Max(val, static_cast<double>(vtkTypeTraits<OutT>::Min()));
1591  val = vtkMath::Min(val, static_cast<double>(vtkTypeTraits<OutT>::Max()));
1592  *ret = static_cast<OutT>((val >= 0.0) ? (val + 0.5) : (val - 0.5));
1593 }
1594 template <>
1595 inline void RoundDoubleToIntegralIfNecessary(double val, double* retVal)
1596 { // OutT is double: passthrough
1597  *retVal = val;
1598 }
1599 template <>
1600 inline void RoundDoubleToIntegralIfNecessary(double val, float* retVal)
1601 { // OutT is float -- just clamp
1602  val = vtkMath::Max(val, static_cast<double>(vtkTypeTraits<float>::Min()));
1603  val = vtkMath::Min(val, static_cast<double>(vtkTypeTraits<float>::Max()));
1604  *retVal = static_cast<float>(val);
1605 }
1606 } // end namespace vtk_detail
1607 
1608 //-----------------------------------------------------------------------------
1609 #if defined(VTK_HAS_ISINF) || defined(VTK_HAS_STD_ISINF)
1610 #define VTK_MATH_ISINF_IS_INLINE
1611 inline vtkTypeBool vtkMath::IsInf(double x)
1612 {
1613 #if defined(VTK_HAS_STD_ISINF)
1614  return std::isinf(x);
1615 #else
1616  return (isinf(x) != 0); // Force conversion to bool
1617 #endif
1618 }
1619 #endif
1620 
1621 //-----------------------------------------------------------------------------
1622 #if defined(VTK_HAS_ISNAN) || defined(VTK_HAS_STD_ISNAN)
1623 #define VTK_MATH_ISNAN_IS_INLINE
1624 inline vtkTypeBool vtkMath::IsNan(double x)
1625 {
1626 #if defined(VTK_HAS_STD_ISNAN)
1627  return std::isnan(x);
1628 #else
1629  return (isnan(x) != 0); // Force conversion to bool
1630 #endif
1631 }
1632 #endif
1633 
1634 //-----------------------------------------------------------------------------
1635 #if defined(VTK_HAS_ISFINITE) || defined(VTK_HAS_STD_ISFINITE) || defined(VTK_HAS_FINITE)
1636 #define VTK_MATH_ISFINITE_IS_INLINE
1637 inline bool vtkMath::IsFinite(double x)
1638 {
1639 #if defined(VTK_HAS_STD_ISFINITE)
1640  return std::isfinite(x);
1641 #elif defined(VTK_HAS_ISFINITE)
1642  return (isfinite(x) != 0); // Force conversion to bool
1643 #else
1644  return (finite(x) != 0); // Force conversion to bool
1645 #endif
1646 }
1647 #endif
1648 
1649 #endif
static void MultiplyScalar2D(float a[2], float s)
Multiplies a 2-vector by a scalar (float version).
Definition: vtkMath.h:357
static bool IsFinite(double x)
Test if a number has finite value i.e.
static float Dot2D(const float x[2], const float y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:531
~vtkMath() override
Definition: vtkMath.h:1233
static float Dot(const float a[3], const float b[3])
Dot product of two 3-vectors (float version).
Definition: vtkMath.h:383
abstract base class for most VTK objects
Definition: vtkObject.h:59
static void LabToXYZ(const double lab[3], double xyz[3])
Convert color from the CIE-L*ab system to CIE XYZ.
Definition: vtkMath.h:994
static double Pi()
A mathematical constant.
Definition: vtkMath.h:100
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static bool IsPowerOfTwo(vtkTypeUInt64 x)
Returns true if integer is a power of two.
Definition: vtkMath.h:1266
void RoundDoubleToIntegralIfNecessary(double val, OutT *ret)
Definition: vtkMath.h:1588
static float Determinant2x2(const float c1[2], const float c2[2])
Compute determinant of 2x2 matrix.
Definition: vtkMath.h:594
static vtkSmartPointer< vtkMathInternal > Internal
Definition: vtkMath.h:1235
static vtkTypeBool IsInf(double x)
Test if a number is equal to the special floating point value infinity.
static void RGBToHSV(const double rgb[3], double hsv[3])
Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value).
Definition: vtkMath.h:967
static vtkTypeBool IsNan(double x)
Test if a number is equal to the special floating point value Not-A-Number (Nan).
static int Round(float f)
Rounds a float to the nearest integer.
Definition: vtkMath.h:121
vtkMath()
Definition: vtkMath.h:1232
static void RGBToHSV(const float rgb[3], float hsv[3])
Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value).
Definition: vtkMath.h:962
static double ClampAndNormalizeValue(double value, const double range[2])
Clamp a value against a range and then normalize it between 0 and 1.
Definition: vtkMath.h:1520
static float Normalize2D(float v[2])
Normalize (in place) a 2-vector.
int vtkTypeBool
Definition: vtkABI.h:69
static void Add(const double a[3], const double b[3], double c[3])
Addition of two 3-vectors (double version).
Definition: vtkMath.h:323
static double Dot(const double a[3], const double b[3])
Dot product of two 3-vectors (double-precision version).
Definition: vtkMath.h:389
static void XYZToRGB(const double xyz[3], double rgb[3])
Convert color from the CIE XYZ system to RGB.
Definition: vtkMath.h:1018
static float Norm2D(const float x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:570
static void UninitializeBounds(double bounds[6])
Set the bounds to an uninitialized state.
Definition: vtkMath.h:1069
static int NearestPowerOfTwo(int x)
Compute the nearest power of two that is not less than x.
Definition: vtkMath.h:1273
static void RGBToXYZ(const double rgb[3], double xyz[3])
Convert color from the RGB system to CIE XYZ.
Definition: vtkMath.h:1030
static T Min(const T &a, const T &b)
Returns the minimum of the two arguments provided.
Definition: vtkMath.h:1304
a simple class to control print indentation
Definition: vtkIndent.h:39
static void Subtract(const float a[3], const float b[3], float c[3])
Subtraction of two 3-vectors (float version).
Definition: vtkMath.h:331
static void Subtract(const double a[3], const double b[3], double c[3])
Subtraction of two 3-vectors (double version).
Definition: vtkMath.h:339
static int Floor(double x)
Rounds a double to the nearest integer not greater than itself.
Definition: vtkMath.h:1287
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:54
static double Determinant2x2(double a, double b, double c, double d)
Calculate the determinant of a 2x2 matrix: | a b | | c d |.
Definition: vtkMath.h:601
static float RadiansFromDegrees(float degrees)
Convert degrees into radians.
Definition: vtkMath.h:1242
static void HSVToRGB(const double hsv[3], double rgb[3])
Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue).
Definition: vtkMath.h:985
Park and Miller Sequence of pseudo random numbers.
static void MultiplyScalar(double a[3], double s)
Multiplies a 3-vector by a scalar (double version).
Definition: vtkMath.h:366
static double Determinant3x3(float A[3][3])
Return the determinant of a 3x3 matrix.
Definition: vtkMath.h:1448
static void RGBToLab(const double rgb[3], double lab[3])
Convert color from the RGB system to CIE-L*ab.
Definition: vtkMath.h:1045
static float DegreesFromRadians(float radians)
Convert radians into degrees.
Definition: vtkMath.h:1254
static float Normalize(float v[3])
Normalize (in place) a 3-vector.
Definition: vtkMath.h:1317
static void Outer2D(const double x[2], const double y[2], double A[2][2])
Outer product of two 2-vectors (float version).
Definition: vtkMath.h:556
static void Outer2D(const float x[2], const float y[2], float A[2][2])
Outer product of two 2-vectors (float version).
Definition: vtkMath.h:543
static int Ceil(double x)
Rounds a double to the nearest integer not less than itself.
Definition: vtkMath.h:1296
performs common math operations
Definition: vtkMath.h:90
static double Dot2D(const double x[2], const double y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:537
static void RoundDoubleToIntegralIfNecessary(double val, OutT *ret)
Round a double to type OutT if OutT is integral, otherwise simply clamp the value to the output range...
Definition: vtkMath.h:131
static float Norm(const float v[3])
Compute the norm of 3-vector.
Definition: vtkMath.h:431
static void MultiplyScalar(float a[3], float s)
Multiplies a 3-vector by a scalar (float version).
Definition: vtkMath.h:348
static void HSVToRGB(const float hsv[3], float rgb[3])
Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue).
Definition: vtkMath.h:980
static void Outer(const double a[3], const double b[3], double C[3][3])
Outer product of two 3-vectors (double-precision version).
Definition: vtkMath.h:403
static T ClampValue(const T &value, const T &min, const T &max)
Clamp some value against a range, return the result.
Definition: vtkMath.h:1461
static void TensorFromSymmetricTensor(T1 symmTensor[6], T2 tensor[9])
Convert a 6-Component symmetric tensor into a 9-Component tensor, no allocation performed.
static double Norm2D(const double x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:577
static void Outer(const float a[3], const float b[3], float C[3][3])
Outer product of two 3-vectors (float version).
Definition: vtkMath.h:395
static int Round(double f)
Definition: vtkMath.h:123
static double Norm(const double v[3])
Compute the norm of 3-vector (double-precision version).
Definition: vtkMath.h:437
static void MultiplyScalar2D(double a[2], double s)
Multiplies a 2-vector by a scalar (double version).
Definition: vtkMath.h:375
static float Distance2BetweenPoints(const float p1[3], const float p2[3])
Compute distance squared between two points p1 and p2.
Definition: vtkMath.h:1401
static void LabToRGB(const double lab[3], double rgb[3])
Convert color from the CIE-L*ab system to RGB.
Definition: vtkMath.h:1057
static vtkObject * New()
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
double vtkDeterminant3x3(T A[3][3])
Definition: vtkMath.h:1440
static float Norm(const float *x, int n)
Compute the norm of n-vector.
static void Cross(const float a[3], const float b[3], float c[3])
Cross product of two 3-vectors.
Definition: vtkMath.h:1420
Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform.
static double Determinant2x2(const double c1[2], const double c2[2])
Calculate the determinant of a 2x2 matrix: | a b | | c d |.
Definition: vtkMath.h:603
static void Add(const float a[3], const float b[3], float c[3])
Addition of two 3-vectors (float version).
Definition: vtkMath.h:315
Template defining traits of native types used by VTK.
Definition: vtkTypeTraits.h:32
static vtkTypeBool AreBoundsInitialized(const double bounds[6])
Are the bounds initialized?
Definition: vtkMath.h:1083
#define max(a, b)
represent and manipulate 3D points
Definition: vtkPoints.h:39
static T Max(const T &a, const T &b)
Returns the maximum of the two arugments provided.
Definition: vtkMath.h:1311
static void XYZToLab(const double xyz[3], double lab[3])
Convert Color from the CIE XYZ system to CIE-L*ab.
Definition: vtkMath.h:1006