VTK
vtkMath.h
Go to the documentation of this file.
1/*=========================================================================
2
3 Program: Visualization Toolkit
4 Module: vtkMath.h
5
6 Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7 All rights reserved.
8 See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9
10 This software is distributed WITHOUT ANY WARRANTY; without even
11 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12 PURPOSE. See the above copyright notice for more information.
13
14=========================================================================
15 Copyright 2011 Sandia Corporation.
16 Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
17 license for use of this work by or on behalf of the
18 U.S. Government. Redistribution and use in source and binary forms, with
19 or without modification, are permitted provided that this Notice and any
20 statement of authorship are reproduced on all copies.
21
22 Contact: pppebay@sandia.gov,dcthomp@sandia.gov
23
24=========================================================================*/
45#ifndef vtkMath_h
46#define vtkMath_h
47
48#include "vtkCommonCoreModule.h" // For export macro
49#include "vtkObject.h"
50#include "vtkTypeTraits.h" // For type traits
51#include "vtkSmartPointer.h" // For vtkSmartPointer.
52
53#include "vtkMathConfigure.h" // For <cmath> and VTK_HAS_ISNAN etc.
54
55#include <cassert> // assert() in inline implementations.
56
57#ifndef DBL_MIN
58# define VTK_DBL_MIN 2.2250738585072014e-308
59#else // DBL_MIN
60# define VTK_DBL_MIN DBL_MIN
61#endif // DBL_MIN
62
63#ifndef DBL_EPSILON
64# define VTK_DBL_EPSILON 2.2204460492503131e-16
65#else // DBL_EPSILON
66# define VTK_DBL_EPSILON DBL_EPSILON
67#endif // DBL_EPSILON
68
69#ifndef VTK_DBL_EPSILON
70# ifndef DBL_EPSILON
71# define VTK_DBL_EPSILON 2.2204460492503131e-16
72# else // DBL_EPSILON
73# define VTK_DBL_EPSILON DBL_EPSILON
74# endif // DBL_EPSILON
75#endif // VTK_DBL_EPSILON
76
77class vtkDataArray;
78class vtkPoints;
79class vtkMathInternal;
82
83namespace vtk_detail
84{
85// forward declaration
86template <typename OutT>
87void RoundDoubleToIntegralIfNecessary(double val, OutT* ret);
88} // end namespace vtk_detail
89
90class VTKCOMMONCORE_EXPORT vtkMath : public vtkObject
91{
92public:
93 static vtkMath *New();
94 vtkTypeMacro(vtkMath,vtkObject);
95 void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;
96
100 static double Pi() { return 3.141592653589793; };
101
103
106 static float RadiansFromDegrees( float degrees);
107 static double RadiansFromDegrees( double degrees);
109
111
114 static float DegreesFromRadians( float radians);
115 static double DegreesFromRadians( double radians);
117
121 static int Round(float f) {
122 return static_cast<int>( f + ( f >= 0.0 ? 0.5 : -0.5 ) ); }
123 static int Round(double f) {
124 return static_cast<int>( f + ( f >= 0.0 ? 0.5 : -0.5 ) ); }
125
130 template <typename OutT>
131 static void RoundDoubleToIntegralIfNecessary(double val, OutT* ret)
132 {
133 // Can't specialize template methods in a template class, so we move the
134 // implementations to a external namespace.
136 }
137
143 static int Floor(double x);
144
150 static int Ceil(double x);
151
157 static int CeilLog2(vtkTypeUInt64 x);
158
162 template<class T>
163 static T Min(const T & a, const T & b);
164
168 template<class T>
169 static T Max(const T & a, const T & b);
170
174 static bool IsPowerOfTwo(vtkTypeUInt64 x);
175
181 static int NearestPowerOfTwo(int x);
182
187 static vtkTypeInt64 Factorial( int N );
188
194 static vtkTypeInt64 Binomial( int m, int n );
195
206 static int* BeginCombination( int m, int n );
207
218 static int NextCombination( int m, int n, int* combination );
219
223 static void FreeCombination( int* combination);
224
240 static void RandomSeed(int s);
241
253 static int GetSeed();
254
268 static double Random();
269
282 static double Random( double min, double max );
283
296 static double Gaussian();
297
310 static double Gaussian( double mean, double std );
311
315 static void Add(const float a[3], const float b[3], float c[3]) {
316 for (int i = 0; i < 3; ++i)
317 c[i] = a[i] + b[i];
318 }
319
323 static void Add(const double a[3], const double b[3], double c[3]) {
324 for (int i = 0; i < 3; ++i)
325 c[i] = a[i] + b[i];
326 }
327
331 static void Subtract(const float a[3], const float b[3], float c[3]) {
332 for (int i = 0; i < 3; ++i)
333 c[i] = a[i] - b[i];
334 }
335
339 static void Subtract(const double a[3], const double b[3], double c[3]) {
340 for (int i = 0; i < 3; ++i)
341 c[i] = a[i] - b[i];
342 }
343
348 static void MultiplyScalar(float a[3], float s) {
349 for (int i = 0; i < 3; ++i)
350 a[i] *= s;
351 }
352
357 static void MultiplyScalar2D(float a[2], float s) {
358 for (int i = 0; i < 2; ++i)
359 a[i] *= s;
360 }
361
366 static void MultiplyScalar(double a[3], double s) {
367 for (int i = 0; i < 3; ++i)
368 a[i] *= s;
369 }
370
375 static void MultiplyScalar2D(double a[2], double s) {
376 for (int i = 0; i < 2; ++i)
377 a[i] *= s;
378 }
379
383 static float Dot(const float a[3], const float b[3]) {
384 return ( a[0] * b[0] + a[1] * b[1] + a[2] * b[2] );};
385
389 static double Dot(const double a[3], const double b[3]) {
390 return ( a[0] * b[0] + a[1] * b[1] + a[2] * b[2] );};
391
395 static void Outer(const float a[3], const float b[3], float C[3][3]) {
396 for (int i=0; i < 3; i++)
397 for (int j=0; j < 3; j++)
398 C[i][j] = a[i] * b[j];
399 }
403 static void Outer(const double a[3], const double b[3], double C[3][3]) {
404 for (int i=0; i < 3; i++)
405 for (int j=0; j < 3; j++)
406 C[i][j] = a[i] * b[j];
407 }
408
412 static void Cross(const float a[3], const float b[3], float c[3]);
413
418 static void Cross(const double a[3], const double b[3], double c[3]);
419
421
424 static float Norm(const float* x, int n);
425 static double Norm(const double* x, int n);
427
431 static float Norm(const float v[3]) {
432 return static_cast<float> (sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] ) );};
433
437 static double Norm(const double v[3]) {
438 return sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] );};
439
443 static float Normalize(float v[3]);
444
449 static double Normalize(double v[3]);
450
452
459 static void Perpendiculars(const double v1[3], double v2[3], double v3[3],
460 double theta);
461 static void Perpendiculars(const float v1[3], float v2[3], float v3[3],
462 double theta);
464
466
471 static bool ProjectVector(const float a[3], const float b[3], float projection[3]);
472 static bool ProjectVector(const double a[3], const double b[3], double projection[3]);
474
476
482 static bool ProjectVector2D(const float a[2], const float b[2], float projection[2]);
483 static bool ProjectVector2D(const double a[2], const double b[2], double projection[2]);
485
489 static float Distance2BetweenPoints(const float p1[3], const float p2[3]);
490
495 static double Distance2BetweenPoints(const double p1[3], const double p2[3]);
496
500 static double AngleBetweenVectors(const double v1[3], const double v2[3]);
501
506 static double GaussianAmplitude(const double variance, const double distanceFromMean);
507
512 static double GaussianAmplitude(const double mean, const double variance, const double position);
513
519 static double GaussianWeight(const double variance, const double distanceFromMean);
520
526 static double GaussianWeight(const double mean, const double variance, const double position);
527
531 static float Dot2D(const float x[2], const float y[2]) {
532 return ( x[0] * y[0] + x[1] * y[1] );};
533
537 static double Dot2D(const double x[2], const double y[2]) {
538 return ( x[0] * y[0] + x[1] * y[1] );};
539
543 static void Outer2D(const float x[2], const float y[2], float A[2][2])
544 {
545 for (int i=0; i < 2; i++)
546 {
547 for (int j=0; j < 2; j++)
548 {
549 A[i][j] = x[i] * y[j];
550 }
551 }
552 }
556 static void Outer2D(const double x[2], const double y[2], double A[2][2])
557 {
558 for (int i=0; i < 2; i++)
559 {
560 for (int j=0; j < 2; j++)
561 {
562 A[i][j] = x[i] * y[j];
563 }
564 }
565 }
566
570 static float Norm2D(const float x[2]) {
571 return static_cast<float> (sqrt( x[0] * x[0] + x[1] * x[1] ) );};
572
577 static double Norm2D(const double x[2]) {
578 return sqrt( x[0] * x[0] + x[1] * x[1] );};
579
583 static float Normalize2D(float v[2]);
584
589 static double Normalize2D(double v[2]);
590
594 static float Determinant2x2(const float c1[2], const float c2[2]) {
595 return (c1[0] * c2[1] - c2[0] * c1[1] );};
596
598
601 static double Determinant2x2(double a, double b, double c, double d) {
602 return (a * d - b * c);};
603 static double Determinant2x2(const double c1[2], const double c2[2]) {
604 return (c1[0] * c2[1] - c2[0] * c1[1] );};
606
608
611 static void LUFactor3x3(float A[3][3], int index[3]);
612 static void LUFactor3x3(double A[3][3], int index[3]);
614
616
619 static void LUSolve3x3(const float A[3][3], const int index[3],
620 float x[3]);
621 static void LUSolve3x3(const double A[3][3], const int index[3],
622 double x[3]);
624
626
630 static void LinearSolve3x3(const float A[3][3], const float x[3],
631 float y[3]);
632 static void LinearSolve3x3(const double A[3][3], const double x[3],
633 double y[3]);
635
637
640 static void Multiply3x3(const float A[3][3], const float in[3],
641 float out[3]);
642 static void Multiply3x3(const double A[3][3], const double in[3],
643 double out[3]);
645
647
650 static void Multiply3x3(const float A[3][3], const float B[3][3],
651 float C[3][3]);
652 static void Multiply3x3(const double A[3][3], const double B[3][3],
653 double C[3][3]);
655
661 static void MultiplyMatrix(double **A, double **B,
662 unsigned int rowA, unsigned int colA,
663 unsigned int rowB, unsigned int colB,
664 double **C);
665
667
671 static void Transpose3x3(const float A[3][3], float AT[3][3]);
672 static void Transpose3x3(const double A[3][3], double AT[3][3]);
674
676
680 static void Invert3x3(const float A[3][3], float AI[3][3]);
681 static void Invert3x3(const double A[3][3], double AI[3][3]);
683
685
688 static void Identity3x3(float A[3][3]);
689 static void Identity3x3(double A[3][3]);
691
693
696 static double Determinant3x3(float A[3][3]);
697 static double Determinant3x3(double A[3][3]);
699
703 static float Determinant3x3(const float c1[3],
704 const float c2[3],
705 const float c3[3]);
706
710 static double Determinant3x3(const double c1[3],
711 const double c2[3],
712 const double c3[3]);
713
720 static double Determinant3x3(double a1, double a2, double a3,
721 double b1, double b2, double b3,
722 double c1, double c2, double c3);
723
725
732 static void QuaternionToMatrix3x3(const float quat[4], float A[3][3]);
733 static void QuaternionToMatrix3x3(const double quat[4], double A[3][3]);
735
737
745 static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4]);
746 static void Matrix3x3ToQuaternion(const double A[3][3], double quat[4]);
748
750
756 static void MultiplyQuaternion( const float q1[4], const float q2[4], float q[4] );
757 static void MultiplyQuaternion( const double q1[4], const double q2[4], double q[4] );
759
761
766 static void Orthogonalize3x3(const float A[3][3], float B[3][3]);
767 static void Orthogonalize3x3(const double A[3][3], double B[3][3]);
769
771
777 static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3]);
778 static void Diagonalize3x3(const double A[3][3],double w[3],double V[3][3]);
780
782
791 static void SingularValueDecomposition3x3(const float A[3][3],
792 float U[3][3], float w[3],
793 float VT[3][3]);
794 static void SingularValueDecomposition3x3(const double A[3][3],
795 double U[3][3], double w[3],
796 double VT[3][3]);
798
805 static int SolveLinearSystem(double **A, double *x, int size);
806
813 static int InvertMatrix(double **A, double **AI, int size);
814
820 static int InvertMatrix(double **A, double **AI, int size,
821 int *tmp1Size, double *tmp2Size);
822
845 static int LUFactorLinearSystem(double **A, int *index, int size);
846
852 static int LUFactorLinearSystem(double **A, int *index, int size,
853 double *tmpSize);
854
863 static void LUSolveLinearSystem(double **A, int *index,
864 double *x, int size);
865
874 static double EstimateMatrixCondition(double **A, int size);
875
877
885 static int Jacobi(float **a, float *w, float **v);
886 static int Jacobi(double **a, double *w, double **v);
888
890
899 static int JacobiN(float **a, int n, float *w, float **v);
900 static int JacobiN(double **a, int n, double *w, double **v);
902
916 static int SolveHomogeneousLeastSquares(int numberOfSamples, double **xt, int xOrder,
917 double **mt);
918
919
934 static int SolveLeastSquares(int numberOfSamples, double **xt, int xOrder,
935 double **yt, int yOrder, double **mt, int checkHomogeneous=1);
936
938
945 static void RGBToHSV(const float rgb[3], float hsv[3])
946 { RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); }
947 static void RGBToHSV(float r, float g, float b, float *h, float *s, float *v);
948 static double* RGBToHSV(const double rgb[3]);
949 static double* RGBToHSV(double r, double g, double b);
950 static void RGBToHSV(const double rgb[3], double hsv[3])
951 { RGBToHSV(rgb[0], rgb[1], rgb[2], hsv, hsv+1, hsv+2); }
952 static void RGBToHSV(double r, double g, double b, double *h, double *s, double *v);
954
956
963 static void HSVToRGB(const float hsv[3], float rgb[3])
964 { HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); }
965 static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b);
966 static double* HSVToRGB(const double hsv[3]);
967 static double* HSVToRGB(double h, double s, double v);
968 static void HSVToRGB(const double hsv[3], double rgb[3])
969 { HSVToRGB(hsv[0], hsv[1], hsv[2], rgb, rgb+1, rgb+2); }
970 static void HSVToRGB(double h, double s, double v, double *r, double *g, double *b);
972
974
977 static void LabToXYZ(const double lab[3], double xyz[3]) {
978 LabToXYZ(lab[0], lab[1], lab[2], xyz+0, xyz+1, xyz+2);
979 }
980 static void LabToXYZ(double L, double a, double b,
981 double *x, double *y, double *z);
982 static double *LabToXYZ(const double lab[3]);
984
986
989 static void XYZToLab(const double xyz[3], double lab[3]) {
990 XYZToLab(xyz[0], xyz[1], xyz[2], lab+0, lab+1, lab+2);
991 }
992 static void XYZToLab(double x, double y, double z,
993 double *L, double *a, double *b);
994 static double *XYZToLab(const double xyz[3]);
996
998
1001 static void XYZToRGB(const double xyz[3], double rgb[3]) {
1002 XYZToRGB(xyz[0], xyz[1], xyz[2], rgb+0, rgb+1, rgb+2);
1003 }
1004 static void XYZToRGB(double x, double y, double z,
1005 double *r, double *g, double *b);
1006 static double *XYZToRGB(const double xyz[3]);
1008
1010
1013 static void RGBToXYZ(const double rgb[3], double xyz[3]) {
1014 RGBToXYZ(rgb[0], rgb[1], rgb[2], xyz+0, xyz+1, xyz+2);
1015 }
1016 static void RGBToXYZ(double r, double g, double b,
1017 double *x, double *y, double *z);
1018 static double *RGBToXYZ(const double rgb[3]);
1020
1022
1028 static void RGBToLab(const double rgb[3], double lab[3]) {
1029 RGBToLab(rgb[0], rgb[1], rgb[2], lab+0, lab+1, lab+2);
1030 }
1031 static void RGBToLab(double red, double green, double blue,
1032 double *L, double *a, double *b);
1033 static double *RGBToLab(const double rgb[3]);
1035
1037
1040 static void LabToRGB(const double lab[3], double rgb[3]) {
1041 LabToRGB(lab[0], lab[1], lab[2], rgb+0, rgb+1, rgb+2);
1042 }
1043 static void LabToRGB(double L, double a, double b,
1044 double *red, double *green, double *blue);
1045 static double *LabToRGB(const double lab[3]);
1047
1049
1052 static void UninitializeBounds(double bounds[6]){
1053 bounds[0] = 1.0;
1054 bounds[1] = -1.0;
1055 bounds[2] = 1.0;
1056 bounds[3] = -1.0;
1057 bounds[4] = 1.0;
1058 bounds[5] = -1.0;
1059 }
1061
1063
1066 static vtkTypeBool AreBoundsInitialized(double bounds[6]){
1067 if ( bounds[1]-bounds[0]<0.0 )
1068 {
1069 return 0;
1070 }
1071 return 1;
1072 }
1074
1079 template<class T>
1080 static T ClampValue(const T & value, const T & min, const T & max);
1081
1083
1087 static void ClampValue(double *value, const double range[2]);
1088 static void ClampValue(double value, const double range[2], double *clamped_value);
1089 static void ClampValues(
1090 double *values, int nb_values, const double range[2]);
1091 static void ClampValues(
1092 const double *values, int nb_values, const double range[2], double *clamped_values);
1094
1101 static double ClampAndNormalizeValue(double value,
1102 const double range[2]);
1103
1113 double range_min, double range_max,
1114 double scale = 1.0, double shift = 0.0);
1115
1125 vtkDataArray *array, int comp, double range[2]);
1126
1131 static vtkTypeBool ExtentIsWithinOtherExtent(int extent1[6], int extent2[6]);
1132
1138 static vtkTypeBool BoundsIsWithinOtherBounds(double bounds1[6], double bounds2[6], double delta[3]);
1139
1145 static vtkTypeBool PointIsWithinBounds(double point[3], double bounds[6], double delta[3]);
1146
1156 static double Solve3PointCircle(const double p1[3], const double p2[3], const double p3[3], double center[3]);
1157
1161 static double Inf();
1162
1166 static double NegInf();
1167
1171 static double Nan();
1172
1176 static vtkTypeBool IsInf(double x);
1177
1181 static vtkTypeBool IsNan(double x);
1182
1186 static bool IsFinite(double x);
1187
1188protected:
1190 ~vtkMath() VTK_OVERRIDE {}
1191
1193private:
1194 vtkMath(const vtkMath&) VTK_DELETE_FUNCTION;
1195 void operator=(const vtkMath&) VTK_DELETE_FUNCTION;
1196};
1197
1198//----------------------------------------------------------------------------
1199inline float vtkMath::RadiansFromDegrees( float x )
1200{
1201 return x * 0.017453292f;
1202}
1203
1204//----------------------------------------------------------------------------
1205inline double vtkMath::RadiansFromDegrees( double x )
1206{
1207 return x * 0.017453292519943295;
1208}
1209
1210//----------------------------------------------------------------------------
1211inline float vtkMath::DegreesFromRadians( float x )
1212{
1213 return x * 57.2957795131f;
1214}
1215
1216//----------------------------------------------------------------------------
1217inline double vtkMath::DegreesFromRadians( double x )
1218{
1219 return x * 57.29577951308232;
1220}
1221
1222//----------------------------------------------------------------------------
1223inline bool vtkMath::IsPowerOfTwo(vtkTypeUInt64 x)
1224{
1225 return ((x != 0) & ((x & (x - 1)) == 0));
1226}
1227
1228//----------------------------------------------------------------------------
1229// Credit goes to Peter Hart and William Lewis on comp.lang.python 1997
1231{
1232 unsigned int z = ((x > 0) ? x - 1 : 0);
1233 z |= z >> 1;
1234 z |= z >> 2;
1235 z |= z >> 4;
1236 z |= z >> 8;
1237 z |= z >> 16;
1238 return static_cast<int>(z + 1);
1239}
1240
1241//----------------------------------------------------------------------------
1242// Modify the trunc() operation provided by static_cast<int>() to get floor(),
1243// Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1244inline int vtkMath::Floor(double x)
1245{
1246 int i = static_cast<int>(x);
1247 return i - ( i > x );
1248}
1249
1250//----------------------------------------------------------------------------
1251// Modify the trunc() operation provided by static_cast<int>() to get ceil(),
1252// Note that in C++ conditions evaluate to values of 1 or 0 (true or false).
1253inline int vtkMath::Ceil(double x)
1254{
1255 int i = static_cast<int>(x);
1256 return i + ( i < x );
1257}
1258
1259//----------------------------------------------------------------------------
1260template<class T>
1261inline T vtkMath::Min(const T & a, const T & b)
1262{
1263 return (a < b ? a : b);
1264}
1265
1266//----------------------------------------------------------------------------
1267template<class T>
1268inline T vtkMath::Max(const T & a, const T & b)
1269{
1270 return (a > b ? a : b);
1271}
1272
1273//----------------------------------------------------------------------------
1274inline float vtkMath::Normalize(float v[3])
1275{
1276 float den = vtkMath::Norm( v );
1277 if ( den != 0.0 )
1278 {
1279 for (int i=0; i < 3; i++)
1280 {
1281 v[i] /= den;
1282 }
1283 }
1284 return den;
1285}
1286
1287//----------------------------------------------------------------------------
1288inline double vtkMath::Normalize(double v[3])
1289{
1290 double den = vtkMath::Norm( v );
1291 if ( den != 0.0 )
1292 {
1293 for (int i=0; i < 3; i++)
1294 {
1295 v[i] /= den;
1296 }
1297 }
1298 return den;
1299}
1300
1301//----------------------------------------------------------------------------
1302inline float vtkMath::Normalize2D(float v[3])
1303{
1304 float den = vtkMath::Norm2D( v );
1305 if ( den != 0.0 )
1306 {
1307 for (int i=0; i < 2; i++)
1308 {
1309 v[i] /= den;
1310 }
1311 }
1312 return den;
1313}
1314
1315//----------------------------------------------------------------------------
1316inline double vtkMath::Normalize2D(double v[3])
1317{
1318 double den = vtkMath::Norm2D( v );
1319 if ( den != 0.0 )
1320 {
1321 for (int i=0; i < 2; i++)
1322 {
1323 v[i] /= den;
1324 }
1325 }
1326 return den;
1327}
1328
1329//----------------------------------------------------------------------------
1330inline float vtkMath::Determinant3x3(const float c1[3],
1331 const float c2[3],
1332 const float c3[3])
1333{
1334 return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1335 c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1336}
1337
1338//----------------------------------------------------------------------------
1339inline double vtkMath::Determinant3x3(const double c1[3],
1340 const double c2[3],
1341 const double c3[3])
1342{
1343 return c1[0] * c2[1] * c3[2] + c2[0] * c3[1] * c1[2] + c3[0] * c1[1] * c2[2] -
1344 c1[0] * c3[1] * c2[2] - c2[0] * c1[1] * c3[2] - c3[0] * c2[1] * c1[2];
1345}
1346
1347//----------------------------------------------------------------------------
1348inline double vtkMath::Determinant3x3(double a1, double a2, double a3,
1349 double b1, double b2, double b3,
1350 double c1, double c2, double c3)
1351{
1352 return ( a1 * vtkMath::Determinant2x2( b2, b3, c2, c3 )
1353 - b1 * vtkMath::Determinant2x2( a2, a3, c2, c3 )
1354 + c1 * vtkMath::Determinant2x2( a2, a3, b2, b3 ) );
1355}
1356
1357//----------------------------------------------------------------------------
1358inline float vtkMath::Distance2BetweenPoints(const float p1[3],
1359 const float p2[3])
1360{
1361 return ( ( p1[0] - p2[0] ) * ( p1[0] - p2[0] )
1362 + ( p1[1] - p2[1] ) * ( p1[1] - p2[1] )
1363 + ( p1[2] - p2[2] ) * ( p1[2] - p2[2] ) );
1364}
1365
1366//----------------------------------------------------------------------------
1367inline double vtkMath::Distance2BetweenPoints(const double p1[3],
1368 const double p2[3])
1369{
1370 return ( ( p1[0] - p2[0] ) * ( p1[0] - p2[0] )
1371 + ( p1[1] - p2[1] ) * ( p1[1] - p2[1] )
1372 + ( p1[2] - p2[2] ) * ( p1[2] - p2[2] ) );
1373}
1374
1375//----------------------------------------------------------------------------
1376// Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1377inline void vtkMath::Cross(const float a[3], const float b[3], float c[3])
1378{
1379 float Cx = a[1] * b[2] - a[2] * b[1];
1380 float Cy = a[2] * b[0] - a[0] * b[2];
1381 float Cz = a[0] * b[1] - a[1] * b[0];
1382 c[0] = Cx; c[1] = Cy; c[2] = Cz;
1383}
1384
1385//----------------------------------------------------------------------------
1386// Cross product of two 3-vectors. Result (a x b) is stored in c[3].
1387inline void vtkMath::Cross(const double a[3], const double b[3], double c[3])
1388{
1389 double Cx = a[1] * b[2] - a[2] * b[1];
1390 double Cy = a[2] * b[0] - a[0] * b[2];
1391 double Cz = a[0] * b[1] - a[1] * b[0];
1392 c[0] = Cx; c[1] = Cy; c[2] = Cz;
1393}
1394
1395//----------------------------------------------------------------------------
1396template<class T>
1397inline double vtkDeterminant3x3(T A[3][3])
1398{
1399 return A[0][0] * A[1][1] * A[2][2] + A[1][0] * A[2][1] * A[0][2] +
1400 A[2][0] * A[0][1] * A[1][2] - A[0][0] * A[2][1] * A[1][2] -
1401 A[1][0] * A[0][1] * A[2][2] - A[2][0] * A[1][1] * A[0][2];
1402}
1403
1404//----------------------------------------------------------------------------
1405inline double vtkMath::Determinant3x3(float A[3][3])
1406{
1407 return vtkDeterminant3x3( A );
1408}
1409
1410//----------------------------------------------------------------------------
1411inline double vtkMath::Determinant3x3(double A[3][3])
1412{
1413 return vtkDeterminant3x3( A );
1414}
1415
1416//----------------------------------------------------------------------------
1417template<class T>
1418inline T vtkMath::ClampValue(const T & value, const T & min, const T & max)
1419{
1420 assert("pre: valid_range" && min<=max);
1421
1422 if (value < min)
1423 {
1424 return min;
1425 }
1426
1427 if (value > max)
1428 {
1429 return max;
1430 }
1431
1432 return value;
1433}
1434
1435//----------------------------------------------------------------------------
1436inline void vtkMath::ClampValue(double *value, const double range[2])
1437{
1438 if (value && range)
1439 {
1440 assert("pre: valid_range" && range[0]<=range[1]);
1441
1442 if (*value < range[0])
1443 {
1444 *value = range[0];
1445 }
1446 else if (*value > range[1])
1447 {
1448 *value = range[1];
1449 }
1450 }
1451}
1452
1453//----------------------------------------------------------------------------
1455 double value, const double range[2], double *clamped_value)
1456{
1457 if (range && clamped_value)
1458 {
1459 assert("pre: valid_range" && range[0]<=range[1]);
1460
1461 if (value < range[0])
1462 {
1463 *clamped_value = range[0];
1464 }
1465 else if (value > range[1])
1466 {
1467 *clamped_value = range[1];
1468 }
1469 else
1470 {
1471 *clamped_value = value;
1472 }
1473 }
1474}
1475
1476// ---------------------------------------------------------------------------
1478 const double range[2])
1479{
1480 assert("pre: valid_range" && range[0]<=range[1]);
1481
1482 double result;
1483 if(range[0]==range[1])
1484 {
1485 result=0.0;
1486 }
1487 else
1488 {
1489 // clamp
1490 if(value<range[0])
1491 {
1492 result=range[0];
1493 }
1494 else
1495 {
1496 if(value>range[1])
1497 {
1498 result=range[1];
1499 }
1500 else
1501 {
1502 result=value;
1503 }
1504 }
1505
1506 // normalize
1507 result=( result - range[0] ) / ( range[1] - range[0] );
1508 }
1509
1510 assert("post: valid_result" && result>=0.0 && result<=1.0);
1511
1512 return result;
1513}
1514
1515namespace vtk_detail
1516{
1517// Can't specialize templates inside a template class, so we move the impl here.
1518template <typename OutT>
1519void RoundDoubleToIntegralIfNecessary(double val, OutT* ret)
1520{ // OutT is integral -- clamp and round
1521 val = vtkMath::Max(val, static_cast<double>(vtkTypeTraits<OutT>::Min()));
1522 val = vtkMath::Min(val, static_cast<double>(vtkTypeTraits<OutT>::Max()));
1523 *ret = static_cast<OutT>((val >= 0.0) ? (val + 0.5) : (val - 0.5));
1524}
1525template <>
1526inline void RoundDoubleToIntegralIfNecessary(double val, double* retVal)
1527{ // OutT is double: passthrough
1528 *retVal = val;
1529}
1530template <>
1531inline void RoundDoubleToIntegralIfNecessary(double val, float* retVal)
1532{ // OutT is float -- just clamp
1533 val = vtkMath::Max(val, static_cast<double>(vtkTypeTraits<float>::Min()));
1534 val = vtkMath::Min(val, static_cast<double>(vtkTypeTraits<float>::Max()));
1535 *retVal = static_cast<float>(val);
1536}
1537} // end namespace vtk_detail
1538
1539//-----------------------------------------------------------------------------
1540#if defined(VTK_HAS_ISINF) || defined(VTK_HAS_STD_ISINF)
1541#define VTK_MATH_ISINF_IS_INLINE
1542inline vtkTypeBool vtkMath::IsInf(double x)
1543{
1544#if defined(VTK_HAS_STD_ISINF)
1545 return std::isinf(x);
1546#else
1547 return (isinf(x) != 0); // Force conversion to bool
1548#endif
1549}
1550#endif
1551
1552//-----------------------------------------------------------------------------
1553#if defined(VTK_HAS_ISNAN) || defined(VTK_HAS_STD_ISNAN)
1554#define VTK_MATH_ISNAN_IS_INLINE
1555inline vtkTypeBool vtkMath::IsNan(double x)
1556{
1557#if defined(VTK_HAS_STD_ISNAN)
1558 return std::isnan(x);
1559#else
1560 return (isnan(x) != 0); // Force conversion to bool
1561#endif
1562}
1563#endif
1564
1565//-----------------------------------------------------------------------------
1566#if defined(VTK_HAS_ISFINITE) || defined(VTK_HAS_STD_ISFINITE) || defined(VTK_HAS_FINITE)
1567#define VTK_MATH_ISFINITE_IS_INLINE
1568inline bool vtkMath::IsFinite(double x)
1569{
1570#if defined(VTK_HAS_STD_ISFINITE)
1571 return std::isfinite(x);
1572#elif defined(VTK_HAS_ISFINITE)
1573 return (isfinite(x) != 0); // Force conversion to bool
1574#else
1575 return (finite(x) != 0); // Force conversion to bool
1576#endif
1577}
1578#endif
1579
1580#endif
Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform.
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:55
a simple class to control print indentation
Definition: vtkIndent.h:40
performs common math operations
Definition: vtkMath.h:91
static void Multiply3x3(const float A[3][3], const float B[3][3], float C[3][3])
Multiply one 3x3 matrix by another according to C = AB.
static double Dot(const double a[3], const double b[3])
Dot product of two 3-vectors (double-precision version).
Definition: vtkMath.h:389
static int Jacobi(double **a, double *w, double **v)
static int GetScalarTypeFittingRange(double range_min, double range_max, double scale=1.0, double shift=0.0)
Return the scalar type that is most likely to have enough precision to store a given range of data on...
static void RGBToXYZ(double r, double g, double b, double *x, double *y, double *z)
static void Multiply3x3(const double A[3][3], const double B[3][3], double C[3][3])
static double Norm(const double *x, int n)
static int Round(float f)
Rounds a float to the nearest integer.
Definition: vtkMath.h:121
static double Norm2D(const double x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:577
static void XYZToRGB(double x, double y, double z, double *r, double *g, double *b)
static void Matrix3x3ToQuaternion(const double A[3][3], double quat[4])
static double * RGBToHSV(double r, double g, double b)
static void Subtract(const float a[3], const float b[3], float c[3])
Subtraction of two 3-vectors (float version).
Definition: vtkMath.h:331
static void LUSolve3x3(const double A[3][3], const int index[3], double x[3])
static void Multiply3x3(const double A[3][3], const double in[3], double out[3])
static void Outer2D(const float x[2], const float y[2], float A[2][2])
Outer product of two 2-vectors (float version).
Definition: vtkMath.h:543
static bool ProjectVector(const double a[3], const double b[3], double projection[3])
static vtkSmartPointer< vtkMathInternal > Internal
Definition: vtkMath.h:1192
static float Norm(const float *x, int n)
Compute the norm of n-vector.
static void Add(const double a[3], const double b[3], double c[3])
Addition of two 3-vectors (double version).
Definition: vtkMath.h:323
static void RGBToHSV(float r, float g, float b, float *h, float *s, float *v)
static float Norm(const float v[3])
Compute the norm of 3-vector.
Definition: vtkMath.h:431
static void XYZToLab(const double xyz[3], double lab[3])
Convert Color from the CIE XYZ system to CIE-L*ab.
Definition: vtkMath.h:989
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
static vtkTypeInt64 Factorial(int N)
Compute N factorial, N! = N*(N-1) * (N-2)...*3*2*1.
static vtkTypeInt64 Binomial(int m, int n)
The number of combinations of n objects from a pool of m objects (m>n).
static vtkTypeBool BoundsIsWithinOtherBounds(double bounds1[6], double bounds2[6], double delta[3])
Return true if first 3D bounds is within the second 3D bounds Bounds is x-min, x-max,...
static double Random()
Generate pseudo-random numbers distributed according to the uniform distribution between 0....
static void Identity3x3(float A[3][3])
Set A to the identity matrix.
static double GaussianAmplitude(const double variance, const double distanceFromMean)
Compute the amplitude of a Gaussian function with mean=0 and specified variance.
static void SingularValueDecomposition3x3(const float A[3][3], float U[3][3], float w[3], float VT[3][3])
Perform singular value decomposition on a 3x3 matrix.
static double Nan()
Special IEEE-754 number used to represent Not-A-Number (Nan).
static void Perpendiculars(const float v1[3], float v2[3], float v3[3], double theta)
static int GetAdjustedScalarRange(vtkDataArray *array, int comp, double range[2])
Get a vtkDataArray's scalar range for a given component.
static double Gaussian(double mean, double std)
Generate pseudo-random numbers distributed according to the Gaussian distribution with mean mean and ...
static bool IsFinite(double x)
Test if a number has finite value i.e.
static void LUSolveLinearSystem(double **A, int *index, double *x, int size)
Solve linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U ...
static void LUFactor3x3(float A[3][3], int index[3])
LU Factorization of a 3x3 matrix.
static void FreeCombination(int *combination)
Free the "iterator" array created by vtkMath::BeginCombination.
static double Random(double min, double max)
Generate pseudo-random numbers distributed according to the uniform distribution between min and max.
static void LabToXYZ(const double lab[3], double xyz[3])
Convert color from the CIE-L*ab system to CIE XYZ.
Definition: vtkMath.h:977
static double * RGBToXYZ(const double rgb[3])
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 AreBoundsInitialized(double bounds[6])
Are the bounds initialized?
Definition: vtkMath.h:1066
static double * LabToXYZ(const double lab[3])
static float Dot(const float a[3], const float b[3])
Dot product of two 3-vectors (float version).
Definition: vtkMath.h:383
static void Diagonalize3x3(const float A[3][3], float w[3], float V[3][3])
Diagonalize a symmetric 3x3 matrix and return the eigenvalues in w and the eigenvectors in the column...
static void LabToXYZ(double L, double a, double b, double *x, double *y, double *z)
static bool ProjectVector(const float a[3], const float b[3], float projection[3])
Compute the projection of vector a on vector b and return it in projection[3].
static void Cross(const float a[3], const float b[3], float c[3])
Cross product of two 3-vectors.
Definition: vtkMath.h:1377
static void MultiplyScalar2D(float a[2], float s)
Multiplies a 2-vector by a scalar (float version).
Definition: vtkMath.h:357
static void HSVToRGB(const float hsv[3], float rgb[3])
Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue).
Definition: vtkMath.h:963
static double Determinant2x2(const double c1[2], const double c2[2])
Definition: vtkMath.h:603
static T Max(const T &a, const T &b)
Returns the maximum of the two arugments provided.
Definition: vtkMath.h:1268
static void Outer2D(const double x[2], const double y[2], double A[2][2])
Outer product of two 2-vectors (float version).
Definition: vtkMath.h:556
static void RandomSeed(int s)
Initialize seed value.
static double Normalize2D(double v[2])
Normalize (in place) a 2-vector.
static double NegInf()
Special IEEE-754 number used to represent negative infinity.
static void MultiplyScalar2D(double a[2], double s)
Multiplies a 2-vector by a scalar (double version).
Definition: vtkMath.h:375
static void LabToRGB(double L, double a, double b, double *red, double *green, double *blue)
static double Gaussian()
Generate pseudo-random numbers distributed according to the standard normal distribution.
static void Multiply3x3(const float A[3][3], const float in[3], float out[3])
Multiply a vector by a 3x3 matrix.
static double * HSVToRGB(double h, double s, double v)
static int Ceil(double x)
Rounds a double to the nearest integer not less than itself.
Definition: vtkMath.h:1253
static void HSVToRGB(const double hsv[3], double rgb[3])
Definition: vtkMath.h:968
static double Inf()
Special IEEE-754 number used to represent positive infinity.
static double GaussianAmplitude(const double mean, const double variance, const double position)
Compute the amplitude of a Gaussian function with specified mean and variance.
static float Normalize2D(float v[2])
Normalize (in place) a 2-vector.
static void RGBToXYZ(const double rgb[3], double xyz[3])
Convert color from the RGB system to CIE XYZ.
Definition: vtkMath.h:1013
static float Distance2BetweenPoints(const float p1[3], const float p2[3])
Compute distance squared between two points p1 and p2.
Definition: vtkMath.h:1358
static int NearestPowerOfTwo(int x)
Compute the nearest power of two that is not less than x.
Definition: vtkMath.h:1230
static void HSVToRGB(double h, double s, double v, double *r, double *g, double *b)
static void SingularValueDecomposition3x3(const double A[3][3], double U[3][3], double w[3], double VT[3][3])
static void Invert3x3(const double A[3][3], double AI[3][3])
static void HSVToRGB(float h, float s, float v, float *r, float *g, float *b)
static void MultiplyQuaternion(const double q1[4], const double q2[4], double q[4])
static int JacobiN(float **a, int n, float *w, float **v)
JacobiN iteration for the solution of eigenvectors/eigenvalues of a nxn real symmetric matrix.
static double * LabToRGB(const double lab[3])
static void LUSolve3x3(const float A[3][3], const int index[3], float x[3])
LU back substitution for a 3x3 matrix.
static int GetSeed()
Return the current seed used by the random number generator.
static float RadiansFromDegrees(float degrees)
Convert degrees into radians.
Definition: vtkMath.h:1199
static vtkTypeBool PointIsWithinBounds(double point[3], double bounds[6], double delta[3])
Return true if point is within the given 3D bounds Bounds is x-min, x-max, y-min, y-max,...
static void MultiplyMatrix(double **A, double **B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double **C)
General matrix multiplication.
static void Add(const float a[3], const float b[3], float c[3])
Addition of two 3-vectors (float version).
Definition: vtkMath.h:315
static int CeilLog2(vtkTypeUInt64 x)
Gives the exponent of the lowest power of two not less than x.
static void Outer(const float a[3], const float b[3], float C[3][3])
Outer product of two 3-vectors (float version).
Definition: vtkMath.h:395
static double Pi()
A mathematical constant.
Definition: vtkMath.h:100
static vtkTypeBool ExtentIsWithinOtherExtent(int extent1[6], int extent2[6])
Return true if first 3D extent is within second 3D extent Extent is x-min, x-max, y-min,...
static bool ProjectVector2D(const double a[2], const double b[2], double projection[2])
static double * RGBToLab(const double rgb[3])
static int InvertMatrix(double **A, double **AI, int size)
Invert input square matrix A into matrix AI.
static int SolveLeastSquares(int numberOfSamples, double **xt, int xOrder, double **yt, int yOrder, double **mt, int checkHomogeneous=1)
Solves for the least squares best fit matrix for the equation X'M' = Y'.
static int NextCombination(int m, int n, int *combination)
Given m, n, and a valid combination of n integers in the range [0,m[, this function alters the intege...
static double GaussianWeight(const double variance, const double distanceFromMean)
Compute the amplitude of an unnormalized Gaussian function with mean=0 and specified variance.
static void Subtract(const double a[3], const double b[3], double c[3])
Subtraction of two 3-vectors (double version).
Definition: vtkMath.h:339
static vtkMath * New()
static void Orthogonalize3x3(const double A[3][3], double B[3][3])
static void XYZToRGB(const double xyz[3], double rgb[3])
Convert color from the CIE XYZ system to RGB.
Definition: vtkMath.h:1001
static double * RGBToHSV(const double rgb[3])
static double ClampAndNormalizeValue(double value, const double range[2])
Clamp a value against a range and then normalized it between 0 and 1.
Definition: vtkMath.h:1477
static void MultiplyScalar(double a[3], double s)
Multiplies a 3-vector by a scalar (double version).
Definition: vtkMath.h:366
static int SolveHomogeneousLeastSquares(int numberOfSamples, double **xt, int xOrder, double **mt)
Solves for the least squares best fit matrix for the homogeneous equation X'M' = 0'.
static double Dot2D(const double x[2], const double y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:537
static void LinearSolve3x3(const float A[3][3], const float x[3], float y[3])
Solve Ay = x for y and place the result in y.
static vtkTypeBool IsNan(double x)
Test if a number is equal to the special floating point value Not-A-Number (Nan).
static void Diagonalize3x3(const double A[3][3], double w[3], double V[3][3])
~vtkMath() override
Definition: vtkMath.h:1190
static void RGBToLab(const double rgb[3], double lab[3])
Convert color from the RGB system to CIE-L*ab.
Definition: vtkMath.h:1028
static int Floor(double x)
Rounds a double to the nearest integer not greater than itself.
Definition: vtkMath.h:1244
static double * XYZToLab(const double xyz[3])
static double Determinant2x2(double a, double b, double c, double d)
Calculate the determinant of a 2x2 matrix: | a b | | c d |.
Definition: vtkMath.h:601
static double EstimateMatrixCondition(double **A, int size)
Estimate the condition number of a LU factored matrix.
static void RGBToHSV(const double rgb[3], double hsv[3])
Definition: vtkMath.h:950
static double AngleBetweenVectors(const double v1[3], const double v2[3])
Compute angle in radians between two vectors.
static float DegreesFromRadians(float radians)
Convert radians into degrees.
Definition: vtkMath.h:1211
static float Determinant2x2(const float c1[2], const float c2[2])
Compute determinant of 2x2 matrix.
Definition: vtkMath.h:594
static int Round(double f)
Definition: vtkMath.h:123
static vtkTypeBool IsInf(double x)
Test if a number is equal to the special floating point value infinity.
static void UninitializeBounds(double bounds[6])
Set the bounds to an uninitialized state.
Definition: vtkMath.h:1052
static void RGBToHSV(double r, double g, double b, double *h, double *s, double *v)
static void Outer(const double a[3], const double b[3], double C[3][3])
Outer product of two 3-vectors (double-precision version).
Definition: vtkMath.h:403
static 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-precision version).
Definition: vtkMath.h:437
static void RoundDoubleToIntegralIfNecessary(double val, OutT *ret)
Round a double to type OutT if OutT is integral, otherwise simply clamp the value to the output range...
Definition: vtkMath.h:131
static int InvertMatrix(double **A, double **AI, int size, int *tmp1Size, double *tmp2Size)
Thread safe version of InvertMatrix method.
static void Matrix3x3ToQuaternion(const float A[3][3], float quat[4])
Convert a 3x3 matrix into a quaternion.
static bool IsPowerOfTwo(vtkTypeUInt64 x)
Returns true if integer is a power of two.
Definition: vtkMath.h:1223
static void Invert3x3(const float A[3][3], float AI[3][3])
Invert a 3x3 matrix.
static float Normalize(float v[3])
Normalize (in place) a 3-vector.
Definition: vtkMath.h:1274
static void Transpose3x3(const double A[3][3], double AT[3][3])
static float Dot2D(const float x[2], const float y[2])
Dot product of two 2-vectors.
Definition: vtkMath.h:531
static void RGBToHSV(const float rgb[3], float hsv[3])
Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value).
Definition: vtkMath.h:945
static int LUFactorLinearSystem(double **A, int *index, int size)
Factor linear equations Ax = b using LU decomposition into the form A = LU where L is a unit lower tr...
static void Orthogonalize3x3(const float A[3][3], float B[3][3])
Orthogonalize a 3x3 matrix and put the result in B.
static bool ProjectVector2D(const float a[2], const float b[2], float projection[2])
Compute the projection of 2D vector a on 2D vector b and returns the result in projection[2].
static int Jacobi(float **a, float *w, float **v)
Jacobi iteration for the solution of eigenvectors/eigenvalues of a 3x3 real symmetric matrix.
static void LabToRGB(const double lab[3], double rgb[3])
Convert color from the CIE-L*ab system to RGB.
Definition: vtkMath.h:1040
static float Norm2D(const float x[2])
Compute the norm of a 2-vector.
Definition: vtkMath.h:570
static double Determinant3x3(float A[3][3])
Return the determinant of a 3x3 matrix.
Definition: vtkMath.h:1405
static double GaussianWeight(const double mean, const double variance, const double position)
Compute the amplitude of an unnormalized Gaussian function with specified mean and variance.
static void LinearSolve3x3(const double A[3][3], const double x[3], double y[3])
static void XYZToLab(double x, double y, double z, double *L, double *a, double *b)
static void MultiplyScalar(float a[3], float s)
Multiplies a 3-vector by a scalar (float version).
Definition: vtkMath.h:348
static T Min(const T &a, const T &b)
Returns the minimum of the two arguments provided.
Definition: vtkMath.h:1261
static int SolveLinearSystem(double **A, double *x, int size)
Solve linear equations Ax = b using Crout's method.
static void QuaternionToMatrix3x3(const double quat[4], double A[3][3])
static void Perpendiculars(const double v1[3], double v2[3], double v3[3], double theta)
Given a unit vector v1, find two unit vectors v2 and v3 such that v1 cross v2 = v3 (i....
static int LUFactorLinearSystem(double **A, int *index, int size, double *tmpSize)
Thread safe version of LUFactorLinearSystem method.
static T ClampValue(const T &value, const T &min, const T &max)
Clamp some value against a range, return the result.
Definition: vtkMath.h:1418
static int JacobiN(double **a, int n, double *w, double **v)
static double * XYZToRGB(const double xyz[3])
static void Identity3x3(double A[3][3])
static void LUFactor3x3(double A[3][3], int index[3])
static void RGBToLab(double red, double green, double blue, double *L, double *a, double *b)
static void MultiplyQuaternion(const float q1[4], const float q2[4], float q[4])
Multiply two quaternions.
static void QuaternionToMatrix3x3(const float quat[4], float A[3][3])
Convert a quaternion to a 3x3 rotation matrix.
vtkMath()
Definition: vtkMath.h:1189
static void ClampValues(const double *values, int nb_values, const double range[2], double *clamped_values)
static double * HSVToRGB(const double hsv[3])
static void Transpose3x3(const float A[3][3], float AT[3][3])
Transpose a 3x3 matrix.
static void ClampValues(double *values, int nb_values, const double range[2])
Park and Miller Sequence of pseudo random numbers.
abstract base class for most VTK objects
Definition: vtkObject.h:60
represent and manipulate 3D points
Definition: vtkPoints.h:40
@ point
Definition: vtkX3D.h:236
@ value
Definition: vtkX3D.h:220
@ scale
Definition: vtkX3D.h:229
@ range
Definition: vtkX3D.h:238
@ center
Definition: vtkX3D.h:230
@ position
Definition: vtkX3D.h:261
@ size
Definition: vtkX3D.h:253
@ index
Definition: vtkX3D.h:246
void RoundDoubleToIntegralIfNecessary(double val, OutT *ret)
Definition: vtkMath.h:1519
Template defining traits of native types used by VTK.
Definition: vtkTypeTraits.h:32
int vtkTypeBool
Definition: vtkABI.h:69
double vtkDeterminant3x3(T A[3][3])
Definition: vtkMath.h:1397
#define max(a, b)