OpenVDB  1.2.0
Namespaces | Classes | Typedefs | Enumerations | Functions
openvdb::v1_2_0::math Namespace Reference

Namespaces

 internal
 

Classes

class  BBox
 Axis-aligned bounding box. More...
 
class  Coord
 Signed (x, y, z) integer coordinates. More...
 
class  CoordBBox
 Axis-aligned bounding box of signed integer coordinates. More...
 
struct  D1
 
struct  D1< CD_2NDT >
 
struct  D1< CD_2ND >
 
struct  D1< CD_4TH >
 
struct  D1< CD_6TH >
 
struct  D1< FD_1ST >
 
struct  D1< FD_2ND >
 
struct  D1< FD_3RD >
 
struct  D1< BD_1ST >
 
struct  D1< BD_2ND >
 
struct  D1< BD_3RD >
 
struct  D1< FD_WENO5 >
 
struct  D1< FD_HJWENO5 >
 
struct  D1< BD_WENO5 >
 
struct  D1< BD_HJWENO5 >
 
struct  D1Vec
 
struct  D1Vec< CD_2NDT >
 
struct  D1Vec< CD_2ND >
 
struct  D1Vec< CD_4TH >
 
struct  D1Vec< CD_6TH >
 
struct  D2
 
struct  D2< CD_SECOND >
 
struct  D2< CD_FOURTH >
 
struct  D2< CD_SIXTH >
 
class  Hermite
 Quantized Hermite data object that stores compressed intersection information (offsets and normlas) for the up-wind edges of a voxel. (Size 10 bytes) More...
 
class  CompoundMap
 Creates the composition of two maps, each of which could be a composition. In the case that each component of the composition classified as linear an acceleration AffineMap is stored. More...
 
struct  is_linear
 Map traits. More...
 
struct  is_linear< AffineMap >
 
struct  is_linear< ScaleMap >
 
struct  is_linear< UniformScaleMap >
 
struct  is_linear< UnitaryMap >
 
struct  is_linear< TranslationMap >
 
struct  is_linear< ScaleTranslateMap >
 
struct  is_linear< UniformScaleTranslateMap >
 
struct  is_linear< CompoundMap< T1, T2 > >
 
struct  is_uniform_scale
 
struct  is_uniform_scale< UniformScaleMap >
 
struct  is_uniform_scale_translate
 
struct  is_uniform_scale_translate< TranslationMap >
 
struct  is_uniform_scale_translate< UniformScaleTranslateMap >
 
struct  is_scale
 
struct  is_scale< ScaleMap >
 
struct  is_scale_translate
 
struct  is_scale_translate< ScaleTranslateMap >
 
struct  is_uniform_diagonal_jacobian
 
struct  is_diagonal_jacobian
 
class  MapBase
 Abstract base class for maps. More...
 
class  MapRegistry
 Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name with a factory function. More...
 
class  AffineMap
 A general linear transform using homogeneous coordinates to perform rotation, scaling, shear and translation. More...
 
class  ScaleMap
 A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions. More...
 
class  UniformScaleMap
 A specialized Affine transform that scales along the principal axis the scaling is uniform in the three-directions. More...
 
class  TranslationMap
 A specialized linear transform that performs a translation. More...
 
class  ScaleTranslateMap
 A specialized Affine transform that scales along the principal axis the scaling need not be uniform in the three-directions, and then translates the result. More...
 
class  UniformScaleTranslateMap
 A specialized Affine transform that uniformaly scales along the principal axis and then translates the result. More...
 
class  UnitaryMap
 A specialized linear transform that performs a unitary maping i.e. rotation and or reflection. More...
 
class  NonlinearFrustumMap
 This map is composed of three steps. Frist it will take a box of size (Lx X Ly X Lz) defined by an member data bounding box and map it into a frustum with near plane (1 X Ly/Lx) and precribed depth Then this frustum is transformed by an internal second map: most often a uniform scale, but other affects can be achieved by accumulating translation, shear and rotation: these are all applied to the second map. More...
 
class  Mat
 
class  Quat
 
class  Vec3
 
class  Mat4
 4x4 -matrix class. More...
 
class  Mat3
 3x3 matrix class. More...
 
class  Vec4
 
class  RandomInt
 Simple random integer generator. More...
 
struct  promote
 
struct  is_vec3d
 
struct  is_vec3d< Vec3d >
 
struct  is_double
 
struct  is_double< double >
 
struct  MapAdapter
 Adapter to associate a map with a world-space operator, giving it the same call signature as an index-space operator. More...
 
struct  ISOpMagnitude
 Adapter for vector-valued index-space operators to return the vector magnitude. More...
 
struct  OpMagnitude
 Adapter for vector-valued world-space operators to return the vector magnitude. More...
 
struct  ISGradient
 Gradient operators defined in index space of various orders. More...
 
struct  BIAS_SCHEME
 
struct  BIAS_SCHEME< FIRST_BIAS >
 
struct  BIAS_SCHEME< SECOND_BIAS >
 
struct  BIAS_SCHEME< THIRD_BIAS >
 
struct  BIAS_SCHEME< WENO5_BIAS >
 
struct  BIAS_SCHEME< HJWENO5_BIAS >
 
struct  ISGradientBiased
 Biased Gradient Operators, using upwinding defined by the Vec3Bias input. More...
 
struct  ISGradientNormSqrd
 
struct  ISLaplacian
 Laplacian defined in index space, using various center-difference stencils. More...
 
struct  ISLaplacian< CD_SECOND >
 
struct  ISLaplacian< CD_FOURTH >
 
struct  ISLaplacian< CD_SIXTH >
 
struct  ISDivergence
 Divergence operator defined in index space using various first derivative schemes. More...
 
struct  ISCurl
 Curl operator defined in index space using various first derivative schemes. More...
 
struct  ISMeanCurvature
 Compute the mean curvature in index space. More...
 
struct  Gradient
 Center difference gradient operators, defined with respect to the range-space of the map. More...
 
struct  Gradient< TranslationMap, DiffScheme >
 
struct  Gradient< UniformScaleMap, CD_2ND >
 
struct  Gradient< UniformScaleTranslateMap, CD_2ND >
 
struct  Gradient< ScaleMap, CD_2ND >
 
struct  Gradient< ScaleTranslateMap, CD_2ND >
 
struct  GradientBiased
 Biased gradient operators, defined with respect to the range-space of the map. More...
 
struct  GradientNormSqrd
 
struct  GradientNormSqrd< UniformScaleMap, GradScheme >
 
struct  GradientNormSqrd< UniformScaleTranslateMap, GradScheme >
 
struct  Divergence
 Compute the divergence of a vector-valued grid using differencing of various orders, the result defined with respect to the range-space of the map. More...
 
struct  Divergence< TranslationMap, DiffScheme >
 
struct  Divergence< UniformScaleMap, DiffScheme >
 
struct  Divergence< UniformScaleTranslateMap, DiffScheme >
 
struct  Divergence< UniformScaleMap, CD_2ND >
 
struct  Divergence< UniformScaleTranslateMap, CD_2ND >
 
struct  Divergence< ScaleMap, DiffScheme >
 
struct  Divergence< ScaleTranslateMap, DiffScheme >
 
struct  Divergence< ScaleMap, CD_2ND >
 
struct  Divergence< ScaleTranslateMap, CD_2ND >
 
struct  Curl
 Compute the curl of a vector-valued grid using differencing of various orders in the space defined by the range of the map. More...
 
struct  Curl< UniformScaleMap, DiffScheme >
 
struct  Curl< UniformScaleTranslateMap, DiffScheme >
 
struct  Curl< UniformScaleMap, CD_2ND >
 
struct  Curl< UniformScaleTranslateMap, CD_2ND >
 
struct  Laplacian
 Compute the Laplacian at a given location in a grid using finite differencing of various orders. The result is defined in the range of the map. More...
 
struct  Laplacian< TranslationMap, DiffScheme >
 
struct  Laplacian< UnitaryMap, DiffScheme >
 
struct  Laplacian< UniformScaleMap, DiffScheme >
 
struct  Laplacian< UniformScaleTranslateMap, DiffScheme >
 
struct  Laplacian< ScaleMap, DiffScheme >
 
struct  Laplacian< ScaleTranslateMap, DiffScheme >
 
struct  CPT
 Compute the closest-point transform to a level set. More...
 
struct  CPT_RANGE
 Compute the closest-point transform to a level set. More...
 
struct  MeanCurvature
 Compute the mean curvature. More...
 
struct  MeanCurvature< TranslationMap, DiffScheme2, DiffScheme1 >
 
struct  MeanCurvature< UniformScaleMap, DiffScheme2, DiffScheme1 >
 
struct  MeanCurvature< UniformScaleTranslateMap, DiffScheme2, DiffScheme1 >
 
class  GenericMap
 A wrapper that holds a MapBase::ConstPtr and exposes a reduced set of functionality needed by the mathematical operators. More...
 
class  QuantizedUnitVec
 
class  Stats
 This class computes statistics (minimum value, maximum value, mean, variance and standard deviation) of a population of floating-point values. More...
 
class  Histogram
 This class computes a histogram, with a fixed interval width, of a population of floating-point values. More...
 
class  BaseStencil
 
class  SevenPointStencil
 
class  SecondOrderDenseStencil
 
class  ThirteenPointStencil
 
class  FourthOrderDenseStencil
 
class  NineteenPointStencil
 
class  SixthOrderDenseStencil
 
class  GradStencil
 
class  WenoStencil
 This is a special 19-point stencil that supports optimal fifth-order WENO upwinding, second-order central differencing, Laplacian, and zero-crossing test. More...
 
class  CurvatureStencil
 
class  DenseStencil
 Dense stencil of a given width. More...
 
class  Transform
 Calculate an axis-aligned bounding box in index space from a bounding sphere in world space. More...
 
class  Tuple
 
struct  TupleAbs
 Helper class to compute the absolute value of a Tuple. More...
 
struct  TupleAbs< SIZE, T, true >
 
class  Mat2
 
class  Vec2
 

Typedefs

typedef CompoundMap
< UnitaryMap, TranslationMap
UnitaryAndTranslationMap
 
typedef CompoundMap
< CompoundMap< UnitaryMap,
ScaleMap >, UnitaryMap
SpectralDecomposedMap
 
typedef SpectralDecomposedMap SymmetricMap
 
typedef CompoundMap
< SymmetricMap,
UnitaryAndTranslationMap
FullyDecomposedMap
 
typedef CompoundMap
< SymmetricMap, UnitaryMap
PolarDecomposedMap
 
typedef Mat3< float > Mat3s
 
typedef Mat3< double > Mat3d
 
typedef Mat3s Mat3f
 
typedef Mat4< float > Mat4s
 
typedef Mat4< double > Mat4d
 
typedef Mat4s Mat4f
 
typedef Quat< float > Quats
 
typedef Quat< double > Quatd
 
typedef Vec2< float > Vec2s
 
typedef Vec2< int > Vec2i
 
typedef Vec2< unsigned int > Vec2ui
 
typedef Vec2< double > Vec2d
 
typedef Vec2s Vec2f
 
typedef Vec3< int > Vec3i
 
typedef Vec3< unsigned int > Vec3ui
 
typedef Vec3< float > Vec3s
 
typedef Vec3< double > Vec3d
 
typedef Vec3s Vec3f
 
typedef Vec4< int > Vec4i
 
typedef Vec4< unsigned int > Vec4ui
 
typedef Vec4< float > Vec4s
 
typedef Vec4< double > Vec4d
 
typedef Vec4s Vec4f
 

Enumerations

enum  DScheme {
  UNKNOWN_DS = -1, CD_2NDT = 0, CD_2ND, CD_4TH,
  CD_6TH, FD_1ST, FD_2ND, FD_3RD,
  BD_1ST, BD_2ND, BD_3RD, FD_WENO5,
  BD_WENO5, FD_HJWENO5, BD_HJWENO5
}
 Different discrete schemes used in the first derivatives. More...
 
enum  { NUM_DS_SCHEMES = BD_HJWENO5 + 1 }
 
enum  DDScheme { UNKNOWN_DD = -1, CD_SECOND = 0, CD_FOURTH, CD_SIXTH }
 Different discrete schemes used in the second derivatives. More...
 
enum  { NUM_DD_SCHEMES = CD_SIXTH + 1 }
 
enum  BiasedGradientScheme {
  UNKNOWN_BIAS = -1, FIRST_BIAS = 0, SECOND_BIAS, THIRD_BIAS,
  WENO5_BIAS, HJWENO5_BIAS
}
 Biased Gradients are limited to non-centered differences. More...
 
enum  { NUM_BIAS_SCHEMES = HJWENO5_BIAS + 1 }
 
enum  TemporalIntegrationScheme { UNKNOWN_TIS = -1, TVD_RK1, TVD_RK2, TVD_RK3 }
 Temporal integrations schemes. More...
 
enum  { NUM_TEMPORAL_SCHEMES = TVD_RK3 + 1 }
 
enum  Axis { X_AXIS = 0, Y_AXIS = 1, Z_AXIS = 2 }
 
enum  RotationOrder {
  XYZ_ROTATION = 0, XZY_ROTATION, YXZ_ROTATION, YZX_ROTATION,
  ZXY_ROTATION, ZYX_ROTATION, XZX_ROTATION, ZXZ_ROTATION
}
 

Functions

template<class VectorType >
std::ostream & operator<< (std::ostream &os, const BBox< VectorType > &b)
 
std::ostream & operator<< (std::ostream &os, const Coord &xyz)
 
std::ostream & operator<< (std::ostream &os, const CoordBBox &b)
 
std::string dsSchemeToString (DScheme dss)
 
DScheme stringToDScheme (const std::string &s)
 
std::string dsSchemeToMenuName (DScheme dss)
 
std::string biasedGradientSchemeToString (BiasedGradientScheme bgs)
 
BiasedGradientScheme stringToBiasedGradientScheme (const std::string &s)
 
std::string biasedGradientSchemeToMenuName (BiasedGradientScheme bgs)
 
std::string temporalIntegrationSchemeToString (TemporalIntegrationScheme tis)
 
TemporalIntegrationScheme stringToTemporalIntegrationScheme (const std::string &s)
 
std::string temporalIntegrationSchemeToMenuName (TemporalIntegrationScheme tis)
 
template<typename ValueType >
ValueType WENO5 (const ValueType &v1, const ValueType &v2, const ValueType &v3, const ValueType &v4, const ValueType &v5, float scale2=0.01)
 implimentation of nonimally fith-order finite-difference WENO. This function returns the numerical flux. See "High Order Finite Difference and Finite Volume WENO Schemes and Discontinuous Galerkin Methods for CFD" - Chi-Wang Shu ICASE Report No 2001-11 (page 6). Also see ICASE No 97-65 for a more complete reference (Shu, 1997) Given v1 = f(x-2dx), v2 = f(x-dx), v3 = f(x), v4 = f(x+dx), v5 = f(x+2dx), the returns and interpolated value f(x+dx/2) with the special property that ( f(x+dx/2) - f(x-dx/2) ) / dx = df/dx (x) + error, where the error is 5-order in smooth regions: O(dx) <= error <=O(dx^5) More...
 
template<typename Real >
Real GudonovsNormSqrd (bool isOutside, Real dP_xm, Real dP_xp, Real dP_ym, Real dP_yp, Real dP_zm, Real dP_zp)
 
template<typename Real >
Real GudonovsNormSqrd (bool isOutside, const Vec3< Real > &gradient_m, const Vec3< Real > &gradient_p)
 
std::ostream & operator<< (std::ostream &ostr, const Hermite &rhs)
 
bool isApproxEqual (const Hermite &lhs, const Hermite &rhs)
 
bool isApproxEqual (const Hermite &lhs, const Hermite &rhs, const Hermite &)
 
OPENVDB_API boost::shared_ptr
< SymmetricMap
createSymmetricMap (const Mat3d &m)
 Utility methods. More...
 
OPENVDB_API boost::shared_ptr
< FullyDecomposedMap
createFullyDecomposedMap (const Mat4d &m)
 General decomposition of a Matrix into a Unitary (e.g. rotation) following a Symmetric (e.g. stretch & shear) More...
 
OPENVDB_API boost::shared_ptr
< PolarDecomposedMap
createPolarDecomposedMap (const Mat3d &m)
 Decomposes a general linear into translation following polar decomposition. More...
 
OPENVDB_API boost::shared_ptr
< MapBase
simplify (boost::shared_ptr< AffineMap > affine)
 reduces an AffineMap to a ScaleMap or a ScaleTranslateMap when it can More...
 
OPENVDB_API Mat4d approxInverse (const Mat4d &mat)
 Returns the left pseudoInverse of the input matrix when the 3x3 part is symmetric otherwise it zeros the 3x3 and reverses the translation. More...
 
template<class MatType >
MatType rotation (const Quat< typename MatType::value_type > &q, typename MatType::value_type eps=1.0e-8)
 
template<class MatType >
MatType rotation (Axis axis, typename MatType::value_type angle)
 Set the matrix to a rotation about the given axis. More...
 
template<class MatType >
MatType rotation (const Vec3< typename MatType::value_type > &_axis, typename MatType::value_type angle)
 
template<class MatType >
Vec3< typename
MatType::value_type > 
eulerAngles (const MatType &mat, RotationOrder rotationOrder, typename MatType::value_type eps=1.0e-8)
 
template<class MatType >
MatType rotation (const Vec3< typename MatType::value_type > &_v1, const Vec3< typename MatType::value_type > &_v2, typename MatType::value_type eps=1.0e-8)
 Set the matrix to a rotation that maps v1 onto v2 about the cross product of v1 and v2. More...
 
template<class MatType >
MatType scale (const Vec3< typename MatType::value_type > &scaling)
 
template<class MatType >
Vec3< typename
MatType::value_type > 
getScale (const MatType &mat)
 
template<class MatType >
MatType unit (const MatType &mat, typename MatType::value_type eps=1.0e-8)
 
template<class MatType >
MatType unit (const MatType &in, typename MatType::value_type eps, Vec3< typename MatType::value_type > &scaling)
 
template<class MatType >
MatType shear (Axis axis0, Axis axis1, typename MatType::value_type shear)
 Set the matrix to a shear along axis0 by a fraction of axis1. More...
 
template<class MatType >
MatType skew (const Vec3< typename MatType::value_type > &skew)
 
template<class MatType >
MatType aim (const Vec3< typename MatType::value_type > &direction, const Vec3< typename MatType::value_type > &vertical)
 
template<class MatType >
static MatType & padMat4 (MatType &dest)
 
template<typename MatType >
void sqrtSolve (const MatType &aA, MatType &aB, double aTol=0.01)
 
template<typename MatType >
void powSolve (const MatType &aA, MatType &aB, double aPower, double aTol=0.01)
 
template<typename MatType >
bool isIdentity (const MatType &m)
 
template<typename MatType >
bool isInvertible (const MatType &m)
 
template<typename MatType >
bool isSymmetric (const MatType &m)
 
template<typename MatType >
bool isUnitary (const MatType &m)
 Determine is a matrix is Unitary (i.e. rotation or reflection) More...
 
template<typename MatType >
bool isDiagonal (const MatType &mat)
 Determine if a matrix is diagonal. More...
 
template<typename MatType >
MatType::ValueType lInfinityNorm (const MatType &matrix)
 takes a n by n matrix and returns the L_Infinty norm More...
 
template<typename MatType >
MatType::ValueType lOneNorm (const MatType &matrix)
 takes an n by n matrix and returns the L_1 norm More...
 
template<typename MatType >
bool polarDecomposition (const MatType &input, MatType &unitary, MatType &positive_hermitian, unsigned int MAX_ITERATIONS=100)
 Decompose an invertible 3x3 matrix into Unitary following a symmetric matrix (postitive semi-defininte Hermitian): i.e. M = U * S if the Unitary.det() = 1 it is a rotation, otherwise Unitary.det() = -1, meaning there is some part reflection. See "Computing the polar decomposition with applications" Higham, N.J. - SIAM J. Sc. Stat Comput 7(4):1160-1174. More...
 
template<typename T0 , typename T1 >
Mat3< typename promote< T0, T1 >
::type > 
operator* (const Mat3< T0 > &m0, const Mat3< T1 > &m1)
 Matrix multiplication. More...
 
template<typename T >
Mat3< T > outerProduct (const Vec3< T > &v1, const Vec3< T > &v2)
 
template<typename T , typename T0 >
Mat3< T > powLerp (const Mat3< T0 > &m1, const Mat3< T0 > &m2, T t)
 
template<typename T >
bool diagonalizeSymmetricMatrix (const Mat3< T > &input, Mat3< T > &Q, Vec3< T > &D, unsigned int MAX_ITERATIONS=250)
 Use Jacobi iterations to decompose a symmetric 3x3 matrix (diagonalize and compute eigenvectors) More...
 
template<typename T0 , typename T1 >
Vec3< T1 > transformNormal (const Mat4< T0 > &m, const Vec3< T1 > &n)
 
template<typename T >
bool isAffine (const Mat4< T > &m)
 
template<typename T >
bool hasTranslation (const Mat4< T > &m)
 
void randSeed (unsigned int seed)
 Initialize the random number generator. More...
 
double randUniform ()
 Return a random number in the interval [0,1]. More...
 
template<typename Type >
Type Clamp (Type x, Type min, Type max)
 Return x clamped to [min, max]. More...
 
template<typename Type >
Type Clamp01 (Type x)
 Return x clamped to [0, 1]. More...
 
template<typename Type >
bool ClampTest01 (Type &x)
 Return true if x is outside [0,1]. More...
 
template<typename Type >
Type SmoothUnitStep (Type x, Type min, Type max)
 Return 0 if x < min, 1 if x > max or else $(3-2t)t^2$, where $t = (x-min)/(max-min)$. More...
 
template<typename Type >
bool isZero (const Type &x)
 Return true if x is exactly equal to zero. More...
 
template<typename Type >
bool isApproxZero (const Type &x)
 Return true if x is equal to zero to within the default floating-point comparison tolerance. More...
 
template<typename Type >
bool isApproxZero (const Type &x, const Type &tolerance)
 Return true if x is equal to zero to within the given tolerance. More...
 
template<typename Type >
bool isNegative (const Type &x)
 
template<typename Type >
bool isApproxEqual (const Type &a, const Type &b)
 
template<typename Type >
bool isApproxEqual (const Type &a, const Type &b, const Type &tolerance)
 
template<>
bool isApproxEqual< bool > (const bool &a, const bool &b)
 
template<>
bool isApproxEqual< bool > (const bool &a, const bool &b, const bool &)
 
template<>
bool isApproxEqual< std::string > (const std::string &a, const std::string &b)
 
template<>
bool isApproxEqual< std::string > (const std::string &a, const std::string &b, const std::string &)
 
template<typename T0 , typename T1 >
bool isExactlyEqual (const T0 &a, const T1 &b)
 
template<typename Type >
bool isRelOrApproxEqual (const Type &a, const Type &b, const Type &absTol, const Type &relTol)
 
template<>
bool isRelOrApproxEqual (const bool &a, const bool &b, const bool &, const bool &)
 
int32_t floatToInt32 (const float aFloatValue)
 
int64_t doubleToInt64 (const double aDoubleValue)
 
bool isUlpsEqual (const double aLeft, const double aRight, const int64_t aUnitsInLastPlace)
 
bool isUlpsEqual (const float aLeft, const float aRight, const int32_t aUnitsInLastPlace)
 
template<typename Type >
Type Pow2 (Type x)
 Return $ x^2 $. More...
 
template<typename Type >
Type Pow3 (Type x)
 Return $ x^3 $. More...
 
template<typename Type >
Type Pow4 (Type x)
 Return $ x^4 $. More...
 
template<typename Type >
Type Pow (Type x, int n)
 Return $ x^n $. More...
 
template<typename Type >
const Type & Max (const Type &a, const Type &b)
 Return the maximum of two values. More...
 
template<typename Type >
const Type & Max (const Type &a, const Type &b, const Type &c)
 Return the maximum of three values. More...
 
template<typename Type >
const Type & Max (const Type &a, const Type &b, const Type &c, const Type &d)
 Return the maximum of four values. More...
 
template<typename Type >
const Type & Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e)
 Return the maximum of five values. More...
 
template<typename Type >
const Type & Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f)
 Return the maximum of six values. More...
 
template<typename Type >
const Type & Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g)
 Return the maximum of seven values. More...
 
template<typename Type >
const Type & Max (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g, const Type &h)
 Return the maximum of eight values. More...
 
template<typename Type >
const Type & Min (const Type &a, const Type &b)
 Return the minimum of two values. More...
 
template<typename Type >
const Type & Min (const Type &a, const Type &b, const Type &c)
 Return the minimum of three values. More...
 
template<typename Type >
const Type & Min (const Type &a, const Type &b, const Type &c, const Type &d)
 Return the minimum of four values. More...
 
template<typename Type >
const Type & Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e)
 Return the minimum of five values. More...
 
template<typename Type >
const Type & Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f)
 Return the minimum of six values. More...
 
template<typename Type >
const Type & Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g)
 Return the minimum of seven values. More...
 
template<typename Type >
const Type & Min (const Type &a, const Type &b, const Type &c, const Type &d, const Type &e, const Type &f, const Type &g, const Type &h)
 Return the minimum of eight values. More...
 
template<typename Type >
int Sign (const Type &x)
 Return the sign of the given value as an integer (either -1, 0 or 1). More...
 
template<typename Type >
bool SignChange (const Type &a, const Type &b)
 Return true if a and b have different signs. More...
 
template<typename Type >
bool ZeroCrossing (const Type &a, const Type &b)
 Return true if the interval [a, b] includes zero, i.e., if either a or b is zero of if they have different signs. More...
 
template<typename Type >
Type RoundUp (Type x, Type base)
 Return x rounded up to the nearest multiple of base. More...
 
template<typename Type >
Type RoundDown (Type x, Type base)
 Return x rounded down to the nearest multiple of base. More...
 
template<typename Type >
Type IntegerPart (Type x)
 Return the integer part of x. More...
 
template<typename Type >
Type FractionalPart (Type x)
 Return the fractional part of x. More...
 
template<typename Type >
Type Chop (Type x, Type delta)
 Return x if it is greater in magnitude than delta. Otherwise, return zero. More...
 
template<typename Type >
Type Truncate (Type x, unsigned int digits)
 Return x truncated to the given number of decimal digits. More...
 
template<typename Type >
Type Inv (Type x)
 Return the inverse of x. More...
 
template<typename Vec3T >
size_t MinIndex (const Vec3T &v)
 Return the index [0,1,2] of the smallest value in a 3D vector. More...
 
template<typename Vec3T >
size_t MaxIndex (const Vec3T &v)
 Return the index [0,1,2] of the largest value in a 3D vector. More...
 
OPENVDB_API Vec3d closestPointOnTriangleToPoint (const Vec3d &a, const Vec3d &b, const Vec3d &c, const Vec3d &p, Vec3d &uvw)
 Closest Point on Triangle to Point. Given a triangle abc and a point p, returns the point on abc closest to p and the corresponding barycentric coordinates. More...
 
OPENVDB_API OPENVDB_DEPRECATED
double 
sLineSeg3ToPointDistSqr (const Vec3d &p0, const Vec3d &p1, const Vec3d &point, double &t, double epsilon=1e-10)
 Squared distance of a line segment p(t) = (1-t)*p0 + t*p1 to point. More...
 
OPENVDB_API OPENVDB_DEPRECATED
double 
sTri3ToPointDistSqr (const Vec3d &v0, const Vec3d &v1, const Vec3d &v2, const Vec3d &point, Vec2d &uv, double epsilon)
 Slightly modified version of the algorithm described in "Geometric Tools for Computer Graphics" pg 376 to 382 by Schneider and Eberly. Extended to handle the case of a degenerate triangle. Also returns barycentric rather than (s,t) coordinates. More...
 
static OPENVDB_DEPRECATED double triToPtnDistSqr (const Vec3d &v0, const Vec3d &v1, const Vec3d &v2, const Vec3d &point)
 
template<typename T >
Quat< T > slerp (const Quat< T > &q1, const Quat< T > &q2, T t, T tolerance=0.00001)
 Linear interpolation between the two quaternions. More...
 
template<typename S , typename T >
Quat< T > operator* (S scalar, const Quat< T > &q)
 Returns V, where $V_i = v_i * scalar$ for $i \in [0, 3]$. More...
 
template<typename T , typename T0 >
Mat3< T > slerp (const Mat3< T0 > &m1, const Mat3< T0 > &m2, T t)
 Interpolate between m1 and m2. Converts to quaternion form and uses slerp m1 and m2 must be rotation matrices! More...
 
template<typename T , typename T0 >
Mat3< T > bezLerp (const Mat3< T0 > &m1, const Mat3< T0 > &m2, const Mat3< T0 > &m3, const Mat3< T0 > &m4, T t)
 
OPENVDB_API void calculateBounds (const Transform &t, const Vec3d &minWS, const Vec3d &maxWS, Vec3d &minIS, Vec3d &maxIS)
 Calculate an axis-aligned bounding box in index space from an axis-aligned bounding box in world space. More...
 
OPENVDB_API std::ostream & operator<< (std::ostream &, const Transform &)
 
template<typename ResolvedMapType , typename OpType >
void doProcessTypedMap (Transform &transform, OpType &op)
 Helper function used internally by processTypedMap() More...
 
template<typename ResolvedMapType , typename OpType >
void doProcessTypedMap (const Transform &transform, OpType &op)
 Helper function used internally by processTypedMap() More...
 
template<typename TransformType , typename OpType >
bool processTypedMap (TransformType &transform, OpType &op)
 Utility function that, given a generic map pointer, calls a functor on the fully-resoved map. More...
 
template<int SIZE, typename T0 , typename T1 >
bool operator< (const Tuple< SIZE, T0 > &t0, const Tuple< SIZE, T1 > &t1)
 
template<int SIZE, typename T0 , typename T1 >
bool operator> (const Tuple< SIZE, T0 > &t0, const Tuple< SIZE, T1 > &t1)
 
template<int SIZE, typename T >
Tuple< SIZE, T > Abs (const Tuple< SIZE, T > &t)
 
template<int SIZE, typename T >
std::ostream & operator<< (std::ostream &ostr, const Tuple< SIZE, T > &classname)
 Write a Tuple to an output stream. More...
 
template<typename S , typename T >
Vec2< typename promote< S, T >
::type > 
operator* (S scalar, const Vec2< T > &v)
 Returns V, where $V_i = v_i * scalar$ for $i \in [0, 1]$. More...
 
template<typename S , typename T >
Vec2< typename promote< S, T >
::type > 
operator* (const Vec2< T > &v, S scalar)
 Returns V, where $V_i = v_i * scalar$ for $i \in [0, 1]$. More...
 
template<typename T0 , typename T1 >
Vec2< typename promote< T0, T1 >
::type > 
operator* (const Vec2< T0 > &v0, const Vec2< T1 > &v1)
 Returns V, where $V_i = v0_i * v1_i$ for $i \in [0, 1]$. More...
 
template<typename S , typename T >
Vec2< typename promote< S, T >
::type > 
operator/ (S scalar, const Vec2< T > &v)
 Returns V, where $V_i = scalar / v_i$ for $i \in [0, 1]$. More...
 
template<typename S , typename T >
Vec2< typename promote< S, T >
::type > 
operator/ (const Vec2< T > &v, S scalar)
 Returns V, where $V_i = v_i / scalar$ for $i \in [0, 1]$. More...
 
template<typename T0 , typename T1 >
Vec2< typename promote< T0, T1 >
::type > 
operator/ (const Vec2< T0 > &v0, const Vec2< T1 > &v1)
 Returns V, where $V_i = v0_i / v1_i$ for $i \in [0, 1]$. More...
 
template<typename T0 , typename T1 >
Vec2< typename promote< T0, T1 >
::type > 
operator+ (const Vec2< T0 > &v0, const Vec2< T1 > &v1)
 Returns V, where $V_i = v0_i + v1_i$ for $i \in [0, 1]$. More...
 
template<typename S , typename T >
Vec2< typename promote< S, T >
::type > 
operator+ (const Vec2< T > &v, S scalar)
 Returns V, where $V_i = v_i + scalar$ for $i \in [0, 1]$. More...
 
template<typename T0 , typename T1 >
Vec2< typename promote< T0, T1 >
::type > 
operator- (const Vec2< T0 > &v0, const Vec2< T1 > &v1)
 Returns V, where $V_i = v0_i - v1_i$ for $i \in [0, 1]$. More...
 
template<typename S , typename T >
Vec2< typename promote< S, T >
::type > 
operator- (const Vec2< T > &v, S scalar)
 Returns V, where $V_i = v_i - scalar$ for $i \in [0, 1]$. More...
 
template<typename T >
angle (const Vec2< T > &v1, const Vec2< T > &v2)
 
template<typename T >
bool isApproxEqual (const Vec2< T > &a, const Vec2< T > &b)
 
template<typename T >
bool isApproxEqual (const Vec2< T > &a, const Vec2< T > &b, const Vec2< T > &eps)
 
template<typename T >
void orthonormalize (Vec2< T > &v1, Vec2< T > &v2)
 
template<typename T >
Vec2< T > minComponent (const Vec2< T > &v1, const Vec2< T > &v2)
 Return component-wise minimum of the two vectors. More...
 
template<typename T >
Vec2< T > maxComponent (const Vec2< T > &v1, const Vec2< T > &v2)
 Return component-wise maximum of the two vectors. More...
 
template<typename T0 , typename T1 >
bool operator== (const Vec3< T0 > &v0, const Vec3< T1 > &v1)
 Equality operator, does exact floating point comparisons. More...
 
template<typename T0 , typename T1 >
bool operator!= (const Vec3< T0 > &v0, const Vec3< T1 > &v1)
 Inequality operator, does exact floating point comparisons. More...
 
template<typename S , typename T >
Vec3< typename promote< S, T >
::type > 
operator* (S scalar, const Vec3< T > &v)
 Returns V, where $V_i = v_i * scalar$ for $i \in [0, 2]$. More...
 
template<typename S , typename T >
Vec3< typename promote< S, T >
::type > 
operator* (const Vec3< T > &v, S scalar)
 Returns V, where $V_i = v_i * scalar$ for $i \in [0, 2]$. More...
 
template<typename T0 , typename T1 >
Vec3< typename promote< T0, T1 >
::type > 
operator* (const Vec3< T0 > &v0, const Vec3< T1 > &v1)
 Returns V, where $V_i = v0_i * v1_i$ for $i \in [0, 2]$. More...
 
template<typename S , typename T >
Vec3< typename promote< S, T >
::type > 
operator/ (S scalar, const Vec3< T > &v)
 Returns V, where $V_i = scalar / v_i$ for $i \in [0, 2]$. More...
 
template<typename S , typename T >
Vec3< typename promote< S, T >
::type > 
operator/ (const Vec3< T > &v, S scalar)
 Returns V, where $V_i = v_i / scalar$ for $i \in [0, 2]$. More...
 
template<typename T0 , typename T1 >
Vec3< typename promote< T0, T1 >
::type > 
operator/ (const Vec3< T0 > &v0, const Vec3< T1 > &v1)
 Returns V, where $V_i = v0_i / v1_i$ for $i \in [0, 2]$. More...
 
template<typename T0 , typename T1 >
Vec3< typename promote< T0, T1 >
::type > 
operator+ (const Vec3< T0 > &v0, const Vec3< T1 > &v1)
 Returns V, where $V_i = v0_i + v1_i$ for $i \in [0, 2]$. More...
 
template<typename S , typename T >
Vec3< typename promote< S, T >
::type > 
operator+ (const Vec3< T > &v, S scalar)
 Returns V, where $V_i = v_i + scalar$ for $i \in [0, 2]$. More...
 
template<typename T0 , typename T1 >
Vec3< typename promote< T0, T1 >
::type > 
operator- (const Vec3< T0 > &v0, const Vec3< T1 > &v1)
 Returns V, where $V_i = v0_i - v1_i$ for $i \in [0, 2]$. More...
 
template<typename S , typename T >
Vec3< typename promote< S, T >
::type > 
operator- (const Vec3< T > &v, S scalar)
 Returns V, where $V_i = v_i - scalar$ for $i \in [0, 2]$. More...
 
template<typename T >
angle (const Vec3< T > &v1, const Vec3< T > &v2)
 
template<typename T >
bool isApproxEqual (const Vec3< T > &a, const Vec3< T > &b)
 
template<typename T >
bool isApproxEqual (const Vec3< T > &a, const Vec3< T > &b, const Vec3< T > &eps)
 
template<typename T >
void orthonormalize (Vec3< T > &v1, Vec3< T > &v2, Vec3< T > &v3)
 
template<typename T >
Vec3< T > minComponent (const Vec3< T > &v1, const Vec3< T > &v2)
 Return component-wise minimum of the two vectors. More...
 
template<typename T >
Vec3< T > maxComponent (const Vec3< T > &v1, const Vec3< T > &v2)
 Return component-wise maximum of the two vectors. More...
 
template<typename T0 , typename T1 >
bool operator== (const Vec4< T0 > &v0, const Vec4< T1 > &v1)
 Equality operator, does exact floating point comparisons. More...
 
template<typename T0 , typename T1 >
bool operator!= (const Vec4< T0 > &v0, const Vec4< T1 > &v1)
 Inequality operator, does exact floating point comparisons. More...
 
template<typename S , typename T >
Vec4< typename promote< S, T >
::type > 
operator* (S scalar, const Vec4< T > &v)
 Returns V, where $V_i = v_i * scalar$ for $i \in [0, 3]$. More...
 
template<typename S , typename T >
Vec4< typename promote< S, T >
::type > 
operator* (const Vec4< T > &v, S scalar)
 Returns V, where $V_i = v_i * scalar$ for $i \in [0, 3]$. More...
 
template<typename T0 , typename T1 >
Vec4< typename promote< T0, T1 >
::type > 
operator* (const Vec4< T0 > &v0, const Vec4< T1 > &v1)
 Returns V, where $V_i = v0_i * v1_i$ for $i \in [0, 3]$. More...
 
template<typename S , typename T >
Vec4< typename promote< S, T >
::type > 
operator/ (S scalar, const Vec4< T > &v)
 Returns V, where $V_i = scalar / v_i$ for $i \in [0, 3]$. More...
 
template<typename S , typename T >
Vec4< typename promote< S, T >
::type > 
operator/ (const Vec4< T > &v, S scalar)
 Returns V, where $V_i = v_i / scalar$ for $i \in [0, 3]$. More...
 
template<typename T0 , typename T1 >
Vec4< typename promote< T0, T1 >
::type > 
operator/ (const Vec4< T0 > &v0, const Vec4< T1 > &v1)
 Returns V, where $V_i = v0_i / v1_i$ for $i \in [0, 3]$. More...
 
template<typename T0 , typename T1 >
Vec4< typename promote< T0, T1 >
::type > 
operator+ (const Vec4< T0 > &v0, const Vec4< T1 > &v1)
 Returns V, where $V_i = v0_i + v1_i$ for $i \in [0, 3]$. More...
 
template<typename S , typename T >
Vec4< typename promote< S, T >
::type > 
operator+ (const Vec4< T > &v, S scalar)
 Returns V, where $V_i = v_i + scalar$ for $i \in [0, 3]$. More...
 
template<typename T0 , typename T1 >
Vec4< typename promote< T0, T1 >
::type > 
operator- (const Vec4< T0 > &v0, const Vec4< T1 > &v1)
 Returns V, where $V_i = v0_i - v1_i$ for $i \in [0, 3]$. More...
 
template<typename S , typename T >
Vec4< typename promote< S, T >
::type > 
operator- (const Vec4< T > &v, S scalar)
 Returns V, where $V_i = v_i - scalar$ for $i \in [0, 3]$. More...
 
template<typename T >
Vec4< T > minComponent (const Vec4< T > &v1, const Vec4< T > &v2)
 Return component-wise minimum of the two vectors. More...
 
template<typename T >
Vec4< T > maxComponent (const Vec4< T > &v1, const Vec4< T > &v2)
 Return component-wise maximum of the two vectors. More...
 
template<typename T >
Vec3< typename promote< T,
typename Coord::ValueType >
::type > 
operator+ (const Vec3< T > &v0, const Coord &v1)
 Allow a Coord to be added to or subtracted from a Vec3. More...
 
template<typename T >
Vec3< typename promote< T,
typename Coord::ValueType >
::type > 
operator+ (const Coord &v1, const Vec3< T > &v0)
 Allow a Coord to be added to or subtracted from a Vec3. More...
 
template<typename T >
Vec3< typename promote< T,
Coord::ValueType >::type > 
operator- (const Vec3< T > &v0, const Coord &v1)
 Allow a Coord to be subtracted from a Vec3. More...
 
template<typename T >
Vec3< typename promote< T,
Coord::ValueType >::type > 
operator- (const Coord &v1, const Vec3< T > &v0)
 Allow a Coord to be subtracted from a Vec3. More...
 
OPENVDB_API Hermite min (const Hermite &, const Hermite &)
 min and max operations done directly on the compressed data. More...
 
OPENVDB_API Hermite max (const Hermite &, const Hermite &)
 min and max operations done directly on the compressed data. More...
 
int32_t Abs (int32_t i)
 Return the absolute value of the given quantity. More...
 
int64_t Abs (int64_t i)
 Return the absolute value of the given quantity. More...
 
float Abs (float x)
 Return the absolute value of the given quantity. More...
 
double Abs (double x)
 Return the absolute value of the given quantity. More...
 
long double Abs (long double x)
 Return the absolute value of the given quantity. More...
 
uint32_t Abs (uint32_t i)
 Return the absolute value of the given quantity. More...
 
uint64_t Abs (uint64_t i)
 Return the absolute value of the given quantity. More...
 
float Pow (float b, float e)
 Return $ b^e $. More...
 
double Pow (double b, double e)
 Return $ b^e $. More...
 
float Sqrt (float x)
 Return the square root of a floating-point value. More...
 
double Sqrt (double x)
 Return the square root of a floating-point value. More...
 
long double Sqrt (long double x)
 Return the square root of a floating-point value. More...
 
float Cbrt (float x)
 Return the cube root of a floating-point value. More...
 
double Cbrt (double x)
 Return the cube root of a floating-point value. More...
 
long double Cbrt (long double x)
 Return the cube root of a floating-point value. More...
 
int Mod (int x, int y)
 Return the remainder of x / y. More...
 
float Mod (float x, float y)
 Return the remainder of x / y. More...
 
double Mod (double x, double y)
 Return the remainder of x / y. More...
 
long double Mod (long double x, long double y)
 Return the remainder of x / y. More...
 
template<typename Type >
Type Remainder (Type x, Type y)
 Return the remainder of x / y. More...
 
float RoundUp (float x)
 Return x rounded up to the nearest integer. More...
 
double RoundUp (double x)
 Return x rounded up to the nearest integer. More...
 
long double RoundUp (long double x)
 Return x rounded up to the nearest integer. More...
 
float RoundDown (float x)
 Return x rounded down to the nearest integer. More...
 
double RoundDown (double x)
 Return x rounded down to the nearest integer. More...
 
long double RoundDown (long double x)
 Return x rounded down to the nearest integer. More...
 
template<typename Type >
Type Round (Type x)
 Return x rounded down to the nearest integer. More...
 
int Floor (float x)
 Return the floor of x. More...
 
int Floor (double x)
 Return the floor of x. More...
 
int Floor (long double x)
 Return the floor of x. More...
 
int Ceil (float x)
 Return the ceiling of x. More...
 
int Ceil (double x)
 Return the ceiling of x. More...
 
int Ceil (long double x)
 Return the ceiling of x. More...
 

Typedef Documentation

typedef Mat3<double> Mat3d
typedef Mat3s Mat3f
typedef Mat3<float> Mat3s
typedef Mat4<double> Mat4d
typedef Mat4s Mat4f
typedef Mat4<float> Mat4s
typedef Quat<double> Quatd
typedef Quat<float> Quats
typedef Vec2<double> Vec2d
typedef Vec2s Vec2f
typedef Vec2<int> Vec2i
typedef Vec2<float> Vec2s
typedef Vec2<unsigned int> Vec2ui
typedef Vec3<double> Vec3d
typedef Vec3s Vec3f
typedef Vec3<int> Vec3i
typedef Vec3<float> Vec3s
typedef Vec3<unsigned int> Vec3ui
typedef Vec4<double> Vec4d
typedef Vec4s Vec4f
typedef Vec4<int> Vec4i
typedef Vec4<float> Vec4s
typedef Vec4<unsigned int> Vec4ui

Enumeration Type Documentation

anonymous enum
Enumerator
NUM_DS_SCHEMES 
anonymous enum
Enumerator
NUM_DD_SCHEMES 
anonymous enum
Enumerator
NUM_BIAS_SCHEMES 
anonymous enum
Enumerator
NUM_TEMPORAL_SCHEMES 
enum Axis
Enumerator
X_AXIS 
Y_AXIS 
Z_AXIS 

Biased Gradients are limited to non-centered differences.

Enumerator
UNKNOWN_BIAS 
FIRST_BIAS 
SECOND_BIAS 
THIRD_BIAS 
WENO5_BIAS 
HJWENO5_BIAS 
enum DDScheme

Different discrete schemes used in the second derivatives.

Enumerator
UNKNOWN_DD 
CD_SECOND 
CD_FOURTH 
CD_SIXTH 
enum DScheme

Different discrete schemes used in the first derivatives.

Enumerator
UNKNOWN_DS 
CD_2NDT 
CD_2ND 
CD_4TH 
CD_6TH 
FD_1ST 
FD_2ND 
FD_3RD 
BD_1ST 
BD_2ND 
BD_3RD 
FD_WENO5 
BD_WENO5 
FD_HJWENO5 
BD_HJWENO5 
Enumerator
XYZ_ROTATION 
XZY_ROTATION 
YXZ_ROTATION 
YZX_ROTATION 
ZXY_ROTATION 
ZYX_ROTATION 
XZX_ROTATION 
ZXZ_ROTATION 

Temporal integrations schemes.

Enumerator
UNKNOWN_TIS 
TVD_RK1 
TVD_RK2 
TVD_RK3 

Function Documentation

int32_t openvdb::v1_2_0::math::Abs ( int32_t  i)
inline

Return the absolute value of the given quantity.

int64_t openvdb::v1_2_0::math::Abs ( int64_t  i)
inline

Return the absolute value of the given quantity.

float openvdb::v1_2_0::math::Abs ( float  x)
inline

Return the absolute value of the given quantity.

double openvdb::v1_2_0::math::Abs ( double  x)
inline

Return the absolute value of the given quantity.

long double openvdb::v1_2_0::math::Abs ( long double  x)
inline

Return the absolute value of the given quantity.

uint32_t openvdb::v1_2_0::math::Abs ( uint32_t  i)
inline

Return the absolute value of the given quantity.

uint64_t openvdb::v1_2_0::math::Abs ( uint64_t  i)
inline

Return the absolute value of the given quantity.

Tuple<SIZE, T> openvdb::v1_2_0::math::Abs ( const Tuple< SIZE, T > &  t)
Returns
the absolute value of the given Tuple.
MatType openvdb::v1_2_0::math::aim ( const Vec3< typename MatType::value_type > &  direction,
const Vec3< typename MatType::value_type > &  vertical 
)

Build an orientation matrix such that z points along direction, and y is along direction/vertical plane.

T openvdb::v1_2_0::math::angle ( const Vec2< T > &  v1,
const Vec2< T > &  v2 
)
inline

Angle between two vectors, the result is between [0, pi], e.g. float a = Vec2f::angle(v1,v2);

T openvdb::v1_2_0::math::angle ( const Vec3< T > &  v1,
const Vec3< T > &  v2 
)
inline

Angle between two vectors, the result is between [0, pi], e.g. double a = Vec3d::angle(v1,v2);

OPENVDB_API Mat4d openvdb::v1_2_0::math::approxInverse ( const Mat4d &  mat)

Returns the left pseudoInverse of the input matrix when the 3x3 part is symmetric otherwise it zeros the 3x3 and reverses the translation.

Mat3<T> openvdb::v1_2_0::math::bezLerp ( const Mat3< T0 > &  m1,
const Mat3< T0 > &  m2,
const Mat3< T0 > &  m3,
const Mat3< T0 > &  m4,
t 
)

Interpolate between m1 and m4 by converting m1 ... m4 into quaternions and treating them as control points of a Bezier curve using slerp in place of lerp in the De Castlejeau evaluation algorithm. Just like a cubic Bezier curve, this will interpolate m1 at t = 0 and m4 at t = 1 but in general will not pass through m2 and m3. Unlike a standard Bezier curve this curve will not have the convex hull property. m1 ... m4 must be rotation matrices!

std::string openvdb::v1_2_0::math::biasedGradientSchemeToMenuName ( BiasedGradientScheme  bgs)
inline
std::string openvdb::v1_2_0::math::biasedGradientSchemeToString ( BiasedGradientScheme  bgs)
inline
OPENVDB_API void openvdb::v1_2_0::math::calculateBounds ( const Transform &  t,
const Vec3d minWS,
const Vec3d maxWS,
Vec3d minIS,
Vec3d maxIS 
)

Calculate an axis-aligned bounding box in index space from an axis-aligned bounding box in world space.

float openvdb::v1_2_0::math::Cbrt ( float  x)
inline

Return the cube root of a floating-point value.

double openvdb::v1_2_0::math::Cbrt ( double  x)
inline

Return the cube root of a floating-point value.

long double openvdb::v1_2_0::math::Cbrt ( long double  x)
inline

Return the cube root of a floating-point value.

int openvdb::v1_2_0::math::Ceil ( float  x)
inline

Return the ceiling of x.

int openvdb::v1_2_0::math::Ceil ( double  x)
inline

Return the ceiling of x.

int openvdb::v1_2_0::math::Ceil ( long double  x)
inline

Return the ceiling of x.

Type openvdb::v1_2_0::math::Chop ( Type  x,
Type  delta 
)
inline

Return x if it is greater in magnitude than delta. Otherwise, return zero.

Type openvdb::v1_2_0::math::Clamp ( Type  x,
Type  min,
Type  max 
)
inline

Return x clamped to [min, max].

Type openvdb::v1_2_0::math::Clamp01 ( Type  x)
inline

Return x clamped to [0, 1].

bool openvdb::v1_2_0::math::ClampTest01 ( Type &  x)
inline

Return true if x is outside [0,1].

OPENVDB_API Vec3d openvdb::v1_2_0::math::closestPointOnTriangleToPoint ( const Vec3d &  a,
const Vec3d &  b,
const Vec3d &  c,
const Vec3d &  p,
Vec3d &  uvw 
)

Closest Point on Triangle to Point. Given a triangle abc and a point p, returns the point on abc closest to p and the corresponding barycentric coordinates.

Note
Algorithm from "Real-Time Collision Detection" pg 136 to 142 by Christer Ericson. The closest point is obtained by first determining which of the triangles Voronoi feature regions p is in and then computing the orthogonal projection of p onto the corresponding feature.
Parameters
aThe triangle's first vertex point.
bThe triangle's second vertex point.
cThe triangle's third vertex point.
pPoint to compute the closest point on abc for.
uvwBarycentric coordinates, computed and returned.
OPENVDB_API boost::shared_ptr<FullyDecomposedMap> openvdb::v1_2_0::math::createFullyDecomposedMap ( const Mat4d &  m)

General decomposition of a Matrix into a Unitary (e.g. rotation) following a Symmetric (e.g. stretch & shear)

OPENVDB_API boost::shared_ptr<PolarDecomposedMap> openvdb::v1_2_0::math::createPolarDecomposedMap ( const Mat3d &  m)

Decomposes a general linear into translation following polar decomposition.

T U S where:

T: Translation U: Unitary (rotation or reflection) S: Symmetric

Note
: the Symmetric is automatically decomposed into Q D Q^T, where Q is rotation and D is diagonal.
OPENVDB_API boost::shared_ptr<SymmetricMap> openvdb::v1_2_0::math::createSymmetricMap ( const Mat3d &  m)

Utility methods.

Create a SymmetricMap from a symmetric matrix. Decomposes the map into Rotation Diagonal Rotation^T

bool openvdb::v1_2_0::math::diagonalizeSymmetricMatrix ( const Mat3< T > &  input,
Mat3< T > &  Q,
Vec3< T > &  D,
unsigned int  MAX_ITERATIONS = 250 
)

Use Jacobi iterations to decompose a symmetric 3x3 matrix (diagonalize and compute eigenvectors)

This is based on the "Efficient numerical diagonalization of Hermitian 3x3 matrices" Joachim Kopp. arXiv.org preprint: physics/0610206 with the addition of largest pivot

void openvdb::v1_2_0::math::doProcessTypedMap ( Transform &  transform,
OpType &  op 
)
inline

Helper function used internally by processTypedMap()

void openvdb::v1_2_0::math::doProcessTypedMap ( const Transform &  transform,
OpType &  op 
)
inline

Helper function used internally by processTypedMap()

int64_t openvdb::v1_2_0::math::doubleToInt64 ( const double  aDoubleValue)
inline
std::string openvdb::v1_2_0::math::dsSchemeToMenuName ( DScheme  dss)
inline
std::string openvdb::v1_2_0::math::dsSchemeToString ( DScheme  dss)
inline
Vec3<typename MatType::value_type> openvdb::v1_2_0::math::eulerAngles ( const MatType &  mat,
RotationOrder  rotationOrder,
typename MatType::value_type  eps = 1.0e-8 
)

Return the euler angles composing this rotation matrix. Optional axes arguments describe in what order elementary rotations are applied. Note that in our convention, XYZ means Rz * Ry * Rx. Because we are using rows rather than columns to represent the local axes of a coordinate frame, the interpretation from a local reference point of view is to first rotate about the x axis, then about the newly rotated y axis, and finally by the new local z axis. From a fixed reference point of view, the interpretation is to rotate about the stationary world z, y, and x axes respectively.

Irrespective of the euler angle convention, in the case of distinct axes, eulerAngles() returns the x, y, and z angles in the corresponding x, y, z components of the returned Vec3. For the XZX convention, the left X value is returned in Vec3.x, and the right X value in Vec3.y. For the ZXZ convention the left Z value is returned in Vec3.z and the right Z value in Vec3.y

Examples of reconstructing r from its euler angle decomposition

v = eulerAngles(r, ZYX_ROTATION); rx.setToRotation(Vec3d(1,0,0), v[0]); ry.setToRotation(Vec3d(0,1,0), v[1]); rz.setToRotation(Vec3d(0,0,1), v[2]); r = rx * ry * rz;

v = eulerAngles(r, ZXZ_ROTATION); rz1.setToRotation(Vec3d(0,0,1), v[2]); rx.setToRotation (Vec3d(1,0,0), v[0]); rz2.setToRotation(Vec3d(0,0,1), v[1]); r = rz2 * rx * rz1;

v = eulerAngles(r, XZX_ROTATION); rx1.setToRotation (Vec3d(1,0,0), v[0]); rx2.setToRotation (Vec3d(1,0,0), v[1]); rz.setToRotation (Vec3d(0,0,1), v[2]); r = rx2 * rz * rx1;

int32_t openvdb::v1_2_0::math::floatToInt32 ( const float  aFloatValue)
inline
int openvdb::v1_2_0::math::Floor ( float  x)
inline

Return the floor of x.

int openvdb::v1_2_0::math::Floor ( double  x)
inline

Return the floor of x.

int openvdb::v1_2_0::math::Floor ( long double  x)
inline

Return the floor of x.

Type openvdb::v1_2_0::math::FractionalPart ( Type  x)
inline

Return the fractional part of x.

Vec3<typename MatType::value_type> openvdb::v1_2_0::math::getScale ( const MatType &  mat)
Returns
a Vec3 representing the lengths of the passed matrix's upper 3x3's rows.
Real openvdb::v1_2_0::math::GudonovsNormSqrd ( bool  isOutside,
Real  dP_xm,
Real  dP_xp,
Real  dP_ym,
Real  dP_yp,
Real  dP_zm,
Real  dP_zp 
)
inline
Real openvdb::v1_2_0::math::GudonovsNormSqrd ( bool  isOutside,
const Vec3< Real > &  gradient_m,
const Vec3< Real > &  gradient_p 
)
inline
bool openvdb::v1_2_0::math::hasTranslation ( const Mat4< T > &  m)
inline
Type openvdb::v1_2_0::math::IntegerPart ( Type  x)
inline

Return the integer part of x.

Type openvdb::v1_2_0::math::Inv ( Type  x)
inline

Return the inverse of x.

bool openvdb::v1_2_0::math::isAffine ( const Mat4< T > &  m)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Type &  a,
const Type &  b 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Type &  a,
const Type &  b,
const Type &  tolerance 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Vec2< T > &  a,
const Vec2< T > &  b 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Vec2< T > &  a,
const Vec2< T > &  b,
const Vec2< T > &  eps 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Hermite &  lhs,
const Hermite &  rhs 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Hermite &  lhs,
const Hermite &  rhs,
const Hermite &   
)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Vec3< T > &  a,
const Vec3< T > &  b 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual ( const Vec3< T > &  a,
const Vec3< T > &  b,
const Vec3< T > &  eps 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual< bool > ( const bool &  a,
const bool &  b 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual< bool > ( const bool &  a,
const bool &  b,
const bool &   
)
inline
bool openvdb::v1_2_0::math::isApproxEqual< std::string > ( const std::string &  a,
const std::string &  b 
)
inline
bool openvdb::v1_2_0::math::isApproxEqual< std::string > ( const std::string &  a,
const std::string &  b,
const std::string &   
)
inline
bool openvdb::v1_2_0::math::isApproxZero ( const Type &  x)
inline

Return true if x is equal to zero to within the default floating-point comparison tolerance.

bool openvdb::v1_2_0::math::isApproxZero ( const Type &  x,
const Type &  tolerance 
)
inline

Return true if x is equal to zero to within the given tolerance.

bool openvdb::v1_2_0::math::isDiagonal ( const MatType &  mat)
inline

Determine if a matrix is diagonal.

bool openvdb::v1_2_0::math::isExactlyEqual ( const T0 &  a,
const T1 &  b 
)
inline
bool openvdb::v1_2_0::math::isIdentity ( const MatType &  m)
inline
bool openvdb::v1_2_0::math::isInvertible ( const MatType &  m)
inline
bool openvdb::v1_2_0::math::isNegative ( const Type &  x)
inline
bool openvdb::v1_2_0::math::isRelOrApproxEqual ( const Type &  a,
const Type &  b,
const Type &  absTol,
const Type &  relTol 
)
inline
bool openvdb::v1_2_0::math::isRelOrApproxEqual ( const bool &  a,
const bool &  b,
const bool &  ,
const bool &   
)
inline
bool openvdb::v1_2_0::math::isSymmetric ( const MatType &  m)
inline

Determine if a matrix is symmetric. This implicitly uses "isApproxEqual" to determine the equality

bool openvdb::v1_2_0::math::isUlpsEqual ( const double  aLeft,
const double  aRight,
const int64_t  aUnitsInLastPlace 
)
inline
bool openvdb::v1_2_0::math::isUlpsEqual ( const float  aLeft,
const float  aRight,
const int32_t  aUnitsInLastPlace 
)
inline
bool openvdb::v1_2_0::math::isUnitary ( const MatType &  m)
inline

Determine is a matrix is Unitary (i.e. rotation or reflection)

bool openvdb::v1_2_0::math::isZero ( const Type &  x)
inline

Return true if x is exactly equal to zero.

MatType::ValueType openvdb::v1_2_0::math::lInfinityNorm ( const MatType &  matrix)

takes a n by n matrix and returns the L_Infinty norm

MatType::ValueType openvdb::v1_2_0::math::lOneNorm ( const MatType &  matrix)

takes an n by n matrix and returns the L_1 norm

OPENVDB_API Hermite openvdb::v1_2_0::math::max ( const Hermite &  ,
const Hermite &   
)

min and max operations done directly on the compressed data.

const Type& openvdb::v1_2_0::math::Max ( const Type &  a,
const Type &  b 
)
inline

Return the maximum of two values.

const Type& openvdb::v1_2_0::math::Max ( const Type &  a,
const Type &  b,
const Type &  c 
)
inline

Return the maximum of three values.

const Type& openvdb::v1_2_0::math::Max ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d 
)
inline

Return the maximum of four values.

const Type& openvdb::v1_2_0::math::Max ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e 
)
inline

Return the maximum of five values.

const Type& openvdb::v1_2_0::math::Max ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e,
const Type &  f 
)
inline

Return the maximum of six values.

const Type& openvdb::v1_2_0::math::Max ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e,
const Type &  f,
const Type &  g 
)
inline

Return the maximum of seven values.

const Type& openvdb::v1_2_0::math::Max ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e,
const Type &  f,
const Type &  g,
const Type &  h 
)
inline

Return the maximum of eight values.

Vec2<T> openvdb::v1_2_0::math::maxComponent ( const Vec2< T > &  v1,
const Vec2< T > &  v2 
)
inline

Return component-wise maximum of the two vectors.

Vec4<T> openvdb::v1_2_0::math::maxComponent ( const Vec4< T > &  v1,
const Vec4< T > &  v2 
)
inline

Return component-wise maximum of the two vectors.

Vec3<T> openvdb::v1_2_0::math::maxComponent ( const Vec3< T > &  v1,
const Vec3< T > &  v2 
)
inline

Return component-wise maximum of the two vectors.

size_t openvdb::v1_2_0::math::MaxIndex ( const Vec3T &  v)

Return the index [0,1,2] of the largest value in a 3D vector.

Note
This methods assumes operator[] exists and avoids branching.
OPENVDB_API Hermite openvdb::v1_2_0::math::min ( const Hermite &  ,
const Hermite &   
)

min and max operations done directly on the compressed data.

const Type& openvdb::v1_2_0::math::Min ( const Type &  a,
const Type &  b 
)
inline

Return the minimum of two values.

const Type& openvdb::v1_2_0::math::Min ( const Type &  a,
const Type &  b,
const Type &  c 
)
inline

Return the minimum of three values.

const Type& openvdb::v1_2_0::math::Min ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d 
)
inline

Return the minimum of four values.

const Type& openvdb::v1_2_0::math::Min ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e 
)
inline

Return the minimum of five values.

const Type& openvdb::v1_2_0::math::Min ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e,
const Type &  f 
)
inline

Return the minimum of six values.

const Type& openvdb::v1_2_0::math::Min ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e,
const Type &  f,
const Type &  g 
)
inline

Return the minimum of seven values.

const Type& openvdb::v1_2_0::math::Min ( const Type &  a,
const Type &  b,
const Type &  c,
const Type &  d,
const Type &  e,
const Type &  f,
const Type &  g,
const Type &  h 
)
inline

Return the minimum of eight values.

Vec2<T> openvdb::v1_2_0::math::minComponent ( const Vec2< T > &  v1,
const Vec2< T > &  v2 
)
inline

Return component-wise minimum of the two vectors.

Remarks
We are switching to a more explicit name because the semantics are different from std::min/max. In that case, the function returns a reference to one of the objects based on a comparator. Here, we must fabricate a new object which might not match either of the inputs.
Vec4<T> openvdb::v1_2_0::math::minComponent ( const Vec4< T > &  v1,
const Vec4< T > &  v2 
)
inline

Return component-wise minimum of the two vectors.

Remarks
We are switching to a more explicit name because the semantics are different from std::min/max. In that case, the function returns a reference to one of the objects based on a comparator. Here, we must fabricate a new object which might not match either of the inputs.
Vec3<T> openvdb::v1_2_0::math::minComponent ( const Vec3< T > &  v1,
const Vec3< T > &  v2 
)
inline

Return component-wise minimum of the two vectors.

Remarks
We are switching to a more explicit name because the semantics are different from std::min/max. In that case, the function returns a reference to one of the objects based on a comparator. Here, we must fabricate a new object which might not match either of the inputs.
size_t openvdb::v1_2_0::math::MinIndex ( const Vec3T &  v)

Return the index [0,1,2] of the smallest value in a 3D vector.

Note
This methods assumes operator[] exists and avoids branching.
int openvdb::v1_2_0::math::Mod ( int  x,
int  y 
)
inline

Return the remainder of x / y.

float openvdb::v1_2_0::math::Mod ( float  x,
float  y 
)
inline

Return the remainder of x / y.

double openvdb::v1_2_0::math::Mod ( double  x,
double  y 
)
inline

Return the remainder of x / y.

long double openvdb::v1_2_0::math::Mod ( long double  x,
long double  y 
)
inline

Return the remainder of x / y.

bool openvdb::v1_2_0::math::operator!= ( const Vec4< T0 > &  v0,
const Vec4< T1 > &  v1 
)
inline

Inequality operator, does exact floating point comparisons.

bool openvdb::v1_2_0::math::operator!= ( const Vec3< T0 > &  v0,
const Vec3< T1 > &  v1 
)
inline

Inequality operator, does exact floating point comparisons.

Vec2<typename promote<S, T>::type> openvdb::v1_2_0::math::operator* ( scalar,
const Vec2< T > &  v 
)
inline

Returns V, where $V_i = v_i * scalar$ for $i \in [0, 1]$.

Vec2<typename promote<S, T>::type> openvdb::v1_2_0::math::operator* ( const Vec2< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i * scalar$ for $i \in [0, 1]$.

Vec2<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator* ( const Vec2< T0 > &  v0,
const Vec2< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i * v1_i$ for $i \in [0, 1]$.

Vec4<typename promote<S, T>::type> openvdb::v1_2_0::math::operator* ( scalar,
const Vec4< T > &  v 
)
inline

Returns V, where $V_i = v_i * scalar$ for $i \in [0, 3]$.

Vec4<typename promote<S, T>::type> openvdb::v1_2_0::math::operator* ( const Vec4< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i * scalar$ for $i \in [0, 3]$.

Vec4<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator* ( const Vec4< T0 > &  v0,
const Vec4< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i * v1_i$ for $i \in [0, 3]$.

Vec3<typename promote<S, T>::type> openvdb::v1_2_0::math::operator* ( scalar,
const Vec3< T > &  v 
)
inline

Returns V, where $V_i = v_i * scalar$ for $i \in [0, 2]$.

Vec3<typename promote<S, T>::type> openvdb::v1_2_0::math::operator* ( const Vec3< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i * scalar$ for $i \in [0, 2]$.

Vec3<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator* ( const Vec3< T0 > &  v0,
const Vec3< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i * v1_i$ for $i \in [0, 2]$.

Quat<T> openvdb::v1_2_0::math::operator* ( scalar,
const Quat< T > &  q 
)

Returns V, where $V_i = v_i * scalar$ for $i \in [0, 3]$.

Mat3<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator* ( const Mat3< T0 > &  m0,
const Mat3< T1 > &  m1 
)

Matrix multiplication.

Returns M, where $M_{ij} = \sum_{n=0}^2\left(m0_{nj} + m1_{in}\right)$ for $i, j \in [0, 2]$

Vec2<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator+ ( const Vec2< T0 > &  v0,
const Vec2< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i + v1_i$ for $i \in [0, 1]$.

Vec2<typename promote<S, T>::type> openvdb::v1_2_0::math::operator+ ( const Vec2< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i + scalar$ for $i \in [0, 1]$.

Vec3<typename promote<T, typename Coord::ValueType>::type> openvdb::v1_2_0::math::operator+ ( const Vec3< T > &  v0,
const Coord &  v1 
)
inline

Allow a Coord to be added to or subtracted from a Vec3.

Vec3<typename promote<T, typename Coord::ValueType>::type> openvdb::v1_2_0::math::operator+ ( const Coord &  v1,
const Vec3< T > &  v0 
)
inline

Allow a Coord to be added to or subtracted from a Vec3.

Vec4<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator+ ( const Vec4< T0 > &  v0,
const Vec4< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i + v1_i$ for $i \in [0, 3]$.

Vec4<typename promote<S, T>::type> openvdb::v1_2_0::math::operator+ ( const Vec4< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i + scalar$ for $i \in [0, 3]$.

Vec3<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator+ ( const Vec3< T0 > &  v0,
const Vec3< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i + v1_i$ for $i \in [0, 2]$.

Vec3<typename promote<S, T>::type> openvdb::v1_2_0::math::operator+ ( const Vec3< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i + scalar$ for $i \in [0, 2]$.

Vec2<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator- ( const Vec2< T0 > &  v0,
const Vec2< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i - v1_i$ for $i \in [0, 1]$.

Vec2<typename promote<S, T>::type> openvdb::v1_2_0::math::operator- ( const Vec2< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i - scalar$ for $i \in [0, 1]$.

Vec3<typename promote<T, Coord::ValueType>::type> openvdb::v1_2_0::math::operator- ( const Vec3< T > &  v0,
const Coord &  v1 
)
inline

Allow a Coord to be subtracted from a Vec3.

Vec3<typename promote<T, Coord::ValueType>::type> openvdb::v1_2_0::math::operator- ( const Coord &  v1,
const Vec3< T > &  v0 
)
inline

Allow a Coord to be subtracted from a Vec3.

Vec4<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator- ( const Vec4< T0 > &  v0,
const Vec4< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i - v1_i$ for $i \in [0, 3]$.

Vec4<typename promote<S, T>::type> openvdb::v1_2_0::math::operator- ( const Vec4< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i - scalar$ for $i \in [0, 3]$.

Vec3<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator- ( const Vec3< T0 > &  v0,
const Vec3< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i - v1_i$ for $i \in [0, 2]$.

Vec3<typename promote<S, T>::type> openvdb::v1_2_0::math::operator- ( const Vec3< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i - scalar$ for $i \in [0, 2]$.

Vec2<typename promote<S, T>::type> openvdb::v1_2_0::math::operator/ ( scalar,
const Vec2< T > &  v 
)
inline

Returns V, where $V_i = scalar / v_i$ for $i \in [0, 1]$.

Vec2<typename promote<S, T>::type> openvdb::v1_2_0::math::operator/ ( const Vec2< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i / scalar$ for $i \in [0, 1]$.

Vec2<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator/ ( const Vec2< T0 > &  v0,
const Vec2< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i / v1_i$ for $i \in [0, 1]$.

Vec4<typename promote<S, T>::type> openvdb::v1_2_0::math::operator/ ( scalar,
const Vec4< T > &  v 
)
inline

Returns V, where $V_i = scalar / v_i$ for $i \in [0, 3]$.

Vec4<typename promote<S, T>::type> openvdb::v1_2_0::math::operator/ ( const Vec4< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i / scalar$ for $i \in [0, 3]$.

Vec4<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator/ ( const Vec4< T0 > &  v0,
const Vec4< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i / v1_i$ for $i \in [0, 3]$.

Vec3<typename promote<S, T>::type> openvdb::v1_2_0::math::operator/ ( scalar,
const Vec3< T > &  v 
)
inline

Returns V, where $V_i = scalar / v_i$ for $i \in [0, 2]$.

Vec3<typename promote<S, T>::type> openvdb::v1_2_0::math::operator/ ( const Vec3< T > &  v,
scalar 
)
inline

Returns V, where $V_i = v_i / scalar$ for $i \in [0, 2]$.

Vec3<typename promote<T0, T1>::type> openvdb::v1_2_0::math::operator/ ( const Vec3< T0 > &  v0,
const Vec3< T1 > &  v1 
)
inline

Returns V, where $V_i = v0_i / v1_i$ for $i \in [0, 2]$.

bool openvdb::v1_2_0::math::operator< ( const Tuple< SIZE, T0 > &  t0,
const Tuple< SIZE, T1 > &  t1 
)
Returns
true if t0 < t1, comparing components in order of significance.
OPENVDB_API std::ostream& openvdb::v1_2_0::math::operator<< ( std::ostream &  ,
const Transform &   
)
std::ostream& openvdb::v1_2_0::math::operator<< ( std::ostream &  ostr,
const Hermite &  rhs 
)
inline
std::ostream& openvdb::v1_2_0::math::operator<< ( std::ostream &  ostr,
const Tuple< SIZE, T > &  classname 
)

Write a Tuple to an output stream.

std::ostream& openvdb::v1_2_0::math::operator<< ( std::ostream &  os,
const BBox< VectorType > &  b 
)
inline
std::ostream& openvdb::v1_2_0::math::operator<< ( std::ostream &  os,
const Coord &  xyz 
)
inline
std::ostream& openvdb::v1_2_0::math::operator<< ( std::ostream &  os,
const CoordBBox &  b 
)
inline
bool openvdb::v1_2_0::math::operator== ( const Vec4< T0 > &  v0,
const Vec4< T1 > &  v1 
)
inline

Equality operator, does exact floating point comparisons.

bool openvdb::v1_2_0::math::operator== ( const Vec3< T0 > &  v0,
const Vec3< T1 > &  v1 
)
inline

Equality operator, does exact floating point comparisons.

bool openvdb::v1_2_0::math::operator> ( const Tuple< SIZE, T0 > &  t0,
const Tuple< SIZE, T1 > &  t1 
)
Returns
true if t0 > t1, comparing components in order of significance.
void openvdb::v1_2_0::math::orthonormalize ( Vec2< T > &  v1,
Vec2< T > &  v2 
)
inline

Orthonormalize vectors v1 and v2 and store back the resulting basis e.g. Vec2f::orthonormalize(v1,v2);

void openvdb::v1_2_0::math::orthonormalize ( Vec3< T > &  v1,
Vec3< T > &  v2,
Vec3< T > &  v3 
)
inline

Orthonormalize vectors v1, v2 and v3 and store back the resulting basis e.g. Vec3d::orthonormalize(v1,v2,v3);

Mat3<T> openvdb::v1_2_0::math::outerProduct ( const Vec3< T > &  v1,
const Vec3< T > &  v2 
)

this = outer product of v1, v2 e.g. M = Mat3f::outerproduct(v1,v2);

static MatType& openvdb::v1_2_0::math::padMat4 ( MatType &  dest)
static

Write 0's along Mat4's last row and column, and a 1 on its diagonal Useful initialization when we're initializing juse the 3x3 block

bool openvdb::v1_2_0::math::polarDecomposition ( const MatType &  input,
MatType &  unitary,
MatType &  positive_hermitian,
unsigned int  MAX_ITERATIONS = 100 
)

Decompose an invertible 3x3 matrix into Unitary following a symmetric matrix (postitive semi-defininte Hermitian): i.e. M = U * S if the Unitary.det() = 1 it is a rotation, otherwise Unitary.det() = -1, meaning there is some part reflection. See "Computing the polar decomposition with applications" Higham, N.J. - SIAM J. Sc. Stat Comput 7(4):1160-1174.

Type openvdb::v1_2_0::math::Pow ( Type  x,
int  n 
)

Return $ x^n $.

float openvdb::v1_2_0::math::Pow ( float  b,
float  e 
)
inline

Return $ b^e $.

double openvdb::v1_2_0::math::Pow ( double  b,
double  e 
)
inline

Return $ b^e $.

Type openvdb::v1_2_0::math::Pow2 ( Type  x)
inline

Return $ x^2 $.

Type openvdb::v1_2_0::math::Pow3 ( Type  x)
inline

Return $ x^3 $.

Type openvdb::v1_2_0::math::Pow4 ( Type  x)
inline

Return $ x^4 $.

Mat3<T> openvdb::v1_2_0::math::powLerp ( const Mat3< T0 > &  m1,
const Mat3< T0 > &  m2,
t 
)

Interpolate the rotation between m1 and m2 using Mat::powSolve. Unlike slerp, translation is not treated independently. This results in smoother animation results.

void openvdb::v1_2_0::math::powSolve ( const MatType &  aA,
MatType &  aB,
double  aPower,
double  aTol = 0.01 
)
inline
bool openvdb::v1_2_0::math::processTypedMap ( TransformType &  transform,
OpType &  op 
)

Utility function that, given a generic map pointer, calls a functor on the fully-resoved map.

Usage:

struct Foo {
template<typename MapT>
void operator()(const MapT& map) const { blah }
};
processTypedMap(myMap, Foo());
Returns
false if the grid type is unknown or unhandled.
void openvdb::v1_2_0::math::randSeed ( unsigned int  seed)
inline

Initialize the random number generator.

double openvdb::v1_2_0::math::randUniform ( )
inline

Return a random number in the interval [0,1].

Type openvdb::v1_2_0::math::Remainder ( Type  x,
Type  y 
)
inline

Return the remainder of x / y.

MatType openvdb::v1_2_0::math::rotation ( const Quat< typename MatType::value_type > &  q,
typename MatType::value_type  eps = 1.0e-8 
)

Returns rotation matrix specified by the quaternion The quaternion is normalized and used to construct the matrix Note that the matrix is transposed to match post-multiplication symantics.

MatType openvdb::v1_2_0::math::rotation ( Axis  axis,
typename MatType::value_type  angle 
)

Set the matrix to a rotation about the given axis.

Parameters
axisThe axis (one of X, Y, Z) to rotate about.
angleThe rotation angle, in radians.
MatType openvdb::v1_2_0::math::rotation ( const Vec3< typename MatType::value_type > &  _axis,
typename MatType::value_type  angle 
)
Returns
matrix to the rotation specified by axis and angle
Note
The axis must be unit vector
MatType openvdb::v1_2_0::math::rotation ( const Vec3< typename MatType::value_type > &  _v1,
const Vec3< typename MatType::value_type > &  _v2,
typename MatType::value_type  eps = 1.0e-8 
)

Set the matrix to a rotation that maps v1 onto v2 about the cross product of v1 and v2.

Type openvdb::v1_2_0::math::Round ( Type  x)
inline

Return x rounded down to the nearest integer.

float openvdb::v1_2_0::math::RoundDown ( float  x)
inline

Return x rounded down to the nearest integer.

double openvdb::v1_2_0::math::RoundDown ( double  x)
inline

Return x rounded down to the nearest integer.

long double openvdb::v1_2_0::math::RoundDown ( long double  x)
inline

Return x rounded down to the nearest integer.

Type openvdb::v1_2_0::math::RoundDown ( Type  x,
Type  base 
)
inline

Return x rounded down to the nearest multiple of base.

float openvdb::v1_2_0::math::RoundUp ( float  x)
inline

Return x rounded up to the nearest integer.

double openvdb::v1_2_0::math::RoundUp ( double  x)
inline

Return x rounded up to the nearest integer.

long double openvdb::v1_2_0::math::RoundUp ( long double  x)
inline

Return x rounded up to the nearest integer.

Type openvdb::v1_2_0::math::RoundUp ( Type  x,
Type  base 
)
inline

Return x rounded up to the nearest multiple of base.

MatType openvdb::v1_2_0::math::scale ( const Vec3< typename MatType::value_type > &  scaling)
Returns
the matrix to a matrix that scales by v
MatType openvdb::v1_2_0::math::shear ( Axis  axis0,
Axis  axis1,
typename MatType::value_type  shear 
)

Set the matrix to a shear along axis0 by a fraction of axis1.

Parameters
axis0The fixed axis of the shear.
axis1The shear axis.
shearThe shear factor.
int openvdb::v1_2_0::math::Sign ( const Type &  x)
inline

Return the sign of the given value as an integer (either -1, 0 or 1).

bool openvdb::v1_2_0::math::SignChange ( const Type &  a,
const Type &  b 
)
inline

Return true if a and b have different signs.

Note
Zero is considered a positive number.
OPENVDB_API boost::shared_ptr<MapBase> openvdb::v1_2_0::math::simplify ( boost::shared_ptr< AffineMap >  affine)

reduces an AffineMap to a ScaleMap or a ScaleTranslateMap when it can

MatType openvdb::v1_2_0::math::skew ( const Vec3< typename MatType::value_type > &  skew)
Returns
a matrix as the cross product of the given vector
Quat<T> openvdb::v1_2_0::math::slerp ( const Quat< T > &  q1,
const Quat< T > &  q2,
t,
tolerance = 0.00001 
)

Linear interpolation between the two quaternions.

Mat3<T> openvdb::v1_2_0::math::slerp ( const Mat3< T0 > &  m1,
const Mat3< T0 > &  m2,
t 
)

Interpolate between m1 and m2. Converts to quaternion form and uses slerp m1 and m2 must be rotation matrices!

OPENVDB_API OPENVDB_DEPRECATED double openvdb::v1_2_0::math::sLineSeg3ToPointDistSqr ( const Vec3d &  p0,
const Vec3d &  p1,
const Vec3d &  point,
double &  t,
double  epsilon = 1e-10 
)

Squared distance of a line segment p(t) = (1-t)*p0 + t*p1 to point.

Returns
the closest point on the line segment as a function of t
Type openvdb::v1_2_0::math::SmoothUnitStep ( Type  x,
Type  min,
Type  max 
)
inline

Return 0 if x < min, 1 if x > max or else $(3-2t)t^2$, where $t = (x-min)/(max-min)$.

float openvdb::v1_2_0::math::Sqrt ( float  x)
inline

Return the square root of a floating-point value.

double openvdb::v1_2_0::math::Sqrt ( double  x)
inline

Return the square root of a floating-point value.

long double openvdb::v1_2_0::math::Sqrt ( long double  x)
inline

Return the square root of a floating-point value.

void openvdb::v1_2_0::math::sqrtSolve ( const MatType &  aA,
MatType &  aB,
double  aTol = 0.01 
)
inline

Solve for A=B*B, given A

Denman-Beavers square root iteration

OPENVDB_API OPENVDB_DEPRECATED double openvdb::v1_2_0::math::sTri3ToPointDistSqr ( const Vec3d &  v0,
const Vec3d &  v1,
const Vec3d &  v2,
const Vec3d &  point,
Vec2d &  uv,
double  epsilon 
)

Slightly modified version of the algorithm described in "Geometric Tools for Computer Graphics" pg 376 to 382 by Schneider and Eberly. Extended to handle the case of a degenerate triangle. Also returns barycentric rather than (s,t) coordinates.

Basic Idea (See book for details):

Write the equation of the line as

T(s,t) = v0 + s*(v1-v0) + t*(v2-v0)

Minimize the quadratic function

|| T(s,t) - point || ^2 

by solving for when the gradient is 0. This can be done without any square roots.

If the resulting solution satisfies 0 <= s + t <= 1, then the solution lies on the interior of the triangle, and we are done (region 0). If it does not then the closest solution lies on a boundary and we have to solve for it by solving a 1D problem where we use one variable as free say "s" and set the other variable t = (1-s)

Returns
the closest point on the triangle and barycentric coordinates.
BiasedGradientScheme openvdb::v1_2_0::math::stringToBiasedGradientScheme ( const std::string &  s)
inline
DScheme openvdb::v1_2_0::math::stringToDScheme ( const std::string &  s)
inline
TemporalIntegrationScheme openvdb::v1_2_0::math::stringToTemporalIntegrationScheme ( const std::string &  s)
inline
std::string openvdb::v1_2_0::math::temporalIntegrationSchemeToMenuName ( TemporalIntegrationScheme  tis)
inline
std::string openvdb::v1_2_0::math::temporalIntegrationSchemeToString ( TemporalIntegrationScheme  tis)
inline
Vec3<T1> openvdb::v1_2_0::math::transformNormal ( const Mat4< T0 > &  m,
const Vec3< T1 > &  n 
)

Transform a Vec3 by pre-multiplication, without translation. Presumes this matrix is inverse of coordinate transform Synonymous to "pretransform3x3"

static OPENVDB_DEPRECATED double openvdb::v1_2_0::math::triToPtnDistSqr ( const Vec3d &  v0,
const Vec3d &  v1,
const Vec3d &  v2,
const Vec3d &  point 
)
inlinestatic
Returns
the closest point on the triangle.
Type openvdb::v1_2_0::math::Truncate ( Type  x,
unsigned int  digits 
)
inline

Return x truncated to the given number of decimal digits.

MatType openvdb::v1_2_0::math::unit ( const MatType &  mat,
typename MatType::value_type  eps = 1.0e-8 
)
Returns
a copy of included matrix with its upper 3x3 rows normalized. This can be geometrically interpretted as a matrix with no scaling along its major axes.
MatType openvdb::v1_2_0::math::unit ( const MatType &  in,
typename MatType::value_type  eps,
Vec3< typename MatType::value_type > &  scaling 
)
Returns
a copy of included matrix with its upper 3x3 rows normalized, and writes the length of each of these rows. This can be geometrically interpretted as a matrix with no scaling along its major axes, and the scaling in the input vector
ValueType openvdb::v1_2_0::math::WENO5 ( const ValueType &  v1,
const ValueType &  v2,
const ValueType &  v3,
const ValueType &  v4,
const ValueType &  v5,
float  scale2 = 0.01 
)
inline

implimentation of nonimally fith-order finite-difference WENO. This function returns the numerical flux. See "High Order Finite Difference and Finite Volume WENO Schemes and Discontinuous Galerkin Methods for CFD" - Chi-Wang Shu ICASE Report No 2001-11 (page 6). Also see ICASE No 97-65 for a more complete reference (Shu, 1997) Given v1 = f(x-2dx), v2 = f(x-dx), v3 = f(x), v4 = f(x+dx), v5 = f(x+2dx), the returns and interpolated value f(x+dx/2) with the special property that ( f(x+dx/2) - f(x-dx/2) ) / dx = df/dx (x) + error, where the error is 5-order in smooth regions: O(dx) <= error <=O(dx^5)

bool openvdb::v1_2_0::math::ZeroCrossing ( const Type &  a,
const Type &  b 
)
inline

Return true if the interval [a, b] includes zero, i.e., if either a or b is zero of if they have different signs.