KrisLibrary  1.0.0
Files | Namespaces | Classes | Functions
Math3D

Definitions of 3D math classes and functions. More...

Files

file  math3d/basis.h
 Utilities to compute special orthogonal bases (that is, rotation matrices).
 
file  math3d/clip.h
 Functions for clipping lines against geometric primitives.
 
file  d/misc.h
 Miscellaneous utilities on 3D primitives.
 
file  polar.h
 Conversions between rectangular and polar forms.
 
file  math3d/primitives.h
 Class declarations for useful 3D math types.
 
file  math3d/random.h
 Sampling routines for 3D primitives.
 
file  rotation.h
 3D rotation representations.
 
file  rotationfit.h
 Least-squares fitting for rotations (and rigid body transformations)
 

Namespaces

 Math3D
 Contains all the definitions in the Math3D package.
 

Classes

struct  Math3D::AABB2D
 A 2D axis-aligned bounding box. More...
 
struct  Math3D::AABB3D
 A 3D axis-aligned bounding box. More...
 
struct  Math3D::Box2D
 A 2D boxThe box is the unit square [0,1]^2 set in the scaled local coordinate system. That is, one corner is at the origin, and it has dimensions [dims.x,dims.y] in the coordinates given by {xbasis,ybasis}. More...
 
struct  Math3D::Box3D
 A 3D boxThe box is the unit cube [0,1]^3 set in the scaled local coordinate system. That is, one corner is at the origin, and it has dimensions [dims.x,dims.y,dims.z] in the coordinates given by {xbasis,ybasis,zbasis}. More...
 
struct  Math3D::Circle2D
 A 2D circle class. More...
 
struct  Math3D::Circle3D
 A 2D circle in 3D space class. More...
 
struct  Math3D::Cylinder3D
 A 3D cylinder. More...
 
struct  Math3D::Ellipsoid3D
 A 3D ellipsoidThe ellipsoid is the centered unit sphere [-1,1]^3 set in the scaled local coordinate system. That is, the center is at the origin, and its major axes are {xbasis,ybasis,zbasis} with radii {dims.x,dims.y,dims.z}. More...
 
struct  Math3D::Line2D
 A 2D line class. More...
 
struct  Math3D::Line3D
 A 3D line class. More...
 
struct  Math3D::Plane2D
 A 2D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset. More...
 
struct  Math3D::Plane3D
 A 3D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset. More...
 
struct  Math3D::Polygon2D
 An arbitrary connected polygon given by a vertex list. More...
 
struct  Math3D::ConvexPolygon2D
 A convex connected polygon such that the vertices are in ccw order. More...
 
struct  Math3D::Polygon3D
 An arbitrary connected polygon in 3D space given by a vertex list. More...
 
struct  Math3D::ConvexPolyhedron3D
 A convex polyhedron given in a dual representation, planes and vertices of convex hull. More...
 
class  Math3D::Vector2
 A 2D vector class. More...
 
class  Math3D::Vector3
 A 3D vector class. More...
 
class  Math3D::Vector4
 A 4D vector class. More...
 
class  Math3D::Matrix2
 A 2x2 matrix class. More...
 
class  Math3D::Matrix3
 A 3x3 matrix class. More...
 
class  Math3D::Matrix4
 A 4x4 matrix class. More...
 
class  Math3D::RigidTransform
 A rigid-body transformation. More...
 
class  Math3D::RigidTransform2D
 Same as above, but in 2D. More...
 
class  Math3D::EulerAngleRotation
 Euler angle 3D rotation parameterization. More...
 
class  Math3D::AngleAxisRotation
 Angle-axis 3D rotation parameterization. More...
 
class  Math3D::MomentRotation
 "Moment", a.k.a. exponential map, 3D rotation parameterization More...
 
class  Math3D::QuaternionRotation
 Quaternion, a.k.a. Euler parameter, 3D rotation parameterization. More...
 
struct  Math3D::Segment2D
 A 2D segment class. More...
 
struct  Math3D::Sphere3D
 A 3D sphere class. More...
 
struct  Math3D::Triangle2D
 A 2D triangle class. More...
 
struct  Math3D::Triangle3D
 A 3D triangle class. More...
 

Functions

void Math3D::GetCanonicalBasis (const Vector2 &x, Vector2 &y)
 
void Math3D::GetCanonicalBasis (const Vector3 &x, Vector3 &y, Vector3 &z)
 
bool Math3D::ClipLine1D (Real q, Real p, Real &umin, Real &umax)
 Clipping primitive in 1D. More...
 
bool Math3D::ClipLine1D (Real x0, Real a, Real b, Real &umin, Real &umax)
 
bool Math3D::ClipLine (const Vector2 &x, const Vector2 &v, const Plane2D &b, Real &u1, Real &u2)
 
bool Math3D::ClipLine (const Vector2 &x, const Vector2 &v, const AABB2D &b, Real &u1, Real &u2)
 Clip the line to the interior of the bbox.
 
bool Math3D::ClipLine (const Vector2 &x, const Vector2 &v, const ConvexPolygon2D &b, Real &u1, Real &u2)
 Clip the line to the interior of the convex polygon.
 
bool Math3D::ClipLine (const Vector3 &x, const Vector3 &v, const Plane3D &b, Real &u1, Real &u2)
 
bool Math3D::ClipLine (const Vector3 &x, const Vector3 &v, const Box3D &b, Real &u1, Real &u2)
 
bool Math3D::ClipLine (const Vector3 &x, const Vector3 &v, const AABB3D &b, Real &u1, Real &u2)
 
bool Math3D::ClipLine (const Vector3 &x, const Vector3 &v, const ConvexPolyhedron3D &p, Real &u1, Real &u2)
 
bool Math3D::IsFinite (const Vector2 &x)
 
bool Math3D::IsFinite (const Vector3 &x)
 
bool Math3D::IsFinite (const Vector4 &x)
 
bool Math3D::IsFinite (const Matrix2 &R)
 
bool Math3D::IsFinite (const Matrix3 &R)
 
bool Math3D::IsFinite (const Matrix4 &R)
 
bool Math3D::IsInf (const Vector2 &x)
 
bool Math3D::IsInf (const Vector3 &x)
 
bool Math3D::IsInf (const Vector4 &x)
 
bool Math3D::IsInf (const Matrix2 &R)
 
bool Math3D::IsInf (const Matrix3 &R)
 
bool Math3D::IsInf (const Matrix4 &R)
 
bool Math3D::FuzzyZero (const Vector2 &x, Real tol=Epsilon)
 
bool Math3D::FuzzyZero (const Vector3 &x, Real tol=Epsilon)
 
bool Math3D::FuzzyZero (const Vector4 &x, Real tol=Epsilon)
 
template<class V >
bool Math3D::NormLess (const V &x, Real d)
 
template<class V >
bool Math3D::NormLEQ (const V &x, Real d)
 
template<class V >
bool Math3D::NormGreater (const V &x, Real d)
 
template<class V >
bool Math3D::NormGEQ (const V &x, Real d)
 
template<class V >
bool Math3D::DistanceLess (const V &x, const V &y, Real d)
 
template<class V >
bool Math3D::DistanceLEQ (const V &x, const V &y, Real d)
 
template<class V >
bool Math3D::DistanceGreater (const V &x, const V &y, Real d)
 
template<class V >
bool Math3D::DistanceGEQ (const V &x, const V &y, Real d)
 
Real Math3D::Orient2D (const Vector2 &p0, const Vector2 &p1, const Vector2 &p2)
 Orientation test for 2d points. More...
 
Real Math3D::DistanceSquared2D (Real x1, Real y1, Real x2, Real y2)
 
Real Math3D::Distance2D (Real x1, Real y1, Real x2, Real y2)
 
bool Math3D::IsSymmetric (const Matrix2 &R, Real tol=Epsilon)
 
bool Math3D::IsSymmetric (const Matrix3 &R, Real tol=Epsilon)
 
bool Math3D::IsSymmetric (const Matrix4 &R, Real tol=Epsilon)
 
bool Math3D::IsUpperTriangular (const Matrix2 &R, Real tol=Epsilon)
 
bool Math3D::IsUpperTriangular (const Matrix3 &R, Real tol=Epsilon)
 
bool Math3D::IsUpperTriangular (const Matrix4 &R, Real tol=Epsilon)
 
void Math3D::PolarToRectangular (const Vector2 &polar, Vector2 &rect)
 
void Math3D::RectangularToPolar (const Vector2 &rect, Vector2 &polar)
 
void Math3D::SphericalToRectangular (const Vector3 &sphere, Vector3 &rect)
 
void Math3D::RectangularToSpherical (const Vector3 &rect, Vector3 &sphere)
 
void Math3D::CylindricalToRectangular (const Vector3 &cyl, Vector3 &rect)
 
void Math3D::RectangularToCylindrical (const Vector3 &rect, Vector3 &cyl)
 
void Math3D::PolarDR (const Vector2 &polar, Vector2 &drect)
 
void Math3D::PolarDTheta (const Vector2 &polar, Vector2 &drect)
 
void Math3D::SphericalDR (const Vector3 &sphere, Vector3 &drect)
 
void Math3D::SphericalDTheta (const Vector3 &sphere, Vector3 &drect)
 
void Math3D::SphericalDPhi (const Vector3 &sphere, Vector3 &drect)
 
void Math3D::CylindricalDR (const Vector3 &cyl, Vector3 &drect)
 
void Math3D::CylindricalDTheta (const Vector3 &cyl, Vector3 &drect)
 
void Math3D::CylindricalDZ (const Vector3 &cyl, Vector3 &drect)
 
Real Math3D::dot (const Vector2 &a, const Vector2 &b)
 
Real Math3D::cross (const Vector2 &a, const Vector2 &b)
 
void Math3D::normalize (Vector2 &a)
 
Vector2 Math3D::project (const Vector2 &a, const Vector2 &b)
 
Vector2 Math3D::operator- (const Vector2 &a)
 
Vector2 Math3D::operator+ (const Vector2 &a, const Vector2 &b)
 
Vector2 Math3D::operator- (const Vector2 &a, const Vector2 &b)
 
Vector2 Math3D::operator* (const Vector2 &a, Real b)
 
Vector2 Math3D::operator* (Real a, const Vector2 &b)
 
Vector2 Math3D::operator/ (const Vector2 &a, Real b)
 
Real Math3D::dot (const Vector3 &a, const Vector3 &b)
 
Vector3 Math3D::cross (const Vector3 &a, const Vector3 &b)
 
void Math3D::normalize (Vector3 &a)
 
Vector3 Math3D::project (const Vector3 &a, const Vector3 &b)
 
Vector3 Math3D::operator- (const Vector3 &a)
 
Vector3 Math3D::operator+ (const Vector3 &a, const Vector3 &b)
 
Vector3 Math3D::operator- (const Vector3 &a, const Vector3 &b)
 
Vector3 Math3D::operator* (const Vector3 &a, Real b)
 
Vector3 Math3D::operator* (Real a, const Vector3 &b)
 
Vector3 Math3D::operator/ (const Vector3 &a, Real b)
 
Real Math3D::dot (const Vector4 &a, const Vector4 &b)
 
Real Math3D::dot3 (const Vector4 &a, const Vector4 &b)
 
Real Math3D::dot3 (const Vector4 &a, const Vector3 &b)
 
Real Math3D::dot3 (const Vector3 &a, const Vector4 &b)
 
void Math3D::normalize (Vector4 &a)
 
Vector4 Math3D::project (const Vector4 &a, const Vector4 &b)
 
Vector4 Math3D::operator- (const Vector4 &a)
 
Vector4 Math3D::operator+ (const Vector4 &a, const Vector4 &b)
 
Vector4 Math3D::operator- (const Vector4 &a, const Vector4 &b)
 
Vector4 Math3D::operator* (const Vector4 &a, Real b)
 
Vector4 Math3D::operator* (Real a, const Vector4 &b)
 
Vector4 Math3D::operator/ (const Vector4 &a, Real b)
 
Real Math3D::determinant (const Matrix2 &)
 
Real Math3D::trace (const Matrix2 &)
 
Matrix2 Math3D::operator+ (const Matrix2 &a, const Matrix2 &b)
 
Matrix2 Math3D::operator- (const Matrix2 &a, const Matrix2 &b)
 
Matrix2 Math3D::operator* (const Matrix2 &a, const Matrix2 &b)
 
Vector2 Math3D::operator* (const Matrix2 &a, const Vector2 &b)
 
Vector2 Math3D::operator* (const Vector2 &a, const Matrix2 &b)
 
Real Math3D::determinant (const Matrix3 &)
 
Real Math3D::trace (const Matrix3 &)
 
Matrix3 Math3D::operator+ (const Matrix3 &a, const Matrix3 &b)
 
Matrix3 Math3D::operator- (const Matrix3 &a, const Matrix3 &b)
 
Matrix3 Math3D::operator* (const Matrix3 &a, const Matrix3 &b)
 
Vector3 Math3D::operator* (const Matrix3 &a, const Vector3 &b)
 
Vector3 Math3D::operator* (const Vector3 &a, const Matrix3 &b)
 
Real Math3D::determinant (const Matrix4 &)
 
Real Math3D::trace (const Matrix4 &)
 
Matrix4 Math3D::operator+ (const Matrix4 &a, const Matrix4 &b)
 
Matrix4 Math3D::operator- (const Matrix4 &a, const Matrix4 &b)
 
Matrix4 Math3D::operator* (const Matrix4 &a, const Matrix4 &b)
 
Vector4 Math3D::operator* (const Matrix4 &a, const Vector4 &b)
 
Vector4 Math3D::operator* (const Vector4 &a, const Matrix4 &b)
 
Vector3 Math3D::operator* (const Matrix4 &a, const Vector3 &b)
 WARNING: vector multiply.
 
Vector3 Math3D::operator* (const Vector3 &a, const Matrix4 &b)
 WARNING: vector multiply (transpose)
 
RigidTransform Math3D::operator* (const RigidTransform &, const RigidTransform &)
 
RigidTransform Math3D::operator* (const RigidTransform &, const Matrix3 &)
 
RigidTransform Math3D::operator* (const Matrix3 &a, const RigidTransform &b)
 
Vector3 Math3D::operator* (const RigidTransform &, const Vector3 &)
 
RigidTransform Math3D::operator+ (const RigidTransform &, const Vector3 &)
 
RigidTransform Math3D::operator- (const RigidTransform &, const Vector3 &)
 
RigidTransform2D Math3D::operator* (const RigidTransform2D &, const RigidTransform2D &)
 
Vector2 Math3D::operator* (const RigidTransform2D &, const Vector2 &)
 
Matrix2 Math3D::transpose (const Matrix2 &m)
 
Matrix2 Math3D::inverse (const Matrix2 &m)
 
Matrix2 Math3D::outerProduct (const Vector2 &a, const Vector2 &b)
 
Matrix2 Math3D::operator* (const Matrix2 &a, Real b)
 
Matrix2 Math3D::operator/ (const Matrix2 &a, Real b)
 
Matrix3 Math3D::transpose (const Matrix3 &m)
 
Matrix3 Math3D::inverse (const Matrix3 &m)
 
Matrix3 Math3D::outerProduct (const Vector3 &a, const Vector3 &b)
 
Matrix3 Math3D::operator* (const Matrix3 &a, Real b)
 
Matrix3 Math3D::operator/ (const Matrix3 &a, Real b)
 
Matrix4 Math3D::transpose (const Matrix4 &m)
 
Matrix4 Math3D::inverse (const Matrix4 &m)
 
Matrix4 Math3D::outerProduct (const Vector4 &a, const Vector4 &b)
 
Matrix4 Math3D::operator* (const Matrix4 &a, Real b)
 
Matrix4 Math3D::operator/ (const Matrix4 &a, Real b)
 
std::ostream & Math3D::operator<< (std::ostream &out, const Vector2 &v)
 
std::istream & Math3D::operator>> (std::istream &in, Vector2 &v)
 
std::ostream & Math3D::operator<< (std::ostream &out, const Vector3 &v)
 
std::istream & Math3D::operator>> (std::istream &in, Vector3 &v)
 
std::ostream & Math3D::operator<< (std::ostream &out, const Vector4 &v)
 
std::istream & Math3D::operator>> (std::istream &in, Vector4 &v)
 
std::ostream & Math3D::operator<< (std::ostream &out, const Matrix2 &m)
 
std::istream & Math3D::operator>> (std::istream &in, Matrix2 &m)
 
std::ostream & Math3D::operator<< (std::ostream &out, const Matrix3 &m)
 
std::istream & Math3D::operator>> (std::istream &in, Matrix3 &m)
 
std::ostream & Math3D::operator<< (std::ostream &out, const Matrix4 &m)
 
std::istream & Math3D::operator>> (std::istream &in, Matrix4 &m)
 
std::ostream & Math3D::operator<< (std::ostream &out, const RigidTransform &x)
 
std::istream & Math3D::operator>> (std::istream &in, RigidTransform &x)
 
std::ostream & Math3D::operator<< (std::ostream &out, const RigidTransform2D &x)
 
std::istream & Math3D::operator>> (std::istream &in, RigidTransform2D &x)
 
void Math3D::SampleCircle (Real r, Vector2 &v)
 
void Math3D::SampleDisk (Real r, Vector2 &v)
 
void Math3D::SampleSphere (Real r, Vector3 &v)
 
void Math3D::SampleBall (Real r, Vector3 &v)
 
void Math3D::SampleSquare (Real d, Vector2 &v)
 
void Math3D::SampleCube (Real d, Vector3 &v)
 
void Math3D::SampleHyperCube (Real d, Vector4 &v)
 
void Math3D::SampleAABB (const Vector2 &bmin, const Vector2 &bmax, Vector2 &v)
 
void Math3D::SampleAABB (const Vector3 &bmin, const Vector3 &bmax, Vector3 &v)
 
void Math3D::SampleAABB (const Vector4 &bmin, const Vector4 &bmax, Vector4 &v)
 
void Math3D::RandRotation (Quaternion &q)
 
Vector2 Math3D::SampleCircle (Real r)
 
Vector2 Math3D::SampleDisk (Real r)
 
Vector3 Math3D::SampleSphere (Real r)
 
Vector3 Math3D::SampleBall (Real r)
 
Vector2 Math3D::SampleSquare (Real d)
 
Vector3 Math3D::SampleCube (Real d)
 
Vector4 Math3D::SampleHyperCube (Real d)
 
Vector2 Math3D::SampleAABB (const Vector2 &bmin, const Vector2 &bmax)
 
Vector3 Math3D::SampleAABB (const Vector3 &bmin, const Vector3 &bmax)
 
Vector4 Math3D::SampleAABB (const Vector4 &bmin, const Vector4 &bmax)
 
Quaternion Math3D::RandRotation ()
 
void Math3D::SetMatrixRotationZYX (Matrix3 &m, const Vector3 &v)
 
void Math3D::SetMatrixRotationZYX (Matrix4 &m, const Vector3 &v)
 
void Math3D::SetMatrixRotationVector (Matrix3 &m, const Vector3 &v)
 
void Math3D::SetMatrixRotationVector (Matrix4 &m, const Vector3 &v)
 
void Math3D::SetMatrixRotationVector (Matrix3 &m, const Vector3 &v, Real angle)
 
void Math3D::SetMatrixRotationVector (Matrix4 &m, const Vector3 &v, Real angle)
 
void Math3D::SetMatrixRotationQuaternion (Matrix3 &m, const Quaternion &q)
 
void Math3D::SetMatrixRotationQuaternion (Matrix4 &m, const Quaternion &q)
 
void Math3D::SLerp (const Quaternion &q0, const Quaternion &q1, Quaternion &out, Real t)
 Linear quaternion rotation interpolation.
 
void Math3D::SCerp (const Quaternion &q_1, const Quaternion &q0, const Quaternion &q1, const Quaternion &q2, Quaternion &out, Real t)
 Cubic quaternion rotation interpolation.
 
void Math3D::SBezier (const Quaternion &q0, const Quaternion &c0, const Quaternion &c1, const Quaternion &q1, Quaternion &out, Real t)
 Bezier-style quaternion rotation interpolation. More...
 
Real Math3D::RotationFit (const std::vector< Vector3 > &a, const std::vector< Vector3 > &b, Matrix3 &R)
 Calculates the least squares rotation fit min_R sum||R*a[i]-b[i]||^2. Returns the sum-of-squared errors.
 
void Math3D::AxisRotationFit (const std::vector< Vector3 > &a, const std::vector< Vector3 > &b, const Vector3 &z, Real &theta)
 Calculates the least squares rotation angle min_theta sum||R(theta,z)*a[i]-b[i]||^2.
 
Real Math3D::TransformFit (std::vector< Vector3 > &a, std::vector< Vector3 > &b, Matrix3 &R, Vector3 &t)
 Calculate the least squares rotation fit min_R,t sum||R*a[i]+t-b[i]||^2. Returns the sum-of-squared errors. More...
 
Real Math3D::WeightedTransformFit (const std::vector< Point3D > &a, const std::vector< Point3D > &b, const std::vector< Real > &w, const std::vector< Vector3 > &c, const std::vector< Vector3 > &d, const std::vector< Real > &v, Matrix3 &R, Vector3 &t)
 Solve the mixed point/vector fitting problem min sum_j wj||R*aj+t-bj||^2 + sum_k vk||Rc-d||^2. More...
 
Real Math3D::FitFrames (const std::vector< Vector3 > &a, const std::vector< Vector3 > &b, RigidTransform &Ta, RigidTransform &Tb, Vector3 &cov)
 Calculate the translations and rotations that match a,b in an axis-aligned frame. The cov vector stores the covariance in each axis.
 
bool Math3D::Vector2::operator== (const Vector2 &) const
 
bool Math3D::Vector2::operator!= (const Vector2 &) const
 
const Vector2 & Math3D::Vector2::operator= (const Vector2 &)
 
void Math3D::Vector2::operator+= (const Vector2 &)
 
void Math3D::Vector2::operator-= (const Vector2 &)
 
void Math3D::Vector2::operator*= (Real)
 
void Math3D::Vector2::operator/= (Real)
 
Real & Math3D::Vector2::operator[] (int)
 
const Real & Math3D::Vector2::operator[] (int) const
 
 Math3D::Vector2::operator Real * ()
 
 Math3D::Vector2::operator const Real * () const
 
void Math3D::Vector2::add (const Vector2 &a, const Vector2 &b)
 
void Math3D::Vector2::sub (const Vector2 &a, const Vector2 &b)
 
void Math3D::Vector2::mul (const Vector2 &a, Real)
 
void Math3D::Vector2::div (const Vector2 &a, Real)
 
void Math3D::Vector2::madd (const Vector2 &b, Real)
 
Real Math3D::Vector2::dot (const Vector2 &a) const
 
Real Math3D::Vector2::cross (const Vector2 &a) const
 2d cross product
 
Real Math3D::Vector2::distance (const Vector2 &a) const
 
Real Math3D::Vector2::distanceSquared (const Vector2 &a) const
 
Real Math3D::Vector2::minElement (int *index=NULL) const
 
Real Math3D::Vector2::maxElement (int *index=NULL) const
 
Real Math3D::Vector2::minAbsElement (int *index=NULL) const
 
Real Math3D::Vector2::maxAbsElement (int *index=NULL) const
 
Real Math3D::Vector2::norm () const
 
Real Math3D::Vector2::normSquared () const
 
Real Math3D::Vector2::length () const
 = norm
 
void Math3D::Vector2::set (const Vector2 &)
 
void Math3D::Vector2::set (Real x)
 
void Math3D::Vector2::set (Real x, Real y)
 
void Math3D::Vector2::set (const Real *data)
 
void Math3D::Vector2::setZero ()
 
void Math3D::Vector2::setRotation (Real rads)
 sets x=cos(rads), y=sin(rads)
 
void Math3D::Vector2::setPerpendicular (const Vector2 &)
 sets this to the vector rotated 90 degrees ccw
 
void Math3D::Vector2::setNegative (const Vector2 &)
 
void Math3D::Vector2::setNormalized (const Vector2 &)
 
void Math3D::Vector2::setProjection (const Vector2 &, const Vector2 &)
 sets this to the projection of a on b
 
void Math3D::Vector2::setMinimum (const Vector2 &)
 
void Math3D::Vector2::setMinimum (const Vector2 &, const Vector2 &)
 
void Math3D::Vector2::setMaximum (const Vector2 &)
 
void Math3D::Vector2::setMaximum (const Vector2 &, const Vector2 &)
 
void Math3D::Vector2::get (Vector2 &) const
 
void Math3D::Vector2::get (Real &x, Real &y) const
 
void Math3D::Vector2::get (Real data[2]) const
 
void Math3D::Vector2::getNegative (Vector2 &) const
 
void Math3D::Vector2::getNormalized (Vector2 &) const
 
void Math3D::Vector2::getOrthogonal (Vector2 &) const
 calculates an orthogonal vector
 
void Math3D::Vector2::inplaceNegative ()
 
void Math3D::Vector2::inplaceMul (Real)
 
void Math3D::Vector2::inplaceDiv (Real)
 
void Math3D::Vector2::inplaceNormalize ()
 
bool Math3D::Vector2::isZero (Real eps=Zero) const
 
bool Math3D::Vector2::isEqual (const Vector2 &, Real eps=Zero) const
 
bool Math3D::Vector3::operator== (const Vector3 &) const
 
bool Math3D::Vector3::operator!= (const Vector3 &) const
 
const Vector3 & Math3D::Vector3::operator= (const Vector3 &)
 
void Math3D::Vector3::operator+= (const Vector3 &)
 
void Math3D::Vector3::operator-= (const Vector3 &)
 
void Math3D::Vector3::operator*= (Real)
 
void Math3D::Vector3::operator/= (Real)
 
Real & Math3D::Vector3::operator[] (int)
 
const Real & Math3D::Vector3::operator[] (int) const
 
 Math3D::Vector3::operator Real * ()
 
 Math3D::Vector3::operator const Real * () const
 
void Math3D::Vector3::add (const Vector3 &a, const Vector3 &b)
 
void Math3D::Vector3::sub (const Vector3 &a, const Vector3 &b)
 
void Math3D::Vector3::mul (const Vector3 &a, Real)
 
void Math3D::Vector3::div (const Vector3 &a, Real)
 
void Math3D::Vector3::madd (const Vector3 &b, Real)
 
Real Math3D::Vector3::dot (const Vector3 &a) const
 
Real Math3D::Vector3::distance (const Vector3 &a) const
 
Real Math3D::Vector3::distanceSquared (const Vector3 &a) const
 
Real Math3D::Vector3::norm () const
 
Real Math3D::Vector3::normSquared () const
 
Real Math3D::Vector3::length () const
 = norm
 
Real Math3D::Vector3::minElement (int *index=NULL) const
 
Real Math3D::Vector3::maxElement (int *index=NULL) const
 
Real Math3D::Vector3::minAbsElement (int *index=NULL) const
 
Real Math3D::Vector3::maxAbsElement (int *index=NULL) const
 
void Math3D::Vector3::set (const Vector3 &)
 
void Math3D::Vector3::set (Real x)
 
void Math3D::Vector3::set (Real x, Real y, Real z)
 
void Math3D::Vector3::set (const Real *data)
 
void Math3D::Vector3::setZero ()
 
void Math3D::Vector3::setNegative (const Vector3 &)
 
void Math3D::Vector3::setCross (const Vector3 &, const Vector3 &)
 
void Math3D::Vector3::setNormalized (const Vector3 &)
 
void Math3D::Vector3::setProjection (const Vector3 &, const Vector3 &)
 
void Math3D::Vector3::setMinimum (const Vector3 &)
 
void Math3D::Vector3::setMinimum (const Vector3 &, const Vector3 &)
 
void Math3D::Vector3::setMaximum (const Vector3 &)
 
void Math3D::Vector3::setMaximum (const Vector3 &, const Vector3 &)
 
void Math3D::Vector3::get (Vector3 &) const
 
void Math3D::Vector3::get (Real &x, Real &y, Real &z) const
 
void Math3D::Vector3::get (Real data[3]) const
 
void Math3D::Vector3::getNegative (Vector3 &) const
 
void Math3D::Vector3::getNormalized (Vector3 &) const
 
void Math3D::Vector3::getOrthogonalBasis (Vector3 &xb, Vector3 &yb) const
 calculates two unit vectors orthogonal to this vector (and positively oriented)
 
void Math3D::Vector3::inplaceNegative ()
 
void Math3D::Vector3::inplaceMul (Real)
 
void Math3D::Vector3::inplaceDiv (Real)
 
void Math3D::Vector3::inplaceNormalize ()
 
bool Math3D::Vector3::isZero (Real eps=Zero) const
 
bool Math3D::Vector3::isEqual (const Vector3 &, Real eps=Zero) const
 
bool Math3D::Vector4::operator== (const Vector4 &) const
 
bool Math3D::Vector4::operator!= (const Vector4 &) const
 
const Vector4 & Math3D::Vector4::operator= (const Vector4 &)
 
void Math3D::Vector4::operator+= (const Vector4 &)
 
void Math3D::Vector4::operator-= (const Vector4 &)
 
void Math3D::Vector4::operator*= (Real)
 
void Math3D::Vector4::operator/= (Real)
 
void Math3D::Vector4::operator+= (const Vector3 &)
 
void Math3D::Vector4::operator-= (const Vector3 &)
 
Real & Math3D::Vector4::operator[] (int)
 
const Real & Math3D::Vector4::operator[] (int) const
 
 Math3D::Vector4::operator Vector3 () const
 
 Math3D::Vector4::operator Real * ()
 
 Math3D::Vector4::operator const Real * () const
 
void Math3D::Vector4::add (const Vector4 &a, const Vector4 &b)
 
void Math3D::Vector4::sub (const Vector4 &a, const Vector4 &b)
 
void Math3D::Vector4::mul (const Vector4 &a, Real)
 
void Math3D::Vector4::div (const Vector4 &a, Real)
 
void Math3D::Vector4::madd (const Vector4 &a, Real)
 
Real Math3D::Vector4::dot (const Vector4 &a) const
 
Real Math3D::Vector4::dot3 (const Vector4 &a) const
 
Real Math3D::Vector4::dot3 (const Vector3 &a) const
 
Real Math3D::Vector4::distance (const Vector4 &a) const
 
Real Math3D::Vector4::distanceSquared (const Vector4 &a) const
 
Real Math3D::Vector4::norm () const
 
Real Math3D::Vector4::normSquared () const
 
Real Math3D::Vector4::length () const
 
Real Math3D::Vector4::minElement (int *index=NULL) const
 
Real Math3D::Vector4::maxElement (int *index=NULL) const
 
Real Math3D::Vector4::minAbsElement (int *index=NULL) const
 
Real Math3D::Vector4::maxAbsElement (int *index=NULL) const
 
void Math3D::Vector4::set (const Vector4 &)
 
void Math3D::Vector4::set (Real x)
 
void Math3D::Vector4::set (Real x, Real y, Real z, Real w=One)
 
void Math3D::Vector4::set (const Real *data)
 
void Math3D::Vector4::setZero ()
 
void Math3D::Vector4::setVector (const Vector3 &)
 sets w = 0
 
void Math3D::Vector4::setHomogeneous (const Vector3 &)
 sets w = 1
 
void Math3D::Vector4::setNegative (const Vector4 &)
 
void Math3D::Vector4::setNormalized (const Vector4 &)
 
void Math3D::Vector4::setProjection (const Vector4 &, const Vector4 &)
 
void Math3D::Vector4::setMinimum (const Vector4 &)
 
void Math3D::Vector4::setMinimum (const Vector4 &, const Vector4 &)
 
void Math3D::Vector4::setMaximum (const Vector4 &)
 
void Math3D::Vector4::setMaximum (const Vector4 &, const Vector4 &)
 
void Math3D::Vector4::get (Vector4 &) const
 
void Math3D::Vector4::get (Real &x, Real &y, Real &z, Real &w) const
 
void Math3D::Vector4::get (Real data[4]) const
 
void Math3D::Vector4::get (Vector3 &) const
 
void Math3D::Vector4::getNegative (Vector4 &) const
 
void Math3D::Vector4::getNormalized (Vector4 &) const
 
void Math3D::Vector4::inplaceNegative ()
 
void Math3D::Vector4::inplaceMul (Real)
 
void Math3D::Vector4::inplaceDiv (Real)
 
void Math3D::Vector4::inplaceNormalize ()
 
bool Math3D::Vector4::isZero (Real eps=Zero) const
 
bool Math3D::Vector4::isEqual (const Vector4 &, Real eps=Zero) const
 
const Matrix2 & Math3D::Matrix2::operator= (const Matrix2 &)
 
void Math3D::Matrix2::operator+= (const Matrix2 &)
 
void Math3D::Matrix2::operator-= (const Matrix2 &)
 
void Math3D::Matrix2::operator*= (const Matrix2 &)
 
void Math3D::Matrix2::operator*= (Real scale)
 
void Math3D::Matrix2::operator/= (Real scale)
 
void Math3D::Matrix2::set (const Matrix2 &)
 
void Math3D::Matrix2::set (Real)
 
void Math3D::Matrix2::set (const Real[2][2])
 
void Math3D::Matrix2::set (const Real *)
 
void Math3D::Matrix2::set (const Vector2 &xb, const Vector2 &yb)
 
void Math3D::Matrix2::setZero ()
 
void Math3D::Matrix2::setIdentity ()
 
void Math3D::Matrix2::setDiagonal (const Vector2 &)
 
void Math3D::Matrix2::setTranspose (const Matrix2 &)
 
void Math3D::Matrix2::setNegative (const Matrix2 &)
 
bool Math3D::Matrix2::setInverse (const Matrix2 &)
 returns true when successful
 
void Math3D::Matrix2::setScale (Real s)
 
void Math3D::Matrix2::setScale (Real sx, Real sy)
 
void Math3D::Matrix2::setRotate (Real rads)
 sets the matrix that rotates ccw by rads
 
void Math3D::Matrix2::setOuterProduct (const Vector2 &a, const Vector2 &b)
 this = a*b^t
 
void Math3D::Matrix2::get (Matrix2 &) const
 
void Math3D::Matrix2::get (Real[2][2]) const
 
void Math3D::Matrix2::get (Real[4]) const
 
void Math3D::Matrix2::get (Vector2 &xb, Vector2 &yb) const
 
void Math3D::Matrix2::getTranspose (Matrix2 &) const
 
void Math3D::Matrix2::getNegative (Matrix2 &) const
 
bool Math3D::Matrix2::getInverse (Matrix2 &) const
 
void Math3D::Matrix2::inplaceTranspose ()
 
void Math3D::Matrix2::inplaceNegative ()
 
void Math3D::Matrix2::inplaceMul (Real s)
 
void Math3D::Matrix2::inplaceDiv (Real s)
 
void Math3D::Matrix2::inplaceRowScale (Real sx, Real sy)
 
void Math3D::Matrix2::inplaceColScale (Real sx, Real sy)
 
bool Math3D::Matrix2::inplaceInverse ()
 
bool Math3D::Matrix2::isZero (Real eps=Zero) const
 
bool Math3D::Matrix2::isEqual (const Matrix2 &, Real eps=Zero) const
 
bool Math3D::Matrix2::isIdentity (Real eps=Zero) const
 
bool Math3D::Matrix2::isInvertible (Real eps=Zero) const
 
Real Math3D::Matrix2::trace () const
 
Real Math3D::Matrix2::determinant () const
 
Real Math3D::Matrix2::minElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix2::maxElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix2::minAbsElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix2::maxAbsElement (int *i=NULL, int *j=NULL) const
 
const Matrix3 & Math3D::Matrix3::operator= (const Matrix3 &)
 
void Math3D::Matrix3::operator+= (const Matrix3 &)
 
void Math3D::Matrix3::operator-= (const Matrix3 &)
 
void Math3D::Matrix3::operator*= (const Matrix3 &)
 
void Math3D::Matrix3::operator*= (Real scale)
 
void Math3D::Matrix3::operator/= (Real scale)
 
void Math3D::Matrix3::mul (const Matrix3 &a, Real b)
 
void Math3D::Matrix3::div (const Matrix3 &a, Real b)
 
void Math3D::Matrix3::set (const Matrix3 &)
 
void Math3D::Matrix3::set (Real)
 
void Math3D::Matrix3::set (const Real[3][3])
 
void Math3D::Matrix3::set (const Vector3 &xb, const Vector3 &yb, const Vector3 &zb)
 
void Math3D::Matrix3::setZero ()
 
void Math3D::Matrix3::setIdentity ()
 
void Math3D::Matrix3::setDiagonal (const Vector3 &)
 
void Math3D::Matrix3::setTranspose (const Matrix3 &)
 
void Math3D::Matrix3::setNegative (const Matrix3 &)
 
void Math3D::Matrix3::setScale (Real s)
 
void Math3D::Matrix3::setScale (Real sx, Real sy, Real sz)
 
void Math3D::Matrix3::setRotateX (Real rads)
 sets the matrix that rotates ccw by rads around the x axis
 
void Math3D::Matrix3::setRotateY (Real rads)
 sets the matrix that rotates ccw by rads around the x axis
 
void Math3D::Matrix3::setRotateZ (Real rads)
 sets the matrix that rotates ccw by rads around the x axis
 
void Math3D::Matrix3::setCrossProduct (const Vector3 &)
 sets the matrix that performs the vector cross product
 
void Math3D::Matrix3::setOuterProduct (const Vector3 &a, const Vector3 &b)
 this = a*b^t
 
void Math3D::Matrix3::get (Matrix3 &) const
 
void Math3D::Matrix3::get (Real[3][3]) const
 
void Math3D::Matrix3::get (Real[9]) const
 
void Math3D::Matrix3::get (Vector3 &xb, Vector3 &yb, Vector3 &zb) const
 
void Math3D::Matrix3::getTranspose (Matrix3 &) const
 
void Math3D::Matrix3::getNegative (Matrix3 &) const
 
bool Math3D::Matrix3::getInverse (Matrix3 &) const
 
void Math3D::Matrix3::getCrossProduct (Vector3 &) const
 if this is a cross-product matrix, returns the vector that performs the cross product
 
void Math3D::Matrix3::inplaceTranspose ()
 
void Math3D::Matrix3::inplaceNegative ()
 
void Math3D::Matrix3::inplaceMul (Real s)
 
void Math3D::Matrix3::inplaceDiv (Real s)
 
void Math3D::Matrix3::inplaceRowScale (Real sx, Real sy, Real sz)
 
void Math3D::Matrix3::inplaceColScale (Real sx, Real sy, Real sz)
 
bool Math3D::Matrix3::inplaceInverse ()
 
bool Math3D::Matrix3::isZero (Real eps=Zero) const
 
bool Math3D::Matrix3::isEqual (const Matrix3 &, Real eps=Zero) const
 
bool Math3D::Matrix3::isIdentity (Real eps=Zero) const
 
bool Math3D::Matrix3::isInvertible (Real eps=Zero) const
 
Real Math3D::Matrix3::trace () const
 
Real Math3D::Matrix3::minElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix3::maxElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix3::minAbsElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix3::maxAbsElement (int *i=NULL, int *j=NULL) const
 
const Matrix4 & Math3D::Matrix4::operator= (const Matrix4 &)
 
void Math3D::Matrix4::operator+= (const Matrix4 &)
 
void Math3D::Matrix4::operator-= (const Matrix4 &)
 
void Math3D::Matrix4::operator*= (const Matrix4 &)
 
void Math3D::Matrix4::operator*= (Real scale)
 
void Math3D::Matrix4::operator/= (Real scale)
 
void Math3D::Matrix4::set (const Matrix4 &)
 
void Math3D::Matrix4::set (Real)
 
void Math3D::Matrix4::set (const Real[4][4])
 
void Math3D::Matrix4::set (const Real *)
 
void Math3D::Matrix4::set (const Vector3 &xb, const Vector3 &yb, const Vector3 &zb, const Vector3 &trans)
 
void Math3D::Matrix4::set (const Vector4 &x, const Vector4 &y, const Vector4 &z, const Vector4 &w)
 
void Math3D::Matrix4::set (const Matrix3 &)
 sets the upper 3x3 matrix
 
void Math3D::Matrix4::set (const Matrix3 &, const Vector3 &trans)
 sets the upper 3x3 matrix and the upper 3x1 vector (making an affine 3D transformation)
 
void Math3D::Matrix4::setZero ()
 
void Math3D::Matrix4::setIdentity ()
 
void Math3D::Matrix4::setDiagonal (const Vector4 &)
 
void Math3D::Matrix4::setTranslate (const Vector3 &trans)
 
void Math3D::Matrix4::setTranspose (const Matrix4 &)
 
void Math3D::Matrix4::setNegative (const Matrix4 &)
 
void Math3D::Matrix4::setOuterProduct (const Vector4 &a, const Vector4 &b)
 this = a*b^t
 
void Math3D::Matrix4::get (Matrix4 &) const
 
void Math3D::Matrix4::get (Real[4][4]) const
 
void Math3D::Matrix4::get (Real[16]) const
 
void Math3D::Matrix4::get (Vector3 &xb, Vector3 &yb, Vector3 &zb, Vector3 &trans) const
 
void Math3D::Matrix4::get (Vector4 &x, Vector4 &y, Vector4 &z, Vector4 &w) const
 
void Math3D::Matrix4::get (Matrix3 &) const
 
void Math3D::Matrix4::get (Matrix3 &, Vector3 &) const
 
void Math3D::Matrix4::getTranspose (Matrix4 &) const
 
void Math3D::Matrix4::getNegative (Matrix4 &) const
 
bool Math3D::Matrix4::getInverse (Matrix4 &) const
 
void Math3D::Matrix4::inplaceTranspose ()
 
void Math3D::Matrix4::inplaceNegative ()
 
bool Math3D::Matrix4::inplaceInverse ()
 
void Math3D::Matrix4::inplaceMul (Real s)
 
void Math3D::Matrix4::inplaceDiv (Real s)
 
bool Math3D::Matrix4::isZero (Real eps=Zero) const
 
bool Math3D::Matrix4::isEqual (const Matrix4 &, Real eps=Zero) const
 
bool Math3D::Matrix4::isIdentity (Real eps=Zero) const
 
bool Math3D::Matrix4::isInvertible (Real eps=Zero) const
 
Real Math3D::Matrix4::trace () const
 
Real Math3D::Matrix4::minElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix4::maxElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix4::minAbsElement (int *i=NULL, int *j=NULL) const
 
Real Math3D::Matrix4::maxAbsElement (int *i=NULL, int *j=NULL) const
 
bool Math3D::RigidTransform::operator== (const RigidTransform &) const
 
bool Math3D::RigidTransform::operator!= (const RigidTransform &) const
 
const RigidTransform & Math3D::RigidTransform::operator= (const RigidTransform &)
 
void Math3D::RigidTransform::operator*= (const RigidTransform &)
 
void Math3D::RigidTransform::operator*= (const Matrix3 &)
 
void Math3D::RigidTransform::operator+= (const Vector3 &)
 
void Math3D::RigidTransform::operator-= (const Vector3 &)
 
 Math3D::RigidTransform::operator Matrix4 () const
 
void Math3D::RigidTransform::compose (const RigidTransform &a, const RigidTransform &b)
 this(v) = a(b(v))
 
void Math3D::RigidTransform::composeInverseA (const RigidTransform &a, const RigidTransform &b)
 this(v) = a^-1(b(v))
 
void Math3D::RigidTransform::composeInverseB (const RigidTransform &a, const RigidTransform &b)
 
void Math3D::RigidTransform::mul (const RigidTransform &a, const RigidTransform &b)
 mul = compose
 
void Math3D::RigidTransform::mulInverseA (const RigidTransform &a, const RigidTransform &b)
 
void Math3D::RigidTransform::mulInverseB (const RigidTransform &a, const RigidTransform &b)
 
void Math3D::RigidTransform::setIdentity ()
 
void Math3D::RigidTransform::set (const RigidTransform &)
 
void Math3D::RigidTransform::set (const Matrix3 &, const Vector3 &)
 
void Math3D::RigidTransform::set (const Vector3 &x, const Vector3 &y, const Vector3 &z, const Vector3 &trans)
 
void Math3D::RigidTransform::set (const Matrix4 &)
 
void Math3D::RigidTransform::setRotate (const Matrix3 &)
 sets the xform to just rotate
 
void Math3D::RigidTransform::setTranslate (const Vector3 &)
 sets the xform to just translate
 
void Math3D::RigidTransform::setRotation (const Matrix3 &)
 
void Math3D::RigidTransform::setTranslation (const Vector3 &)
 
void Math3D::RigidTransform::setInverse (const RigidTransform &)
 
void Math3D::RigidTransform::setRotated (const RigidTransform &a, const Matrix3 &r)
 
void Math3D::RigidTransform::setShifted (const RigidTransform &a, const Vector3 &v)
 
void Math3D::RigidTransform::get (RigidTransform &) const
 
void Math3D::RigidTransform::get (Matrix3 &, Vector3 &) const
 
void Math3D::RigidTransform::get (Vector3 &x, Vector3 &y, Vector3 &z, Vector3 &trans) const
 
void Math3D::RigidTransform::get (Matrix4 &) const
 
void Math3D::RigidTransform::getRotation (Matrix3 &) const
 
void Math3D::RigidTransform::getTranslation (Vector3 &) const
 
void Math3D::RigidTransform::getInverse (RigidTransform &)
 
void Math3D::RigidTransform::inplaceInverse ()
 
void Math3D::RigidTransform::inplaceRotate (const Matrix3 &)
 
void Math3D::RigidTransform::inplaceShift (const Vector3 &)
 
bool Math3D::RigidTransform::isIdentity (Real eps=Zero) const
 
const RigidTransform2D & Math3D::RigidTransform2D::operator= (const RigidTransform2D &)
 
void Math3D::RigidTransform2D::operator*= (const RigidTransform2D &)
 
void Math3D::RigidTransform2D::compose (const RigidTransform2D &a, const RigidTransform2D &b)
 
void Math3D::RigidTransform2D::composeInverseA (const RigidTransform2D &a, const RigidTransform2D &b)
 
void Math3D::RigidTransform2D::composeInverseB (const RigidTransform2D &a, const RigidTransform2D &b)
 
void Math3D::RigidTransform2D::mul (const RigidTransform2D &a, const RigidTransform2D &b)
 
void Math3D::RigidTransform2D::mulInverseA (const RigidTransform2D &a, const RigidTransform2D &b)
 
void Math3D::RigidTransform2D::mulInverseB (const RigidTransform2D &a, const RigidTransform2D &b)
 
void Math3D::RigidTransform2D::mul (const Vector3 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::mul (const Vector2 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::mulPoint (const Vector2 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::mulVector (const Vector2 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::mulInverse (const Vector2 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::mulInverse (const Vector3 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::mulPointInverse (const Vector2 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::mulVectorInverse (const Vector2 &a, Vector2 &out) const
 
void Math3D::RigidTransform2D::setIdentity ()
 
void Math3D::RigidTransform2D::set (const RigidTransform2D &rhs)
 
void Math3D::RigidTransform2D::set (const Matrix3 &mat)
 
void Math3D::RigidTransform2D::set (Real theta, const Vector2 &t)
 
void Math3D::RigidTransform2D::setInverse (const RigidTransform2D &)
 
void Math3D::RigidTransform2D::get (RigidTransform2D &rhs) const
 
void Math3D::RigidTransform2D::get (Matrix3 &mat) const
 
void Math3D::RigidTransform2D::get (Real &theta, Vector2 &t) const
 
bool Math3D::RigidTransform2D::isIdentity (Real eps=Zero) const
 

matrix ops (this = a op b)

void Math3D::Matrix2::add (const Matrix2 &a, const Matrix2 &b)
 
void Math3D::Matrix2::sub (const Matrix2 &a, const Matrix2 &b)
 
void Math3D::Matrix2::mul (const Matrix2 &a, const Matrix2 &b)
 
void Math3D::Matrix2::mulTransposeA (const Matrix2 &a, const Matrix2 &b)
 
void Math3D::Matrix2::mulTransposeB (const Matrix2 &a, const Matrix2 &b)
 

scalar ops (this = a op b)

void Math3D::Matrix2::mul (const Matrix2 &a, Real b)
 
void Math3D::Matrix2::div (const Matrix2 &a, Real b)
 

vector ops (out = this op a)

void Math3D::Matrix2::mul (const Vector2 &a, Vector2 &out) const
 
void Math3D::Matrix2::mulTranspose (const Vector2 &a, Vector2 &out) const
 

matrix ops (this = a op b)

void Math3D::Matrix3::add (const Matrix3 &a, const Matrix3 &b)
 
void Math3D::Matrix3::sub (const Matrix3 &a, const Matrix3 &b)
 
void Math3D::Matrix3::mul (const Matrix3 &a, const Matrix3 &b)
 
void Math3D::Matrix3::mulTransposeA (const Matrix3 &a, const Matrix3 &b)
 
void Math3D::Matrix3::mulTransposeB (const Matrix3 &a, const Matrix3 &b)
 

vector ops (out = this op a)

void Math3D::Matrix3::mul (const Vector3 &a, Vector3 &out) const
 Note: result is incorrect if out = a.
 
void Math3D::Matrix3::mulTranspose (const Vector3 &a, Vector3 &out) const
 

homogeneous vector ops (3rd coord is homogeneous coord)

void Math3D::Matrix3::mulPoint (const Vector2 &a, Vector2 &out) const
 assumes w = 1
 
void Math3D::Matrix3::mulVector (const Vector2 &a, Vector2 &out) const
 assumes w = 0
 
void Math3D::Matrix3::mulVectorTranspose (const Vector2 &a, Vector2 &out) const
 

matrix ops (this = a op b)

void Math3D::Matrix4::add (const Matrix4 &a, const Matrix4 &b)
 
void Math3D::Matrix4::sub (const Matrix4 &a, const Matrix4 &b)
 
void Math3D::Matrix4::mul (const Matrix4 &a, const Matrix4 &b)
 
void Math3D::Matrix4::mulTransposeA (const Matrix4 &a, const Matrix4 &b)
 
void Math3D::Matrix4::mulTransposeB (const Matrix4 &a, const Matrix4 &b)
 

scalar ops (this = a op b)

void Math3D::Matrix4::mul (const Matrix4 &a, Real b)
 
void Math3D::Matrix4::div (const Matrix4 &a, Real b)
 
void Math3D::Matrix4::mul (const Vector4 &a, Vector4 &out) const
 
void Math3D::Matrix4::mulTranspose (const Vector4 &a, Vector4 &out) const
 

homogeneous vector ops (4th coord is homogeneous coord)

void Math3D::Matrix4::mulPoint (const Vector3 &a, Vector3 &out) const
 assumes w = 1
 
void Math3D::Matrix4::mulVector (const Vector3 &a, Vector3 &out) const
 assumes w = 0
 
void Math3D::Matrix4::mulVectorTranspose (const Vector3 &a, Vector3 &out) const
 

vector operators

void Math3D::RigidTransform::mul (const Vector3 &a, Vector3 &out) const
 = mulPoint
 
void Math3D::RigidTransform::mul (const Vector4 &a, Vector3 &out) const
 
void Math3D::RigidTransform::mulPoint (const Vector3 &a, Vector3 &out) const
 
void Math3D::RigidTransform::mulVector (const Vector3 &a, Vector3 &out) const
 
void Math3D::RigidTransform::mulInverse (const Vector3 &a, Vector3 &out) const
 = mulPointInverse
 
void Math3D::RigidTransform::mulInverse (const Vector4 &a, Vector3 &out) const
 
void Math3D::RigidTransform::mulPointInverse (const Vector3 &a, Vector3 &out) const
 
void Math3D::RigidTransform::mulVectorInverse (const Vector3 &a, Vector3 &out) const
 

Detailed Description

Definitions of 3D math classes and functions.

Function Documentation

bool Math3D::ClipLine ( const Vector2 x,
const Vector2 v,
const Plane2D b,
Real &  u1,
Real &  u2 
)
bool Math3D::ClipLine1D ( Real  q,
Real  p,
Real &  umin,
Real &  umax 
)

Clipping primitive in 1D.

Given line segment x = q+p*u, u in [umin,umax], clips the range to the constraint x <= 0.

Returns true the resulting range is non-empty.

Referenced by ClipLine(), ClipLine1D(), Math3D::Triangle3D::closestPointCoords(), and Geometry::CollisionMeshQuery::WithinDistance().

bool Math3D::ClipLine1D ( Real  x0,
Real  a,
Real  b,
Real &  umin,
Real &  umax 
)
inline

Given line segment x = x0+u, u in [umin,umax], clips the range to the constraint a*x <= b

References ClipLine(), and ClipLine1D().

void Math3D::RigidTransform::composeInverseB ( const RigidTransform a,
const RigidTransform b 
)
inline

this(v) = a(b^-1(v))

void Math3D::GetCanonicalBasis ( const Vector2 x,
Vector2 y 
)
inline
void Math3D::GetCanonicalBasis ( const Vector3 x,
Vector3 y,
Vector3 z 
)
inline

Computes vectors y,z s.t. x,y,z is a (minimal) rotation from the standard basis.

References Math::FuzzyEquals().

void Matrix3::mulTranspose ( const Vector3 a,
Vector3 out 
) const
inline
void Matrix3::mulVectorTranspose ( const Vector2 a,
Vector2 out 
) const
inline

assumes w = 0

References Math3D::Matrix3::data, and Math::Delta().

void Math3D::Matrix4::mulVectorTranspose ( const Vector3 a,
Vector3 out 
) const
inline

assumes w = 0

References Math3D::Matrix4::data.

Referenced by operator*().

Real Math3D::Orient2D ( const Vector2 p0,
const Vector2 p1,
const Vector2 p2 
)
inline

Orientation test for 2d points.

Returns
>0 for p2 left of the line through p0 and p1
=0 for p2 on the line
<0 for p2 right of the line

References Math::FuzzyEquals().

Referenced by Math3D::Polygon2D::getPlane(), Math3D::Segment2D::orientation(), Math3D::Polygon2D::rayLeft(), Math3D::Polygon2D::rayRight(), Math3D::Polygon2D::raySplits(), and Math3D::Polygon2D::residue().

void Math3D::SBezier ( const Quaternion q0,
const Quaternion c0,
const Quaternion c1,
const Quaternion q1,
Quaternion out,
Real  t 
)

Bezier-style quaternion rotation interpolation.

The curve interpolates q0 and q1, using c0 and c1 as "control points"

References SLerp().

Referenced by SCerp().

Real Math3D::TransformFit ( vector< Vector3 > &  a,
vector< Vector3 > &  b,
Matrix3 R,
Vector3 t 
)

Calculate the least squares rotation fit min_R,t sum||R*a[i]+t-b[i]||^2. Returns the sum-of-squared errors.

Here, a and b provide temporary storage, their contents are modified

References RotationFit().

Referenced by Geometry::DenseTSDFReconstruction::Register(), and Geometry::SparseTSDFReconstruction::Register().

Real Math3D::WeightedTransformFit ( const vector< Point3D > &  a,
const vector< Point3D > &  b,
const vector< Real > &  w,
const vector< Vector3 > &  c,
const vector< Vector3 > &  d,
const vector< Real > &  v,
Matrix3 R,
Vector3 t 
)

Solve the mixed point/vector fitting problem min sum_j wj||R*aj+t-bj||^2 + sum_k vk||Rc-d||^2.

R is a rotation, t is a translation, a and b are points, c and d are vectors, and w and v are optional weights.

References RotationFit().