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) VTK_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 
766  static void Orthogonalize3x3(const float A[3][3], float B[3][3]);
767  static void Orthogonalize3x3(const double A[3][3], double B[3][3]);
769 
771 
777  static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3]);
778  static void Diagonalize3x3(const double A[3][3],double w[3],double V[3][3]);
780 
782 
791  static void SingularValueDecomposition3x3(const float A[3][3],
792  float U[3][3], float w[3],
793  float VT[3][3]);
794  static void SingularValueDecomposition3x3(const double A[3][3],
795  double U[3][3], double w[3],
796  double VT[3][3]);
798 
805  static int SolveLinearSystem(double **A, double *x, int size);
806 
813  static int InvertMatrix(double **A, double **AI, int size);
814 
820  static int InvertMatrix(double **A, double **AI, int size,
821  int *tmp1Size, double *tmp2Size);
822 
845  static int LUFactorLinearSystem(double **A, int *index, int size);
846 
852  static int LUFactorLinearSystem(double **A, int *index, int size,
853  double *tmpSize);
854 
863  static void LUSolveLinearSystem(double **A, int *index,
864  double *x, int size);
865 
874  static double EstimateMatrixCondition(double **A, int size);
875 
877 
885  static int Jacobi(float **a, float *w, float **v);
886  static int Jacobi(double **a, double *w, double **v);
888 
890 
899  static int JacobiN(float **a, int n, float *w, float **v);
900  static int JacobiN(double **a, int n, double *w, double **v);
902 
916  static int SolveHomogeneousLeastSquares(int numberOfSamples, double **xt, int xOrder,
917  double **mt);
918 
919 
934  static int SolveLeastSquares(int numberOfSamples, double **xt, int xOrder,
935  double **yt, int yOrder, double **mt, int checkHomogeneous=1);
936 
938 
945  static void RGBToHSV(const float rgb[3], float hsv[3])
946  { RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); }
947  static void RGBToHSV(float r, float g, float b, float *h, float *s, float *v);
948  static double* RGBToHSV(const double rgb[3]);
949  static double* RGBToHSV(double r, double g, double b);
950  static void RGBToHSV(const double rgb[3], double hsv[3])
951  { RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); }
952  static void RGBToHSV(double r, double g, double b, double *h, double *s, double *v);
954 
956 
963  static void HSVToRGB(const float hsv[3], float rgb[3])
964  { HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); }
965  static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b);
966  static double* HSVToRGB(const double hsv[3]);
967  static double* HSVToRGB(double h, double s, double v);
968  static void HSVToRGB(const double hsv[3], double rgb[3])
969  { HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); }
970  static void HSVToRGB(double h, double s, double v, double *r, double *g, double *b);
972 
974 
977  static void LabToXYZ(const double lab[3], double xyz[3]) {
978  LabToXYZ(lab[0], lab[1], lab[2], xyz+0, xyz+1, xyz+2);
979  }
980  static void LabToXYZ(double L, double a, double b,
981  double *x, double *y, double *z);
982  static double *LabToXYZ(const double lab[3]);
984 
986 
989  static void XYZToLab(const double xyz[3], double lab[3]) {
990  XYZToLab(xyz[0], xyz[1], xyz[2], lab+0, lab+1, lab+2);
991  }
992  static void XYZToLab(double x, double y, double z,
993  double *L, double *a, double *b);
994  static double *XYZToLab(const double xyz[3]);
996 
998 
1001  static void XYZToRGB(const double xyz[3], double rgb[3]) {
1002  XYZToRGB(xyz[0], xyz[1], xyz[2], rgb+0, rgb+1, rgb+2);
1003  }
1004  static void XYZToRGB(double x, double y, double z,
1005  double *r, double *g, double *b);
1006  static double *XYZToRGB(const double xyz[3]);
1008 
1010 
1013  static void RGBToXYZ(const double rgb[3], double xyz[3]) {
1014  RGBToXYZ(rgb[0], rgb[1], rgb[2], xyz+0, xyz+1, xyz+2);
1015  }
1016  static void RGBToXYZ(double r, double g, double b,
1017  double *x, double *y, double *z);
1018  static double *RGBToXYZ(const double rgb[3]);
1020 
1022 
1028  static void RGBToLab(const double rgb[3], double lab[3]) {
1029  RGBToLab(rgb[0], rgb[1], rgb[2], lab+0, lab+1, lab+2);
1030  }
1031  static void RGBToLab(double red, double green, double blue,
1032  double *L, double *a, double *b);
1033  static double *RGBToLab(const double rgb[3]);
1035 
1037 
1040  static void LabToRGB(const double lab[3], double rgb[3]) {
1041  LabToRGB(lab[0], lab[1], lab[2], rgb+0, rgb+1, rgb+2);
1042  }
1043  static void LabToRGB(double L, double a, double b,
1044  double *red, double *green, double *blue);
1045  static double *LabToRGB(const double lab[3]);
1047 
1049 
1052  static void UninitializeBounds(double bounds[6]){
1053  bounds[0] = 1.0;
1054  bounds[1] = -1.0;
1055  bounds[2] = 1.0;
1056  bounds[3] = -1.0;
1057  bounds[4] = 1.0;
1058  bounds[5] = -1.0;
1059  }
1061 
1063 
1066  static vtkTypeBool AreBoundsInitialized(double bounds[6]){
1067  if ( bounds[1]-bounds[0]<0.0 )
1068  {
1069  return 0;
1070  }
1071  return 1;
1072  }
1074 
1079  template<class T>
1080  static T ClampValue(const T & value, const T & min, const T & max);
1081 
1083 
1087  static void ClampValue(double *value, const double range[2]);
1088  static void ClampValue(double value, const double range[2], double *clamped_value);
1089  static void ClampValues(
1090  double *values, int nb_values, const double range[2]);
1091  static void ClampValues(
1092  const double *values, int nb_values, const double range[2], double *clamped_values);
1094 
1101  static double ClampAndNormalizeValue(double value,
1102  const double range[2]);
1103 
1113  double range_min, double range_max,
1114  double scale = 1.0, double shift = 0.0);
1115 
1125  vtkDataArray *array, int comp, double range[2]);
1126 
1131  static vtkTypeBool ExtentIsWithinOtherExtent(int extent1[6], int extent2[6]);
1132 
1138  static vtkTypeBool BoundsIsWithinOtherBounds(double bounds1[6], double bounds2[6], double delta[3]);
1139 
1145  static vtkTypeBool PointIsWithinBounds(double point[3], double bounds[6], double delta[3]);
1146 
1156  static double Solve3PointCircle(const double p1[3], const double p2[3], const double p3[3], double center[3]);
1157 
1161  static double Inf();
1162 
1166  static double NegInf();
1167 
1171  static double Nan();
1172 
1176  static vtkTypeBool IsInf(double x);
1177 
1181  static vtkTypeBool IsNan(double x);
1182 
1186  static bool IsFinite(double x);
1187 
1188 protected:
1189  vtkMath() {}
1190  ~vtkMath() VTK_OVERRIDE {}
1191 
1193 private:
1194  vtkMath(const vtkMath&) VTK_DELETE_FUNCTION;
1195  void operator=(const vtkMath&) VTK_DELETE_FUNCTION;
1196 };
1197 
1198 //----------------------------------------------------------------------------
1199 inline float vtkMath::RadiansFromDegrees( float x )
1200 {
1201  return x * 0.017453292f;
1202 }
1203 
1204 //----------------------------------------------------------------------------
1205 inline double vtkMath::RadiansFromDegrees( double x )
1206 {
1207  return x * 0.017453292519943295;
1208 }
1209 
1210 //----------------------------------------------------------------------------
1211 inline float vtkMath::DegreesFromRadians( float x )
1212 {
1213  return x * 57.2957795131f;
1214 }
1215 
1216 //----------------------------------------------------------------------------
1217 inline double vtkMath::DegreesFromRadians( double x )
1218 {
1219  return x * 57.29577951308232;
1220 }
1221 
1222 //----------------------------------------------------------------------------
1223 inline bool vtkMath::IsPowerOfTwo(vtkTypeUInt64 x)
1224 {
1225  return ((x != 0) & ((x & (x - 1)) == 0));
1226 }
1227 
1228 //----------------------------------------------------------------------------
1229 // Credit goes to Peter Hart and William Lewis on comp.lang.python 1997
1231 {
1232  unsigned int z = ((x > 0) ? x - 1 : 0);
1233  z |= z >> 1;
1234  z |= z >> 2;
1235  z |= z >> 4;
1236  z |= z >> 8;
1237  z |= z >> 16;
1238  return static_cast<int>(z + 1);
1239 }
1240 
1241 //----------------------------------------------------------------------------
1242 // Modify the trunc() operation provided by static_cast<int>() to get floor(),
1243 // Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1244 inline int vtkMath::Floor(double x)
1245 {
1246  int i = static_cast<int>(x);
1247  return i - ( i > x );
1248 }
1249 
1250 //----------------------------------------------------------------------------
1251 // Modify the trunc() operation provided by static_cast<int>() to get ceil(),
1252 // Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1253 inline int vtkMath::Ceil(double x)
1254 {
1255  int i = static_cast<int>(x);
1256  return i + ( i < x );
1257 }
1258 
1259 //----------------------------------------------------------------------------
1260 template<class T>
1261 inline T vtkMath::Min(const T & a, const T & b)
1262 {
1263  return (a < b ? a : b);
1264 }
1265 
1266 //----------------------------------------------------------------------------
1267 template<class T>
1268 inline T vtkMath::Max(const T & a, const T & b)
1269 {
1270  return (a > b ? a : b);
1271 }
1272 
1273 //----------------------------------------------------------------------------
1274 inline float vtkMath::Normalize(float v[3])
1275 {
1276  float den = vtkMath::Norm( v );
1277  if ( den != 0.0 )
1278  {
1279  for (int i=0; i < 3; i++)
1280  {
1281  v[i] /= den;
1282  }
1283  }
1284  return den;
1285 }
1286 
1287 //----------------------------------------------------------------------------
1288 inline double vtkMath::Normalize(double v[3])
1289 {
1290  double den = vtkMath::Norm( v );
1291  if ( den != 0.0 )
1292  {
1293  for (int i=0; i < 3; i++)
1294  {
1295  v[i] /= den;
1296  }
1297  }
1298  return den;
1299 }
1300 
1301 //----------------------------------------------------------------------------
1302 inline float vtkMath::Normalize2D(float v[3])
1303 {
1304  float den = vtkMath::Norm2D( v );
1305  if ( den != 0.0 )
1306  {
1307  for (int i=0; i < 2; i++)
1308  {
1309  v[i] /= den;
1310  }
1311  }
1312  return den;
1313 }
1314 
1315 //----------------------------------------------------------------------------
1316 inline double vtkMath::Normalize2D(double v[3])
1317 {
1318  double den = vtkMath::Norm2D( v );
1319  if ( den != 0.0 )
1320  {
1321  for (int i=0; i < 2; i++)
1322  {
1323  v[i] /= den;
1324  }
1325  }
1326  return den;
1327 }
1328 
1329 //----------------------------------------------------------------------------
1330 inline float vtkMath::Determinant3x3(const float c1[3],
1331  const float c2[3],
1332  const float c3[3])
1333 {
1334  return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1335  c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1336 }
1337 
1338 //----------------------------------------------------------------------------
1339 inline double vtkMath::Determinant3x3(const double c1[3],
1340  const double c2[3],
1341  const double c3[3])
1342 {
1343  return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1344  c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1345 }
1346 
1347 //----------------------------------------------------------------------------
1348 inline double vtkMath::Determinant3x3(double a1, double a2, double a3,
1349  double b1, double b2, double b3,
1350  double c1, double c2, double c3)
1351 {
1352  return ( a1 * vtkMath::Determinant2x2( b2, b3, c2, c3 )
1353  - b1 * vtkMath::Determinant2x2( a2, a3, c2, c3 )
1354  + c1 * vtkMath::Determinant2x2( a2, a3, b2, b3 ) );
1355 }
1356 
1357 //----------------------------------------------------------------------------
1358 inline float vtkMath::Distance2BetweenPoints(const float p1[3],
1359  const float p2[3])
1360 {
1361  return ( ( p1[0] - p2[0] ) * ( p1[0] - p2[0] )
1362  + ( p1[1] - p2[1] ) * ( p1[1] - p2[1] )
1363  + ( p1[2] - p2[2] ) * ( p1[2] - p2[2] ) );
1364 }
1365 
1366 //----------------------------------------------------------------------------
1367 inline double vtkMath::Distance2BetweenPoints(const double p1[3],
1368  const double p2[3])
1369 {
1370  return ( ( p1[0] - p2[0] ) * ( p1[0] - p2[0] )
1371  + ( p1[1] - p2[1] ) * ( p1[1] - p2[1] )
1372  + ( p1[2] - p2[2] ) * ( p1[2] - p2[2] ) );
1373 }
1374 
1375 //----------------------------------------------------------------------------
1376 // Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1377 inline void vtkMath::Cross(const float a[3], const float b[3], float c[3])
1378 {
1379  float Cx = a[1] * b[2] - a[2] * b[1];
1380  float Cy = a[2] * b[0] - a[0] * b[2];
1381  float Cz = a[0] * b[1] - a[1] * b[0];
1382  c[0] = Cx; c[1] = Cy; c[2] = Cz;
1383 }
1384 
1385 //----------------------------------------------------------------------------
1386 // Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1387 inline void vtkMath::Cross(const double a[3], const double b[3], double c[3])
1388 {
1389  double Cx = a[1] * b[2] - a[2] * b[1];
1390  double Cy = a[2] * b[0] - a[0] * b[2];
1391  double Cz = a[0] * b[1] - a[1] * b[0];
1392  c[0] = Cx; c[1] = Cy; c[2] = Cz;
1393 }
1394 
1395 //----------------------------------------------------------------------------
1396 template<class T>
1397 inline double vtkDeterminant3x3(T A[3][3])
1398 {
1399  return A[0][0] * A[1][1] * A[2][2] + A[1][0] * A[2][1] * A[0][2] +
1400  A[2][0] * A[0][1] * A[1][2] - A[0][0] * A[2][1] * A[1][2] -
1401  A[1][0] * A[0][1] * A[2][2] - A[2][0] * A[1][1] * A[0][2];
1402 }
1403 
1404 //----------------------------------------------------------------------------
1405 inline double vtkMath::Determinant3x3(float A[3][3])
1406 {
1407  return vtkDeterminant3x3( A );
1408 }
1409 
1410 //----------------------------------------------------------------------------
1411 inline double vtkMath::Determinant3x3(double A[3][3])
1412 {
1413  return vtkDeterminant3x3( A );
1414 }
1415 
1416 //----------------------------------------------------------------------------
1417 template<class T>
1418 inline T vtkMath::ClampValue(const T & value, const T & min, const T & max)
1419 {
1420  assert("pre: valid_range" && min<=max);
1421 
1422  if (value < min)
1423  {
1424  return min;
1425  }
1426 
1427  if (value > max)
1428  {
1429  return max;
1430  }
1431 
1432  return value;
1433 }
1434 
1435 //----------------------------------------------------------------------------
1436 inline void vtkMath::ClampValue(double *value, const double range[2])
1437 {
1438  if (value && range)
1439  {
1440  assert("pre: valid_range" && range[0]<=range[1]);
1441 
1442  if (*value < range[0])
1443  {
1444  *value = range[0];
1445  }
1446  else if (*value > range[1])
1447  {
1448  *value = range[1];
1449  }
1450  }
1451 }
1452 
1453 //----------------------------------------------------------------------------
1455  double value, const double range[2], double *clamped_value)
1456 {
1457  if (range && clamped_value)
1458  {
1459  assert("pre: valid_range" && range[0]<=range[1]);
1460 
1461  if (value < range[0])
1462  {
1463  *clamped_value = range[0];
1464  }
1465  else if (value > range[1])
1466  {
1467  *clamped_value = range[1];
1468  }
1469  else
1470  {
1471  *clamped_value = value;
1472  }
1473  }
1474 }
1475 
1476 // ---------------------------------------------------------------------------
1478  const double range[2])
1479 {
1480  assert("pre: valid_range" && range[0]<=range[1]);
1481 
1482  double result;
1483  if(range[0]==range[1])
1484  {
1485  result=0.0;
1486  }
1487  else
1488  {
1489  // clamp
1490  if(value<range[0])
1491  {
1492  result=range[0];
1493  }
1494  else
1495  {
1496  if(value>range[1])
1497  {
1498  result=range[1];
1499  }
1500  else
1501  {
1502  result=value;
1503  }
1504  }
1505 
1506  // normalize
1507  result=( result - range[0] ) / ( range[1] - range[0] );
1508  }
1509 
1510  assert("post: valid_result" && result>=0.0 && result<=1.0);
1511 
1512  return result;
1513 }
1514 
1515 namespace vtk_detail
1516 {
1517 // Can't specialize templates inside a template class, so we move the impl here.
1518 template <typename OutT>
1519 void RoundDoubleToIntegralIfNecessary(double val, OutT* ret)
1520 { // OutT is integral -- clamp and round
1521  val = vtkMath::Max(val, static_cast<double>(vtkTypeTraits<OutT>::Min()));
1522  val = vtkMath::Min(val, static_cast<double>(vtkTypeTraits<OutT>::Max()));
1523  *ret = static_cast<OutT>((val >= 0.0) ? (val + 0.5) : (val - 0.5));
1524 }
1525 template <>
1526 inline void RoundDoubleToIntegralIfNecessary(double val, double* retVal)
1527 { // OutT is double: passthrough
1528  *retVal = val;
1529 }
1530 template <>
1531 inline void RoundDoubleToIntegralIfNecessary(double val, float* retVal)
1532 { // OutT is float -- just clamp
1533  val = vtkMath::Max(val, static_cast<double>(vtkTypeTraits<float>::Min()));
1534  val = vtkMath::Min(val, static_cast<double>(vtkTypeTraits<float>::Max()));
1535  *retVal = static_cast<float>(val);
1536 }
1537 } // end namespace vtk_detail
1538 
1539 //-----------------------------------------------------------------------------
1540 #if defined(VTK_HAS_ISINF) || defined(VTK_HAS_STD_ISINF)
1541 #define VTK_MATH_ISINF_IS_INLINE
1542 inline vtkTypeBool vtkMath::IsInf(double x)
1543 {
1544 #if defined(VTK_HAS_STD_ISINF)
1545  return std::isinf(x);
1546 #else
1547  return (isinf(x) != 0); // Force conversion to bool
1548 #endif
1549 }
1550 #endif
1551 
1552 //-----------------------------------------------------------------------------
1553 #if defined(VTK_HAS_ISNAN) || defined(VTK_HAS_STD_ISNAN)
1554 #define VTK_MATH_ISNAN_IS_INLINE
1555 inline vtkTypeBool vtkMath::IsNan(double x)
1556 {
1557 #if defined(VTK_HAS_STD_ISNAN)
1558  return std::isnan(x);
1559 #else
1560  return (isnan(x) != 0); // Force conversion to bool
1561 #endif
1562 }
1563 #endif
1564 
1565 //-----------------------------------------------------------------------------
1566 #if defined(VTK_HAS_ISFINITE) || defined(VTK_HAS_STD_ISFINITE) || defined(VTK_HAS_FINITE)
1567 #define VTK_MATH_ISFINITE_IS_INLINE
1568 inline bool vtkMath::IsFinite(double x)
1569 {
1570 #if defined(VTK_HAS_STD_ISFINITE)
1571  return std::isfinite(x);
1572 #elif defined(VTK_HAS_ISFINITE)
1573  return (isfinite(x) != 0); // Force conversion to bool
1574 #else
1575  return (finite(x) != 0); // Force conversion to bool
1576 #endif
1577 }
1578 #endif
1579 
1580 #endif
Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
a simple class to control print indentation
Definition: vtkIndent.h:40
performs common math operations
Definition: vtkMath.h:91
static void Multiply3x3(const float A[3][3], const float B[3][3], float C[3][3])
Multiply one 3x3 matrix by another according to C = AB.
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 int Jacobi(double **a, double *w, double **v)
static int GetScalarTypeFittingRange(double range_min, double range_max, double scale=1.0, double shift=0.0)
Return the scalar type that is most likely to have enough precision to store a given range of data on...
static void RGBToXYZ(double r, double g, double b, double *x, double *y, double *z)
static void Multiply3x3(const double A[3][3], const double B[3][3], double C[3][3])
static double Norm(const double *x, int n)
static int Round(float f)
Rounds a float to the nearest integer.
Definition: vtkMath.h:121
static int * BeginCombination(int m, int n)
Start iterating over "m choose n" objects.
static double Norm2D(const double x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:577
static void XYZToRGB(double x, double y, double z, double *r, double *g, double *b)
static void Matrix3x3ToQuaternion(const double A[3][3], double quat[4])
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 LUSolve3x3(const double A[3][3], const int index[3], double x[3])
static void Multiply3x3(const double A[3][3], const double in[3], double out[3])
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 bool ProjectVector(const double a[3], const double b[3], double projection[3])
static vtkSmartPointer< vtkMathInternal > Internal
Definition: vtkMath.h:1192
static float Norm(const float *x, int n)
Compute the norm of n-vector.
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 void RGBToHSV(float r, float g, float b, float *h, float *s, float *v)
static float Norm(const float v[3])
Compute the norm of 3-vector.
Definition: vtkMath.h:431
static void XYZToLab(const double xyz[3], double lab[3])
Convert Color from the CIE XYZ system to CIE-L*ab.
Definition: vtkMath.h:989
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static vtkTypeInt64 Factorial(int N)
Compute N factorial, N! = N*(N-1) * (N-2)...*3*2*1.
static vtkTypeInt64 Binomial(int m, int n)
The number of combinations of n objects from a pool of m objects (m>n).
static vtkTypeBool BoundsIsWithinOtherBounds(double bounds1[6], double bounds2[6], double delta[3])
Return true if first 3D bounds is within the second 3D bounds Bounds is x-min, x-max,...
static double Random()
Generate pseudo-random numbers distributed according to the uniform distribution between 0....
static void Identity3x3(float A[3][3])
Set A to the identity matrix.
static double GaussianAmplitude(const double variance, const double distanceFromMean)
Compute the amplitude of a Gaussian function with mean=0 and specified variance.
static void SingularValueDecomposition3x3(const float A[3][3], float U[3][3], float w[3], float VT[3][3])
Perform singular value decomposition on a 3x3 matrix.
static double Nan()
Special IEEE-754 number used to represent Not-A-Number (Nan).
static void Perpendiculars(const float v1[3], float v2[3], float v3[3], double theta)
static int GetAdjustedScalarRange(vtkDataArray *array, int comp, double range[2])
Get a vtkDataArray's scalar range for a given component.
static double Gaussian(double mean, double std)
Generate pseudo-random numbers distributed according to the Gaussian distribution with mean mean and ...
static bool IsFinite(double x)
Test if a number has finite value i.e.
static void LUSolveLinearSystem(double **A, int *index, double *x, int size)
Solve linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U ...
static void LUFactor3x3(float A[3][3], int index[3])
LU Factorization of a 3x3 matrix.
static void FreeCombination(int *combination)
Free the "iterator" array created by vtkMath::BeginCombination.
static double Random(double min, double max)
Generate pseudo-random numbers distributed according to the uniform distribution between min and max.
static void LabToXYZ(const double lab[3], double xyz[3])
Convert color from the CIE-L*ab system to CIE XYZ.
Definition: vtkMath.h:977
static double Solve3PointCircle(const double p1[3], const double p2[3], const double p3[3], double center[3])
In Euclidean space, there is a unique circle passing through any given three non-collinear points P1,...
static double * HSVToRGB(double h, double s, double v)
static vtkTypeBool AreBoundsInitialized(double bounds[6])
Are the bounds initialized?
Definition: vtkMath.h:1066
static float Dot(const float a[3], const float b[3])
Dot product of two 3-vectors (float version).
Definition: vtkMath.h:383
static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3])
Diagonalize a symmetric 3x3 matrix and return the eigenvalues in w and the eigenvectors in the column...
static void LabToXYZ(double L, double a, double b, double *x, double *y, double *z)
static bool ProjectVector(const float a[3], const float b[3], float projection[3])
Compute the projection of vector a on vector b and return it in projection[3].
static void Cross(const float a[3], const float b[3], float c[3])
Cross product of two 3-vectors.
Definition: vtkMath.h:1377
static void MultiplyScalar2D(float a[2], float s)
Multiplies a 2-vector by a scalar (float version).
Definition: vtkMath.h:357
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:963
static double Determinant2x2(const double c1[2], const double c2[2])
Definition: vtkMath.h:603
static T Max(const T &a, const T &b)
Returns the maximum of the two arugments provided.
Definition: vtkMath.h:1268
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 RandomSeed(int s)
Initialize seed value.
static double Normalize2D(double v[2])
Normalize (in place) a 2-vector.
static double NegInf()
Special IEEE-754 number used to represent negative infinity.
static void MultiplyScalar2D(double a[2], double s)
Multiplies a 2-vector by a scalar (double version).
Definition: vtkMath.h:375
static void LabToRGB(double L, double a, double b, double *red, double *green, double *blue)
static double Gaussian()
Generate pseudo-random numbers distributed according to the standard normal distribution.
static void Multiply3x3(const float A[3][3], const float in[3], float out[3])
Multiply a vector by a 3x3 matrix.
static int Ceil(double x)
Rounds a double to the nearest integer not less than itself.
Definition: vtkMath.h:1253
static void HSVToRGB(const double hsv[3], double rgb[3])
Definition: vtkMath.h:968
static double Inf()
Special IEEE-754 number used to represent positive infinity.
static vtkMath * New()
static double GaussianAmplitude(const double mean, const double variance, const double position)
Compute the amplitude of a Gaussian function with specified mean and variance.
static float Normalize2D(float v[2])
Normalize (in place) a 2-vector.
static void RGBToXYZ(const double rgb[3], double xyz[3])
Convert color from the RGB system to CIE XYZ.
Definition: vtkMath.h:1013
static float Distance2BetweenPoints(const float p1[3], const float p2[3])
Compute distance squared between two points p1 and p2.
Definition: vtkMath.h:1358
static int NearestPowerOfTwo(int x)
Compute the nearest power of two that is not less than x.
Definition: vtkMath.h:1230
static void HSVToRGB(double h, double s, double v, double *r, double *g, double *b)
static void SingularValueDecomposition3x3(const double A[3][3], double U[3][3], double w[3], double VT[3][3])
static void Invert3x3(const double A[3][3], double AI[3][3])
static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b)
static void MultiplyQuaternion(const double q1[4], const double q2[4], double q[4])
static int JacobiN(float **a, int n, float *w, float **v)
JacobiN iteration for the solution of eigenvectors/eigenvalues of a nxn real symmetric matrix.
static void LUSolve3x3(const float A[3][3], const int index[3], float x[3])
LU back substitution for a 3x3 matrix.
static int GetSeed()
Return the current seed used by the random number generator.
static float RadiansFromDegrees(float degrees)
Convert degrees into radians.
Definition: vtkMath.h:1199
static vtkTypeBool PointIsWithinBounds(double point[3], double bounds[6], double delta[3])
Return true if point is within the given 3D bounds Bounds is x-min, x-max, y-min, y-max,...
static void MultiplyMatrix(double **A, double **B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double **C)
General matrix multiplication.
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
static int CeilLog2(vtkTypeUInt64 x)
Gives the exponent of the lowest power of two not less than x.
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 double Pi()
A mathematical constant.
Definition: vtkMath.h:100
static vtkTypeBool ExtentIsWithinOtherExtent(int extent1[6], int extent2[6])
Return true if first 3D extent is within second 3D extent Extent is x-min, x-max, y-min,...
static bool ProjectVector2D(const double a[2], const double b[2], double projection[2])
static int InvertMatrix(double **A, double **AI, int size)
Invert input square matrix A into matrix AI.
static int SolveLeastSquares(int numberOfSamples, double **xt, int xOrder, double **yt, int yOrder, double **mt, int checkHomogeneous=1)
Solves for the least squares best fit matrix for the equation X'M' = Y'.
static int NextCombination(int m, int n, int *combination)
Given m, n, and a valid combination of n integers in the range [0,m[, this function alters the intege...
static double GaussianWeight(const double variance, const double distanceFromMean)
Compute the amplitude of an unnormalized Gaussian function with mean=0 and specified variance.
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 double * LabToXYZ(const double lab[3])
static void Orthogonalize3x3(const double A[3][3], double B[3][3])
static void XYZToRGB(const double xyz[3], double rgb[3])
Convert color from the CIE XYZ system to RGB.
Definition: vtkMath.h:1001
static double ClampAndNormalizeValue(double value, const double range[2])
Clamp a value against a range and then normalized it between 0 and 1.
Definition: vtkMath.h:1477
static void MultiplyScalar(double a[3], double s)
Multiplies a 3-vector by a scalar (double version).
Definition: vtkMath.h:366
static int SolveHomogeneousLeastSquares(int numberOfSamples, double **xt, int xOrder, double **mt)
Solves for the least squares best fit matrix for the homogeneous equation X'M' = 0'.
static double Dot2D(const double x[2], const double y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:537
static void LinearSolve3x3(const float A[3][3], const float x[3], float y[3])
Solve Ay = x for y and place the result in y.
static vtkTypeBool IsNan(double x)
Test if a number is equal to the special floating point value Not-A-Number (Nan).
static void Diagonalize3x3(const double A[3][3], double w[3], double V[3][3])
~vtkMath() override
Definition: vtkMath.h:1190
static void RGBToLab(const double rgb[3], double lab[3])
Convert color from the RGB system to CIE-L*ab.
Definition: vtkMath.h:1028
static int Floor(double x)
Rounds a double to the nearest integer not greater than itself.
Definition: vtkMath.h:1244
static double * RGBToXYZ(const double rgb[3])
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 double * XYZToLab(const double xyz[3])
static double EstimateMatrixCondition(double **A, int size)
Estimate the condition number of a LU factored matrix.
static void RGBToHSV(const double rgb[3], double hsv[3])
Definition: vtkMath.h:950
static double AngleBetweenVectors(const double v1[3], const double v2[3])
Compute angle in radians between two vectors.
static float DegreesFromRadians(float radians)
Convert radians into degrees.
Definition: vtkMath.h:1211
static float Determinant2x2(const float c1[2], const float c2[2])
Compute determinant of 2x2 matrix.
Definition: vtkMath.h:594
static int Round(double f)
Definition: vtkMath.h:123
static vtkTypeBool IsInf(double x)
Test if a number is equal to the special floating point value infinity.
static void UninitializeBounds(double bounds[6])
Set the bounds to an uninitialized state.
Definition: vtkMath.h:1052
static void RGBToHSV(double r, double g, double b, double *h, double *s, double *v)
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 double * RGBToLab(const double rgb[3])
static double Norm(const double v[3])
Compute the norm of 3-vector (double-precision version).
Definition: vtkMath.h:437
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 int InvertMatrix(double **A, double **AI, int size, int *tmp1Size, double *tmp2Size)
Thread safe version of InvertMatrix method.
static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4])
Convert a 3x3 matrix into a quaternion.
static bool IsPowerOfTwo(vtkTypeUInt64 x)
Returns true if integer is a power of two.
Definition: vtkMath.h:1223
static void Invert3x3(const float A[3][3], float AI[3][3])
Invert a 3x3 matrix.
static float Normalize(float v[3])
Normalize (in place) a 3-vector.
Definition: vtkMath.h:1274
static void Transpose3x3(const double A[3][3], double AT[3][3])
static float Dot2D(const float x[2], const float y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:531
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:945
static double * RGBToHSV(const double rgb[3])
static int LUFactorLinearSystem(double **A, int *index, int size)
Factor linear equations Ax = b using LU decomposition into the form A = LU where L is a unit lower tr...
static void Orthogonalize3x3(const float A[3][3], float B[3][3])
Orthogonalize a 3x3 matrix and put the result in B.
static bool ProjectVector2D(const float a[2], const float b[2], float projection[2])
Compute the projection of 2D vector a on 2D vector b and returns the result in projection[2].
static int Jacobi(float **a, float *w, float **v)
Jacobi iteration for the solution of eigenvectors/eigenvalues of a 3x3 real symmetric matrix.
static void LabToRGB(const double lab[3], double rgb[3])
Convert color from the CIE-L*ab system to RGB.
Definition: vtkMath.h:1040
static float Norm2D(const float x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:570
static double Determinant3x3(float A[3][3])
Return the determinant of a 3x3 matrix.
Definition: vtkMath.h:1405
static double GaussianWeight(const double mean, const double variance, const double position)
Compute the amplitude of an unnormalized Gaussian function with specified mean and variance.
static void LinearSolve3x3(const double A[3][3], const double x[3], double y[3])
static void XYZToLab(double x, double y, double z, double *L, double *a, double *b)
static void MultiplyScalar(float a[3], float s)
Multiplies a 3-vector by a scalar (float version).
Definition: vtkMath.h:348
static T Min(const T &a, const T &b)
Returns the minimum of the two arguments provided.
Definition: vtkMath.h:1261
static int SolveLinearSystem(double **A, double *x, int size)
Solve linear equations Ax = b using Crout's method.
static void QuaternionToMatrix3x3(const double quat[4], double A[3][3])
static void Perpendiculars(const double v1[3], double v2[3], double v3[3], double theta)
Given a unit vector v1, find two unit vectors v2 and v3 such that v1 cross v2 = v3 (i....
static int LUFactorLinearSystem(double **A, int *index, int size, double *tmpSize)
Thread safe version of LUFactorLinearSystem method.
static double * RGBToHSV(double r, double g, double b)
static T ClampValue(const T &value, const T &min, const T &max)
Clamp some value against a range, return the result.
Definition: vtkMath.h:1418
static int JacobiN(double **a, int n, double *w, double **v)
static void Identity3x3(double A[3][3])
static double * HSVToRGB(const double hsv[3])
static void LUFactor3x3(double A[3][3], int index[3])
static void RGBToLab(double red, double green, double blue, double *L, double *a, double *b)
static double * LabToRGB(const double lab[3])
static void MultiplyQuaternion(const float q1[4], const float q2[4], float q[4])
Multiply two quaternions.
static double * XYZToRGB(const double xyz[3])
static void QuaternionToMatrix3x3(const float quat[4], float A[3][3])
Convert a quaternion to a 3x3 rotation matrix.
vtkMath()
Definition: vtkMath.h:1189
static void ClampValues(const double *values, int nb_values, const double range[2], double *clamped_values)
static void Transpose3x3(const float A[3][3], float AT[3][3])
Transpose a 3x3 matrix.
static void ClampValues(double *values, int nb_values, const double range[2])
Park and Miller Sequence of pseudo random numbers.
abstract base class for most VTK objects
Definition: vtkObject.h:60
represent and manipulate 3D points
Definition: vtkPoints.h:40
@ point
Definition: vtkX3D.h:236
@ value
Definition: vtkX3D.h:220
@ scale
Definition: vtkX3D.h:229
@ range
Definition: vtkX3D.h:238
@ center
Definition: vtkX3D.h:230
@ position
Definition: vtkX3D.h:261
@ size
Definition: vtkX3D.h:253
@ index
Definition: vtkX3D.h:246
void RoundDoubleToIntegralIfNecessary(double val, OutT *ret)
Definition: vtkMath.h:1519
Template defining traits of native types used by VTK.
Definition: vtkTypeTraits.h:32
int vtkTypeBool
Definition: vtkABI.h:69
double vtkDeterminant3x3(T A[3][3])
Definition: vtkMath.h:1397
#define max(a, b)