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
60VTK_ABI_NAMESPACE_BEGIN
61class vtkDataArray;
62class vtkPoints;
63class vtkMathInternal;
66VTK_ABI_NAMESPACE_END
67
68namespace vtk_detail
69{
70VTK_ABI_NAMESPACE_BEGIN
71// forward declaration
72template <typename OutT>
73void RoundDoubleToIntegralIfNecessary(double val, OutT* ret);
74VTK_ABI_NAMESPACE_END
75} // end namespace vtk_detail
76
77VTK_ABI_NAMESPACE_BEGIN
78class VTKCOMMONCORE_EXPORT vtkMath : public vtkObject
79{
80public:
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 &&
472 !std::is_array<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 &&
625 !std::is_array<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
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
1644protected:
1645 vtkMath() = default;
1646 ~vtkMath() override = default;
1647
1649
1650private:
1651 vtkMath(const vtkMath&) = delete;
1652 void operator=(const vtkMath&) = delete;
1653};
1654
1655//----------------------------------------------------------------------------
1656inline float vtkMath::RadiansFromDegrees(float x)
1657{
1658 return x * 0.017453292f;
1659}
1660
1661//----------------------------------------------------------------------------
1662inline double vtkMath::RadiansFromDegrees(double x)
1663{
1664 return x * 0.017453292519943295;
1665}
1666
1667//----------------------------------------------------------------------------
1668inline float vtkMath::DegreesFromRadians(float x)
1669{
1670 return x * 57.2957795131f;
1671}
1672
1673//----------------------------------------------------------------------------
1674inline double vtkMath::DegreesFromRadians(double x)
1675{
1676 return x * 57.29577951308232;
1677}
1678
1679//----------------------------------------------------------------------------
1680inline 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).
1701inline 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).
1710inline int vtkMath::Ceil(double x)
1711{
1712 int i = static_cast<int>(x);
1713 return i + (i < x);
1714}
1715
1716//----------------------------------------------------------------------------
1717template <class T>
1718inline T vtkMath::Min(const T& a, const T& b)
1719{
1720 return (b <= a ? b : a);
1721}
1722
1723//----------------------------------------------------------------------------
1724template <class T>
1725inline T vtkMath::Max(const T& a, const T& b)
1726{
1727 return (b > a ? b : a);
1728}
1729
1730//----------------------------------------------------------------------------
1731inline 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//----------------------------------------------------------------------------
1745inline 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//----------------------------------------------------------------------------
1759inline 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//----------------------------------------------------------------------------
1773inline 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//----------------------------------------------------------------------------
1787inline 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//----------------------------------------------------------------------------
1794inline 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//----------------------------------------------------------------------------
1809inline 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//----------------------------------------------------------------------------
1816inline 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//----------------------------------------------------------------------------
1823template <typename ReturnTypeT, typename TupleRangeT1, typename TupleRangeT2, typename EnableT>
1824inline 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//----------------------------------------------------------------------------
1831template <class VectorT1, class VectorT2, class VectorT3>
1832void 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].
1841inline 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].
1853inline 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//----------------------------------------------------------------------------
1864template <class T>
1865inline 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//----------------------------------------------------------------------------
1872inline double vtkMath::Determinant3x3(const float A[3][3])
1873{
1874 return vtkDeterminant3x3(A);
1875}
1876
1877//----------------------------------------------------------------------------
1878inline double vtkMath::Determinant3x3(const double A[3][3])
1879{
1880 return vtkDeterminant3x3(A);
1881}
1882
1883//----------------------------------------------------------------------------
1884template <class T>
1885inline 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//----------------------------------------------------------------------------
1900inline 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//----------------------------------------------------------------------------
1911inline 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// ---------------------------------------------------------------------------
1922inline 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//-----------------------------------------------------------------------------
1946template <class T1, class T2>
1947inline 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//-----------------------------------------------------------------------------
1959template <class T>
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}
1970VTK_ABI_NAMESPACE_END
1971
1972namespace
1973{
1974template <class QuaternionT, class MatrixT>
1975inline 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
2014VTK_ABI_NAMESPACE_BEGIN
2015//------------------------------------------------------------------------------
2016inline void vtkMath::QuaternionToMatrix3x3(const float quat[4], float A[3][3])
2017{
2018 vtkQuaternionToMatrix3x3(quat, A);
2019}
2020
2021//------------------------------------------------------------------------------
2022inline void vtkMath::QuaternionToMatrix3x3(const double quat[4], double A[3][3])
2023{
2024 vtkQuaternionToMatrix3x3(quat, A);
2025}
2026
2027//-----------------------------------------------------------------------------
2028template <class QuaternionT, class MatrixT, class EnableT>
2029inline void vtkMath::QuaternionToMatrix3x3(const QuaternionT& q, MatrixT&& A)
2030{
2031 vtkQuaternionToMatrix3x3(q, A);
2032}
2033VTK_ABI_NAMESPACE_END
2034
2035namespace
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
2042template <class MatrixT, class QuaternionT>
2043inline 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
2090VTK_ABI_NAMESPACE_BEGIN
2091//------------------------------------------------------------------------------
2092inline void vtkMath::Matrix3x3ToQuaternion(const float A[3][3], float quat[4])
2093{
2094 vtkMatrix3x3ToQuaternion(A, quat);
2095}
2096
2097//------------------------------------------------------------------------------
2098inline void vtkMath::Matrix3x3ToQuaternion(const double A[3][3], double quat[4])
2099{
2100 vtkMatrix3x3ToQuaternion(A, quat);
2101}
2102
2103//-----------------------------------------------------------------------------
2104template <class MatrixT, class QuaternionT, class EnableT>
2105inline void vtkMath::Matrix3x3ToQuaternion(const MatrixT& A, QuaternionT&& q)
2106{
2107 vtkMatrix3x3ToQuaternion(A, q);
2108}
2109VTK_ABI_NAMESPACE_END
2110
2111namespace vtk_detail
2112{
2113VTK_ABI_NAMESPACE_BEGIN
2114// Can't specialize templates inside a template class, so we move the impl here.
2115template <typename OutT>
2116void 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}
2128template <>
2129inline void RoundDoubleToIntegralIfNecessary(double val, double* retVal)
2130{ // OutT is double: passthrough
2131 *retVal = val;
2132}
2133template <>
2134inline 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}
2145VTK_ABI_NAMESPACE_END
2146} // end namespace vtk_detail
2147
2148VTK_ABI_NAMESPACE_BEGIN
2149//-----------------------------------------------------------------------------
2150#if defined(VTK_HAS_ISINF) || defined(VTK_HAS_STD_ISINF)
2151#define VTK_MATH_ISINF_IS_INLINE
2152inline 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
2165inline 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
2178inline 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
2190VTK_ABI_NAMESPACE_END
2191#endif
Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform.
abstract superclass for arrays of numeric data
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 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 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 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 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 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 vtkMath * New()
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 int * BeginCombination(int m, int n)
Start iterating over "m choose n" objects.
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.
Park and Miller Sequence of pseudo random numbers.
abstract base class for most VTK objects
Definition vtkObject.h:49
represent and manipulate 3D points
Definition vtkPoints.h:29
Computes the portion of a dataset which is inside a selection.
Hold a reference to a vtkObjectBase instance.
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.
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)