vtkMath Class Reference

#include <vtkMath.h>

Inheritance diagram for vtkMath:

[legend]

Collaboration diagram for vtkMath:

[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 random number generation.

Examples:: vtkMath (Examples)

Tests:: vtkMath (Tests)

Definition at line 54 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 vtkMath *	New ()
static int	IsTypeOf (const char *type)
static vtkMath *	SafeDownCast (vtkObject *o)
static int	Floor (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	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 float	Normalize2D (float x[3])
static double	Normalize2D (double x[3])
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 void	RandomSeed (long s)
static long	GetSeed ()
static double	Random ()
static double	Random (double min, double max)
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 float	Pi ()
static float	DegreesToRadians ()
static float	RadiansToDegrees ()

static double	DoubleDegreesToRadians ()
static double	DoublePi ()
static double	DoubleRadiansToDegrees ()

static int	Round (float f)
static int	Round (double f)

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 float	Dot2D (const float x[3], const float y[3])

static double	Dot2D (const double x[3], const double y[3])

static void	Outer2D (const float x[3], const float y[3], float A[3][3])
static void	Outer2D (const double x[3], const double y[3], double A[3][3])

static float	Norm2D (const float x[3])

static double	Norm2D (const double x[3])

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 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])

static double	Inf ()
static double	NegInf ()
static double	Nan ()
Protected Member Functions
	vtkMath ()
	~vtkMath ()
Static Protected Attributes
static long	Seed

Member Typedef Documentation

typedef vtkObject vtkMath::Superclass

Reimplemented from vtkObject.

Definition at line 58 of file vtkMath.h.

Constructor & Destructor Documentation

vtkMath::vtkMath ( ) [inline, protected]

Definition at line 745 of file vtkMath.h.

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

Definition at line 746 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 vtkTypeRevisionMacro 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 vtkTypeRevisionMacro 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]

Useful constants.

Definition at line 63 of file vtkMath.h.

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

Useful constants.

Definition at line 64 of file vtkMath.h.

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

Useful constants.

Definition at line 65 of file vtkMath.h.

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

Useful constants. (double-precision version)

Definition at line 70 of file vtkMath.h.

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

Useful constants. (double-precision version)

Definition at line 71 of file vtkMath.h.

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

Useful constants. (double-precision version)

Definition at line 72 of file vtkMath.h.

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

Rounds a float to the nearest integer.

Definition at line 77 of file vtkMath.h.

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

Rounds a float to the nearest integer.

Definition at line 79 of file vtkMath.h.

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

Definition at line 766 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 755 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 float vtkMath::Dot	(	const float	x[3],
		const float	y[3]
	)			`[inline, static]`

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

Definition at line 115 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 121 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 127 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 134 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 vector in z[3].

Definition at line 891 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 vector in z[3]. (double-precision version)

Definition at line 901 of file vtkMath.h.

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

Compute the norm of n-vector.

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

Compute the norm of n-vector.

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

Compute the norm of 3-vector.

Definition at line 156 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 162 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 784 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 798 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.

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

Compute distance squared between two points.

Definition at line 868 of file vtkMath.h.

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

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

Definition at line 876 of file vtkMath.h.

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

Dot product of two 2-vectors. The third (z) component is ignored.

Definition at line 194 of file vtkMath.h.

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

Dot product of two 2-vectors. The third (z) component is ignored (double-precision version).

Definition at line 201 of file vtkMath.h.

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

Outer product of two 2-vectors (float version). z-comp is ignored

Definition at line 207 of file vtkMath.h.

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

Outer product of two 2-vectors (float version). z-comp is ignored

Definition at line 214 of file vtkMath.h.

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

Compute the norm of a 2-vector. Ignores z-component.

Definition at line 223 of file vtkMath.h.

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

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

Definition at line 230 of file vtkMath.h.

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

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

Definition at line 812 of file vtkMath.h.

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

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

Definition at line 826 of file vtkMath.h.

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 244 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 250 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 252 of file vtkMath.h.

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

LU Factorization of a 3x3 matrix. The diagonal elements are the multiplicative inverse of those in the standard LU factorization.

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

LU Factorization of a 3x3 matrix. The diagonal elements are the multiplicative inverse of those in the standard LU factorization.

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

LU back substitution for a 3x3 matrix. The diagonal elements are the multiplicative inverse of those in the standard LU factorization.

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

LU back substitution for a 3x3 matrix. The diagonal elements are the multiplicative inverse of those in the standard LU factorization.

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.

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

Transpose a 3x3 matrix.

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

Invert a 3x3 matrix.

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

Invert a 3x3 matrix.

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 921 of file vtkMath.h.

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

Return the determinant of a 3x3 matrix.

Definition at line 927 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 840 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 849 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 858 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 void vtkMath::RandomSeed ( long 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().

static long vtkMath::GetSeed ( ) [static]

Return the current seed used by the random number generator.

static double vtkMath::Random ( ) [static]

Generate random numbers between 0.0 and 1.0. This is used to provide portability across different systems.

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

Generate random number between (min,max).

Definition at line 884 of file vtkMath.h.

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

static double* vtkMath::SolveCubic	(	double	c0,
		double	c1,
		double	c2,
		double	c3
	)			`[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()).

static double* vtkMath::SolveQuadratic	(	double	c0,
		double	c1,
		double	c2
	)			`[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.

static double* vtkMath::SolveLinear	(	double	c0,
		double	c1
	)			`[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.

static int vtkMath::SolveCubic	(	double	c0,
		double	c1,
		double	c2,
		double	c3,
		double *	r1,
		double *	r2,
		double *	r3,
		int *	num_roots
	)			`[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).

static int vtkMath::SolveQuadratic	(	double	c0,
		double	c1,
		double	c2,
		double *	r1,
		double *	r2,
		int *	num_roots
	)			`[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

static int vtkMath::SolveQuadratic	(	double *	c,
		double *	r,
		int *	m
	)			`[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.

static int vtkMath::SolveLinear	(	double	c0,
		double	c1,
		double *	r1,
		int *	num_roots
	)			`[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.

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]`