ActiViz .NET  5.8.0
Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Private Member Functions | Static Private Member Functions
Kitware.VTK.vtkMath Class Reference

vtkMath - performs common math operations More...

Inheritance diagram for Kitware.VTK.vtkMath:
[legend]
Collaboration diagram for Kitware.VTK.vtkMath:
[legend]

List of all members.

Public Member Functions

 vtkMath (IntPtr rawCppThis, bool callDisposalMethod, bool strong)
 Automatically generated constructor - called from generated code. DO NOT call directly.
 vtkMath ()
 Undocumented Block.
override int IsA (string type)
 Undocumented Block.
new vtkMath NewInstance ()
 Undocumented Block.

Static Public Member Functions

static new vtkMath New ()
 Undocumented Block.
static void Add (IntPtr a, IntPtr b, IntPtr c)
 Addition of two 3-vectors (float version). Result is stored in c.
static int AreBoundsInitialized (IntPtr bounds)
 Are the bounds initialized?
static IntPtr BeginCombination (int m, int n)
 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[.
static long Binomial (int m, int n)
 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 BoundsIsWithinOtherBounds (IntPtr bounds1, IntPtr bounds2, IntPtr delta)
 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 Ceil (double x)
static double ClampAndNormalizeValue (double value, IntPtr range)
static void ClampValue (IntPtr value, IntPtr range)
static void ClampValue (double value, IntPtr range, IntPtr clamped_value)
static void ClampValues (IntPtr values, int nb_values, IntPtr range)
 Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.
static void ClampValues (IntPtr values, int nb_values, IntPtr range, IntPtr clamped_values)
 Clamp some values against a range The method without 'clamped_values' will perform in-place clamping.
static void Cross (IntPtr x, IntPtr y, IntPtr z)
static float DegreesFromRadians (float x)
static double DegreesFromRadians (double x)
static float Determinant2x2 (IntPtr c1, IntPtr c2)
 Compute determinant of 2x2 matrix. Two columns of matrix are input.
static double Determinant2x2 (double a, double b, double c, double d)
 Calculate the determinant of a 2x2 matrix: | a b | | c d |.
static float Determinant3x3 (IntPtr c1, IntPtr c2, IntPtr c3)
static double Determinant3x3 (double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3)
static float Distance2BetweenPoints (IntPtr x, IntPtr y)
static float Dot (IntPtr x, IntPtr y)
 Dot product of two 3-vectors (float version).
static float Dot2D (IntPtr x, IntPtr y)
 Dot product of two 2-vectors.
static double DoublePi ()
 A mathematical constant (double-precision version). This version is 3.1415926535897932384626.
static double DoubleTwoPi ()
 A mathematical constant (double-precision version). This version is 6.283185307179586.
static int ExtentIsWithinOtherExtent (IntPtr extent1, IntPtr extent2)
 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 long Factorial (int N)
static int Floor (double x)
static void FreeCombination (IntPtr combination)
 Free the "iterator" array created by vtkMath::BeginCombination.
static double Gaussian ()
 Generate pseudo-random numbers distributed according to the standard normal distribution.
static double Gaussian (double mean, double std)
 Generate pseudo-random numbers distributed according to the Gaussian distribution with mean mean and standard deviation std.
static double GaussianAmplitude (double variance, double distanceFromMean)
 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 GaussianAmplitude (double mean, double variance, double position)
 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 GaussianWeight (double variance, double distanceFromMean)
 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 GaussianWeight (double mean, double variance, double position)
 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 int GetAdjustedScalarRange (vtkDataArray array, int comp, IntPtr range)
 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 GetScalarTypeFittingRange (double range_min, double range_max, double scale, double shift)
 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 GetSeed ()
 Return the current seed used by the random number generator.
static void HSVToRGB (IntPtr hsv, IntPtr rgb)
 Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.
static void HSVToRGB (float h, float s, float v, IntPtr r, IntPtr g, IntPtr b)
 Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.
static double[] HSVToRGB (IntPtr hsv)
 Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.
static double[] HSVToRGB (double h, double s, double v)
 Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.
static void HSVToRGB (double h, double s, double v, IntPtr r, IntPtr g, IntPtr b)
 Convert color in HSV format (Hue, Saturation, Value) to RGB format (Red, Green, Blue). The input color is not modified.
static double Inf ()
 Special IEEE-754 number used to represent positive infinity.
static int IsInf (double x)
 Test if a number is equal to the special floating point value infinity.
static int IsNan (double x)
 Test if a number is equal to the special floating point value Not-A-Number (Nan).
static new int IsTypeOf (string type)
 Undocumented Block.
static void LabToRGB (IntPtr lab, IntPtr rgb)
 Convert color from the CIE-L*ab system to RGB.
static void LabToRGB (double L, double a, double b, IntPtr red, IntPtr green, IntPtr blue)
 Convert color from the CIE-L*ab system to RGB.
static IntPtr LabToRGB (IntPtr lab)
 Convert color from the CIE-L*ab system to RGB.
static void LabToXYZ (IntPtr lab, IntPtr xyz)
 Convert color from the CIE-L*ab system to CIE XYZ.
static void LabToXYZ (double L, double a, double b, IntPtr x, IntPtr y, IntPtr z)
 Convert color from the CIE-L*ab system to CIE XYZ.
static IntPtr LabToXYZ (IntPtr lab)
 Convert color from the CIE-L*ab system to CIE XYZ.
static void MultiplyScalar (IntPtr a, float s)
 Multiplies a 3-vector by a scalar (float version). This modifies the input 3-vector.
static void MultiplyScalar (IntPtr a, double s)
 Multiplies a 3-vector by a scalar (double version). This modifies the input 3-vector.
static void MultiplyScalar2D (IntPtr a, float s)
 Multiplies a 2-vector by a scalar (float version). This modifies the input 2-vector.
static void MultiplyScalar2D (IntPtr a, double s)
 Multiplies a 2-vector by a scalar (double version). This modifies the input 2-vector.
static double Nan ()
 Special IEEE-754 number used to represent Not-A-Number (Nan).
static double NegInf ()
 Special IEEE-754 number used to represent negative infinity.
static int NextCombination (int m, int n, IntPtr combination)
 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.
static float Norm (IntPtr x, int n)
 Compute the norm of n-vector. x is the vector, n is its length.
static float Norm (IntPtr x)
 Compute the norm of 3-vector.
static float Norm2D (IntPtr x)
 Compute the norm of a 2-vector.
static float Normalize (IntPtr x)
static float Normalize2D (IntPtr x)
static void Perpendiculars (IntPtr x, IntPtr y, IntPtr z, double theta)
 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 float Pi ()
 A mathematical constant. This version is 3.14159265358979f.
static int PointIsWithinBounds (IntPtr point, IntPtr bounds, IntPtr delta)
 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 bool ProjectVector (IntPtr a, IntPtr b, IntPtr projection)
 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 ProjectVector2D (IntPtr a, IntPtr b, IntPtr projection)
 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 void RGBToHSV (IntPtr rgb, IntPtr hsv)
 Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.
static void RGBToHSV (float r, float g, float b, IntPtr h, IntPtr s, IntPtr v)
 Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.
static double[] RGBToHSV (IntPtr rgb)
 Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.
static double[] RGBToHSV (double r, double g, double b)
 Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.
static void RGBToHSV (double r, double g, double b, IntPtr h, IntPtr s, IntPtr v)
 Convert color in RGB format (Red, Green, Blue) to HSV format (Hue, Saturation, Value). The input color is not modified.
static void RGBToLab (IntPtr rgb, IntPtr lab)
 Convert color from the RGB system to CIE-L*ab.
static void RGBToLab (double red, double green, double blue, IntPtr L, IntPtr a, IntPtr b)
 Convert color from the RGB system to CIE-L*ab.
static IntPtr RGBToLab (IntPtr rgb)
 Convert color from the RGB system to CIE-L*ab.
static void RGBToXYZ (IntPtr rgb, IntPtr xyz)
 Convert color from the RGB system to CIE XYZ.
static void RGBToXYZ (double r, double g, double b, IntPtr x, IntPtr y, IntPtr z)
 Convert color from the RGB system to CIE XYZ.
static IntPtr RGBToXYZ (IntPtr rgb)
 Convert color from the RGB system to CIE XYZ.
static float RadiansFromDegrees (float x)
static double RadiansFromDegrees (double x)
static double Random ()
 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.
static double Random (double min, double max)
 Generate pseudo-random numbers distributed according to the uniform distribution between min and max.
static void RandomSeed (int s)
 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 int Round (float f)
 Rounds a float to the nearest integer.
static int Round (double f)
 Rounds a float to the nearest integer.
static new vtkMath SafeDownCast (vtkObjectBase o)
 Undocumented Block.
static double Solve3PointCircle (IntPtr p1, IntPtr p2, IntPtr p3, IntPtr center)
 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 void Subtract (IntPtr a, IntPtr b, IntPtr c)
 Subtraction of two 3-vectors (float version). Result is stored in c according to c = a - b.
static void UninitializeBounds (IntPtr bounds)
 Set the bounds to an uninitialized state.
static void XYZToLab (IntPtr xyz, IntPtr lab)
 Convert Color from the CIE XYZ system to CIE-L*ab.
static void XYZToLab (double x, double y, double z, IntPtr L, IntPtr a, IntPtr b)
 Convert Color from the CIE XYZ system to CIE-L*ab.
static IntPtr XYZToLab (IntPtr xyz)
 Convert Color from the CIE XYZ system to CIE-L*ab.
static void XYZToRGB (IntPtr xyz, IntPtr rgb)
 Convert color from the CIE XYZ system to RGB.
static void XYZToRGB (double x, double y, double z, IntPtr r, IntPtr g, IntPtr b)
 Convert color from the CIE XYZ system to RGB.
static IntPtr XYZToRGB (IntPtr xyz)
 Convert color from the CIE XYZ system to RGB.

Public Attributes

new const string MRFullTypeName = "Kitware.VTK.vtkMath"
 Automatically generated type registration mechanics.

Static Public Attributes

static new readonly string MRClassNameKey = "7vtkMath"
 Automatically generated type registration mechanics.

Protected Member Functions

override void Dispose (bool disposing)
 Automatically generated protected Dispose method - called from public Dispose or the C# destructor. DO NOT call directly.

Private Member Functions

static internal IntPtr vtkMath_New (ref uint mteStatus, ref uint mteIndex, ref uint rawRefCount)
static internal void vtkMath_Add_01 (IntPtr a, IntPtr b, IntPtr c)
static internal int vtkMath_AreBoundsInitialized_02 (IntPtr bounds)
static internal IntPtr vtkMath_BeginCombination_03 (int m, int n)
static internal long vtkMath_Binomial_04 (int m, int n)
static internal int vtkMath_BoundsIsWithinOtherBounds_05 (IntPtr bounds1, IntPtr bounds2, IntPtr delta)
static internal int vtkMath_Ceil_06 (double x)
static internal double vtkMath_ClampAndNormalizeValue_07 (double value, IntPtr range)
static internal void vtkMath_ClampValue_08 (IntPtr value, IntPtr range)
static internal void vtkMath_ClampValue_09 (double value, IntPtr range, IntPtr clamped_value)
static internal void vtkMath_ClampValues_10 (IntPtr values, int nb_values, IntPtr range)
static internal void vtkMath_ClampValues_11 (IntPtr values, int nb_values, IntPtr range, IntPtr clamped_values)
static internal void vtkMath_Cross_12 (IntPtr x, IntPtr y, IntPtr z)
static internal float vtkMath_DegreesFromRadians_13 (float x)
static internal double vtkMath_DegreesFromRadians_14 (double x)
static internal float vtkMath_Determinant2x2_15 (IntPtr c1, IntPtr c2)
static internal double vtkMath_Determinant2x2_16 (double a, double b, double c, double d)
static internal float vtkMath_Determinant3x3_17 (IntPtr c1, IntPtr c2, IntPtr c3)
static internal double vtkMath_Determinant3x3_18 (double a1, double a2, double a3, double b1, double b2, double b3, double c1, double c2, double c3)
static internal float vtkMath_Distance2BetweenPoints_19 (IntPtr x, IntPtr y)
static internal float vtkMath_Dot_20 (IntPtr x, IntPtr y)
static internal float vtkMath_Dot2D_21 (IntPtr x, IntPtr y)
static internal double vtkMath_DoublePi_22 ()
static internal double vtkMath_DoubleTwoPi_23 ()
static internal int vtkMath_ExtentIsWithinOtherExtent_24 (IntPtr extent1, IntPtr extent2)
static internal long vtkMath_Factorial_25 (int N)
static internal int vtkMath_Floor_26 (double x)
static internal void vtkMath_FreeCombination_27 (IntPtr combination)
static internal double vtkMath_Gaussian_28 ()
static internal double vtkMath_Gaussian_29 (double mean, double std)
static internal double vtkMath_GaussianAmplitude_30 (double variance, double distanceFromMean)
static internal double vtkMath_GaussianAmplitude_31 (double mean, double variance, double position)
static internal double vtkMath_GaussianWeight_32 (double variance, double distanceFromMean)
static internal double vtkMath_GaussianWeight_33 (double mean, double variance, double position)
static internal int vtkMath_GetAdjustedScalarRange_34 (HandleRef array, int comp, IntPtr range)
static internal int vtkMath_GetScalarTypeFittingRange_35 (double range_min, double range_max, double scale, double shift)
static internal int vtkMath_GetSeed_36 ()
static internal void vtkMath_HSVToRGB_37 (IntPtr hsv, IntPtr rgb)
static internal void vtkMath_HSVToRGB_38 (float h, float s, float v, IntPtr r, IntPtr g, IntPtr b)
static internal IntPtr vtkMath_HSVToRGB_39 (IntPtr hsv)
static internal IntPtr vtkMath_HSVToRGB_40 (double h, double s, double v)
static internal void vtkMath_HSVToRGB_41 (double h, double s, double v, IntPtr r, IntPtr g, IntPtr b)
static internal double vtkMath_Inf_42 ()
static internal int vtkMath_IsA_43 (HandleRef pThis, string type)
static internal int vtkMath_IsInf_44 (double x)
static internal int vtkMath_IsNan_45 (double x)
static internal int vtkMath_IsTypeOf_46 (string type)
static internal void vtkMath_LabToRGB_47 (IntPtr lab, IntPtr rgb)
static internal void vtkMath_LabToRGB_48 (double L, double a, double b, IntPtr red, IntPtr green, IntPtr blue)
static internal IntPtr vtkMath_LabToRGB_49 (IntPtr lab)
static internal void vtkMath_LabToXYZ_50 (IntPtr lab, IntPtr xyz)
static internal void vtkMath_LabToXYZ_51 (double L, double a, double b, IntPtr x, IntPtr y, IntPtr z)
static internal IntPtr vtkMath_LabToXYZ_52 (IntPtr lab)
static internal void vtkMath_MultiplyScalar_53 (IntPtr a, float s)
static internal void vtkMath_MultiplyScalar_54 (IntPtr a, double s)
static internal void vtkMath_MultiplyScalar2D_55 (IntPtr a, float s)
static internal void vtkMath_MultiplyScalar2D_56 (IntPtr a, double s)
static internal double vtkMath_Nan_57 ()
static internal double vtkMath_NegInf_58 ()
static internal IntPtr vtkMath_NewInstance_60 (HandleRef pThis, ref uint mteStatus, ref uint mteIndex, ref uint rawRefCount)
static internal int vtkMath_NextCombination_61 (int m, int n, IntPtr combination)
static internal float vtkMath_Norm_62 (IntPtr x, int n)
static internal float vtkMath_Norm_63 (IntPtr x)
static internal float vtkMath_Norm2D_64 (IntPtr x)
static internal float vtkMath_Normalize_65 (IntPtr x)
static internal float vtkMath_Normalize2D_66 (IntPtr x)
static internal void vtkMath_Perpendiculars_67 (IntPtr x, IntPtr y, IntPtr z, double theta)
static internal float vtkMath_Pi_68 ()
static internal int vtkMath_PointIsWithinBounds_69 (IntPtr point, IntPtr bounds, IntPtr delta)
static internal byte vtkMath_ProjectVector_70 (IntPtr a, IntPtr b, IntPtr projection)
static internal byte vtkMath_ProjectVector2D_71 (IntPtr a, IntPtr b, IntPtr projection)
static internal void vtkMath_RGBToHSV_72 (IntPtr rgb, IntPtr hsv)
static internal void vtkMath_RGBToHSV_73 (float r, float g, float b, IntPtr h, IntPtr s, IntPtr v)
static internal IntPtr vtkMath_RGBToHSV_74 (IntPtr rgb)
static internal IntPtr vtkMath_RGBToHSV_75 (double r, double g, double b)
static internal void vtkMath_RGBToHSV_76 (double r, double g, double b, IntPtr h, IntPtr s, IntPtr v)
static internal void vtkMath_RGBToLab_77 (IntPtr rgb, IntPtr lab)
static internal void vtkMath_RGBToLab_78 (double red, double green, double blue, IntPtr L, IntPtr a, IntPtr b)
static internal IntPtr vtkMath_RGBToLab_79 (IntPtr rgb)
static internal void vtkMath_RGBToXYZ_80 (IntPtr rgb, IntPtr xyz)
static internal void vtkMath_RGBToXYZ_81 (double r, double g, double b, IntPtr x, IntPtr y, IntPtr z)
static internal IntPtr vtkMath_RGBToXYZ_82 (IntPtr rgb)
static internal float vtkMath_RadiansFromDegrees_83 (float x)
static internal double vtkMath_RadiansFromDegrees_84 (double x)
static internal double vtkMath_Random_85 ()
static internal double vtkMath_Random_86 (double min, double max)
static internal void vtkMath_RandomSeed_87 (int s)
static internal int vtkMath_Round_88 (float f)
static internal int vtkMath_Round_89 (double f)
static internal IntPtr vtkMath_SafeDownCast_90 (HandleRef o, ref uint mteStatus, ref uint mteIndex, ref uint rawRefCount)
static internal double vtkMath_Solve3PointCircle_91 (IntPtr p1, IntPtr p2, IntPtr p3, IntPtr center)
static internal void vtkMath_Subtract_92 (IntPtr a, IntPtr b, IntPtr c)
static internal void vtkMath_UninitializeBounds_93 (IntPtr bounds)
static internal void vtkMath_XYZToLab_94 (IntPtr xyz, IntPtr lab)
static internal void vtkMath_XYZToLab_95 (double x, double y, double z, IntPtr L, IntPtr a, IntPtr b)
static internal IntPtr vtkMath_XYZToLab_96 (IntPtr xyz)
static internal void vtkMath_XYZToRGB_97 (IntPtr xyz, IntPtr rgb)
static internal void vtkMath_XYZToRGB_98 (double x, double y, double z, IntPtr r, IntPtr g, IntPtr b)
static internal IntPtr vtkMath_XYZToRGB_99 (IntPtr xyz)

Static Private Member Functions

static vtkMath ()
 Automatically generated type registration mechanics.

Detailed Description

vtkMath - performs common math operations

Description 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).

vtkMinimalStandardRandomSequence, vtkBoxMuellerRandomSequence


Constructor & Destructor Documentation

static Kitware.VTK.vtkMath.vtkMath ( ) [static, private]

Automatically generated type registration mechanics.

Kitware.VTK.vtkMath.vtkMath ( IntPtr  rawCppThis,
bool  callDisposalMethod,
bool  strong 
)

Automatically generated constructor - called from generated code. DO NOT call directly.

Undocumented Block.


Member Function Documentation

static void Kitware.VTK.vtkMath.Add ( IntPtr  a,
IntPtr  b,
IntPtr  c 
) [static]

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

static int Kitware.VTK.vtkMath.AreBoundsInitialized ( IntPtr  bounds) [static]

Are the bounds initialized?

static IntPtr Kitware.VTK.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 long Kitware.VTK.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 Kitware.VTK.vtkMath.BoundsIsWithinOtherBounds ( IntPtr  bounds1,
IntPtr  bounds2,
IntPtr  delta 
) [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 Kitware.VTK.vtkMath.Ceil ( double  x) [static]

----------------------------------------------------------------------------

static double Kitware.VTK.vtkMath.ClampAndNormalizeValue ( double  value,
IntPtr  range 
) [static]

---------------------------------------------------------------------------

static void Kitware.VTK.vtkMath.ClampValue ( IntPtr  value,
IntPtr  range 
) [static]

----------------------------------------------------------------------------

static void Kitware.VTK.vtkMath.ClampValue ( double  value,
IntPtr  range,
IntPtr  clamped_value 
) [static]

----------------------------------------------------------------------------

static void Kitware.VTK.vtkMath.ClampValues ( IntPtr  values,
int  nb_values,
IntPtr  range 
) [static]

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

static void Kitware.VTK.vtkMath.ClampValues ( IntPtr  values,
int  nb_values,
IntPtr  range,
IntPtr  clamped_values 
) [static]

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

static void Kitware.VTK.vtkMath.Cross ( IntPtr  x,
IntPtr  y,
IntPtr  z 
) [static]

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

static float Kitware.VTK.vtkMath.DegreesFromRadians ( float  x) [static]

----------------------------------------------------------------------------

static double Kitware.VTK.vtkMath.DegreesFromRadians ( double  x) [static]

----------------------------------------------------------------------------

static float Kitware.VTK.vtkMath.Determinant2x2 ( IntPtr  c1,
IntPtr  c2 
) [static]

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

static double Kitware.VTK.vtkMath.Determinant2x2 ( double  a,
double  b,
double  c,
double  d 
) [static]

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

static float Kitware.VTK.vtkMath.Determinant3x3 ( IntPtr  c1,
IntPtr  c2,
IntPtr  c3 
) [static]

----------------------------------------------------------------------------

static double Kitware.VTK.vtkMath.Determinant3x3 ( double  a1,
double  a2,
double  a3,
double  b1,
double  b2,
double  b3,
double  c1,
double  c2,
double  c3 
) [static]

----------------------------------------------------------------------------

override void Kitware.VTK.vtkMath.Dispose ( bool  disposing) [protected]

Automatically generated protected Dispose method - called from public Dispose or the C# destructor. DO NOT call directly.

Reimplemented from Kitware.VTK.vtkObject.

static float Kitware.VTK.vtkMath.Distance2BetweenPoints ( IntPtr  x,
IntPtr  y 
) [static]

----------------------------------------------------------------------------

static float Kitware.VTK.vtkMath.Dot ( IntPtr  x,
IntPtr  y 
) [static]

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

static float Kitware.VTK.vtkMath.Dot2D ( IntPtr  x,
IntPtr  y 
) [static]

Dot product of two 2-vectors.

static double Kitware.VTK.vtkMath.DoublePi ( ) [static]

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

static double Kitware.VTK.vtkMath.DoubleTwoPi ( ) [static]

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

static int Kitware.VTK.vtkMath.ExtentIsWithinOtherExtent ( IntPtr  extent1,
IntPtr  extent2 
) [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 long Kitware.VTK.vtkMath.Factorial ( int  N) [static]

----------------------------------------------------------------------------

static int Kitware.VTK.vtkMath.Floor ( double  x) [static]

----------------------------------------------------------------------------

static void Kitware.VTK.vtkMath.FreeCombination ( IntPtr  combination) [static]

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

static double Kitware.VTK.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 Kitware.VTK.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 double Kitware.VTK.vtkMath.GaussianAmplitude ( double  variance,
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 Kitware.VTK.vtkMath.GaussianAmplitude ( double  mean,
double  variance,
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 Kitware.VTK.vtkMath.GaussianWeight ( double  variance,
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 Kitware.VTK.vtkMath.GaussianWeight ( double  mean,
double  variance,
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 int Kitware.VTK.vtkMath.GetAdjustedScalarRange ( vtkDataArray  array,
int  comp,
IntPtr  range 
) [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 Kitware.VTK.vtkMath.GetScalarTypeFittingRange ( double  range_min,
double  range_max,
double  scale,
double  shift 
) [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 Kitware.VTK.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 void Kitware.VTK.vtkMath.HSVToRGB ( IntPtr  hsv,
IntPtr  rgb 
) [static]

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

static void Kitware.VTK.vtkMath.HSVToRGB ( float  h,
float  s,
float  v,
IntPtr  r,
IntPtr  g,
IntPtr  b 
) [static]

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

static double [] Kitware.VTK.vtkMath.HSVToRGB ( IntPtr  hsv) [static]

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

static double [] Kitware.VTK.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 Kitware.VTK.vtkMath.HSVToRGB ( double  h,
double  s,
double  v,
IntPtr  r,
IntPtr  g,
IntPtr  b 
) [static]

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

static double Kitware.VTK.vtkMath.Inf ( ) [static]

Special IEEE-754 number used to represent positive infinity.

override int Kitware.VTK.vtkMath.IsA ( string  type) [virtual]

Undocumented Block.

Reimplemented from Kitware.VTK.vtkObject.

static int Kitware.VTK.vtkMath.IsInf ( double  x) [static]

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

static int Kitware.VTK.vtkMath.IsNan ( double  x) [static]

Test if a number is equal to the special floating point value Not-A-Number (Nan).

static new int Kitware.VTK.vtkMath.IsTypeOf ( string  type) [static]

Undocumented Block.

Reimplemented from Kitware.VTK.vtkObject.

static void Kitware.VTK.vtkMath.LabToRGB ( IntPtr  lab,
IntPtr  rgb 
) [static]

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

static void Kitware.VTK.vtkMath.LabToRGB ( double  L,
double  a,
double  b,
IntPtr  red,
IntPtr  green,
IntPtr  blue 
) [static]

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

static IntPtr Kitware.VTK.vtkMath.LabToRGB ( IntPtr  lab) [static]

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

static void Kitware.VTK.vtkMath.LabToXYZ ( IntPtr  lab,
IntPtr  xyz 
) [static]

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

static void Kitware.VTK.vtkMath.LabToXYZ ( double  L,
double  a,
double  b,
IntPtr  x,
IntPtr  y,
IntPtr  z 
) [static]

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

static IntPtr Kitware.VTK.vtkMath.LabToXYZ ( IntPtr  lab) [static]

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

static void Kitware.VTK.vtkMath.MultiplyScalar ( IntPtr  a,
float  s 
) [static]

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

static void Kitware.VTK.vtkMath.MultiplyScalar ( IntPtr  a,
double  s 
) [static]

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

static void Kitware.VTK.vtkMath.MultiplyScalar2D ( IntPtr  a,
float  s 
) [static]

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

static void Kitware.VTK.vtkMath.MultiplyScalar2D ( IntPtr  a,
double  s 
) [static]

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

static double Kitware.VTK.vtkMath.Nan ( ) [static]

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

static double Kitware.VTK.vtkMath.NegInf ( ) [static]

Special IEEE-754 number used to represent negative infinity.

static new vtkMath Kitware.VTK.vtkMath.New ( ) [static]

Undocumented Block.

Reimplemented from Kitware.VTK.vtkObject.

Undocumented Block.

Reimplemented from Kitware.VTK.vtkObject.

static int Kitware.VTK.vtkMath.NextCombination ( int  m,
int  n,
IntPtr  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 float Kitware.VTK.vtkMath.Norm ( IntPtr  x,
int  n 
) [static]

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

static float Kitware.VTK.vtkMath.Norm ( IntPtr  x) [static]

Compute the norm of 3-vector.

static float Kitware.VTK.vtkMath.Norm2D ( IntPtr  x) [static]

Compute the norm of a 2-vector.

static float Kitware.VTK.vtkMath.Normalize ( IntPtr  x) [static]

----------------------------------------------------------------------------

static float Kitware.VTK.vtkMath.Normalize2D ( IntPtr  x) [static]

----------------------------------------------------------------------------

static void Kitware.VTK.vtkMath.Perpendiculars ( IntPtr  x,
IntPtr  y,
IntPtr  z,
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 float Kitware.VTK.vtkMath.Pi ( ) [static]

A mathematical constant. This version is 3.14159265358979f.

static int Kitware.VTK.vtkMath.PointIsWithinBounds ( IntPtr  point,
IntPtr  bounds,
IntPtr  delta 
) [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 bool Kitware.VTK.vtkMath.ProjectVector ( IntPtr  a,
IntPtr  b,
IntPtr  projection 
) [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 Kitware.VTK.vtkMath.ProjectVector2D ( IntPtr  a,
IntPtr  b,
IntPtr  projection 
) [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 float Kitware.VTK.vtkMath.RadiansFromDegrees ( float  x) [static]

----------------------------------------------------------------------------

static double Kitware.VTK.vtkMath.RadiansFromDegrees ( double  x) [static]

----------------------------------------------------------------------------

static double Kitware.VTK.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 Kitware.VTK.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 void Kitware.VTK.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 void Kitware.VTK.vtkMath.RGBToHSV ( IntPtr  rgb,
IntPtr  hsv 
) [static]

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

static void Kitware.VTK.vtkMath.RGBToHSV ( float  r,
float  g,
float  b,
IntPtr  h,
IntPtr  s,
IntPtr  v 
) [static]

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

static double [] Kitware.VTK.vtkMath.RGBToHSV ( IntPtr  rgb) [static]

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

static double [] Kitware.VTK.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 Kitware.VTK.vtkMath.RGBToHSV ( double  r,
double  g,
double  b,
IntPtr  h,
IntPtr  s,
IntPtr  v 
) [static]

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

static void Kitware.VTK.vtkMath.RGBToLab ( IntPtr  rgb,
IntPtr  lab 
) [static]

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

static void Kitware.VTK.vtkMath.RGBToLab ( double  red,
double  green,
double  blue,
IntPtr  L,
IntPtr  a,
IntPtr  b 
) [static]

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

static IntPtr Kitware.VTK.vtkMath.RGBToLab ( IntPtr  rgb) [static]

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

static void Kitware.VTK.vtkMath.RGBToXYZ ( IntPtr  rgb,
IntPtr  xyz 
) [static]

Convert color from the RGB system to CIE XYZ.

static void Kitware.VTK.vtkMath.RGBToXYZ ( double  r,
double  g,
double  b,
IntPtr  x,
IntPtr  y,
IntPtr  z 
) [static]

Convert color from the RGB system to CIE XYZ.

static IntPtr Kitware.VTK.vtkMath.RGBToXYZ ( IntPtr  rgb) [static]

Convert color from the RGB system to CIE XYZ.

static int Kitware.VTK.vtkMath.Round ( float  f) [static]

Rounds a float to the nearest integer.

static int Kitware.VTK.vtkMath.Round ( double  f) [static]

Rounds a float to the nearest integer.

Undocumented Block.

Reimplemented from Kitware.VTK.vtkObject.

Here is the call graph for this function:

static double Kitware.VTK.vtkMath.Solve3PointCircle ( IntPtr  p1,
IntPtr  p2,
IntPtr  p3,
IntPtr  center 
) [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 void Kitware.VTK.vtkMath.Subtract ( IntPtr  a,
IntPtr  b,
IntPtr  c 
) [static]

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

static void Kitware.VTK.vtkMath.UninitializeBounds ( IntPtr  bounds) [static]

Set the bounds to an uninitialized state.

static internal void Kitware.VTK.vtkMath.vtkMath_Add_01 ( IntPtr  a,
IntPtr  b,
IntPtr  c 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_AreBoundsInitialized_02 ( IntPtr  bounds) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_BeginCombination_03 ( int  m,
int  n 
) [private]
static internal long Kitware.VTK.vtkMath.vtkMath_Binomial_04 ( int  m,
int  n 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_BoundsIsWithinOtherBounds_05 ( IntPtr  bounds1,
IntPtr  bounds2,
IntPtr  delta 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_Ceil_06 ( double  x) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_ClampAndNormalizeValue_07 ( double  value,
IntPtr  range 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_ClampValue_08 ( IntPtr  value,
IntPtr  range 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_ClampValue_09 ( double  value,
IntPtr  range,
IntPtr  clamped_value 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_ClampValues_10 ( IntPtr  values,
int  nb_values,
IntPtr  range 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_ClampValues_11 ( IntPtr  values,
int  nb_values,
IntPtr  range,
IntPtr  clamped_values 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_Cross_12 ( IntPtr  x,
IntPtr  y,
IntPtr  z 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_DegreesFromRadians_13 ( float  x) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_DegreesFromRadians_14 ( double  x) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Determinant2x2_15 ( IntPtr  c1,
IntPtr  c2 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Determinant2x2_16 ( double  a,
double  b,
double  c,
double  d 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Determinant3x3_17 ( IntPtr  c1,
IntPtr  c2,
IntPtr  c3 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Determinant3x3_18 ( double  a1,
double  a2,
double  a3,
double  b1,
double  b2,
double  b3,
double  c1,
double  c2,
double  c3 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Distance2BetweenPoints_19 ( IntPtr  x,
IntPtr  y 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Dot2D_21 ( IntPtr  x,
IntPtr  y 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Dot_20 ( IntPtr  x,
IntPtr  y 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_DoublePi_22 ( ) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_DoubleTwoPi_23 ( ) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_ExtentIsWithinOtherExtent_24 ( IntPtr  extent1,
IntPtr  extent2 
) [private]
static internal long Kitware.VTK.vtkMath.vtkMath_Factorial_25 ( int  N) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_Floor_26 ( double  x) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_FreeCombination_27 ( IntPtr  combination) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Gaussian_28 ( ) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Gaussian_29 ( double  mean,
double  std 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_GaussianAmplitude_30 ( double  variance,
double  distanceFromMean 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_GaussianAmplitude_31 ( double  mean,
double  variance,
double  position 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_GaussianWeight_32 ( double  variance,
double  distanceFromMean 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_GaussianWeight_33 ( double  mean,
double  variance,
double  position 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_GetAdjustedScalarRange_34 ( HandleRef  array,
int  comp,
IntPtr  range 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_GetScalarTypeFittingRange_35 ( double  range_min,
double  range_max,
double  scale,
double  shift 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_GetSeed_36 ( ) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_HSVToRGB_37 ( IntPtr  hsv,
IntPtr  rgb 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_HSVToRGB_38 ( float  h,
float  s,
float  v,
IntPtr  r,
IntPtr  g,
IntPtr  b 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_HSVToRGB_39 ( IntPtr  hsv) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_HSVToRGB_40 ( double  h,
double  s,
double  v 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_HSVToRGB_41 ( double  h,
double  s,
double  v,
IntPtr  r,
IntPtr  g,
IntPtr  b 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Inf_42 ( ) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_IsA_43 ( HandleRef  pThis,
string  type 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_IsInf_44 ( double  x) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_IsNan_45 ( double  x) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_IsTypeOf_46 ( string  type) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_LabToRGB_47 ( IntPtr  lab,
IntPtr  rgb 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_LabToRGB_48 ( double  L,
double  a,
double  b,
IntPtr  red,
IntPtr  green,
IntPtr  blue 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_LabToRGB_49 ( IntPtr  lab) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_LabToXYZ_50 ( IntPtr  lab,
IntPtr  xyz 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_LabToXYZ_51 ( double  L,
double  a,
double  b,
IntPtr  x,
IntPtr  y,
IntPtr  z 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_LabToXYZ_52 ( IntPtr  lab) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_MultiplyScalar2D_55 ( IntPtr  a,
float  s 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_MultiplyScalar2D_56 ( IntPtr  a,
double  s 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_MultiplyScalar_53 ( IntPtr  a,
float  s 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_MultiplyScalar_54 ( IntPtr  a,
double  s 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Nan_57 ( ) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_NegInf_58 ( ) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_New ( ref uint  mteStatus,
ref uint  mteIndex,
ref uint  rawRefCount 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_NewInstance_60 ( HandleRef  pThis,
ref uint  mteStatus,
ref uint  mteIndex,
ref uint  rawRefCount 
) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_NextCombination_61 ( int  m,
int  n,
IntPtr  combination 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Norm2D_64 ( IntPtr  x) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Norm_62 ( IntPtr  x,
int  n 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Norm_63 ( IntPtr  x) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Normalize2D_66 ( IntPtr  x) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Normalize_65 ( IntPtr  x) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_Perpendiculars_67 ( IntPtr  x,
IntPtr  y,
IntPtr  z,
double  theta 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_Pi_68 ( ) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_PointIsWithinBounds_69 ( IntPtr  point,
IntPtr  bounds,
IntPtr  delta 
) [private]
static internal byte Kitware.VTK.vtkMath.vtkMath_ProjectVector2D_71 ( IntPtr  a,
IntPtr  b,
IntPtr  projection 
) [private]
static internal byte Kitware.VTK.vtkMath.vtkMath_ProjectVector_70 ( IntPtr  a,
IntPtr  b,
IntPtr  projection 
) [private]
static internal float Kitware.VTK.vtkMath.vtkMath_RadiansFromDegrees_83 ( float  x) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_RadiansFromDegrees_84 ( double  x) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Random_85 ( ) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Random_86 ( double  min,
double  max 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RandomSeed_87 ( int  s) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RGBToHSV_72 ( IntPtr  rgb,
IntPtr  hsv 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RGBToHSV_73 ( float  r,
float  g,
float  b,
IntPtr  h,
IntPtr  s,
IntPtr  v 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_RGBToHSV_74 ( IntPtr  rgb) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_RGBToHSV_75 ( double  r,
double  g,
double  b 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RGBToHSV_76 ( double  r,
double  g,
double  b,
IntPtr  h,
IntPtr  s,
IntPtr  v 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RGBToLab_77 ( IntPtr  rgb,
IntPtr  lab 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RGBToLab_78 ( double  red,
double  green,
double  blue,
IntPtr  L,
IntPtr  a,
IntPtr  b 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_RGBToLab_79 ( IntPtr  rgb) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RGBToXYZ_80 ( IntPtr  rgb,
IntPtr  xyz 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_RGBToXYZ_81 ( double  r,
double  g,
double  b,
IntPtr  x,
IntPtr  y,
IntPtr  z 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_RGBToXYZ_82 ( IntPtr  rgb) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_Round_88 ( float  f) [private]
static internal int Kitware.VTK.vtkMath.vtkMath_Round_89 ( double  f) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_SafeDownCast_90 ( HandleRef  o,
ref uint  mteStatus,
ref uint  mteIndex,
ref uint  rawRefCount 
) [private]
static internal double Kitware.VTK.vtkMath.vtkMath_Solve3PointCircle_91 ( IntPtr  p1,
IntPtr  p2,
IntPtr  p3,
IntPtr  center 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_Subtract_92 ( IntPtr  a,
IntPtr  b,
IntPtr  c 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_UninitializeBounds_93 ( IntPtr  bounds) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_XYZToLab_94 ( IntPtr  xyz,
IntPtr  lab 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_XYZToLab_95 ( double  x,
double  y,
double  z,
IntPtr  L,
IntPtr  a,
IntPtr  b 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_XYZToLab_96 ( IntPtr  xyz) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_XYZToRGB_97 ( IntPtr  xyz,
IntPtr  rgb 
) [private]
static internal void Kitware.VTK.vtkMath.vtkMath_XYZToRGB_98 ( double  x,
double  y,
double  z,
IntPtr  r,
IntPtr  g,
IntPtr  b 
) [private]
static internal IntPtr Kitware.VTK.vtkMath.vtkMath_XYZToRGB_99 ( IntPtr  xyz) [private]
static void Kitware.VTK.vtkMath.XYZToLab ( IntPtr  xyz,
IntPtr  lab 
) [static]

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

static void Kitware.VTK.vtkMath.XYZToLab ( double  x,
double  y,
double  z,
IntPtr  L,
IntPtr  a,
IntPtr  b 
) [static]

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

static IntPtr Kitware.VTK.vtkMath.XYZToLab ( IntPtr  xyz) [static]

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

static void Kitware.VTK.vtkMath.XYZToRGB ( IntPtr  xyz,
IntPtr  rgb 
) [static]

Convert color from the CIE XYZ system to RGB.

static void Kitware.VTK.vtkMath.XYZToRGB ( double  x,
double  y,
double  z,
IntPtr  r,
IntPtr  g,
IntPtr  b 
) [static]

Convert color from the CIE XYZ system to RGB.

static IntPtr Kitware.VTK.vtkMath.XYZToRGB ( IntPtr  xyz) [static]

Convert color from the CIE XYZ system to RGB.


Member Data Documentation

new readonly string Kitware.VTK.vtkMath.MRClassNameKey = "7vtkMath" [static]

Automatically generated type registration mechanics.

Reimplemented from Kitware.VTK.vtkObject.

new const string Kitware.VTK.vtkMath.MRFullTypeName = "Kitware.VTK.vtkMath"

Automatically generated type registration mechanics.

Reimplemented from Kitware.VTK.vtkObject.


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