VTK  9.3.0
vtkMath.h
Go to the documentation of this file.
1 // SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
2 // SPDX-FileCopyrightText: Copyright 2011 Sandia Corporation
3 // SPDX-License-Identifier: LicenseRef-BSD-3-Clause-Sandia-USGov
24 #ifndef vtkMath_h
25 #define vtkMath_h
26 
27 #include "vtkCommonCoreModule.h" // For export macro
28 #include "vtkMathPrivate.hxx" // For Matrix meta-class helpers
29 #include "vtkMatrixUtilities.h" // For Matrix wrapping / mapping
30 #include "vtkObject.h"
31 #include "vtkSmartPointer.h" // For vtkSmartPointer.
32 #include "vtkTypeTraits.h" // For type traits
33 
34 #include "vtkMathConfigure.h" // For <cmath> and VTK_HAS_ISNAN etc.
35 
36 #include <algorithm> // for std::clamp
37 #include <cassert> // assert() in inline implementations.
38 #include <type_traits> // for type_traits
39 
40 #ifndef DBL_MIN
41 #define VTK_DBL_MIN 2.2250738585072014e-308
42 #else // DBL_MIN
43 #define VTK_DBL_MIN DBL_MIN
44 #endif // DBL_MIN
45 
46 #ifndef DBL_EPSILON
47 #define VTK_DBL_EPSILON 2.2204460492503131e-16
48 #else // DBL_EPSILON
49 #define VTK_DBL_EPSILON DBL_EPSILON
50 #endif // DBL_EPSILON
51 
52 #ifndef VTK_DBL_EPSILON
53 #ifndef DBL_EPSILON
54 #define VTK_DBL_EPSILON 2.2204460492503131e-16
55 #else // DBL_EPSILON
56 #define VTK_DBL_EPSILON DBL_EPSILON
57 #endif // DBL_EPSILON
58 #endif // VTK_DBL_EPSILON
59 
60 VTK_ABI_NAMESPACE_BEGIN
61 class vtkDataArray;
62 class vtkPoints;
63 class vtkMathInternal;
66 VTK_ABI_NAMESPACE_END
67 
68 namespace vtk_detail
69 {
70 VTK_ABI_NAMESPACE_BEGIN
71 // forward declaration
72 template <typename OutT>
73 void RoundDoubleToIntegralIfNecessary(double val, OutT* ret);
74 VTK_ABI_NAMESPACE_END
75 } // end namespace vtk_detail
76 
77 VTK_ABI_NAMESPACE_BEGIN
78 class VTKCOMMONCORE_EXPORT vtkMath : public vtkObject
79 {
80 public:
81  static vtkMath* New();
82  vtkTypeMacro(vtkMath, vtkObject);
83  void PrintSelf(ostream& os, vtkIndent indent) override;
84 
88  static constexpr double Pi() { return 3.141592653589793; }
89 
91 
94  static float RadiansFromDegrees(float degrees);
95  static double RadiansFromDegrees(double degrees);
97 
99 
102  static float DegreesFromRadians(float radians);
103  static double DegreesFromRadians(double radians);
105 
109 #if 1
110  static int Round(float f) { return static_cast<int>(f + (f >= 0.0 ? 0.5 : -0.5)); }
111  static int Round(double f) { return static_cast<int>(f + (f >= 0.0 ? 0.5 : -0.5)); }
112 #endif
113 
118  template <typename OutT>
119  static void RoundDoubleToIntegralIfNecessary(double val, OutT* ret)
120  {
121  // Can't specialize template methods in a template class, so we move the
122  // implementations to a external namespace.
124  }
125 
131  static int Floor(double x);
132 
138  static int Ceil(double x);
139 
145  static int CeilLog2(vtkTypeUInt64 x);
146 
151  template <class T>
152  static T Min(const T& a, const T& b);
153 
158  template <class T>
159  static T Max(const T& a, const T& b);
160 
164  static bool IsPowerOfTwo(vtkTypeUInt64 x);
165 
171  static int NearestPowerOfTwo(int x);
172 
177  static vtkTypeInt64 Factorial(int N);
178 
184  static vtkTypeInt64 Binomial(int m, int n);
185 
197  static int* BeginCombination(int m, int n);
198 
209  static int NextCombination(int m, int n, int* combination);
210 
214  static void FreeCombination(int* combination);
215 
231  static void RandomSeed(int s);
232 
244  static int GetSeed();
245 
259  static double Random();
260 
273  static double Random(double min, double max);
274 
287  static double Gaussian();
288 
301  static double Gaussian(double mean, double std);
302 
307  template <class VectorT1, class VectorT2>
308  static void Assign(const VectorT1& a, VectorT2&& b)
309  {
310  b[0] = a[0];
311  b[1] = a[1];
312  b[2] = a[2];
313  }
314 
318  static void Assign(const double a[3], double b[3]) { vtkMath::Assign<>(a, b); }
319 
323  static void Add(const float a[3], const float b[3], float c[3])
324  {
325  for (int i = 0; i < 3; ++i)
326  {
327  c[i] = a[i] + b[i];
328  }
329  }
330 
334  static void Add(const double a[3], const double b[3], double c[3])
335  {
336  for (int i = 0; i < 3; ++i)
337  {
338  c[i] = a[i] + b[i];
339  }
340  }
341 
347  template <class VectorT1, class VectorT2, class VectorT3>
348  static void Add(VectorT1&& a, VectorT2&& b, VectorT3& c)
349  {
350  for (int i = 0; i < 3; ++i)
351  {
352  c[i] = a[i] + b[i];
353  }
354  }
355 
359  static void Subtract(const float a[3], const float b[3], float c[3])
360  {
361  for (int i = 0; i < 3; ++i)
362  {
363  c[i] = a[i] - b[i];
364  }
365  }
366 
370  static void Subtract(const double a[3], const double b[3], double c[3])
371  {
372  for (int i = 0; i < 3; ++i)
373  {
374  c[i] = a[i] - b[i];
375  }
376  }
377 
383  template <class VectorT1, class VectorT2, class VectorT3>
384  static void Subtract(const VectorT1& a, const VectorT2& b, VectorT3&& c)
385  {
386  c[0] = a[0] - b[0];
387  c[1] = a[1] - b[1];
388  c[2] = a[2] - b[2];
389  }
390 
395  static void MultiplyScalar(float a[3], float s)
396  {
397  for (int i = 0; i < 3; ++i)
398  {
399  a[i] *= s;
400  }
401  }
402 
407  static void MultiplyScalar2D(float a[2], float s)
408  {
409  for (int i = 0; i < 2; ++i)
410  {
411  a[i] *= s;
412  }
413  }
414 
419  static void MultiplyScalar(double a[3], double s)
420  {
421  for (int i = 0; i < 3; ++i)
422  {
423  a[i] *= s;
424  }
425  }
426 
431  static void MultiplyScalar2D(double a[2], double s)
432  {
433  for (int i = 0; i < 2; ++i)
434  {
435  a[i] *= s;
436  }
437  }
438 
442  static float Dot(const float a[3], const float b[3])
443  {
444  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
445  }
446 
450  static double Dot(const double a[3], const double b[3])
451  {
452  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
453  }
454 
470  template <typename ReturnTypeT = double, typename TupleRangeT1, typename TupleRangeT2,
471  typename EnableT = typename std::conditional<!std::is_pointer<TupleRangeT1>::value &&
473  TupleRangeT1, TupleRangeT2>::type::value_type>
474  static ReturnTypeT Dot(const TupleRangeT1& a, const TupleRangeT2& b)
475  {
476  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
477  }
478 
482  static void Outer(const float a[3], const float b[3], float c[3][3])
483  {
484  for (int i = 0; i < 3; ++i)
485  {
486  for (int j = 0; j < 3; ++j)
487  {
488  c[i][j] = a[i] * b[j];
489  }
490  }
491  }
492 
496  static void Outer(const double a[3], const double b[3], double c[3][3])
497  {
498  for (int i = 0; i < 3; ++i)
499  {
500  for (int j = 0; j < 3; ++j)
501  {
502  c[i][j] = a[i] * b[j];
503  }
504  }
505  }
506 
512  template <class VectorT1, class VectorT2, class VectorT3>
513  static void Cross(VectorT1&& a, VectorT2&& b, VectorT3& c);
514 
519  static void Cross(const float a[3], const float b[3], float c[3]);
520 
525  static void Cross(const double a[3], const double b[3], double c[3]);
526 
528 
531  static float Norm(const float* x, int n);
532  static double Norm(const double* x, int n);
534 
538  static float Norm(const float v[3]) { return std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); }
539 
543  static double Norm(const double v[3])
544  {
545  return std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
546  }
547 
557  template <typename ReturnTypeT = double, typename TupleRangeT>
558  static ReturnTypeT SquaredNorm(const TupleRangeT& v)
559  {
560  return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
561  }
562 
567  static float Normalize(float v[3]);
568 
573  static double Normalize(double v[3]);
574 
576 
583  static void Perpendiculars(const double v1[3], double v2[3], double v3[3], double theta);
584  static void Perpendiculars(const float v1[3], float v2[3], float v3[3], double theta);
586 
588 
593  static bool ProjectVector(const float a[3], const float b[3], float projection[3]);
594  static bool ProjectVector(const double a[3], const double b[3], double projection[3]);
596 
598 
604  static bool ProjectVector2D(const float a[2], const float b[2], float projection[2]);
605  static bool ProjectVector2D(const double a[2], const double b[2], double projection[2]);
607 
623  template <typename ReturnTypeT = double, typename TupleRangeT1, typename TupleRangeT2,
624  typename EnableT = typename std::conditional<!std::is_pointer<TupleRangeT1>::value &&
626  TupleRangeT1, TupleRangeT2>::type::value_type>
627  static ReturnTypeT Distance2BetweenPoints(const TupleRangeT1& p1, const TupleRangeT2& p2);
628 
633  static float Distance2BetweenPoints(const float p1[3], const float p2[3]);
634 
639  static double Distance2BetweenPoints(const double p1[3], const double p2[3]);
640 
644  static double AngleBetweenVectors(const double v1[3], const double v2[3]);
645 
650  const double v1[3], const double v2[3], const double vn[3]);
651 
656  static double GaussianAmplitude(double variance, double distanceFromMean);
657 
662  static double GaussianAmplitude(double mean, double variance, double position);
663 
669  static double GaussianWeight(double variance, double distanceFromMean);
670 
676  static double GaussianWeight(double mean, double variance, double position);
677 
681  static float Dot2D(const float x[2], const float y[2]) { return x[0] * y[0] + x[1] * y[1]; }
682 
686  static double Dot2D(const double x[2], const double y[2]) { return x[0] * y[0] + x[1] * y[1]; }
687 
691  static void Outer2D(const float x[2], const float y[2], float A[2][2])
692  {
693  for (int i = 0; i < 2; ++i)
694  {
695  for (int j = 0; j < 2; ++j)
696  {
697  A[i][j] = x[i] * y[j];
698  }
699  }
700  }
701 
705  static void Outer2D(const double x[2], const double y[2], double A[2][2])
706  {
707  for (int i = 0; i < 2; ++i)
708  {
709  for (int j = 0; j < 2; ++j)
710  {
711  A[i][j] = x[i] * y[j];
712  }
713  }
714  }
715 
720  static float Norm2D(const float x[2]) { return std::sqrt(x[0] * x[0] + x[1] * x[1]); }
721 
726  static double Norm2D(const double x[2]) { return std::sqrt(x[0] * x[0] + x[1] * x[1]); }
727 
732  static float Normalize2D(float v[2]);
733 
738  static double Normalize2D(double v[2]);
739 
743  static float Determinant2x2(const float c1[2], const float c2[2])
744  {
745  return c1[0] * c2[1] - c2[0] * c1[1];
746  }
747 
749 
752  static double Determinant2x2(double a, double b, double c, double d) { return a * d - b * c; }
753  static double Determinant2x2(const double c1[2], const double c2[2])
754  {
755  return c1[0] * c2[1] - c2[0] * c1[1];
756  }
758 
760 
763  static void LUFactor3x3(float A[3][3], int index[3]);
764  static void LUFactor3x3(double A[3][3], int index[3]);
766 
768 
771  static void LUSolve3x3(const float A[3][3], const int index[3], float x[3]);
772  static void LUSolve3x3(const double A[3][3], const int index[3], double x[3]);
774 
776 
780  static void LinearSolve3x3(const float A[3][3], const float x[3], float y[3]);
781  static void LinearSolve3x3(const double A[3][3], const double x[3], double y[3]);
783 
785 
788  static void Multiply3x3(const float A[3][3], const float v[3], float u[3]);
789  static void Multiply3x3(const double A[3][3], const double v[3], double u[3]);
791 
793 
796  static void Multiply3x3(const float A[3][3], const float B[3][3], float C[3][3]);
797  static void Multiply3x3(const double A[3][3], const double B[3][3], double C[3][3]);
799 
823  template <int RowsT, int MidDimT, int ColsT,
824  class LayoutT1 = vtkMatrixUtilities::Layout::Identity,
825  class LayoutT2 = vtkMatrixUtilities::Layout::Identity, class MatrixT1, class MatrixT2,
826  class MatrixT3>
827  static void MultiplyMatrix(const MatrixT1& M1, const MatrixT2& M2, MatrixT3&& M3)
828  {
829  vtkMathPrivate::MultiplyMatrix<RowsT, MidDimT, ColsT, LayoutT1, LayoutT2>::Compute(M1, M2, M3);
830  }
831 
852  template <int RowsT, int ColsT, class LayoutT = vtkMatrixUtilities::Layout::Identity,
853  class MatrixT, class VectorT1, class VectorT2>
854  static void MultiplyMatrixWithVector(const MatrixT& M, const VectorT1& X, VectorT2&& Y)
855  {
856  vtkMathPrivate::MultiplyMatrix<RowsT, ColsT, 1, LayoutT>::Compute(M, X, Y);
857  }
858 
864  template <class ScalarT, int SizeT, class VectorT1, class VectorT2>
865  static ScalarT Dot(const VectorT1& x, const VectorT2& y)
866  {
867  return vtkMathPrivate::ContractRowWithCol<ScalarT, 1, SizeT, 1, 0, 0,
868  vtkMatrixUtilities::Layout::Identity, vtkMatrixUtilities::Layout::Transpose>::Compute(x, y);
869  }
870 
887  template <int SizeT, class LayoutT = vtkMatrixUtilities::Layout::Identity, class MatrixT>
889  const MatrixT& M)
890  {
891  return vtkMathPrivate::Determinant<SizeT, LayoutT>::Compute(M);
892  }
893 
909  template <int SizeT, class LayoutT = vtkMatrixUtilities::Layout::Identity, class MatrixT1,
910  class MatrixT2>
911  static void InvertMatrix(const MatrixT1& M1, MatrixT2&& M2)
912  {
913  vtkMathPrivate::InvertMatrix<SizeT, LayoutT>::Compute(M1, M2);
914  }
915 
929  template <int RowsT, int ColsT, class LayoutT = vtkMatrixUtilities::Layout::Identity,
930  class MatrixT, class VectorT1, class VectorT2>
931  static void LinearSolve(const MatrixT& M, const VectorT1& x, VectorT2& y)
932  {
933  vtkMathPrivate::LinearSolve<RowsT, ColsT, LayoutT>::Compute(M, x, y);
934  }
935 
950  template <class ScalarT, int SizeT, class LayoutT = vtkMatrixUtilities::Layout::Identity,
951  class VectorT1, class MatrixT, class VectorT2>
952  static ScalarT Dot(const VectorT1& x, const MatrixT& M, const VectorT2& y)
953  {
954  ScalarT tmp[SizeT];
955  vtkMathPrivate::MultiplyMatrix<SizeT, SizeT, 1, LayoutT>::Compute(M, y, tmp);
956  return vtkMathPrivate::ContractRowWithCol<ScalarT, 1, SizeT, 1, 0, 0,
957  vtkMatrixUtilities::Layout::Identity, vtkMatrixUtilities::Layout::Transpose>::Compute(x, tmp);
958  }
959 
965  static void MultiplyMatrix(const double* const* A, const double* const* B, unsigned int rowA,
966  unsigned int colA, unsigned int rowB, unsigned int colB, double** C);
967 
969 
973  static void Transpose3x3(const float A[3][3], float AT[3][3]);
974  static void Transpose3x3(const double A[3][3], double AT[3][3]);
976 
978 
982  static void Invert3x3(const float A[3][3], float AI[3][3]);
983  static void Invert3x3(const double A[3][3], double AI[3][3]);
985 
987 
990  static void Identity3x3(float A[3][3]);
991  static void Identity3x3(double A[3][3]);
993 
995 
998  static double Determinant3x3(const float A[3][3]);
999  static double Determinant3x3(const double A[3][3]);
1001 
1005  static float Determinant3x3(const float c1[3], const float c2[3], const float c3[3]);
1006 
1010  static double Determinant3x3(const double c1[3], const double c2[3], const double c3[3]);
1011 
1018  static double Determinant3x3(double a1, double a2, double a3, double b1, double b2, double b3,
1019  double c1, double c2, double c3);
1020 
1022 
1029  static void QuaternionToMatrix3x3(const float quat[4], float A[3][3]);
1030  static void QuaternionToMatrix3x3(const double quat[4], double A[3][3]);
1031  template <class QuaternionT, class MatrixT,
1032  class EnableT = typename std::enable_if<!vtkMatrixUtilities::MatrixIs2DArray<MatrixT>()>::type>
1033  static void QuaternionToMatrix3x3(const QuaternionT& q, MatrixT&& A);
1035 
1037 
1046  static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4]);
1047  static void Matrix3x3ToQuaternion(const double A[3][3], double quat[4]);
1048  template <class MatrixT, class QuaternionT,
1049  class EnableT = typename std::enable_if<!vtkMatrixUtilities::MatrixIs2DArray<MatrixT>()>::type>
1050  static void Matrix3x3ToQuaternion(const MatrixT& A, QuaternionT&& q);
1052 
1054 
1060  static void MultiplyQuaternion(const float q1[4], const float q2[4], float q[4]);
1061  static void MultiplyQuaternion(const double q1[4], const double q2[4], double q[4]);
1063 
1065 
1069  static void RotateVectorByNormalizedQuaternion(const float v[3], const float q[4], float r[3]);
1070  static void RotateVectorByNormalizedQuaternion(const double v[3], const double q[4], double r[3]);
1072 
1074 
1078  static void RotateVectorByWXYZ(const float v[3], const float q[4], float r[3]);
1079  static void RotateVectorByWXYZ(const double v[3], const double q[4], double r[3]);
1081 
1083 
1088  static void Orthogonalize3x3(const float A[3][3], float B[3][3]);
1089  static void Orthogonalize3x3(const double A[3][3], double B[3][3]);
1091 
1093 
1099  static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3]);
1100  static void Diagonalize3x3(const double A[3][3], double w[3], double V[3][3]);
1102 
1104 
1114  const float A[3][3], float U[3][3], float w[3], float VT[3][3]);
1116  const double A[3][3], double U[3][3], double w[3], double VT[3][3]);
1118 
1127  double a00, double a01, double a10, double a11, double b0, double b1, double& x0, double& x1);
1128 
1137  static vtkTypeBool SolveLinearSystem(double** A, double* x, int size);
1138 
1145  static vtkTypeBool InvertMatrix(double** A, double** AI, int size);
1146 
1153  double** A, double** AI, int size, int* tmp1Size, double* tmp2Size);
1154 
1177  static vtkTypeBool LUFactorLinearSystem(double** A, int* index, int size);
1178 
1184  static vtkTypeBool LUFactorLinearSystem(double** A, int* index, int size, double* tmpSize);
1185 
1194  static void LUSolveLinearSystem(double** A, int* index, double* x, int size);
1195 
1204  static double EstimateMatrixCondition(const double* const* A, int size);
1205 
1207 
1215  static vtkTypeBool Jacobi(float** a, float* w, float** v);
1216  static vtkTypeBool Jacobi(double** a, double* w, double** v);
1218 
1220 
1229  static vtkTypeBool JacobiN(float** a, int n, float* w, float** v);
1230  static vtkTypeBool JacobiN(double** a, int n, double* w, double** v);
1232 
1247  int numberOfSamples, double** xt, int xOrder, double** mt);
1248 
1263  static vtkTypeBool SolveLeastSquares(int numberOfSamples, double** xt, int xOrder, double** yt,
1264  int yOrder, double** mt, int checkHomogeneous = 1);
1265 
1267 
1274  static void RGBToHSV(const float rgb[3], float hsv[3])
1275  {
1276  RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv + 1, hsv + 2);
1277  }
1278  static void RGBToHSV(float r, float g, float b, float* h, float* s, float* v);
1279  static void RGBToHSV(const double rgb[3], double hsv[3])
1280  {
1281  RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv + 1, hsv + 2);
1282  }
1283  static void RGBToHSV(double r, double g, double b, double* h, double* s, double* v);
1285 
1287 
1294  static void HSVToRGB(const float hsv[3], float rgb[3])
1295  {
1296  HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb + 1, rgb + 2);
1297  }
1298  static void HSVToRGB(float h, float s, float v, float* r, float* g, float* b);
1299  static void HSVToRGB(const double hsv[3], double rgb[3])
1300  {
1301  HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb + 1, rgb + 2);
1302  }
1303  static void HSVToRGB(double h, double s, double v, double* r, double* g, double* b);
1305 
1307 
1310  static void LabToXYZ(const double lab[3], double xyz[3])
1311  {
1312  LabToXYZ(lab[0], lab[1], lab[2], xyz + 0, xyz + 1, xyz + 2);
1313  }
1314  static void LabToXYZ(double L, double a, double b, double* x, double* y, double* z);
1316 
1318 
1321  static void XYZToLab(const double xyz[3], double lab[3])
1322  {
1323  XYZToLab(xyz[0], xyz[1], xyz[2], lab + 0, lab + 1, lab + 2);
1324  }
1325  static void XYZToLab(double x, double y, double z, double* L, double* a, double* b);
1327 
1329 
1332  static void XYZToRGB(const double xyz[3], double rgb[3])
1333  {
1334  XYZToRGB(xyz[0], xyz[1], xyz[2], rgb + 0, rgb + 1, rgb + 2);
1335  }
1336  static void XYZToRGB(double x, double y, double z, double* r, double* g, double* b);
1338 
1340 
1343  static void RGBToXYZ(const double rgb[3], double xyz[3])
1344  {
1345  RGBToXYZ(rgb[0], rgb[1], rgb[2], xyz + 0, xyz + 1, xyz + 2);
1346  }
1347  static void RGBToXYZ(double r, double g, double b, double* x, double* y, double* z);
1349 
1351 
1357  static void RGBToLab(const double rgb[3], double lab[3])
1358  {
1359  RGBToLab(rgb[0], rgb[1], rgb[2], lab + 0, lab + 1, lab + 2);
1360  }
1361  static void RGBToLab(double red, double green, double blue, double* L, double* a, double* b);
1363 
1365 
1368  static void LabToRGB(const double lab[3], double rgb[3])
1369  {
1370  LabToRGB(lab[0], lab[1], lab[2], rgb + 0, rgb + 1, rgb + 2);
1371  }
1372  static void LabToRGB(double L, double a, double b, double* red, double* green, double* blue);
1374 
1376 
1379  static void UninitializeBounds(double bounds[6])
1380  {
1381  bounds[0] = 1.0;
1382  bounds[1] = -1.0;
1383  bounds[2] = 1.0;
1384  bounds[3] = -1.0;
1385  bounds[4] = 1.0;
1386  bounds[5] = -1.0;
1387  }
1389 
1391 
1394  static vtkTypeBool AreBoundsInitialized(const double bounds[6])
1395  {
1396  if (bounds[1] - bounds[0] < 0.0)
1397  {
1398  return 0;
1399  }
1400  return 1;
1401  }
1403 
1408  template <class T>
1409  static T ClampValue(const T& value, const T& min, const T& max);
1410 
1412 
1416  static void ClampValue(double* value, const double range[2]);
1417  static void ClampValue(double value, const double range[2], double* clamped_value);
1418  static void ClampValues(double* values, int nb_values, const double range[2]);
1419  static void ClampValues(
1420  const double* values, int nb_values, const double range[2], double* clamped_values);
1422 
1429  static double ClampAndNormalizeValue(double value, const double range[2]);
1430 
1435  template <class T1, class T2>
1436  static void TensorFromSymmetricTensor(const T1 symmTensor[6], T2 tensor[9]);
1437 
1443  template <class T>
1444  static void TensorFromSymmetricTensor(T tensor[9]);
1445 
1455  double range_min, double range_max, double scale = 1.0, double shift = 0.0);
1456 
1465  static vtkTypeBool GetAdjustedScalarRange(vtkDataArray* array, int comp, double range[2]);
1466 
1471  static vtkTypeBool ExtentIsWithinOtherExtent(const int extent1[6], const int extent2[6]);
1472 
1479  const double bounds1[6], const double bounds2[6], const double delta[3]);
1480 
1487  const double point[3], const double bounds[6], const double delta[3]);
1488 
1499  const double bounds[6], const double normal[3], const double point[3]);
1500 
1510  static double Solve3PointCircle(
1511  const double p1[3], const double p2[3], const double p3[3], double center[3]);
1512 
1516  static double Inf();
1517 
1521  static double NegInf();
1522 
1526  static double Nan();
1527 
1531  static vtkTypeBool IsInf(double x);
1532 
1536  static vtkTypeBool IsNan(double x);
1537 
1542  static bool IsFinite(double x);
1543 
1548  static int QuadraticRoot(double a, double b, double c, double min, double max, double* u);
1549 
1555  static vtkIdType ComputeGCD(vtkIdType m, vtkIdType n) { return (n ? ComputeGCD(n, m % n) : m); }
1556 
1560  enum class ConvolutionMode
1561  {
1562  FULL,
1563  SAME,
1564  VALID
1565  };
1566 
1589  template <class Iter1, class Iter2, class Iter3>
1590  static void Convolve1D(Iter1 beginSample, Iter1 endSample, Iter2 beginKernel, Iter2 endKernel,
1591  Iter3 beginOut, Iter3 endOut, ConvolutionMode mode = ConvolutionMode::FULL)
1592  {
1593  int sampleSize = std::distance(beginSample, endSample);
1594  int kernelSize = std::distance(beginKernel, endKernel);
1595  int outSize = std::distance(beginOut, endOut);
1596 
1597  if (sampleSize <= 0 || kernelSize <= 0 || outSize <= 0)
1598  {
1599  return;
1600  }
1601 
1602  int begin = 0;
1603  int end = outSize;
1604 
1605  switch (mode)
1606  {
1607  case ConvolutionMode::SAME:
1608  begin = static_cast<int>(std::ceil((std::min)(sampleSize, kernelSize) / 2.0)) - 1;
1609  end = begin + (std::max)(sampleSize, kernelSize);
1610  break;
1611  case ConvolutionMode::VALID:
1612  begin = (std::min)(sampleSize, kernelSize) - 1;
1613  end = begin + std::abs(sampleSize - kernelSize) + 1;
1614  break;
1615  case ConvolutionMode::FULL:
1616  default:
1617  break;
1618  }
1619 
1620  for (int i = begin; i < end; i++)
1621  {
1622  Iter3 out = beginOut + i - begin;
1623  *out = 0;
1624  for (int j = (std::max)(i - sampleSize + 1, 0); j <= (std::min)(i, kernelSize - 1); j++)
1625  {
1626  *out += *(beginSample + (i - j)) * *(beginKernel + j);
1627  }
1628  }
1629  }
1630 
1635  static void GetPointAlongLine(double result[3], double p1[3], double p2[3], const double offset)
1636  {
1637  double directionVector[3] = { p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2] };
1638  vtkMath::Normalize(directionVector);
1639  result[0] = p2[0] + (offset * directionVector[0]);
1640  result[1] = p2[1] + (offset * directionVector[1]);
1641  result[2] = p2[2] + (offset * directionVector[2]);
1642  }
1643 
1644 protected:
1645  vtkMath() = default;
1646  ~vtkMath() override = default;
1647 
1649 
1650 private:
1651  vtkMath(const vtkMath&) = delete;
1652  void operator=(const vtkMath&) = delete;
1653 };
1654 
1655 //----------------------------------------------------------------------------
1656 inline float vtkMath::RadiansFromDegrees(float x)
1657 {
1658  return x * 0.017453292f;
1659 }
1660 
1661 //----------------------------------------------------------------------------
1662 inline double vtkMath::RadiansFromDegrees(double x)
1663 {
1664  return x * 0.017453292519943295;
1665 }
1666 
1667 //----------------------------------------------------------------------------
1668 inline float vtkMath::DegreesFromRadians(float x)
1669 {
1670  return x * 57.2957795131f;
1671 }
1672 
1673 //----------------------------------------------------------------------------
1674 inline double vtkMath::DegreesFromRadians(double x)
1675 {
1676  return x * 57.29577951308232;
1677 }
1678 
1679 //----------------------------------------------------------------------------
1680 inline bool vtkMath::IsPowerOfTwo(vtkTypeUInt64 x)
1681 {
1682  return ((x != 0) & ((x & (x - 1)) == 0));
1683 }
1684 
1685 //----------------------------------------------------------------------------
1686 // Credit goes to Peter Hart and William Lewis on comp.lang.python 1997
1688 {
1689  unsigned int z = static_cast<unsigned int>(((x > 0) ? x - 1 : 0));
1690  z |= z >> 1;
1691  z |= z >> 2;
1692  z |= z >> 4;
1693  z |= z >> 8;
1694  z |= z >> 16;
1695  return static_cast<int>(z + 1);
1696 }
1697 
1698 //----------------------------------------------------------------------------
1699 // Modify the trunc() operation provided by static_cast<int>() to get floor(),
1700 // Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1701 inline int vtkMath::Floor(double x)
1702 {
1703  int i = static_cast<int>(x);
1704  return i - (i > x);
1705 }
1706 
1707 //----------------------------------------------------------------------------
1708 // Modify the trunc() operation provided by static_cast<int>() to get ceil(),
1709 // Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1710 inline int vtkMath::Ceil(double x)
1711 {
1712  int i = static_cast<int>(x);
1713  return i + (i < x);
1714 }
1715 
1716 //----------------------------------------------------------------------------
1717 template <class T>
1718 inline T vtkMath::Min(const T& a, const T& b)
1719 {
1720  return (b <= a ? b : a);
1721 }
1722 
1723 //----------------------------------------------------------------------------
1724 template <class T>
1725 inline T vtkMath::Max(const T& a, const T& b)
1726 {
1727  return (b > a ? b : a);
1728 }
1729 
1730 //----------------------------------------------------------------------------
1731 inline float vtkMath::Normalize(float v[3])
1732 {
1733  float den = vtkMath::Norm(v);
1734  if (den != 0.0)
1735  {
1736  for (int i = 0; i < 3; ++i)
1737  {
1738  v[i] /= den;
1739  }
1740  }
1741  return den;
1742 }
1743 
1744 //----------------------------------------------------------------------------
1745 inline double vtkMath::Normalize(double v[3])
1746 {
1747  double den = vtkMath::Norm(v);
1748  if (den != 0.0)
1749  {
1750  for (int i = 0; i < 3; ++i)
1751  {
1752  v[i] /= den;
1753  }
1754  }
1755  return den;
1756 }
1757 
1758 //----------------------------------------------------------------------------
1759 inline float vtkMath::Normalize2D(float v[2])
1760 {
1761  float den = vtkMath::Norm2D(v);
1762  if (den != 0.0)
1763  {
1764  for (int i = 0; i < 2; ++i)
1765  {
1766  v[i] /= den;
1767  }
1768  }
1769  return den;
1770 }
1771 
1772 //----------------------------------------------------------------------------
1773 inline double vtkMath::Normalize2D(double v[2])
1774 {
1775  double den = vtkMath::Norm2D(v);
1776  if (den != 0.0)
1777  {
1778  for (int i = 0; i < 2; ++i)
1779  {
1780  v[i] /= den;
1781  }
1782  }
1783  return den;
1784 }
1785 
1786 //----------------------------------------------------------------------------
1787 inline float vtkMath::Determinant3x3(const float c1[3], const float c2[3], const float c3[3])
1788 {
1789  return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1790  c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1791 }
1792 
1793 //----------------------------------------------------------------------------
1794 inline double vtkMath::Determinant3x3(const double c1[3], const double c2[3], const double c3[3])
1795 {
1796  return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1797  c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1798 }
1799 
1800 //----------------------------------------------------------------------------
1802  double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3)
1803 {
1804  return (a1 * vtkMath::Determinant2x2(b2, b3, c2, c3) -
1805  b1 * vtkMath::Determinant2x2(a2, a3, c2, c3) + c1 * vtkMath::Determinant2x2(a2, a3, b2, b3));
1806 }
1807 
1808 //----------------------------------------------------------------------------
1809 inline float vtkMath::Distance2BetweenPoints(const float p1[3], const float p2[3])
1810 {
1811  return ((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]) +
1812  (p1[2] - p2[2]) * (p1[2] - p2[2]));
1813 }
1814 
1815 //----------------------------------------------------------------------------
1816 inline double vtkMath::Distance2BetweenPoints(const double p1[3], const double p2[3])
1817 {
1818  return ((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]) +
1819  (p1[2] - p2[2]) * (p1[2] - p2[2]));
1820 }
1821 
1822 //----------------------------------------------------------------------------
1823 template <typename ReturnTypeT, typename TupleRangeT1, typename TupleRangeT2, typename EnableT>
1824 inline ReturnTypeT vtkMath::Distance2BetweenPoints(const TupleRangeT1& p1, const TupleRangeT2& p2)
1825 {
1826  return ((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]) +
1827  (p1[2] - p2[2]) * (p1[2] - p2[2]));
1828 }
1829 
1830 //----------------------------------------------------------------------------
1831 template <class VectorT1, class VectorT2, class VectorT3>
1832 void vtkMath::Cross(VectorT1&& a, VectorT2&& b, VectorT3& c)
1833 {
1834  c[0] = a[1] * b[2] - a[2] * b[1];
1835  c[1] = a[2] * b[0] - a[0] * b[2];
1836  c[2] = a[0] * b[1] - a[1] * b[0];
1837 }
1838 
1839 //----------------------------------------------------------------------------
1840 // Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1841 inline void vtkMath::Cross(const float a[3], const float b[3], float c[3])
1842 {
1843  float Cx = a[1] * b[2] - a[2] * b[1];
1844  float Cy = a[2] * b[0] - a[0] * b[2];
1845  float Cz = a[0] * b[1] - a[1] * b[0];
1846  c[0] = Cx;
1847  c[1] = Cy;
1848  c[2] = Cz;
1849 }
1850 
1851 //----------------------------------------------------------------------------
1852 // Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1853 inline void vtkMath::Cross(const double a[3], const double b[3], double c[3])
1854 {
1855  double Cx = a[1] * b[2] - a[2] * b[1];
1856  double Cy = a[2] * b[0] - a[0] * b[2];
1857  double Cz = a[0] * b[1] - a[1] * b[0];
1858  c[0] = Cx;
1859  c[1] = Cy;
1860  c[2] = Cz;
1861 }
1862 
1863 //----------------------------------------------------------------------------
1864 template <class T>
1865 inline double vtkDeterminant3x3(const T A[3][3])
1866 {
1867  return A[0][0] * A[1][1] * A[2][2] + A[1][0] * A[2][1] * A[0][2] + A[2][0] * A[0][1] * A[1][2] -
1868  A[0][0] * A[2][1] * A[1][2] - A[1][0] * A[0][1] * A[2][2] - A[2][0] * A[1][1] * A[0][2];
1869 }
1870 
1871 //----------------------------------------------------------------------------
1872 inline double vtkMath::Determinant3x3(const float A[3][3])
1873 {
1874  return vtkDeterminant3x3(A);
1875 }
1876 
1877 //----------------------------------------------------------------------------
1878 inline double vtkMath::Determinant3x3(const double A[3][3])
1879 {
1880  return vtkDeterminant3x3(A);
1881 }
1882 
1883 //----------------------------------------------------------------------------
1884 template <class T>
1885 inline T vtkMath::ClampValue(const T& value, const T& min, const T& max)
1886 {
1887  assert("pre: valid_range" && min <= max);
1888 
1889 #if __cplusplus >= 201703L
1890  return std::clamp(value, min, max);
1891 #else
1892  // compilers are good at optimizing the ternary operator,
1893  // use '<' since it is preferred by STL for custom types
1894  T v = (min < value ? value : min);
1895  return (v < max ? v : max);
1896 #endif
1897 }
1898 
1899 //----------------------------------------------------------------------------
1900 inline void vtkMath::ClampValue(double* value, const double range[2])
1901 {
1902  if (value && range)
1903  {
1904  assert("pre: valid_range" && range[0] <= range[1]);
1905 
1906  *value = vtkMath::ClampValue(*value, range[0], range[1]);
1907  }
1908 }
1909 
1910 //----------------------------------------------------------------------------
1911 inline void vtkMath::ClampValue(double value, const double range[2], double* clamped_value)
1912 {
1913  if (range && clamped_value)
1914  {
1915  assert("pre: valid_range" && range[0] <= range[1]);
1916 
1917  *clamped_value = vtkMath::ClampValue(value, range[0], range[1]);
1918  }
1919 }
1920 
1921 // ---------------------------------------------------------------------------
1922 inline double vtkMath::ClampAndNormalizeValue(double value, const double range[2])
1923 {
1924  assert("pre: valid_range" && range[0] <= range[1]);
1925 
1926  double result;
1927  if (range[0] == range[1])
1928  {
1929  result = 0.0;
1930  }
1931  else
1932  {
1933  // clamp
1934  result = vtkMath::ClampValue(value, range[0], range[1]);
1935 
1936  // normalize
1937  result = (result - range[0]) / (range[1] - range[0]);
1938  }
1939 
1940  assert("post: valid_result" && result >= 0.0 && result <= 1.0);
1941 
1942  return result;
1943 }
1944 
1945 //-----------------------------------------------------------------------------
1946 template <class T1, class T2>
1947 inline void vtkMath::TensorFromSymmetricTensor(const T1 symmTensor[9], T2 tensor[9])
1948 {
1949  for (int i = 0; i < 3; ++i)
1950  {
1951  tensor[4 * i] = symmTensor[i];
1952  }
1953  tensor[1] = tensor[3] = symmTensor[3];
1954  tensor[2] = tensor[6] = symmTensor[5];
1955  tensor[5] = tensor[7] = symmTensor[4];
1956 }
1957 
1958 //-----------------------------------------------------------------------------
1959 template <class T>
1960 inline void vtkMath::TensorFromSymmetricTensor(T tensor[9])
1961 {
1962  tensor[6] = tensor[5]; // XZ
1963  tensor[7] = tensor[4]; // YZ
1964  tensor[8] = tensor[2]; // ZZ
1965  tensor[4] = tensor[1]; // YY
1966  tensor[5] = tensor[7]; // YZ
1967  tensor[2] = tensor[6]; // XZ
1968  tensor[1] = tensor[3]; // XY
1969 }
1970 VTK_ABI_NAMESPACE_END
1971 
1972 namespace
1973 {
1974 template <class QuaternionT, class MatrixT>
1975 inline void vtkQuaternionToMatrix3x3(const QuaternionT& quat, MatrixT& A)
1976 {
1978 
1979  Scalar ww = quat[0] * quat[0];
1980  Scalar wx = quat[0] * quat[1];
1981  Scalar wy = quat[0] * quat[2];
1982  Scalar wz = quat[0] * quat[3];
1983 
1984  Scalar xx = quat[1] * quat[1];
1985  Scalar yy = quat[2] * quat[2];
1986  Scalar zz = quat[3] * quat[3];
1987 
1988  Scalar xy = quat[1] * quat[2];
1989  Scalar xz = quat[1] * quat[3];
1990  Scalar yz = quat[2] * quat[3];
1991 
1992  Scalar rr = xx + yy + zz;
1993  // normalization factor, just in case quaternion was not normalized
1994  Scalar f = 1 / (ww + rr);
1995  Scalar s = (ww - rr) * f;
1996  f *= 2;
1997 
1999 
2000  Wrapper::template Get<0, 0>(A) = xx * f + s;
2001  Wrapper::template Get<1, 0>(A) = (xy + wz) * f;
2002  Wrapper::template Get<2, 0>(A) = (xz - wy) * f;
2003 
2004  Wrapper::template Get<0, 1>(A) = (xy - wz) * f;
2005  Wrapper::template Get<1, 1>(A) = yy * f + s;
2006  Wrapper::template Get<2, 1>(A) = (yz + wx) * f;
2007 
2008  Wrapper::template Get<0, 2>(A) = (xz + wy) * f;
2009  Wrapper::template Get<1, 2>(A) = (yz - wx) * f;
2010  Wrapper::template Get<2, 2>(A) = zz * f + s;
2011 }
2012 } // anonymous namespace
2013 
2014 VTK_ABI_NAMESPACE_BEGIN
2015 //------------------------------------------------------------------------------
2016 inline void vtkMath::QuaternionToMatrix3x3(const float quat[4], float A[3][3])
2017 {
2018  vtkQuaternionToMatrix3x3(quat, A);
2019 }
2020 
2021 //------------------------------------------------------------------------------
2022 inline void vtkMath::QuaternionToMatrix3x3(const double quat[4], double A[3][3])
2023 {
2024  vtkQuaternionToMatrix3x3(quat, A);
2025 }
2026 
2027 //-----------------------------------------------------------------------------
2028 template <class QuaternionT, class MatrixT, class EnableT>
2029 inline void vtkMath::QuaternionToMatrix3x3(const QuaternionT& q, MatrixT&& A)
2030 {
2031  vtkQuaternionToMatrix3x3(q, A);
2032 }
2033 VTK_ABI_NAMESPACE_END
2034 
2035 namespace
2036 {
2037 //------------------------------------------------------------------------------
2038 // The solution is based on
2039 // Berthold K. P. Horn (1987),
2040 // "Closed-form solution of absolute orientation using unit quaternions,"
2041 // Journal of the Optical Society of America A, 4:629-642
2042 template <class MatrixT, class QuaternionT>
2043 inline void vtkMatrix3x3ToQuaternion(const MatrixT& A, QuaternionT& quat)
2044 {
2046 
2047  Scalar N[4][4];
2048 
2050 
2051  // on-diagonal elements
2052  N[0][0] = Wrapper::template Get<0, 0>(A) + Wrapper::template Get<1, 1>(A) +
2053  Wrapper::template Get<2, 2>(A);
2054  N[1][1] = Wrapper::template Get<0, 0>(A) - Wrapper::template Get<1, 1>(A) -
2055  Wrapper::template Get<2, 2>(A);
2056  N[2][2] = -Wrapper::template Get<0, 0>(A) + Wrapper::template Get<1, 1>(A) -
2057  Wrapper::template Get<2, 2>(A);
2058  N[3][3] = -Wrapper::template Get<0, 0>(A) - Wrapper::template Get<1, 1>(A) +
2059  Wrapper::template Get<2, 2>(A);
2060 
2061  // off-diagonal elements
2062  N[0][1] = N[1][0] = Wrapper::template Get<2, 1>(A) - Wrapper::template Get<1, 2>(A);
2063  N[0][2] = N[2][0] = Wrapper::template Get<0, 2>(A) - Wrapper::template Get<2, 0>(A);
2064  N[0][3] = N[3][0] = Wrapper::template Get<1, 0>(A) - Wrapper::template Get<0, 1>(A);
2065 
2066  N[1][2] = N[2][1] = Wrapper::template Get<1, 0>(A) + Wrapper::template Get<0, 1>(A);
2067  N[1][3] = N[3][1] = Wrapper::template Get<0, 2>(A) + Wrapper::template Get<2, 0>(A);
2068  N[2][3] = N[3][2] = Wrapper::template Get<2, 1>(A) + Wrapper::template Get<1, 2>(A);
2069 
2070  Scalar eigenvectors[4][4], eigenvalues[4];
2071 
2072  // convert into format that JacobiN can use,
2073  // then use Jacobi to find eigenvalues and eigenvectors
2074  Scalar *NTemp[4], *eigenvectorsTemp[4];
2075  for (int i = 0; i < 4; ++i)
2076  {
2077  NTemp[i] = N[i];
2078  eigenvectorsTemp[i] = eigenvectors[i];
2079  }
2080  vtkMath::JacobiN(NTemp, 4, eigenvalues, eigenvectorsTemp);
2081 
2082  // the first eigenvector is the one we want
2083  quat[0] = eigenvectors[0][0];
2084  quat[1] = eigenvectors[1][0];
2085  quat[2] = eigenvectors[2][0];
2086  quat[3] = eigenvectors[3][0];
2087 }
2088 } // anonymous namespace
2089 
2090 VTK_ABI_NAMESPACE_BEGIN
2091 //------------------------------------------------------------------------------
2092 inline void vtkMath::Matrix3x3ToQuaternion(const float A[3][3], float quat[4])
2093 {
2094  vtkMatrix3x3ToQuaternion(A, quat);
2095 }
2096 
2097 //------------------------------------------------------------------------------
2098 inline void vtkMath::Matrix3x3ToQuaternion(const double A[3][3], double quat[4])
2099 {
2100  vtkMatrix3x3ToQuaternion(A, quat);
2101 }
2102 
2103 //-----------------------------------------------------------------------------
2104 template <class MatrixT, class QuaternionT, class EnableT>
2105 inline void vtkMath::Matrix3x3ToQuaternion(const MatrixT& A, QuaternionT&& q)
2106 {
2107  vtkMatrix3x3ToQuaternion(A, q);
2108 }
2109 VTK_ABI_NAMESPACE_END
2110 
2111 namespace vtk_detail
2112 {
2113 VTK_ABI_NAMESPACE_BEGIN
2114 // Can't specialize templates inside a template class, so we move the impl here.
2115 template <typename OutT>
2116 void RoundDoubleToIntegralIfNecessary(double val, OutT* ret)
2117 { // OutT is integral -- clamp and round
2118  if (!vtkMath::IsNan(val))
2119  {
2120  double min = static_cast<double>(vtkTypeTraits<OutT>::Min());
2121  double max = static_cast<double>(vtkTypeTraits<OutT>::Max());
2122  val = vtkMath::ClampValue(val, min, max);
2123  *ret = static_cast<OutT>((val >= 0.0) ? (val + 0.5) : (val - 0.5));
2124  }
2125  else
2126  *ret = 0;
2127 }
2128 template <>
2129 inline void RoundDoubleToIntegralIfNecessary(double val, double* retVal)
2130 { // OutT is double: passthrough
2131  *retVal = val;
2132 }
2133 template <>
2134 inline void RoundDoubleToIntegralIfNecessary(double val, float* retVal)
2135 { // OutT is float -- just clamp (as doubles, then the cast to float is well-defined.)
2136  if (!vtkMath::IsNan(val))
2137  {
2138  double min = static_cast<double>(vtkTypeTraits<float>::Min());
2139  double max = static_cast<double>(vtkTypeTraits<float>::Max());
2140  val = vtkMath::ClampValue(val, min, max);
2141  }
2142 
2143  *retVal = static_cast<float>(val);
2144 }
2145 VTK_ABI_NAMESPACE_END
2146 } // end namespace vtk_detail
2147 
2148 VTK_ABI_NAMESPACE_BEGIN
2149 //-----------------------------------------------------------------------------
2150 #if defined(VTK_HAS_ISINF) || defined(VTK_HAS_STD_ISINF)
2151 #define VTK_MATH_ISINF_IS_INLINE
2152 inline vtkTypeBool vtkMath::IsInf(double x)
2153 {
2154 #if defined(VTK_HAS_STD_ISINF)
2155  return std::isinf(x);
2156 #else
2157  return (isinf(x) != 0); // Force conversion to bool
2158 #endif
2159 }
2160 #endif
2161 
2162 //-----------------------------------------------------------------------------
2163 #if defined(VTK_HAS_ISNAN) || defined(VTK_HAS_STD_ISNAN)
2164 #define VTK_MATH_ISNAN_IS_INLINE
2165 inline vtkTypeBool vtkMath::IsNan(double x)
2166 {
2167 #if defined(VTK_HAS_STD_ISNAN)
2168  return std::isnan(x);
2169 #else
2170  return (isnan(x) != 0); // Force conversion to bool
2171 #endif
2172 }
2173 #endif
2174 
2175 //-----------------------------------------------------------------------------
2176 #if defined(VTK_HAS_ISFINITE) || defined(VTK_HAS_STD_ISFINITE) || defined(VTK_HAS_FINITE)
2177 #define VTK_MATH_ISFINITE_IS_INLINE
2178 inline bool vtkMath::IsFinite(double x)
2179 {
2180 #if defined(VTK_HAS_STD_ISFINITE)
2181  return std::isfinite(x);
2182 #elif defined(VTK_HAS_ISFINITE)
2183  return (isfinite(x) != 0); // Force conversion to bool
2184 #else
2185  return (finite(x) != 0); // Force conversion to bool
2186 #endif
2187 }
2188 #endif
2189 
2190 VTK_ABI_NAMESPACE_END
2191 #endif
Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:45
a simple class to control print indentation
Definition: vtkIndent.h:29
performs common math operations
Definition: vtkMath.h:79
static ReturnTypeT Distance2BetweenPoints(const TupleRangeT1 &p1, const TupleRangeT2 &p2)
Compute distance squared between two points p1 and p2.
Definition: vtkMath.h:1824
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 version).
Definition: vtkMath.h:450
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)
Convert color from the RGB system to CIE XYZ.
static void Multiply3x3(const double A[3][3], const double B[3][3], double C[3][3])
Multiply one 3x3 matrix by another according to C = AB.
static double Norm(const double *x, int n)
Compute the norm of n-vector.
static int Round(float f)
Rounds a float to the nearest integer.
Definition: vtkMath.h:110
static int * BeginCombination(int m, int n)
Start iterating over "m choose n" objects.
static vtkIdType ComputeGCD(vtkIdType m, vtkIdType n)
Compute the greatest common divisor (GCD) of two positive integers m and n.
Definition: vtkMath.h:1555
static void MultiplyMatrixWithVector(const MatrixT &M, const VectorT1 &X, VectorT2 &&Y)
Multiply matrix M with vector Y such that Y = M x X.
Definition: vtkMath.h:854
static double Norm2D(const double x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:726
static double GaussianAmplitude(double variance, double distanceFromMean)
Compute the amplitude of a Gaussian function with mean=0 and specified variance.
static void XYZToRGB(double x, double y, double z, double *r, double *g, double *b)
Convert color from the CIE XYZ system to RGB.
static void GetPointAlongLine(double result[3], double p1[3], double p2[3], const double offset)
Get the coordinates of a point along a line defined by p1 and p2, at a specified offset relative to p...
Definition: vtkMath.h:1635
static void Subtract(const float a[3], const float b[3], float c[3])
Subtraction of two 3-vectors (float version).
Definition: vtkMath.h:359
static void LUSolve3x3(const double A[3][3], const int index[3], double x[3])
LU back substitution for a 3x3 matrix.
static vtkTypeBool 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 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:691
static bool ProjectVector(const double a[3], const double b[3], double projection[3])
Compute the projection of vector a on vector b and return it in projection[3].
static vtkSmartPointer< vtkMathInternal > Internal
Definition: vtkMath.h:1648
static float Norm(const float *x, int n)
Compute the norm of n-vector.
static vtkTypeBool ExtentIsWithinOtherExtent(const int extent1[6], const int extent2[6])
Return true if first 3D extent is within second 3D extent Extent is x-min, x-max, y-min,...
static double GaussianAmplitude(double mean, double variance, double position)
Compute the amplitude of a Gaussian function with specified mean and variance.
static void Add(const double a[3], const double b[3], double c[3])
Addition of two 3-vectors (double version).
Definition: vtkMath.h:334
static void RGBToHSV(float r, float g, float b, float *h, float *s, float *v)
Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value).
static float Norm(const float v[3])
Compute the norm of 3-vector (float version).
Definition: vtkMath.h:538
static ReturnTypeT Dot(const TupleRangeT1 &a, const TupleRangeT2 &b)
Compute dot product between two points p1 and p2.
Definition: vtkMath.h:474
static vtkTypeBool Jacobi(double **a, double *w, double **v)
Jacobi iteration for the solution of eigenvectors/eigenvalues of a 3x3 real symmetric matrix.
static void XYZToLab(const double xyz[3], double lab[3])
Convert Color from the CIE XYZ system to CIE-L*ab.
Definition: vtkMath.h:1321
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 double Random()
Generate pseudo-random numbers distributed according to the uniform distribution between 0....
static void LinearSolve(const MatrixT &M, const VectorT1 &x, VectorT2 &y)
This method solves linear systems M * x = y.
Definition: vtkMath.h:931
static void Identity3x3(float A[3][3])
Set A to the identity matrix.
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)
Given a unit vector v1, find two unit vectors v2 and v3 such that v1 cross v2 = v3 (i....
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 double EstimateMatrixCondition(const double *const *A, int size)
Estimate the condition number of a LU factored matrix.
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 TensorFromSymmetricTensor(const T1 symmTensor[6], T2 tensor[9])
Convert a 6-Component symmetric tensor into a 9-Component tensor, no allocation performed.
static void LabToXYZ(const double lab[3], double xyz[3])
Convert color from the CIE-L*ab system to CIE XYZ.
Definition: vtkMath.h:1310
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 vtkTypeBool PointIsWithinBounds(const double point[3], const double bounds[6], const double delta[3])
Return true if point is within the given 3D bounds Bounds is x-min, x-max, y-min, y-max,...
static float Dot(const float a[3], const float b[3])
Dot product of two 3-vectors (float version).
Definition: vtkMath.h:442
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)
Convert color from the CIE-L*ab system to CIE XYZ.
static vtkMatrixUtilities::ScalarTypeExtractor< MatrixT >::value_type Determinant(const MatrixT &M)
Computes the determinant of input square SizeT x SizeT matrix M.
Definition: vtkMath.h:888
static vtkTypeBool GetAdjustedScalarRange(vtkDataArray *array, int comp, double range[2])
Get a vtkDataArray's scalar range for a given component.
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 MultiplyScalar2D(float a[2], float s)
Multiplies a 2-vector by a scalar (float version).
Definition: vtkMath.h:407
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:1294
static void Assign(const double a[3], double b[3])
Assign values to a 3-vector (double version).
Definition: vtkMath.h:318
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:753
static T Max(const T &a, const T &b)
Returns the maximum of the two arguments provided.
Definition: vtkMath.h:1725
static void Outer2D(const double x[2], const double y[2], double A[2][2])
Outer product of two 2-vectors (double version).
Definition: vtkMath.h:705
static void RandomSeed(int s)
Initialize seed value.
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:431
static void LabToRGB(double L, double a, double b, double *red, double *green, double *blue)
Convert color from the CIE-L*ab system to RGB.
static double Gaussian()
Generate pseudo-random numbers distributed according to the standard normal distribution.
static int Ceil(double x)
Rounds a double to the nearest integer not less than itself.
Definition: vtkMath.h:1710
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:1299
~vtkMath() override=default
static ScalarT Dot(const VectorT1 &x, const VectorT2 &y)
Computes the dot product between 2 vectors x and y.
Definition: vtkMath.h:865
static double Inf()
Special IEEE-754 number used to represent positive infinity.
static vtkMath * New()
static vtkTypeBool Jacobi(float **a, float *w, float **v)
Jacobi iteration for the solution of eigenvectors/eigenvalues of a 3x3 real symmetric matrix.
static int PlaneIntersectsAABB(const double bounds[6], const double normal[3], const double point[3])
Implements Plane / Axis-Aligned Bounding-Box intersection as described in Graphics Gems IV,...
static void RGBToXYZ(const double rgb[3], double xyz[3])
Convert color from the RGB system to CIE XYZ.
Definition: vtkMath.h:1343
static void QuaternionToMatrix3x3(const float quat[4], float A[3][3])
Convert a quaternion to a 3x3 rotation matrix.
Definition: vtkMath.h:2016
static int NearestPowerOfTwo(int x)
Compute the nearest power of two that is not less than x.
Definition: vtkMath.h:1687
static void HSVToRGB(double h, double s, double v, double *r, double *g, double *b)
Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue).
static void SingularValueDecomposition3x3(const double A[3][3], double U[3][3], double w[3], double VT[3][3])
Perform singular value decomposition on a 3x3 matrix.
static double SignedAngleBetweenVectors(const double v1[3], const double v2[3], const double vn[3])
Compute signed angle in radians between two vectors with regard to a third orthogonal vector.
static float Normalize2D(float v[2])
Normalize (in place) a 2-vector.
Definition: vtkMath.h:1759
static void Invert3x3(const double A[3][3], double AI[3][3])
Invert a 3x3 matrix.
static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b)
Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue).
static void MultiplyQuaternion(const double q1[4], const double q2[4], double q[4])
Multiply two quaternions.
static void Multiply3x3(const double A[3][3], const double v[3], double u[3])
Multiply a vector by a 3x3 matrix.
static void Outer(const double a[3], const double b[3], double c[3][3])
Outer product of two 3-vectors (double version).
Definition: vtkMath.h:496
static vtkTypeBool InvertMatrix(double **A, double **AI, int size, int *tmp1Size, double *tmp2Size)
Thread safe version of InvertMatrix method.
static vtkTypeBool InvertMatrix(double **A, double **AI, int size)
Invert input square matrix A into matrix AI.
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 void Assign(const VectorT1 &a, VectorT2 &&b)
Assign values to a 3-vector (templated version).
Definition: vtkMath.h:308
static float RadiansFromDegrees(float degrees)
Convert degrees into radians.
Definition: vtkMath.h:1656
static void Convolve1D(Iter1 beginSample, Iter1 endSample, Iter2 beginKernel, Iter2 endKernel, Iter3 beginOut, Iter3 endOut, ConvolutionMode mode=ConvolutionMode::FULL)
Compute the convolution of a sampled 1D signal by a given kernel.
Definition: vtkMath.h:1590
static void RotateVectorByWXYZ(const double v[3], const double q[4], double r[3])
rotate a vector by WXYZ using // https://en.wikipedia.org/wiki/Rodrigues%27_rotation_formula
static void Add(const float a[3], const float b[3], float c[3])
Addition of two 3-vectors (float version).
Definition: vtkMath.h:323
static int CeilLog2(vtkTypeUInt64 x)
Gives the exponent of the lowest power of two not less than x.
static vtkTypeBool AreBoundsInitialized(const double bounds[6])
Are the bounds initialized?
Definition: vtkMath.h:1394
static bool ProjectVector2D(const double a[2], const double b[2], double projection[2])
Compute the projection of 2D vector a on 2D vector b and returns the result in projection[2].
static vtkTypeBool JacobiN(float **a, int n, float *w, float **v)
JacobiN iteration for the solution of eigenvectors/eigenvalues of a nxn real symmetric matrix.
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 constexpr double Pi()
A mathematical constant.
Definition: vtkMath.h:88
static void Multiply3x3(const float A[3][3], const float v[3], float u[3])
Multiply a vector by a 3x3 matrix.
static void Subtract(const double a[3], const double b[3], double c[3])
Subtraction of two 3-vectors (double version).
Definition: vtkMath.h:370
static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4])
Convert a 3x3 matrix into a quaternion.
Definition: vtkMath.h:2092
static void Orthogonalize3x3(const double A[3][3], double B[3][3])
Orthogonalize a 3x3 matrix and put the result in B.
static void XYZToRGB(const double xyz[3], double rgb[3])
Convert color from the CIE XYZ system to RGB.
Definition: vtkMath.h:1332
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:1922
static void MultiplyScalar(double a[3], double s)
Multiplies a 3-vector by a scalar (double version).
Definition: vtkMath.h:419
static double Dot2D(const double x[2], const double y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:686
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 void MultiplyMatrix(const MatrixT1 &M1, const MatrixT2 &M2, MatrixT3 &&M3)
Multiply matrices such that M3 = M1 x M2.
Definition: vtkMath.h:827
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])
Diagonalize a symmetric 3x3 matrix and return the eigenvalues in w and the eigenvectors in the column...
static void RGBToLab(const double rgb[3], double lab[3])
Convert color from the RGB system to CIE-L*ab.
Definition: vtkMath.h:1357
static int Floor(double x)
Rounds a double to the nearest integer not greater than itself.
Definition: vtkMath.h:1701
static void RotateVectorByNormalizedQuaternion(const double v[3], const double q[4], double r[3])
rotate a vector by a normalized quaternion using // https://en.wikipedia.org/wiki/Rodrigues%27_rotati...
static void Subtract(const VectorT1 &a, const VectorT2 &b, VectorT3 &&c)
Subtraction of two 3-vectors (templated version).
Definition: vtkMath.h:384
static vtkTypeBool BoundsIsWithinOtherBounds(const double bounds1[6], const double bounds2[6], const double delta[3])
Return true if first 3D bounds is within the second 3D bounds Bounds is x-min, x-max,...
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:752
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:1279
static vtkTypeBool JacobiN(double **a, int n, double *w, double **v)
JacobiN iteration for the solution of eigenvectors/eigenvalues of a nxn real symmetric matrix.
static double AngleBetweenVectors(const double v1[3], const double v2[3])
Compute angle in radians between two vectors.
static void MultiplyMatrix(const double *const *A, const double *const *B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double **C)
General matrix multiplication.
static float DegreesFromRadians(float radians)
Convert radians into degrees.
Definition: vtkMath.h:1668
static float Determinant2x2(const float c1[2], const float c2[2])
Compute determinant of 2x2 matrix.
Definition: vtkMath.h:743
static int Round(double f)
Definition: vtkMath.h:111
static vtkTypeBool IsInf(double x)
Test if a number is equal to the special floating point value infinity.
static double GaussianWeight(double mean, double variance, double position)
Compute the amplitude of an unnormalized Gaussian function with specified mean and variance.
static void UninitializeBounds(double bounds[6])
Set the bounds to an uninitialized state.
Definition: vtkMath.h:1379
vtkMath()=default
static void RGBToHSV(double r, double g, double b, double *h, double *s, double *v)
Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value).
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:482
static double Norm(const double v[3])
Compute the norm of 3-vector (double version).
Definition: vtkMath.h:543
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:119
static void RotateVectorByWXYZ(const float v[3], const float q[4], float r[3])
rotate a vector by WXYZ using // https://en.wikipedia.org/wiki/Rodrigues%27_rotation_formula
static bool IsPowerOfTwo(vtkTypeUInt64 x)
Returns true if integer is a power of two.
Definition: vtkMath.h:1680
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:1731
static void Transpose3x3(const double A[3][3], double AT[3][3])
Transpose a 3x3 matrix.
static ReturnTypeT SquaredNorm(const TupleRangeT &v)
Compute the squared norm of a 3-vector.
Definition: vtkMath.h:558
static double Determinant3x3(const float A[3][3])
Return the determinant of a 3x3 matrix.
Definition: vtkMath.h:1872
static float Dot2D(const float x[2], const float y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:681
ConvolutionMode
Support the convolution operations.
Definition: vtkMath.h:1561
static void RotateVectorByNormalizedQuaternion(const float v[3], const float q[4], float r[3])
rotate a vector by a normalized quaternion using // https://en.wikipedia.org/wiki/Rodrigues%27_rotati...
static ScalarT Dot(const VectorT1 &x, const MatrixT &M, const VectorT2 &y)
Computes the dot product x^T M y, where x and y are vectors and M is a metric matrix.
Definition: vtkMath.h:952
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:1274
static void Add(VectorT1 &&a, VectorT2 &&b, VectorT3 &c)
Addition of two 3-vectors (double version).
Definition: vtkMath.h:348
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 vtkTypeBool SolveLinearSystemGEPP2x2(double a00, double a01, double a10, double a11, double b0, double b1, double &x0, double &x1)
Solve linear equation Ax = b using Gaussian Elimination with Partial Pivoting for a 2x2 system.
static vtkTypeBool SolveLinearSystem(double **A, double *x, int size)
Solve linear equations Ax = b using Crout's method.
static void LabToRGB(const double lab[3], double rgb[3])
Convert color from the CIE-L*ab system to RGB.
Definition: vtkMath.h:1368
static float Norm2D(const float x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:720
static vtkTypeBool LUFactorLinearSystem(double **A, int *index, int size, double *tmpSize)
Thread safe version of LUFactorLinearSystem method.
static void LinearSolve3x3(const double A[3][3], const double x[3], double y[3])
Solve Ay = x for y and place the result in y.
static void XYZToLab(double x, double y, double z, double *L, double *a, double *b)
Convert Color from the CIE XYZ system to CIE-L*ab.
static void InvertMatrix(const MatrixT1 &M1, MatrixT2 &&M2)
Computes the inverse of input matrix M1 into M2.
Definition: vtkMath.h:911
static void MultiplyScalar(float a[3], float s)
Multiplies a 3-vector by a scalar (float version).
Definition: vtkMath.h:395
static T Min(const T &a, const T &b)
Returns the minimum of the two arguments provided.
Definition: vtkMath.h:1718
static void Cross(VectorT1 &&a, VectorT2 &&b, VectorT3 &c)
Cross product of two 3-vectors.
Definition: vtkMath.h:1832
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 T ClampValue(const T &value, const T &min, const T &max)
Clamp some value against a range, return the result.
Definition: vtkMath.h:1885
static vtkTypeBool 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 void Identity3x3(double A[3][3])
Set A to the identity matrix.
static void LUFactor3x3(double A[3][3], int index[3])
LU Factorization of a 3x3 matrix.
static vtkTypeBool 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 RGBToLab(double red, double green, double blue, double *L, double *a, double *b)
Convert color from the RGB system to CIE-L*ab.
static void MultiplyQuaternion(const float q1[4], const float q2[4], float q[4])
Multiply two quaternions.
static double GaussianWeight(double variance, double distanceFromMean)
Compute the amplitude of an unnormalized Gaussian function with mean=0 and specified variance.
static void ClampValues(const double *values, int nb_values, const double range[2], double *clamped_values)
Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.
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])
Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.
static int QuadraticRoot(double a, double b, double c, double min, double max, double *u)
find roots of ax^2+bx+c=0 in the interval min,max.
Matrix wrapping class.
Park and Miller Sequence of pseudo random numbers.
abstract base class for most VTK objects
Definition: vtkObject.h:52
represent and manipulate 3D points
Definition: vtkPoints.h:29
Computes the portion of a dataset which is inside a selection.
@ point
Definition: vtkX3D.h:236
@ mode
Definition: vtkX3D.h:247
@ value
Definition: vtkX3D.h:220
@ scale
Definition: vtkX3D.h:229
@ range
Definition: vtkX3D.h:238
@ center
Definition: vtkX3D.h:230
@ type
Definition: vtkX3D.h:516
@ position
Definition: vtkX3D.h:261
@ size
Definition: vtkX3D.h:253
@ index
Definition: vtkX3D.h:246
@ offset
Definition: vtkX3D.h:438
void RoundDoubleToIntegralIfNecessary(double val, OutT *ret)
Definition: vtkMath.h:2116
detail::ScalarTypeExtractor< std::is_array< DerefContainer >::value||std::is_pointer< DerefContainer >::value, ContainerT >::value_type value_type
Template defining traits of native types used by VTK.
Definition: vtkTypeTraits.h:23
int vtkTypeBool
Definition: vtkABI.h:64
double vtkDeterminant3x3(const T A[3][3])
Definition: vtkMath.h:1865
int vtkIdType
Definition: vtkType.h:315
#define max(a, b)