151#include "vtkCommonCoreModule.h"
152#include "vtkMathPrivate.hxx"
158#include "vtkMathConfigure.h"
164#define VTK_DBL_MIN 2.2250738585072014e-308
166#define VTK_DBL_MIN DBL_MIN
170#define VTK_DBL_EPSILON 2.2204460492503131e-16
172#define VTK_DBL_EPSILON DBL_EPSILON
175#ifndef VTK_DBL_EPSILON
177#define VTK_DBL_EPSILON 2.2204460492503131e-16
179#define VTK_DBL_EPSILON DBL_EPSILON
185class vtkMathInternal;
192template <
typename OutT>
206 static constexpr double Pi() {
return 3.141592653589793; }
212 static float RadiansFromDegrees(
float degrees);
213 static double RadiansFromDegrees(
double degrees);
220 static float DegreesFromRadians(
float radians);
221 static double DegreesFromRadians(
double radians);
228 static int Round(
float f) {
return static_cast<int>(f + (f >= 0.0 ? 0.5 : -0.5)); }
229 static int Round(
double f) {
return static_cast<int>(f + (f >= 0.0 ? 0.5 : -0.5)); }
236 template <
typename OutT>
249 static int Floor(
double x);
256 static int Ceil(
double x);
270 static T Min(
const T& a,
const T& b);
277 static T Max(
const T& a,
const T& b);
282 static bool IsPowerOfTwo(vtkTypeUInt64 x);
289 static int NearestPowerOfTwo(
int x);
425 template <
class VectorT1,
class VectorT2>
426 static void Assign(
const VectorT1& a, VectorT2&& b)
436 static void Assign(
const double a[3],
double b[3]) { vtkMath::Assign<>(a, b); }
441 static void Add(
const float a[3],
const float b[3],
float c[3])
443 for (
int i = 0; i < 3; ++i)
452 static void Add(
const double a[3],
const double b[3],
double c[3])
454 for (
int i = 0; i < 3; ++i)
463 static void Subtract(
const float a[3],
const float b[3],
float c[3])
465 for (
int i = 0; i < 3; ++i)
474 static void Subtract(
const double a[3],
const double b[3],
double c[3])
476 for (
int i = 0; i < 3; ++i)
487 template <
class VectorT1,
class VectorT2,
class VectorT3>
488 static void Subtract(
const VectorT1& a,
const VectorT2& b, VectorT3&& c)
501 for (
int i = 0; i < 3; ++i)
513 for (
int i = 0; i < 2; ++i)
525 for (
int i = 0; i < 3; ++i)
537 for (
int i = 0; i < 2; ++i)
546 static float Dot(
const float a[3],
const float b[3])
548 return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
554 static double Dot(
const double a[3],
const double b[3])
556 return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
574 template <
typename ReturnTypeT = double,
typename TupleRangeT1,
typename TupleRangeT2,
575 typename EnableT =
typename std::conditional<!std::is_pointer<TupleRangeT1>::value &&
576 !std::is_array<TupleRangeT1>::value,
577 TupleRangeT1, TupleRangeT2>::type::value_type>
578 static ReturnTypeT
Dot(
const TupleRangeT1& a,
const TupleRangeT2& b)
580 return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
586 static void Outer(
const float a[3],
const float b[3],
float c[3][3])
588 for (
int i = 0; i < 3; ++i)
590 for (
int j = 0; j < 3; ++j)
592 c[i][j] = a[i] * b[j];
600 static void Outer(
const double a[3],
const double b[3],
double c[3][3])
602 for (
int i = 0; i < 3; ++i)
604 for (
int j = 0; j < 3; ++j)
606 c[i][j] = a[i] * b[j];
615 static void Cross(
const float a[3],
const float b[3],
float c[3]);
621 static void Cross(
const double a[3],
const double b[3],
double c[3]);
627 static float Norm(
const float* x,
int n);
628 static double Norm(
const double* x,
int n);
634 static float Norm(
const float v[3]) {
return std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); }
639 static double Norm(
const double v[3])
641 return std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
653 template <
typename ReturnTypeT =
double,
typename TupleRangeT>
656 return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
663 static float Normalize(
float v[3]);
669 static double Normalize(
double v[3]);
679 static void Perpendiculars(
const double v1[3],
double v2[3],
double v3[3],
double theta);
680 static void Perpendiculars(
const float v1[3],
float v2[3],
float v3[3],
double theta);
689 static bool ProjectVector(
const float a[3],
const float b[3],
float projection[3]);
690 static bool ProjectVector(
const double a[3],
const double b[3],
double projection[3]);
701 static bool ProjectVector2D(
const double a[2],
const double b[2],
double projection[2]);
719 template <
typename ReturnTypeT = double,
typename TupleRangeT1,
typename TupleRangeT2,
720 typename EnableT =
typename std::conditional<!std::is_pointer<TupleRangeT1>::value &&
721 !std::is_array<TupleRangeT1>::value,
722 TupleRangeT1, TupleRangeT2>::type::value_type>
723 static ReturnTypeT Distance2BetweenPoints(
const TupleRangeT1& p1,
const TupleRangeT2& p2);
729 static float Distance2BetweenPoints(
const float p1[3],
const float p2[3]);
735 static double Distance2BetweenPoints(
const double p1[3],
const double p2[3]);
746 const double v1[3],
const double v2[3],
const double vn[3]);
758 static double GaussianAmplitude(
const double mean,
const double variance,
const double position);
765 static double GaussianWeight(
const double variance,
const double distanceFromMean);
772 static double GaussianWeight(
const double mean,
const double variance,
const double position);
777 static float Dot2D(
const float x[2],
const float y[2]) {
return x[0] * y[0] + x[1] * y[1]; }
782 static double Dot2D(
const double x[2],
const double y[2]) {
return x[0] * y[0] + x[1] * y[1]; }
787 static void Outer2D(
const float x[2],
const float y[2],
float A[2][2])
789 for (
int i = 0; i < 2; ++i)
791 for (
int j = 0; j < 2; ++j)
793 A[i][j] = x[i] * y[j];
801 static void Outer2D(
const double x[2],
const double y[2],
double A[2][2])
803 for (
int i = 0; i < 2; ++i)
805 for (
int j = 0; j < 2; ++j)
807 A[i][j] = x[i] * y[j];
816 static float Norm2D(
const float x[2]) {
return std::sqrt(x[0] * x[0] + x[1] * x[1]); }
822 static double Norm2D(
const double x[2]) {
return std::sqrt(x[0] * x[0] + x[1] * x[1]); }
828 static float Normalize2D(
float v[2]);
834 static double Normalize2D(
double v[2]);
841 return c1[0] * c2[1] - c2[0] * c1[1];
848 static double Determinant2x2(
double a,
double b,
double c,
double d) {
return a * d - b * c; }
851 return c1[0] * c2[1] - c2[0] * c1[1];
867 static void LUSolve3x3(
const float A[3][3],
const int index[3],
float x[3]);
868 static void LUSolve3x3(
const double A[3][3],
const int index[3],
double x[3]);
877 static void LinearSolve3x3(
const double A[3][3],
const double x[3],
double y[3]);
884 static void Multiply3x3(
const float A[3][3],
const float v[3],
float u[3]);
885 static void Multiply3x3(
const double A[3][3],
const double v[3],
double u[3]);
892 static void Multiply3x3(
const float A[3][3],
const float B[3][3],
float C[3][3]);
893 static void Multiply3x3(
const double A[3][3],
const double B[3][3],
double C[3][3]);
919 template <
int RowsT,
int MidDimT,
int ColsT,
920 class LayoutT1 = vtkMatrixUtilities::Layout::Identity,
921 class LayoutT2 = vtkMatrixUtilities::Layout::Identity,
class MatrixT1,
class MatrixT2,
923 static void MultiplyMatrix(
const MatrixT1& M1,
const MatrixT2& M2, MatrixT3&& M3)
925 vtkMathPrivate::MultiplyMatrix<RowsT, MidDimT, ColsT, LayoutT1, LayoutT2>::Compute(M1, M2, M3);
948 template <
int RowsT,
int ColsT,
class LayoutT = vtkMatrixUtilities::Layout::Identity,
949 class MatrixT,
class VectorT1,
class VectorT2>
952 vtkMathPrivate::MultiplyMatrix<RowsT, ColsT, 1, LayoutT>::Compute(M, X, Y);
960 template <
class ScalarT,
int SizeT,
class VectorT1,
class VectorT2>
961 static ScalarT
Dot(
const VectorT1& x,
const VectorT2& y)
963 return vtkMathPrivate::ContractRowWithCol<ScalarT, 1, SizeT, 1, 0, 0,
964 vtkMatrixUtilities::Layout::Identity, vtkMatrixUtilities::Layout::Transpose>::Compute(x, y);
983 template <
int SizeT,
class LayoutT = vtkMatrixUtilities::Layout::Identity,
class MatrixT>
987 return vtkMathPrivate::Determinant<SizeT, LayoutT>::Compute(M);
1005 template <
int SizeT,
class LayoutT = vtkMatrixUtilities::Layout::Identity,
class MatrixT1,
1009 vtkMathPrivate::InvertMatrix<SizeT, LayoutT>::Compute(M1, M2);
1025 template <
int RowsT,
int ColsT,
class LayoutT = vtkMatrixUtilities::Layout::Identity,
1026 class MatrixT,
class VectorT1,
class VectorT2>
1027 static void LinearSolve(
const MatrixT& M,
const VectorT1& x, VectorT2& y)
1029 vtkMathPrivate::LinearSolve<RowsT, ColsT, LayoutT>::Compute(M, x, y);
1046 template <
class ScalarT,
int SizeT,
class LayoutT = vtkMatrixUtilities::Layout::Identity,
1047 class VectorT1,
class MatrixT,
class VectorT2>
1048 static ScalarT
Dot(
const VectorT1& x,
const MatrixT& M,
const VectorT2& y)
1051 vtkMathPrivate::MultiplyMatrix<SizeT, SizeT, 1, LayoutT>::Compute(M, y, tmp);
1052 return vtkMathPrivate::ContractRowWithCol<ScalarT, 1, SizeT, 1, 0, 0,
1053 vtkMatrixUtilities::Layout::Identity, vtkMatrixUtilities::Layout::Transpose>::Compute(x, tmp);
1061 static void MultiplyMatrix(
const double*
const* A,
const double*
const* B,
unsigned int rowA,
1062 unsigned int colA,
unsigned int rowB,
unsigned int colB,
double** C);
1079 static void Invert3x3(
const double A[3][3],
double AI[3][3]);
1094 static double Determinant3x3(
const float A[3][3]);
1095 static double Determinant3x3(
const double A[3][3]);
1101 static float Determinant3x3(
const float c1[3],
const float c2[3],
const float c3[3]);
1106 static double Determinant3x3(
const double c1[3],
const double c2[3],
const double c3[3]);
1114 static double Determinant3x3(
double a1,
double a2,
double a3,
double b1,
double b2,
double b3,
1115 double c1,
double c2,
double c3);
1125 static void QuaternionToMatrix3x3(
const float quat[4],
float A[3][3]);
1126 static void QuaternionToMatrix3x3(
const double quat[4],
double A[3][3]);
1127 template <
class QuaternionT,
class MatrixT,
1128 class EnableT =
typename std::enable_if<!vtkMatrixUtilities::MatrixIs2DArray<MatrixT>()>::type>
1129 static void QuaternionToMatrix3x3(
const QuaternionT& q, MatrixT&& A);
1142 static void Matrix3x3ToQuaternion(
const float A[3][3],
float quat[4]);
1143 static void Matrix3x3ToQuaternion(
const double A[3][3],
double quat[4]);
1144 template <
class MatrixT,
class QuaternionT,
1145 class EnableT =
typename std::enable_if<!vtkMatrixUtilities::MatrixIs2DArray<MatrixT>()>::type>
1146 static void Matrix3x3ToQuaternion(
const MatrixT& A, QuaternionT&& q);
1210 const float A[3][3],
float U[3][3],
float w[3],
float VT[3][3]);
1212 const double A[3][3],
double U[3][3],
double w[3],
double VT[3][3]);
1223 double a00,
double a01,
double a10,
double a11,
double b0,
double b1,
double& x0,
double& x1);
1249 double** A,
double** AI,
int size,
int* tmp1Size,
double* tmp2Size);
1343 int numberOfSamples,
double** xt,
int xOrder,
double** mt);
1360 int yOrder,
double** mt,
int checkHomogeneous = 1);
1372 RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv + 1, hsv + 2);
1374 static void RGBToHSV(
float r,
float g,
float b,
float*
h,
float* s,
float* v);
1375 static void RGBToHSV(
const double rgb[3],
double hsv[3])
1377 RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv + 1, hsv + 2);
1379 static void RGBToHSV(
double r,
double g,
double b,
double*
h,
double* s,
double* v);
1392 HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb + 1, rgb + 2);
1394 static void HSVToRGB(
float h,
float s,
float v,
float* r,
float* g,
float* b);
1395 static void HSVToRGB(
const double hsv[3],
double rgb[3])
1397 HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb + 1, rgb + 2);
1399 static void HSVToRGB(
double h,
double s,
double v,
double* r,
double* g,
double* b);
1406 static void LabToXYZ(
const double lab[3],
double xyz[3])
1408 LabToXYZ(lab[0], lab[1], lab[2], xyz + 0, xyz + 1, xyz + 2);
1410 static void LabToXYZ(
double L,
double a,
double b,
double* x,
double* y,
double* z);
1417 static void XYZToLab(
const double xyz[3],
double lab[3])
1419 XYZToLab(xyz[0], xyz[1], xyz[2], lab + 0, lab + 1, lab + 2);
1421 static void XYZToLab(
double x,
double y,
double z,
double* L,
double* a,
double* b);
1428 static void XYZToRGB(
const double xyz[3],
double rgb[3])
1430 XYZToRGB(xyz[0], xyz[1], xyz[2], rgb + 0, rgb + 1, rgb + 2);
1432 static void XYZToRGB(
double x,
double y,
double z,
double* r,
double* g,
double* b);
1439 static void RGBToXYZ(
const double rgb[3],
double xyz[3])
1441 RGBToXYZ(rgb[0], rgb[1], rgb[2], xyz + 0, xyz + 1, xyz + 2);
1443 static void RGBToXYZ(
double r,
double g,
double b,
double* x,
double* y,
double* z);
1453 static void RGBToLab(
const double rgb[3],
double lab[3])
1455 RGBToLab(rgb[0], rgb[1], rgb[2], lab + 0, lab + 1, lab + 2);
1457 static void RGBToLab(
double red,
double green,
double blue,
double* L,
double* a,
double* b);
1464 static void LabToRGB(
const double lab[3],
double rgb[3])
1466 LabToRGB(lab[0], lab[1], lab[2], rgb + 0, rgb + 1, rgb + 2);
1468 static void LabToRGB(
double L,
double a,
double b,
double* red,
double* green,
double* blue);
1492 if (bounds[1] - bounds[0] < 0.0)
1505 static T ClampValue(
const T& value,
const T& min,
const T&
max);
1512 static void ClampValue(
double* value,
const double range[2]);
1513 static void ClampValue(
double value,
const double range[2],
double* clamped_value);
1514 static void ClampValues(
double* values,
int nb_values,
const double range[2]);
1516 const double* values,
int nb_values,
const double range[2],
double* clamped_values);
1525 static double ClampAndNormalizeValue(
double value,
const double range[2]);
1531 template <
class T1,
class T2>
1540 static void TensorFromSymmetricTensor(T tensor[9]);
1551 double range_min,
double range_max,
double scale = 1.0,
double shift = 0.0);
1575 const double bounds1[6],
const double bounds2[6],
const double delta[3]);
1583 const double point[3],
const double bounds[6],
const double delta[3]);
1595 const double bounds[6],
const double normal[3],
const double point[3]);
1607 const double p1[3],
const double p2[3],
const double p3[3],
double center[3]);
1654 void operator=(
const vtkMath&) =
delete;
1660 return x * 0.017453292f;
1666 return x * 0.017453292519943295;
1672 return x * 57.2957795131f;
1678 return x * 57.29577951308232;
1684 return ((x != 0) & ((x & (x - 1)) == 0));
1691 unsigned int z =
static_cast<unsigned int>(((x > 0) ? x - 1 : 0));
1697 return static_cast<int>(z + 1);
1705 int i =
static_cast<int>(x);
1714 int i =
static_cast<int>(x);
1722 return (b <= a ? b : a);
1729 return (b > a ? b : a);
1738 for (
int i = 0; i < 3; ++i)
1752 for (
int i = 0; i < 3; ++i)
1766 for (
int i = 0; i < 2; ++i)
1780 for (
int i = 0; i < 2; ++i)
1791 return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1792 c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1798 return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1799 c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1804 double a1,
double a2,
double a3,
double b1,
double b2,
double b3,
double c1,
double c2,
double c3)
1813 return ((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]) +
1814 (p1[2] - p2[2]) * (p1[2] - p2[2]));
1820 return ((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]) +
1821 (p1[2] - p2[2]) * (p1[2] - p2[2]));
1825template <
typename ReturnTypeT,
typename TupleRangeT1,
typename TupleRangeT2,
typename EnableT>
1828 return ((p1[0] - p2[0]) * (p1[0] - p2[0]) + (p1[1] - p2[1]) * (p1[1] - p2[1]) +
1829 (p1[2] - p2[2]) * (p1[2] - p2[2]));
1836 float Cx = a[1] * b[2] - a[2] * b[1];
1837 float Cy = a[2] * b[0] - a[0] * b[2];
1838 float Cz = a[0] * b[1] - a[1] * b[0];
1848 double Cx = a[1] * b[2] - a[2] * b[1];
1849 double Cy = a[2] * b[0] - a[0] * b[2];
1850 double Cz = a[0] * b[1] - a[1] * b[0];
1860 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] -
1861 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];
1880 assert(
"pre: valid_range" && min <=
max);
1882#if __cplusplus >= 201703L
1883 return std::clamp(value, min,
max);
1887 T v = (min < value ? value : min);
1888 return (v <
max ? v :
max);
1897 assert(
"pre: valid_range" && range[0] <= range[1]);
1906 if (range && clamped_value)
1908 assert(
"pre: valid_range" && range[0] <= range[1]);
1917 assert(
"pre: valid_range" && range[0] <= range[1]);
1920 if (range[0] == range[1])
1930 result = (result - range[0]) / (range[1] - range[0]);
1933 assert(
"post: valid_result" && result >= 0.0 && result <= 1.0);
1939template <
class T1,
class T2>
1942 for (
int i = 0; i < 3; ++i)
1944 tensor[4 * i] = symmTensor[i];
1946 tensor[1] = tensor[3] = symmTensor[3];
1947 tensor[2] = tensor[6] = symmTensor[5];
1948 tensor[5] = tensor[7] = symmTensor[4];
1955 tensor[6] = tensor[5];
1956 tensor[7] = tensor[4];
1957 tensor[8] = tensor[2];
1958 tensor[4] = tensor[1];
1959 tensor[5] = tensor[7];
1960 tensor[2] = tensor[6];
1961 tensor[1] = tensor[3];
1966template <
class QuaternionT,
class MatrixT>
1967inline void vtkQuaternionToMatrix3x3(
const QuaternionT& quat, MatrixT& A)
1971 Scalar ww = quat[0] * quat[0];
1972 Scalar wx = quat[0] * quat[1];
1973 Scalar wy = quat[0] * quat[2];
1974 Scalar wz = quat[0] * quat[3];
1976 Scalar xx = quat[1] * quat[1];
1977 Scalar yy = quat[2] * quat[2];
1978 Scalar zz = quat[3] * quat[3];
1980 Scalar xy = quat[1] * quat[2];
1981 Scalar xz = quat[1] * quat[3];
1982 Scalar yz = quat[2] * quat[3];
1984 Scalar rr = xx + yy + zz;
1986 Scalar f = 1 / (ww + rr);
1987 Scalar s = (ww - rr) * f;
1992 Wrapper::template Get<0, 0>(A) = xx * f + s;
1993 Wrapper::template Get<1, 0>(A) = (xy + wz) * f;
1994 Wrapper::template Get<2, 0>(A) = (xz - wy) * f;
1996 Wrapper::template Get<0, 1>(A) = (xy - wz) * f;
1997 Wrapper::template Get<1, 1>(A) = yy * f + s;
1998 Wrapper::template Get<2, 1>(A) = (yz + wx) * f;
2000 Wrapper::template Get<0, 2>(A) = (xz + wy) * f;
2001 Wrapper::template Get<1, 2>(A) = (yz - wx) * f;
2002 Wrapper::template Get<2, 2>(A) = zz * f + s;
2009 vtkQuaternionToMatrix3x3(quat, A);
2015 vtkQuaternionToMatrix3x3(quat, A);
2019template <
class QuaternionT,
class MatrixT,
class EnableT>
2022 vtkQuaternionToMatrix3x3(q, A);
2032template <
class MatrixT,
class QuaternionT>
2033inline void vtkMatrix3x3ToQuaternion(
const MatrixT& A, QuaternionT& quat)
2042 N[0][0] = Wrapper::template Get<0, 0>(A) + Wrapper::template Get<1, 1>(A) +
2043 Wrapper::template Get<2, 2>(A);
2044 N[1][1] = Wrapper::template Get<0, 0>(A) - Wrapper::template Get<1, 1>(A) -
2045 Wrapper::template Get<2, 2>(A);
2046 N[2][2] = -Wrapper::template Get<0, 0>(A) + Wrapper::template Get<1, 1>(A) -
2047 Wrapper::template Get<2, 2>(A);
2048 N[3][3] = -Wrapper::template Get<0, 0>(A) - Wrapper::template Get<1, 1>(A) +
2049 Wrapper::template Get<2, 2>(A);
2052 N[0][1] = N[1][0] = Wrapper::template Get<2, 1>(A) - Wrapper::template Get<1, 2>(A);
2053 N[0][2] = N[2][0] = Wrapper::template Get<0, 2>(A) - Wrapper::template Get<2, 0>(A);
2054 N[0][3] = N[3][0] = Wrapper::template Get<1, 0>(A) - Wrapper::template Get<0, 1>(A);
2056 N[1][2] = N[2][1] = Wrapper::template Get<1, 0>(A) + Wrapper::template Get<0, 1>(A);
2057 N[1][3] = N[3][1] = Wrapper::template Get<0, 2>(A) + Wrapper::template Get<2, 0>(A);
2058 N[2][3] = N[3][2] = Wrapper::template Get<2, 1>(A) + Wrapper::template Get<1, 2>(A);
2060 Scalar eigenvectors[4][4], eigenvalues[4];
2064 Scalar *NTemp[4], *eigenvectorsTemp[4];
2065 for (
int i = 0; i < 4; ++i)
2068 eigenvectorsTemp[i] = eigenvectors[i];
2073 quat[0] = eigenvectors[0][0];
2074 quat[1] = eigenvectors[1][0];
2075 quat[2] = eigenvectors[2][0];
2076 quat[3] = eigenvectors[3][0];
2083 vtkMatrix3x3ToQuaternion(A, quat);
2089 vtkMatrix3x3ToQuaternion(A, quat);
2093template <
class MatrixT,
class QuaternionT,
class EnableT>
2096 vtkMatrix3x3ToQuaternion(A, q);
2102template <
typename OutT>
2110 *ret =
static_cast<OutT
>((val >= 0.0) ? (val + 0.5) : (val - 0.5));
2130 *retVal =
static_cast<float>(val);
2135#if defined(VTK_HAS_ISINF) || defined(VTK_HAS_STD_ISINF)
2136#define VTK_MATH_ISINF_IS_INLINE
2139#if defined(VTK_HAS_STD_ISINF)
2140 return std::isinf(x);
2142 return (isinf(x) != 0);
2148#if defined(VTK_HAS_ISNAN) || defined(VTK_HAS_STD_ISNAN)
2149#define VTK_MATH_ISNAN_IS_INLINE
2152#if defined(VTK_HAS_STD_ISNAN)
2153 return std::isnan(x);
2155 return (
isnan(x) != 0);
2161#if defined(VTK_HAS_ISFINITE) || defined(VTK_HAS_STD_ISFINITE) || defined(VTK_HAS_FINITE)
2162#define VTK_MATH_ISFINITE_IS_INLINE
2165#if defined(VTK_HAS_STD_ISFINITE)
2166 return std::isfinite(x);
2167#elif defined(VTK_HAS_ISFINITE)
2168 return (isfinite(x) != 0);
2170 return (finite(x) != 0);
Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform.
abstract superclass for arrays of numeric data
vtkFrustumSelector is a vtkSelector that selects elements based on whether they are inside or interse...
a simple class to control print indentation
performs common math operations
static ReturnTypeT Distance2BetweenPoints(const TupleRangeT1 &p1, const TupleRangeT2 &p2)
Compute distance squared between two points p1 and p2.
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).
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.
static void MultiplyMatrixWithVector(const MatrixT &M, const VectorT1 &X, VectorT2 &&Y)
Multiply matrix M with vector Y such that Y = M x X.
static double Norm2D(const double x[2])
Compute the norm of a 2-vector.
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 Subtract(const float a[3], const float b[3], float c[3])
Subtraction of two 3-vectors (float version).
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).
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
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 void Add(const double a[3], const double b[3], double c[3])
Addition of two 3-vectors (double version).
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).
static ReturnTypeT Dot(const TupleRangeT1 &a, const TupleRangeT2 &b)
Compute dot product between two points p1 and p2.
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.
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.
static void Identity3x3(float A[3][3])
Set A to the identity matrix.
static double GaussianAmplitude(const double variance, const double distanceFromMean)
Compute the amplitude of a Gaussian function with mean=0 and specified variance.
static void SingularValueDecomposition3x3(const float A[3][3], float U[3][3], float w[3], float VT[3][3])
Perform singular value decomposition on a 3x3 matrix.
static double Nan()
Special IEEE-754 number used to represent Not-A-Number (Nan).
static void Perpendiculars(const float v1[3], float v2[3], float v3[3], double theta)
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.
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).
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 Cross(const float a[3], const float b[3], float c[3])
Cross product of two 3-vectors.
static void MultiplyScalar2D(float a[2], float s)
Multiplies a 2-vector by a scalar (float version).
static void HSVToRGB(const float hsv[3], float rgb[3])
Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue).
static void Assign(const double a[3], double b[3])
Assign values to a 3-vector (double version).
static double Determinant2x2(const double c1[2], const double c2[2])
Calculate the determinant of a 2x2 matrix: | a b | | c d |.
static T Max(const T &a, const T &b)
Returns the maximum of the two arguments provided.
static void Outer2D(const double x[2], const double y[2], double A[2][2])
Outer product of two 2-vectors (double version).
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).
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.
static void HSVToRGB(const double hsv[3], double rgb[3])
Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue).
~vtkMath() override=default
static ScalarT Dot(const VectorT1 &x, const VectorT2 &y)
Computes the dot product between 2 vectors x and y.
static double Inf()
Special IEEE-754 number used to represent positive infinity.
static double GaussianAmplitude(const double mean, const double variance, const double position)
Compute the amplitude of a Gaussian function with specified mean and variance.
static 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.
static void QuaternionToMatrix3x3(const float quat[4], float A[3][3])
Convert a quaternion to a 3x3 rotation matrix.
static int NearestPowerOfTwo(int x)
Compute the nearest power of two that is not less than x.
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.
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).
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).
static float RadiansFromDegrees(float degrees)
Convert degrees into radians.
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).
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?
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.
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.
static double GaussianWeight(const double variance, const double distanceFromMean)
Compute the amplitude of an unnormalized Gaussian function with mean=0 and specified variance.
static void 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).
static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4])
Convert a 3x3 matrix into a quaternion.
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.
static double ClampAndNormalizeValue(double value, const double range[2])
Clamp a value against a range and then normalize it between 0 and 1.
static void MultiplyScalar(double a[3], double s)
Multiplies a 3-vector by a scalar (double version).
static double Dot2D(const double x[2], const double y[2])
Dot product of two 2-vectors.
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.
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.
static int Floor(double x)
Rounds a double to the nearest integer not greater than itself.
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).
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 |.
static void RGBToHSV(const double rgb[3], double hsv[3])
Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value).
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.
static float Determinant2x2(const float c1[2], const float c2[2])
Compute determinant of 2x2 matrix.
static int Round(double f)
static vtkTypeBool IsInf(double x)
Test if a number is equal to the special floating point value infinity.
static void UninitializeBounds(double bounds[6])
Set the bounds to an uninitialized state.
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).
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).
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...
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.
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.
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.
static double Determinant3x3(const float A[3][3])
Return the determinant of a 3x3 matrix.
static float Dot2D(const float x[2], const float y[2])
Dot product of two 2-vectors.
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.
static void RGBToHSV(const float rgb[3], float hsv[3])
Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value).
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.
static float Norm2D(const float x[2])
Compute the norm of a 2-vector.
static double GaussianWeight(const double mean, const double variance, const double position)
Compute the amplitude of an unnormalized Gaussian function with specified mean and variance.
static 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.
static void MultiplyScalar(float a[3], float s)
Multiplies a 3-vector by a scalar (float version).
static T Min(const T &a, const T &b)
Returns the minimum of the two arguments provided.
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.
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 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
represent and manipulate 3D points
Hold a reference to a vtkObjectBase instance.
void RoundDoubleToIntegralIfNecessary(double val, OutT *ret)
Template defining traits of native types used by VTK.
double vtkDeterminant3x3(const T A[3][3])