vtkMath Class Reference

#include <vtkMath.h>

Inheritance diagram for vtkMath:

Inheritance graph
[legend]
Collaboration diagram for vtkMath:

Collaboration graph
[legend]

List of all members.


Detailed Description

performs common math operations

vtkMath provides methods to perform common math operations. These include providing constants such as Pi; conversion from degrees to radians; vector operations such as dot and cross products and vector norm; matrix determinant for 2x2 and 3x3 matrices; univariate polynomial solvers; and for random number generation (for backward compatibility only).

See also:
vtkMinimalStandardRandomSequence, vtkBoxMuellerRandomSequence
Examples:
vtkMath (Examples)
Tests:
vtkMath (Tests)

Definition at line 65 of file vtkMath.h.


Public Types

typedef vtkObject Superclass

Public Member Functions

virtual const char * GetClassName ()
virtual int IsA (const char *type)
void PrintSelf (ostream &os, vtkIndent indent)

Static Public Member Functions

static vtkMathNew ()
static int IsTypeOf (const char *type)
static vtkMathSafeDownCast (vtkObject *o)
static float Pi ()
static double DoubleTwoPi ()
static double DoublePi ()
static int Floor (double x)
static int Ceil (double x)
static vtkTypeInt64 Factorial (int N)
static vtkTypeInt64 Binomial (int m, int n)
static int * BeginCombination (int m, int n)
static int NextCombination (int m, int n, int *combination)
static void FreeCombination (int *combination)
static void RandomSeed (int s)
static int GetSeed ()
static double Random ()
static double Random (double min, double max)
static double Gaussian ()
static double Gaussian (double mean, double std)
static void Cross (const float x[3], const float y[3], float z[3])
static void Cross (const double x[3], const double y[3], double z[3])
static float Normalize (float x[3])
static double Normalize (double x[3])
static float Distance2BetweenPoints (const float x[3], const float y[3])
static double Distance2BetweenPoints (const double x[3], const double y[3])
static double GaussianAmplitude (const double variance, const double distanceFromMean)
static double GaussianAmplitude (const double mean, const double variance, const double position)
static double GaussianWeight (const double variance, const double distanceFromMean)
static double GaussianWeight (const double mean, const double variance, const double position)
static float Normalize2D (float x[2])
static double Normalize2D (double x[2])
static int SolveLinearSystem (double **A, double *x, int size)
static int InvertMatrix (double **A, double **AI, int size)
static int LUFactorLinearSystem (double **A, int *index, int size)
static double EstimateMatrixCondition (double **A, int size)
static double * SolveCubic (double c0, double c1, double c2, double c3)
static double * SolveQuadratic (double c0, double c1, double c2)
static double * SolveLinear (double c0, double c1)
static int SolveQuadratic (double *c, double *r, int *m)
static int SolveLinear (double c0, double c1, double *r1, int *num_roots)
static int ExtentIsWithinOtherExtent (int extent1[6], int extent2[6])
static int BoundsIsWithinOtherBounds (double bounds1[6], double bounds2[6], double delta[3])
static int PointIsWithinBounds (double point[3], double bounds[6], double delta[3])
static double Solve3PointCircle (const double p1[3], const double p2[3], const double p3[3], double center[3])
static double Inf ()
static double NegInf ()
static double Nan ()
static int IsInf (double x)
static int IsNan (double x)
static float RadiansFromDegrees (float degrees)
static double RadiansFromDegrees (double degrees)
static float DegreesFromRadians (float radians)
static double DegreesFromRadians (double radians)
static int Round (float f)
static int Round (double f)
static void Add (const float a[3], const float b[3], float c[3])
static void Add (const double a[3], const double b[3], double c[3])
static void Subtract (const float a[3], const float b[3], float c[3])
static void Subtract (const double a[3], const double b[3], double c[3])
static void MultiplyScalar (float a[3], float s)
static void MultiplyScalar2D (float a[2], float s)
static void MultiplyScalar (double a[3], double s)
static void MultiplyScalar2D (double a[2], double s)
static float Dot (const float x[3], const float y[3])
static double Dot (const double x[3], const double y[3])
static void Outer (const float x[3], const float y[3], float A[3][3])
static void Outer (const double x[3], const double y[3], double A[3][3])
static float Norm (const float *x, int n)
static double Norm (const double *x, int n)
static float Norm (const float x[3])
static double Norm (const double x[3])
static void Perpendiculars (const double x[3], double y[3], double z[3], double theta)
static void Perpendiculars (const float x[3], float y[3], float z[3], double theta)
static bool ProjectVector (const float a[3], const float b[3], float projection[3])
static bool ProjectVector (const double a[3], const double b[3], double projection[3])
static bool ProjectVector2D (const float a[2], const float b[2], float projection[2])
static bool ProjectVector2D (const double a[2], const double b[2], double projection[2])
static float Dot2D (const float x[2], const float y[2])
static double Dot2D (const double x[2], const double y[2])
static void Outer2D (const float x[2], const float y[2], float A[2][2])
static void Outer2D (const double x[2], const double y[2], double A[2][2])
static float Norm2D (const float x[2])
static double Norm2D (const double x[2])
static float Determinant2x2 (const float c1[2], const float c2[2])
static double Determinant2x2 (double a, double b, double c, double d)
static double Determinant2x2 (const double c1[2], const double c2[2])
static void LUFactor3x3 (float A[3][3], int index[3])
static void LUFactor3x3 (double A[3][3], int index[3])
static void LUSolve3x3 (const float A[3][3], const int index[3], float x[3])
static void LUSolve3x3 (const double A[3][3], const int index[3], double x[3])
static void LinearSolve3x3 (const float A[3][3], const float x[3], float y[3])
static void LinearSolve3x3 (const double A[3][3], const double x[3], double y[3])
static void Multiply3x3 (const float A[3][3], const float in[3], float out[3])
static void Multiply3x3 (const double A[3][3], const double in[3], double out[3])
static void Multiply3x3 (const float A[3][3], const float B[3][3], float C[3][3])
static void Multiply3x3 (const double A[3][3], const double B[3][3], double C[3][3])
static void MultiplyMatrix (const double **A, const double **B, unsigned int rowA, unsigned int colA, unsigned int rowB, unsigned int colB, double **C)
static void Transpose3x3 (const float A[3][3], float AT[3][3])
static void Transpose3x3 (const double A[3][3], double AT[3][3])
static void Invert3x3 (const float A[3][3], float AI[3][3])
static void Invert3x3 (const double A[3][3], double AI[3][3])
static void Identity3x3 (float A[3][3])
static void Identity3x3 (double A[3][3])
static double Determinant3x3 (float A[3][3])
static double Determinant3x3 (double A[3][3])
static float Determinant3x3 (const float c1[3], const float c2[3], const float c3[3])
static double Determinant3x3 (const double c1[3], const double c2[3], const double c3[3])
static double Determinant3x3 (double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3)
static void QuaternionToMatrix3x3 (const float quat[4], float A[3][3])
static void QuaternionToMatrix3x3 (const double quat[4], double A[3][3])
static void Matrix3x3ToQuaternion (const float A[3][3], float quat[4])
static void Matrix3x3ToQuaternion (const double A[3][3], double quat[4])
static void Orthogonalize3x3 (const float A[3][3], float B[3][3])
static void Orthogonalize3x3 (const double A[3][3], double B[3][3])
static void Diagonalize3x3 (const float A[3][3], float w[3], float V[3][3])
static void Diagonalize3x3 (const double A[3][3], double w[3], double V[3][3])
static void SingularValueDecomposition3x3 (const float A[3][3], float U[3][3], float w[3], float VT[3][3])
static void SingularValueDecomposition3x3 (const double A[3][3], double U[3][3], double w[3], double VT[3][3])
static int InvertMatrix (double **A, double **AI, int size, int *tmp1Size, double *tmp2Size)
static int LUFactorLinearSystem (double **A, int *index, int size, double *tmpSize)
static void LUSolveLinearSystem (double **A, int *index, double *x, int size)
static int Jacobi (float **a, float *w, float **v)
static int Jacobi (double **a, double *w, double **v)
static int JacobiN (float **a, int n, float *w, float **v)
static int JacobiN (double **a, int n, double *w, double **v)
static int SolveCubic (double c0, double c1, double c2, double c3, double *r1, double *r2, double *r3, int *num_roots)
static int SolveQuadratic (double c0, double c1, double c2, double *r1, double *r2, int *num_roots)
static int SolveHomogeneousLeastSquares (int numberOfSamples, double **xt, int xOrder, double **mt)
static int SolveLeastSquares (int numberOfSamples, double **xt, int xOrder, double **yt, int yOrder, double **mt, int checkHomogeneous=1)
static void RGBToHSV (const float rgb[3], float hsv[3])
static void RGBToHSV (float r, float g, float b, float *h, float *s, float *v)
static double * RGBToHSV (const double rgb[3])
static double * RGBToHSV (double r, double g, double b)
static void RGBToHSV (const double rgb[3], double hsv[3])
static void RGBToHSV (double r, double g, double b, double *h, double *s, double *v)
static void HSVToRGB (const float hsv[3], float rgb[3])
static void HSVToRGB (float h, float s, float v, float *r, float *g, float *b)
static double * HSVToRGB (const double hsv[3])
static double * HSVToRGB (double h, double s, double v)
static void HSVToRGB (const double hsv[3], double rgb[3])
static void HSVToRGB (double h, double s, double v, double *r, double *g, double *b)
static void LabToXYZ (const double lab[3], double xyz[3])
static void LabToXYZ (double L, double a, double b, double *x, double *y, double *z)
static double * LabToXYZ (const double lab[3])
static void XYZToLab (const double xyz[3], double lab[3])
static void XYZToLab (double x, double y, double z, double *L, double *a, double *b)
static double * XYZToLab (const double xyz[3])
static void XYZToRGB (const double xyz[3], double rgb[3])
static void XYZToRGB (double x, double y, double z, double *r, double *g, double *b)
static double * XYZToRGB (const double xyz[3])
static void RGBToXYZ (const double rgb[3], double xyz[3])
static void RGBToXYZ (double r, double g, double b, double *x, double *y, double *z)
static double * RGBToXYZ (const double rgb[3])
static void RGBToLab (const double rgb[3], double lab[3])
static void RGBToLab (double red, double green, double blue, double *L, double *a, double *b)
static double * RGBToLab (const double rgb[3])
static void LabToRGB (const double lab[3], double rgb[3])
static void LabToRGB (double L, double a, double b, double *red, double *green, double *blue)
static double * LabToRGB (const double lab[3])
static void UninitializeBounds (double bounds[6])
static int AreBoundsInitialized (double bounds[6])
static void ClampValue (double *value, const double range[2])
static void ClampValue (double value, const double range[2], double *clamped_value)
static void ClampValues (double *values, int nb_values, const double range[2])
static void ClampValues (const double *values, int nb_values, const double range[2], double *clamped_values)
static double ClampAndNormalizeValue (double value, const double range[2])
static int GetScalarTypeFittingRange (double range_min, double range_max, double scale=1.0, double shift=0.0)
static int GetAdjustedScalarRange (vtkDataArray *array, int comp, double range[2])

Protected Member Functions

 vtkMath ()
 ~vtkMath ()

Static Protected Attributes

static vtkMathInternal Internal

Member Typedef Documentation

Reimplemented from vtkObject.

Definition at line 69 of file vtkMath.h.


Constructor & Destructor Documentation

vtkMath::vtkMath (  )  [inline, protected]

Definition at line 969 of file vtkMath.h.

vtkMath::~vtkMath (  )  [inline, protected]

Definition at line 970 of file vtkMath.h.


Member Function Documentation

static vtkMath* vtkMath::New (  )  [static]

Create an object with Debug turned off, modified time initialized to zero, and reference counting on.

Reimplemented from vtkObject.

virtual const char* vtkMath::GetClassName (  )  [virtual]

Reimplemented from vtkObject.

static int vtkMath::IsTypeOf ( const char *  name  )  [static]

Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h.

Reimplemented from vtkObject.

virtual int vtkMath::IsA ( const char *  name  )  [virtual]

Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h.

Reimplemented from vtkObject.

static vtkMath* vtkMath::SafeDownCast ( vtkObject o  )  [static]

Reimplemented from vtkObject.

void vtkMath::PrintSelf ( ostream &  os,
vtkIndent  indent 
) [virtual]

Methods invoked by print to print information about the object including superclasses. Typically not called by the user (use Print() instead) but used in the hierarchical print process to combine the output of several classes.

Reimplemented from vtkObject.

static float vtkMath::Pi (  )  [inline, static]

A mathematical constant. This version is 3.14159265358979f.

Definition at line 73 of file vtkMath.h.

static double vtkMath::DoubleTwoPi (  )  [inline, static]

A mathematical constant (double-precision version). This version is 6.283185307179586.

Definition at line 77 of file vtkMath.h.

static double vtkMath::DoublePi (  )  [inline, static]

A mathematical constant (double-precision version). This version is 3.1415926535897932384626.

Definition at line 81 of file vtkMath.h.

float vtkMath::RadiansFromDegrees ( float  degrees  )  [inline, static]

Convert degrees into radians

Definition at line 979 of file vtkMath.h.

double vtkMath::RadiansFromDegrees ( double  degrees  )  [inline, static]

Convert degrees into radians

Definition at line 985 of file vtkMath.h.

float vtkMath::DegreesFromRadians ( float  radians  )  [inline, static]

Convert radians into degrees

Definition at line 991 of file vtkMath.h.

double vtkMath::DegreesFromRadians ( double  radians  )  [inline, static]

Convert radians into degrees

Definition at line 997 of file vtkMath.h.

static int vtkMath::Round ( float  f  )  [inline, static]

Rounds a float to the nearest integer.

Definition at line 97 of file vtkMath.h.

static int vtkMath::Round ( double  f  )  [inline, static]

Rounds a float to the nearest integer.

Definition at line 99 of file vtkMath.h.

int vtkMath::Floor ( double  x  )  [inline, static]

Rounds a double to the nearest integer not greater than itself. This is faster than floor() but provides undefined output on overflow.

Definition at line 1014 of file vtkMath.h.

int vtkMath::Ceil ( double  x  )  [inline, static]

Rounds a double to the nearest integer not less than itself. This is faster than ceil() but provides undefined output on overflow.

Definition at line 1023 of file vtkMath.h.

vtkTypeInt64 vtkMath::Factorial ( int  N  )  [inline, static]

Compute N factorial, N! = N*(N-1) * (N-2)...*3*2*1. 0! is taken to be 1.

Definition at line 1003 of file vtkMath.h.

static vtkTypeInt64 vtkMath::Binomial ( int  m,
int  n 
) [static]

The number of combinations of n objects from a pool of m objects (m>n). This is commonly known as "m choose n" and sometimes denoted $_mC_n$ or $\left(\begin{array}{c}m \\ n\end{array}\right)$.

static int* vtkMath::BeginCombination ( int  m,
int  n 
) [static]

Start iterating over "m choose n" objects. This function returns an array of n integers, each from 0 to m-1. These integers represent the n items chosen from the set [0,m[. You are responsible for calling vtkMath::FreeCombination() once the iterator is no longer needed. Warning: this gets large very quickly, especially when n nears m/2! (Hint: think of Pascal's triangle.)

static int vtkMath::NextCombination ( int  m,
int  n,
int *  combination 
) [static]

Given m, n, and a valid combination of n integers in the range [0,m[, this function alters the integers into the next combination in a sequence of all combinations of n items from a pool of m. If the combination is the last item in the sequence on input, then combination is unaltered and 0 is returned. Otherwise, 1 is returned and combination is updated.

static void vtkMath::FreeCombination ( int *  combination  )  [static]

Free the "iterator" array created by vtkMath::BeginCombination.

static void vtkMath::RandomSeed ( int  s  )  [static]

Initialize seed value. NOTE: Random() has the bad property that the first random number returned after RandomSeed() is called is proportional to the seed value! To help solve this, call RandomSeed() a few times inside seed. This doesn't ruin the repeatability of Random(). DON'T USE Random(), RandomSeed(), GetSeed(), Gaussian() THIS IS STATIC SO THIS IS PRONE TO ERRORS (SPECIALLY FOR REGRESSION TESTS) THIS IS HERE FOR BACKWARD COMPATIBILITY ONLY. Instead, for a sequence of random numbers with a uniform distribution create a vtkMinimalStandardRandomSequence object. For a sequence of random numbers with a gaussian/normal distribution create a vtkBoxMuellerRandomSequence object.

static int vtkMath::GetSeed (  )  [static]

Return the current seed used by the random number generator. DON'T USE Random(), RandomSeed(), GetSeed(), Gaussian() THIS IS STATIC SO THIS IS PRONE TO ERRORS (SPECIALLY FOR REGRESSION TESTS) THIS IS HERE FOR BACKWARD COMPATIBILITY ONLY. Instead, for a sequence of random numbers with a uniform distribution create a vtkMinimalStandardRandomSequence object. For a sequence of random numbers with a gaussian/normal distribution create a vtkBoxMuellerRandomSequence object.

static double vtkMath::Random (  )  [static]

Generate pseudo-random numbers distributed according to the uniform distribution between 0.0 and 1.0. This is used to provide portability across different systems. DON'T USE Random(), RandomSeed(), GetSeed(), Gaussian() THIS IS STATIC SO THIS IS PRONE TO ERRORS (SPECIALLY FOR REGRESSION TESTS) THIS IS HERE FOR BACKWARD COMPATIBILITY ONLY. Instead, for a sequence of random numbers with a uniform distribution create a vtkMinimalStandardRandomSequence object. For a sequence of random numbers with a gaussian/normal distribution create a vtkBoxMuellerRandomSequence object.

static double vtkMath::Random ( double  min,
double  max 
) [static]

Generate pseudo-random numbers distributed according to the uniform distribution between min and max. DON'T USE Random(), RandomSeed(), GetSeed(), Gaussian() THIS IS STATIC SO THIS IS PRONE TO ERRORS (SPECIALLY FOR REGRESSION TESTS) THIS IS HERE FOR BACKWARD COMPATIBILITY ONLY. Instead, for a sequence of random numbers with a uniform distribution create a vtkMinimalStandardRandomSequence object. For a sequence of random numbers with a gaussian/normal distribution create a vtkBoxMuellerRandomSequence object.

static double vtkMath::Gaussian (  )  [static]

Generate pseudo-random numbers distributed according to the standard normal distribution. DON'T USE Random(), RandomSeed(), GetSeed(), Gaussian() THIS IS STATIC SO THIS IS PRONE TO ERRORS (SPECIALLY FOR REGRESSION TESTS) THIS IS HERE FOR BACKWARD COMPATIBILITY ONLY. Instead, for a sequence of random numbers with a uniform distribution create a vtkMinimalStandardRandomSequence object. For a sequence of random numbers with a gaussian/normal distribution create a vtkBoxMuellerRandomSequence object.

static double vtkMath::Gaussian ( double  mean,
double  std 
) [static]

Generate pseudo-random numbers distributed according to the Gaussian distribution with mean mean and standard deviation std. DON'T USE Random(), RandomSeed(), GetSeed(), Gaussian() THIS IS STATIC SO THIS IS PRONE TO ERRORS (SPECIALLY FOR REGRESSION TESTS) THIS IS HERE FOR BACKWARD COMPATIBILITY ONLY. Instead, for a sequence of random numbers with a uniform distribution create a vtkMinimalStandardRandomSequence object. For a sequence of random numbers with a gaussian/normal distribution create a vtkBoxMuellerRandomSequence object.

static void vtkMath::Add ( const float  a[3],
const float  b[3],
float  c[3] 
) [inline, static]

Addition of two 3-vectors (float version). Result is stored in c.

Definition at line 206 of file vtkMath.h.

static void vtkMath::Add ( const double  a[3],
const double  b[3],
double  c[3] 
) [inline, static]

Addition of two 3-vectors (double version). Result is stored in c.

Definition at line 214 of file vtkMath.h.

static void vtkMath::Subtract ( const float  a[3],
const float  b[3],
float  c[3] 
) [inline, static]

Subtraction of two 3-vectors (float version). Result is stored in c according to c = a - b.

Definition at line 223 of file vtkMath.h.

static void vtkMath::Subtract ( const double  a[3],
const double  b[3],
double  c[3] 
) [inline, static]

Subtraction of two 3-vectors (double version). Result is stored in c according to c = a - b.

Definition at line 232 of file vtkMath.h.

static void vtkMath::MultiplyScalar ( float  a[3],
float  s 
) [inline, static]

Multiplies a 3-vector by a scalar (float version). This modifies the input 3-vector.

Definition at line 241 of file vtkMath.h.

static void vtkMath::MultiplyScalar2D ( float  a[2],
float  s 
) [inline, static]

Multiplies a 2-vector by a scalar (float version). This modifies the input 2-vector.

Definition at line 250 of file vtkMath.h.

static void vtkMath::MultiplyScalar ( double  a[3],
double  s 
) [inline, static]

Multiplies a 3-vector by a scalar (double version). This modifies the input 3-vector.

Definition at line 259 of file vtkMath.h.

static void vtkMath::MultiplyScalar2D ( double  a[2],
double  s 
) [inline, static]

Multiplies a 2-vector by a scalar (double version). This modifies the input 2-vector.

Definition at line 268 of file vtkMath.h.

static float vtkMath::Dot ( const float  x[3],
const float  y[3] 
) [inline, static]

Dot product of two 3-vectors (float version).

Definition at line 276 of file vtkMath.h.

static double vtkMath::Dot ( const double  x[3],
const double  y[3] 
) [inline, static]

Dot product of two 3-vectors (double-precision version).

Definition at line 282 of file vtkMath.h.

static void vtkMath::Outer ( const float  x[3],
const float  y[3],
float  A[3][3] 
) [inline, static]

Outer product of two 3-vectors (float version).

Definition at line 288 of file vtkMath.h.

static void vtkMath::Outer ( const double  x[3],
const double  y[3],
double  A[3][3] 
) [inline, static]

Outer product of two 3-vectors (float version).

Definition at line 295 of file vtkMath.h.

void vtkMath::Cross ( const float  x[3],
const float  y[3],
float  z[3] 
) [inline, static]

Cross product of two 3-vectors. Result (a x b) is stored in z.

Definition at line 1135 of file vtkMath.h.

void vtkMath::Cross ( const double  x[3],
const double  y[3],
double  z[3] 
) [inline, static]

Cross product of two 3-vectors. Result (a x b) is stored in z. (double-precision version)

Definition at line 1145 of file vtkMath.h.

static float vtkMath::Norm ( const float *  x,
int  n 
) [static]

Compute the norm of n-vector. x is the vector, n is its length.

static double vtkMath::Norm ( const double *  x,
int  n 
) [static]

Compute the norm of n-vector. x is the vector, n is its length.

static float vtkMath::Norm ( const float  x[3]  )  [inline, static]

Compute the norm of 3-vector.

Definition at line 317 of file vtkMath.h.

static double vtkMath::Norm ( const double  x[3]  )  [inline, static]

Compute the norm of 3-vector (double-precision version).

Definition at line 323 of file vtkMath.h.

float vtkMath::Normalize ( float  x[3]  )  [inline, static]

Normalize (in place) a 3-vector. Returns norm of vector.

Definition at line 1032 of file vtkMath.h.

double vtkMath::Normalize ( double  x[3]  )  [inline, static]

Normalize (in place) a 3-vector. Returns norm of vector (double-precision version).

Definition at line 1046 of file vtkMath.h.

static void vtkMath::Perpendiculars ( const double  x[3],
double  y[3],
double  z[3],
double  theta 
) [static]

Given a unit vector x, find two unit vectors y and z such that x cross y = z (i.e. the vectors are perpendicular to each other). There is an infinite number of such vectors, specify an angle theta to choose one set. If you want only one perpendicular vector, specify NULL for z.

static void vtkMath::Perpendiculars ( const float  x[3],
float  y[3],
float  z[3],
double  theta 
) [static]

Given a unit vector x, find two unit vectors y and z such that x cross y = z (i.e. the vectors are perpendicular to each other). There is an infinite number of such vectors, specify an angle theta to choose one set. If you want only one perpendicular vector, specify NULL for z.

static bool vtkMath::ProjectVector ( const float  a[3],
const float  b[3],
float  projection[3] 
) [static]

Compute the projection of vector a on vector b and return it in projection[3]. If b is a zero vector, the function returns false and 'projection' is invalid. Otherwise, it returns true.

static bool vtkMath::ProjectVector ( const double  a[3],
const double  b[3],
double  projection[3] 
) [static]

Compute the projection of vector a on vector b and return it in projection[3]. If b is a zero vector, the function returns false and 'projection' is invalid. Otherwise, it returns true.

static bool vtkMath::ProjectVector2D ( const float  a[2],
const float  b[2],
float  projection[2] 
) [static]

Compute the projection of 2D vector 'a' on 2D vector 'b' and returns the result in projection[2]. If b is a zero vector, the function returns false and 'projection' is invalid. Otherwise, it returns true.

static bool vtkMath::ProjectVector2D ( const double  a[2],
const double  b[2],
double  projection[2] 
) [static]

Compute the projection of 2D vector 'a' on 2D vector 'b' and returns the result in projection[2]. If b is a zero vector, the function returns false and 'projection' is invalid. Otherwise, it returns true.

float vtkMath::Distance2BetweenPoints ( const float  x[3],
const float  y[3] 
) [inline, static]

Compute distance squared between two points x and y.

Definition at line 1116 of file vtkMath.h.

double vtkMath::Distance2BetweenPoints ( const double  x[3],
const double  y[3] 
) [inline, static]

Compute distance squared between two points x and y(double precision version).

Definition at line 1125 of file vtkMath.h.

static double vtkMath::GaussianAmplitude ( const double  variance,
const double  distanceFromMean 
) [static]

Compute the amplitude of a Gaussian function with mean=0 and specified variance. That is, 1./(sqrt(2 Pi * variance)) * exp(-distanceFromMean^2/(2.*variance)).

static double vtkMath::GaussianAmplitude ( const double  mean,
const double  variance,
const double  position 
) [static]

Compute the amplitude of a Gaussian function with specified mean and variance. That is, 1./(sqrt(2 Pi * variance)) * exp(-(position - mean)^2/(2.*variance)).

static double vtkMath::GaussianWeight ( const double  variance,
const double  distanceFromMean 
) [static]

Compute the amplitude of an unnormalized Gaussian function with mean=0 and specified variance. That is, exp(-distanceFromMean^2/(2.*variance)). When distanceFromMean = 0, this function returns 1.

static double vtkMath::GaussianWeight ( const double  mean,
const double  variance,
const double  position 
) [static]

Compute the amplitude of an unnormalized Gaussian function with specified mean and variance. That is, exp(-(position - mean)^2/(2.*variance)). When the distance from 'position' to 'mean' is 0, this function returns 1.

static float vtkMath::Dot2D ( const float  x[2],
const float  y[2] 
) [inline, static]

Dot product of two 2-vectors.

Definition at line 394 of file vtkMath.h.

static double vtkMath::Dot2D ( const double  x[2],
const double  y[2] 
) [inline, static]

Dot product of two 2-vectors. (double-precision version).

Definition at line 400 of file vtkMath.h.

static void vtkMath::Outer2D ( const float  x[2],
const float  y[2],
float  A[2][2] 
) [inline, static]

Outer product of two 2-vectors (float version).

Definition at line 406 of file vtkMath.h.

static void vtkMath::Outer2D ( const double  x[2],
const double  y[2],
double  A[2][2] 
) [inline, static]

Outer product of two 2-vectors (float version).

Definition at line 418 of file vtkMath.h.

static float vtkMath::Norm2D ( const float  x[2]  )  [inline, static]

Compute the norm of a 2-vector.

Definition at line 432 of file vtkMath.h.

static double vtkMath::Norm2D ( const double  x[2]  )  [inline, static]

Compute the norm of a 2-vector. (double-precision version).

Definition at line 438 of file vtkMath.h.

static float vtkMath::Normalize2D ( float  x[2]  )  [static]

Normalize (in place) a 2-vector. Returns norm of vector.

static double vtkMath::Normalize2D ( double  x[2]  )  [static]

Normalize (in place) a 2-vector. Returns norm of vector. (double-precision version).

static float vtkMath::Determinant2x2 ( const float  c1[2],
const float  c2[2] 
) [inline, static]

Compute determinant of 2x2 matrix. Two columns of matrix are input.

Definition at line 451 of file vtkMath.h.

static double vtkMath::Determinant2x2 ( double  a,
double  b,
double  c,
double  d 
) [inline, static]

Calculate the determinant of a 2x2 matrix: | a b | | c d |

Definition at line 457 of file vtkMath.h.

static double vtkMath::Determinant2x2 ( const double  c1[2],
const double  c2[2] 
) [inline, static]

Calculate the determinant of a 2x2 matrix: | a b | | c d |

Definition at line 459 of file vtkMath.h.

static void vtkMath::LUFactor3x3 ( float  A[3][3],
int  index[3] 
) [static]

LU Factorization of a 3x3 matrix.

static void vtkMath::LUFactor3x3 ( double  A[3][3],
int  index[3] 
) [static]

LU Factorization of a 3x3 matrix.

static void vtkMath::LUSolve3x3 ( const float  A[3][3],
const int  index[3],
float  x[3] 
) [static]

LU back substitution for a 3x3 matrix.

static void vtkMath::LUSolve3x3 ( const double  A[3][3],
const int  index[3],
double  x[3] 
) [static]

LU back substitution for a 3x3 matrix.

static void vtkMath::LinearSolve3x3 ( const float  A[3][3],
const float  x[3],
float  y[3] 
) [static]

Solve Ay = x for y and place the result in y. The matrix A is destroyed in the process.

static void vtkMath::LinearSolve3x3 ( const double  A[3][3],
const double  x[3],
double  y[3] 
) [static]

Solve Ay = x for y and place the result in y. The matrix A is destroyed in the process.

static void vtkMath::Multiply3x3 ( const float  A[3][3],
const float  in[3],
float  out[3] 
) [static]

Multiply a vector by a 3x3 matrix. The result is placed in out.

static void vtkMath::Multiply3x3 ( const double  A[3][3],
const double  in[3],
double  out[3] 
) [static]

Multiply a vector by a 3x3 matrix. The result is placed in out.

static void vtkMath::Multiply3x3 ( const float  A[3][3],
const float  B[3][3],
float  C[3][3] 
) [static]

Multiply one 3x3 matrix by another according to C = AB.

static void vtkMath::Multiply3x3 ( const double  A[3][3],
const double  B[3][3],
double  C[3][3] 
) [static]

Multiply one 3x3 matrix by another according to C = AB.

static void vtkMath::MultiplyMatrix ( const double **  A,
const double **  B,
unsigned int  rowA,
unsigned int  colA,
unsigned int  rowB,
unsigned int  colB,
double **  C 
) [static]

General matrix multiplication. You must allocate output storage. colA == rowB and matrix C is rowA x colB

static void vtkMath::Transpose3x3 ( const float  A[3][3],
float  AT[3][3] 
) [static]

Transpose a 3x3 matrix. The input matrix is A. The output is stored in AT.

static void vtkMath::Transpose3x3 ( const double  A[3][3],
double  AT[3][3] 
) [static]

Transpose a 3x3 matrix. The input matrix is A. The output is stored in AT.

static void vtkMath::Invert3x3 ( const float  A[3][3],
float  AI[3][3] 
) [static]

Invert a 3x3 matrix. The input matrix is A. The output is stored in AI.

static void vtkMath::Invert3x3 ( const double  A[3][3],
double  AI[3][3] 
) [static]

Invert a 3x3 matrix. The input matrix is A. The output is stored in AI.

static void vtkMath::Identity3x3 ( float  A[3][3]  )  [static]

Set A to the identity matrix.

static void vtkMath::Identity3x3 ( double  A[3][3]  )  [static]

Set A to the identity matrix.

double vtkMath::Determinant3x3 ( float  A[3][3]  )  [inline, static]

Return the determinant of a 3x3 matrix.

Definition at line 1165 of file vtkMath.h.

double vtkMath::Determinant3x3 ( double  A[3][3]  )  [inline, static]

Return the determinant of a 3x3 matrix.

Definition at line 1171 of file vtkMath.h.

float vtkMath::Determinant3x3 ( const float  c1[3],
const float  c2[3],
const float  c3[3] 
) [inline, static]

Compute determinant of 3x3 matrix. Three columns of matrix are input.

Definition at line 1088 of file vtkMath.h.

double vtkMath::Determinant3x3 ( const double  c1[3],
const double  c2[3],
const double  c3[3] 
) [inline, static]

Compute determinant of 3x3 matrix. Three columns of matrix are input.

Definition at line 1097 of file vtkMath.h.

double vtkMath::Determinant3x3 ( double  a1,
double  a2,
double  a3,
double  b1,
double  b2,
double  b3,
double  c1,
double  c2,
double  c3 
) [inline, static]

Calculate the determinant of a 3x3 matrix in the form: | a1, b1, c1 | | a2, b2, c2 | | a3, b3, c3 |

Definition at line 1106 of file vtkMath.h.

static void vtkMath::QuaternionToMatrix3x3 ( const float  quat[4],
float  A[3][3] 
) [static]

Convert a quaternion to a 3x3 rotation matrix. The quaternion does not have to be normalized beforehand.

static void vtkMath::QuaternionToMatrix3x3 ( const double  quat[4],
double  A[3][3] 
) [static]

Convert a quaternion to a 3x3 rotation matrix. The quaternion does not have to be normalized beforehand.

static void vtkMath::Matrix3x3ToQuaternion ( const float  A[3][3],
float  quat[4] 
) [static]

Convert a 3x3 matrix into a quaternion. This will provide the best possible answer even if the matrix is not a pure rotation matrix. The method used is that of B.K.P. Horn.

static void vtkMath::Matrix3x3ToQuaternion ( const double  A[3][3],
double  quat[4] 
) [static]

Convert a 3x3 matrix into a quaternion. This will provide the best possible answer even if the matrix is not a pure rotation matrix. The method used is that of B.K.P. Horn.

static void vtkMath::Orthogonalize3x3 ( const float  A[3][3],
float  B[3][3] 
) [static]

Orthogonalize a 3x3 matrix and put the result in B. If matrix A has a negative determinant, then B will be a rotation plus a flip i.e. it will have a determinant of -1.

static void vtkMath::Orthogonalize3x3 ( const double  A[3][3],
double  B[3][3] 
) [static]

Orthogonalize a 3x3 matrix and put the result in B. If matrix A has a negative determinant, then B will be a rotation plus a flip i.e. it will have a determinant of -1.

static void vtkMath::Diagonalize3x3 ( const float  A[3][3],
float  w[3],
float  V[3][3] 
) [static]

Diagonalize a symmetric 3x3 matrix and return the eigenvalues in w and the eigenvectors in the columns of V. The matrix V will have a positive determinant, and the three eigenvectors will be aligned as closely as possible with the x, y, and z axes.

static void vtkMath::Diagonalize3x3 ( const double  A[3][3],
double  w[3],
double  V[3][3] 
) [static]

Diagonalize a symmetric 3x3 matrix and return the eigenvalues in w and the eigenvectors in the columns of V. The matrix V will have a positive determinant, and the three eigenvectors will be aligned as closely as possible with the x, y, and z axes.

static void vtkMath::SingularValueDecomposition3x3 ( const float  A[3][3],
float  U[3][3],
float  w[3],
float  VT[3][3] 
) [static]

Perform singular value decomposition on a 3x3 matrix. This is not done using a conventional SVD algorithm, instead it is done using Orthogonalize3x3 and Diagonalize3x3. Both output matrices U and VT will have positive determinants, and the w values will be arranged such that the three rows of VT are aligned as closely as possible with the x, y, and z axes respectively. If the determinant of A is negative, then the three w values will be negative.

static void vtkMath::SingularValueDecomposition3x3 ( const double  A[3][3],
double  U[3][3],
double  w[3],
double  VT[3][3] 
) [static]

Perform singular value decomposition on a 3x3 matrix. This is not done using a conventional SVD algorithm, instead it is done using Orthogonalize3x3 and Diagonalize3x3. Both output matrices U and VT will have positive determinants, and the w values will be arranged such that the three rows of VT are aligned as closely as possible with the x, y, and z axes respectively. If the determinant of A is negative, then the three w values will be negative.

static int vtkMath::SolveLinearSystem ( double **  A,
double *  x,
int  size 
) [static]

Solve linear equations Ax = b using Crout's method. Input is square matrix A and load vector x. Solution x is written over load vector. The dimension of the matrix is specified in size. If error is found, method returns a 0.

static int vtkMath::InvertMatrix ( double **  A,
double **  AI,
int  size 
) [static]

Invert input square matrix A into matrix AI. Note that A is modified during the inversion. The size variable is the dimension of the matrix. Returns 0 if inverse not computed.

static int vtkMath::InvertMatrix ( double **  A,
double **  AI,
int  size,
int *  tmp1Size,
double *  tmp2Size 
) [static]

Thread safe version of InvertMatrix method. Working memory arrays tmp1SIze and tmp2Size of length size must be passed in.

static int vtkMath::LUFactorLinearSystem ( double **  A,
int *  index,
int  size 
) [static]

Factor linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U is upper triangular matrix. Input is square matrix A, integer array of pivot indices index[0->n-1], and size of square matrix n. Output factorization LU is in matrix A. If error is found, method returns 0.

static int vtkMath::LUFactorLinearSystem ( double **  A,
int *  index,
int  size,
double *  tmpSize 
) [static]

Thread safe version of LUFactorLinearSystem method. Working memory array tmpSize of length size must be passed in.

static void vtkMath::LUSolveLinearSystem ( double **  A,
int *  index,
double *  x,
int  size 
) [static]

Solve linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U is upper triangular matrix. Input is factored matrix A=LU, integer array of pivot indices index[0->n-1], load vector x[0->n-1], and size of square matrix n. Note that A=LU and index[] are generated from method LUFactorLinearSystem). Also, solution vector is written directly over input load vector.

static double vtkMath::EstimateMatrixCondition ( double **  A,
int  size 
) [static]

Estimate the condition number of a LU factored matrix. Used to judge the accuracy of the solution. The matrix A must have been previously factored using the method LUFactorLinearSystem. The condition number is the ratio of the infinity matrix norm (i.e., maximum value of matrix component) divided by the minimum diagonal value. (This works for triangular matrices only: see Conte and de Boor, Elementary Numerical Analysis.)

static int vtkMath::Jacobi ( float **  a,
float *  w,
float **  v 
) [static]

Jacobi iteration for the solution of eigenvectors/eigenvalues of a 3x3 real symmetric matrix. Square 3x3 matrix a; output eigenvalues in w; and output eigenvectors in v. Resulting eigenvalues/vectors are sorted in decreasing order; eigenvectors are normalized.

static int vtkMath::Jacobi ( double **  a,
double *  w,
double **  v 
) [static]

Jacobi iteration for the solution of eigenvectors/eigenvalues of a 3x3 real symmetric matrix. Square 3x3 matrix a; output eigenvalues in w; and output eigenvectors in v. Resulting eigenvalues/vectors are sorted in decreasing order; eigenvectors are normalized.

static int vtkMath::JacobiN ( float **  a,
int  n,
float *  w,
float **  v 
) [static]

JacobiN iteration for the solution of eigenvectors/eigenvalues of a nxn real symmetric matrix. Square nxn matrix a; size of matrix in n; output eigenvalues in w; and output eigenvectors in v. Resulting eigenvalues/vectors are sorted in decreasing order; eigenvectors are normalized. w and v need to be allocated previously

static int vtkMath::JacobiN ( double **  a,
int  n,
double *  w,
double **  v 
) [static]

JacobiN iteration for the solution of eigenvectors/eigenvalues of a nxn real symmetric matrix. Square nxn matrix a; size of matrix in n; output eigenvalues in w; and output eigenvectors in v. Resulting eigenvalues/vectors are sorted in decreasing order; eigenvectors are normalized. w and v need to be allocated previously

double * vtkMath::SolveCubic ( double  c0,
double  c1,
double  c2,
double  c3 
) [inline, static]

Solves a cubic equation c0*t^3 + c1*t^2 + c2*t + c3 = 0 when c0, c1, c2, and c3 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Return array contains number of (real) roots (counting multiple roots as one) followed by roots themselves. The value in roots[4] is a integer giving further information about the roots (see return codes for int SolveCubic() ).

Deprecated:
Replaced by vtkPolynomialSolversUnivariate::SolveCubic() as of VTK 5.8.

Definition at line 1178 of file vtkMath.h.

double * vtkMath::SolveQuadratic ( double  c0,
double  c1,
double  c2 
) [inline, static]

Solves a quadratic equation c1*t^2 + c2*t + c3 = 0 when c1, c2, and c3 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Return array contains number of (real) roots (counting multiple roots as one) followed by roots themselves. Note that roots[3] contains a return code further describing solution - see documentation for SolveCubic() for meaning of return codes.

Deprecated:
Replaced by vtkPolynomialSolversUnivariate::SolveQuadratic() as of VTK 5.8.

Definition at line 1186 of file vtkMath.h.

double * vtkMath::SolveLinear ( double  c0,
double  c1 
) [inline, static]

Solves a linear equation c2*t + c3 = 0 when c2 and c3 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Return array contains number of roots followed by roots themselves.

Deprecated:
Replaced by vtkPolynomialSolversUnivariate::SolveLinear() as of VTK 5.8.

Definition at line 1194 of file vtkMath.h.

int vtkMath::SolveCubic ( double  c0,
double  c1,
double  c2,
double  c3,
double *  r1,
double *  r2,
double *  r3,
int *  num_roots 
) [inline, static]

Solves a cubic equation when c0, c1, c2, And c3 Are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Roots and number of real roots are stored in user provided variables r1, r2, r3, and num_roots. Note that the function can return the following integer values describing the roots: (0)-no solution; (-1)-infinite number of solutions; (1)-one distinct real root of multiplicity 3 (stored in r1); (2)-two distinct real roots, one of multiplicity 2 (stored in r1 & r2); (3)-three distinct real roots; (-2)-quadratic equation with complex conjugate solution (real part of root returned in r1, imaginary in r2); (-3)-one real root and a complex conjugate pair (real root in r1 and real part of pair in r2 and imaginary in r3).

Deprecated:
Replaced by vtkPolynomialSolversUnivariate::SolveCubic() as of VTK 5.8.

Definition at line 1202 of file vtkMath.h.

int vtkMath::SolveQuadratic ( double  c0,
double  c1,
double  c2,
double *  r1,
double *  r2,
int *  num_roots 
) [inline, static]

Solves a quadratic equation c1*t^2 + c2*t + c3 = 0 when c1, c2, and c3 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Roots and number of roots are stored in user provided variables r1, r2, num_roots

Deprecated:
Replaced by vtkPolynomialSolversUnivariate::SolveQuadratic() as of VTK 5.8.

Definition at line 1211 of file vtkMath.h.

int vtkMath::SolveQuadratic ( double *  c,
double *  r,
int *  m 
) [inline, static]

Algebraically extracts REAL roots of the quadratic polynomial with REAL coefficients c[0] X^2 + c[1] X + c[2] and stores them (when they exist) and their respective multiplicities in the r and m arrays. Returns either the number of roots, or -1 if ininite number of roots.

Deprecated:
Replaced by vtkPolynomialSolversUnivariate::SolveQuadratic() as of VTK 5.8.

Definition at line 1220 of file vtkMath.h.

int vtkMath::SolveLinear ( double  c0,
double  c1,
double *  r1,
int *  num_roots 
) [inline, static]

Solves a linear equation c2*t + c3 = 0 when c2 and c3 are REAL. Solution is motivated by Numerical Recipes In C 2nd Ed. Root and number of (real) roots are stored in user provided variables r2 and num_roots.

Deprecated:
Replaced by vtkPolynomialSolversUnivariate::SolveLinear() as of VTK 5.8.

Definition at line 1228 of file vtkMath.h.

static int vtkMath::SolveHomogeneousLeastSquares ( int  numberOfSamples,
double **  xt,
int  xOrder,
double **  mt 
) [static]

Solves for the least squares best fit matrix for the homogeneous equation X'M' = 0'. Uses the method described on pages 40-41 of Computer Vision by Forsyth and Ponce, which is that the solution is the eigenvector associated with the minimum eigenvalue of T(X)X, where T(X) is the transpose of X. The inputs and output are transposed matrices. Dimensions: X' is numberOfSamples by xOrder, M' dimension is xOrder by yOrder. M' should be pre-allocated. All matrices are row major. The resultant matrix M' should be pre-multiplied to X' to get 0', or transposed and then post multiplied to X to get 0

static int vtkMath::SolveLeastSquares ( int  numberOfSamples,
double **  xt,
int  xOrder,
double **  yt,
int  yOrder,
double **  mt,
int  checkHomogeneous = 1 
) [static]

Solves for the least squares best fit matrix for the equation X'M' = Y'. Uses pseudoinverse to get the ordinary least squares. The inputs and output are transposed matrices. Dimensions: X' is numberOfSamples by xOrder, Y' is numberOfSamples by yOrder, M' dimension is xOrder by yOrder. M' should be pre-allocated. All matrices are row major. The resultant matrix M' should be pre-multiplied to X' to get Y', or transposed and then post multiplied to X to get Y By default, this method checks for the homogeneous condition where Y==0, and if so, invokes SolveHomogeneousLeastSquares. For better performance when the system is known not to be homogeneous, invoke with checkHomogeneous=0.

static void vtkMath::RGBToHSV ( const float  rgb[3],
float  hsv[3] 
) [inline, static]

Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.

Definition at line 781 of file vtkMath.h.

static void vtkMath::RGBToHSV ( float  r,
float  g,
float  b,
float *  h,
float *  s,
float *  v 
) [static]

Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.

static double* vtkMath::RGBToHSV ( const double  rgb[3]  )  [static]

Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.

static double* vtkMath::RGBToHSV ( double  r,
double  g,
double  b 
) [static]

Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.

static void vtkMath::RGBToHSV ( const double  rgb[3],
double  hsv[3] 
) [inline, static]

Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.

Definition at line 786 of file vtkMath.h.

static void vtkMath::RGBToHSV ( double  r,
double  g,
double  b,
double *  h,
double *  s,
double *  v 
) [static]

Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.

static void vtkMath::HSVToRGB ( const float  hsv[3],
float  rgb[3] 
) [inline, static]

Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.

Definition at line 794 of file vtkMath.h.

static void vtkMath::HSVToRGB ( float  h,
float  s,
float  v,
float *  r,
float *  g,
float *  b 
) [static]

Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.

static double* vtkMath::HSVToRGB ( const double  hsv[3]  )  [static]

Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.

static double* vtkMath::HSVToRGB ( double  h,
double  s,
double  v 
) [static]

Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.

static void vtkMath::HSVToRGB ( const double  hsv[3],
double  rgb[3] 
) [inline, static]

Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.

Definition at line 799 of file vtkMath.h.

static void vtkMath::HSVToRGB ( double  h,
double  s,
double  v,
double *  r,
double *  g,
double *  b 
) [static]

Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.

static void vtkMath::LabToXYZ ( const double  lab[3],
double  xyz[3] 
) [inline, static]

Convert color from the CIE-L*ab system to CIE XYZ.

Definition at line 806 of file vtkMath.h.

static void vtkMath::LabToXYZ ( double  L,
double  a,
double  b,
double *  x,
double *  y,
double *  z 
) [static]

Convert color from the CIE-L*ab system to CIE XYZ.

static double* vtkMath::LabToXYZ ( const double  lab[3]  )  [static]

Convert color from the CIE-L*ab system to CIE XYZ.

static void vtkMath::XYZToLab ( const double  xyz[3],
double  lab[3] 
) [inline, static]

Convert Color from the CIE XYZ system to CIE-L*ab.

Definition at line 816 of file vtkMath.h.

static void vtkMath::XYZToLab ( double  x,
double  y,
double  z,
double *  L,
double *  a,
double *  b 
) [static]

Convert Color from the CIE XYZ system to CIE-L*ab.

static double* vtkMath::XYZToLab ( const double  xyz[3]  )  [static]

Convert Color from the CIE XYZ system to CIE-L*ab.

static void vtkMath::XYZToRGB ( const double  xyz[3],
double  rgb[3] 
) [inline, static]

Convert color from the CIE XYZ system to RGB.

Definition at line 826 of file vtkMath.h.

static void vtkMath::XYZToRGB ( double  x,
double  y,
double  z,
double *  r,
double *  g,
double *  b 
) [static]

Convert color from the CIE XYZ system to RGB.

static double* vtkMath::XYZToRGB ( const double  xyz[3]  )  [static]

Convert color from the CIE XYZ system to RGB.

static void vtkMath::RGBToXYZ ( const double  rgb[3],
double  xyz[3] 
) [inline, static]

Convert color from the RGB system to CIE XYZ.

Definition at line 836 of file vtkMath.h.

static void vtkMath::RGBToXYZ ( double  r,
double  g,
double  b,
double *  x,
double *  y,
double *  z 
) [static]

Convert color from the RGB system to CIE XYZ.

static double* vtkMath::RGBToXYZ ( const double  rgb[3]  )  [static]

Convert color from the RGB system to CIE XYZ.

static void vtkMath::RGBToLab ( const double  rgb[3],
double  lab[3] 
) [inline, static]

Convert color from the RGB system to CIE-L*ab.

Definition at line 846 of file vtkMath.h.

static void vtkMath::RGBToLab ( double  red,
double  green,
double  blue,
double *  L,
double *  a,
double *  b 
) [static]

Convert color from the RGB system to CIE-L*ab.

static double* vtkMath::RGBToLab ( const double  rgb[3]  )  [static]

Convert color from the RGB system to CIE-L*ab.

static void vtkMath::LabToRGB ( const double  lab[3],
double  rgb[3] 
) [inline, static]

Convert color from the CIE-L*ab system to RGB.

Definition at line 856 of file vtkMath.h.

static void vtkMath::LabToRGB ( double  L,
double  a,
double  b,
double *  red,
double *  green,
double *  blue 
) [static]

Convert color from the CIE-L*ab system to RGB.

static double* vtkMath::LabToRGB ( const double  lab[3]  )  [static]

Convert color from the CIE-L*ab system to RGB.

static void vtkMath::UninitializeBounds ( double  bounds[6]  )  [inline, static]

Set the bounds to an uninitialized state

Definition at line 866 of file vtkMath.h.

static int vtkMath::AreBoundsInitialized ( double  bounds[6]  )  [inline, static]

Are the bounds initialized?

Definition at line 878 of file vtkMath.h.

void vtkMath::ClampValue ( double *  value,
const double  range[2] 
) [inline, static]

Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.

Definition at line 1237 of file vtkMath.h.

void vtkMath::ClampValue ( double  value,
const double  range[2],
double *  clamped_value 
) [inline, static]

Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.

Definition at line 1253 of file vtkMath.h.

static void vtkMath::ClampValues ( double *  values,
int  nb_values,
const double  range[2] 
) [static]

Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.

static void vtkMath::ClampValues ( const double *  values,
int  nb_values,
const double  range[2],
double *  clamped_values 
) [static]

Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.

double vtkMath::ClampAndNormalizeValue ( double  value,
const double  range[2] 
) [inline, static]

Clamp a value against a range and then normalized it between 0 and 1. If range[0]==range[1], the result is 0.

Precondition:
valid_range: range[0]<=range[1]
Postcondition:
valid_result: result>=0.0 && result<=1.0

Definition at line 1274 of file vtkMath.h.

static int vtkMath::GetScalarTypeFittingRange ( double  range_min,
double  range_max,
double  scale = 1.0,
double  shift = 0.0 
) [static]

Return the scalar type that is most likely to have enough precision to store a given range of data once it has been scaled and shifted (i.e. [range_min * scale + shift, range_max * scale + shift]. If any one of the parameters is not an integer number (decimal part != 0), the search will default to float types only (float or double) Return -1 on error or no scalar type found.

static int vtkMath::GetAdjustedScalarRange ( vtkDataArray array,
int  comp,
double  range[2] 
) [static]

Get a vtkDataArray's scalar range for a given component. If the vtkDataArray's data type is unsigned char (VTK_UNSIGNED_CHAR) the range is adjusted to the whole data type range [0, 255.0]. Same goes for unsigned short (VTK_UNSIGNED_SHORT) but the upper bound is also adjusted down to 4095.0 if was between ]255, 4095.0]. Return 1 on success, 0 otherwise.

static int vtkMath::ExtentIsWithinOtherExtent ( int  extent1[6],
int  extent2[6] 
) [static]

Return true if first 3D extent is within second 3D extent Extent is x-min, x-max, y-min, y-max, z-min, z-max

static int vtkMath::BoundsIsWithinOtherBounds ( double  bounds1[6],
double  bounds2[6],
double  delta[3] 
) [static]

Return true if first 3D bounds is within the second 3D bounds Bounds is x-min, x-max, y-min, y-max, z-min, z-max Delta is the error margin along each axis (usually a small number)

static int vtkMath::PointIsWithinBounds ( double  point[3],
double  bounds[6],
double  delta[3] 
) [static]

Return true if point is within the given 3D bounds Bounds is x-min, x-max, y-min, y-max, z-min, z-max Delta is the error margin along each axis (usually a small number)

static double vtkMath::Solve3PointCircle ( const double  p1[3],
const double  p2[3],
const double  p3[3],
double  center[3] 
) [static]

In Euclidean space, there is a unique circle passing through any given three non-collinear points P1, P2, and P3. Using Cartesian coordinates to represent these points as spatial vectors, it is possible to use the dot product and cross product to calculate the radius and center of the circle. See: http://en.wikipedia.org/wiki/Circumcircle and more specifically the section Barycentric coordinates from cross- and dot-products

static double vtkMath::Inf (  )  [static]

Special IEEE-754 number used to represent positive infinity.

static double vtkMath::NegInf (  )  [static]

Special IEEE-754 number used to represent negative infinity.

static double vtkMath::Nan (  )  [static]

Special IEEE-754 number used to represent Not-A-Number (Nan).

static int vtkMath::IsInf ( double  x  )  [static]

Test if a number is equal to the special floating point value infinity.

static int vtkMath::IsNan ( double  x  )  [static]


Member Data Documentation

vtkMathInternal vtkMath::Internal [static, protected]

Definition at line 970 of file vtkMath.h.


The documentation for this class was generated from the following file:

Generated on Wed Aug 24 11:46:59 2011 for VTK by  doxygen 1.5.6