spat Namespace Reference

The namespace provides classes and methods for spatial computations. More...

Namespaces
namespace	ptreesupport
	ptree operator support

Classes
struct	Position
	Implements a 3D - position in cartesian coordinates. More...
struct	Sphere
	Sphere with center and radius. More...
struct	Vector
	Implements a 3D - vector in cartesian coordinates. More...
struct	Box
	Axis aligned box. More...
struct	VectorBundle
	Implements a Vector bundle. More...
struct	VectorBundle2
	Implements a tangential space bundle. More...
class	Rotation
	Rotation matrix. More...
class	Matrix
	Matrix template for arbitrary dimensions and value type. More...
struct	Frame
	A Frame ("TNBFrame") describes a location in 3d space and an orientation using a right handed coordinate cross of vectors. More...
struct	Vector2D
	Implements a 2D - vector in cartesian coordinates. More...
class	SquareMatrix
	Square matrix with nColumns == nRows. More...
class	Transformation
	Homogenous transformation matrix. More...
struct	PositionH
	Implements a 4D - position in homogenous coordinates. More...
struct	Position2D
	Implements a 2D - position in cartesian coordinates. More...
struct	Rect
	Axis aligned rectangle. More...

Typedefs
template<typename Valtype, typename ValtypeT = Valtype>
using	VectorBundle3 = Frame<Valtype,ValtypeT>
	Different name for Frame.
template<typename Valtype, typename ValtypeT = Valtype>
using	VectorBundle1 = VectorBundle<Valtype,ValtypeT>
	Different name for VectorBundle.

Functions
template<typename Valtype, typename ValtypeT = Valtype, typename Valtype2 = Valtype, typename ValtypeT2 = Valtype>
Frame< Valtype, ValtypeT > &	spatial_cast (Frame< Valtype2, ValtypeT2 > &from) noexcept
	Cast to Frame with different underlying value types.
template<typename Valtype, typename ValtypeT = Valtype, typename Valtype2 = Valtype, typename ValtypeT2 = Valtype>
const Frame< Valtype, ValtypeT > &	spatial_cast (const Frame< Valtype2, ValtypeT2 > &from) noexcept
	Cast to Frame with different underlying value types.
template<typename Valtype, typename ValtypeT = Valtype>
constexpr bool	operator== (const Frame< Valtype, ValtypeT > &frame1, const Frame< Valtype, ValtypeT > &frame2) noexcept
	Comparison.
template<typename Valtype, typename ValtypeT = Valtype>
constexpr bool	operator!= (const Frame< Valtype, ValtypeT > &frame1, const Frame< Valtype, ValtypeT > &frame2) noexcept
	Comparison.
template<typename Valtype, typename ValtypeT>
Frame< Valtype, ValtypeT > &	operator*= (Frame< Valtype, ValtypeT > &frame, ValtypeT param) noexcept
	Scale the vectors of Frame by a factor.
template<typename Valtype, typename ValtypeT>
auto	Normalize (const Frame< Valtype, ValtypeT > &f) noexcept -> std::pair< Vector< ValtypeT >, Frame< Valtype, decltype(ValtypeT{}/ValtypeT{})> >
	Outer normalizing.
template<typename Valtype, const unsigned short nCols>
constexpr Vector< Valtype >	Column (const Matrix< Valtype, nCols, 3 > &m, unsigned short idx) noexcept
template<typename Valtype, const unsigned short nRows>
constexpr Vector< Valtype >	Row (const Matrix< Valtype, 3, nRows > &m, unsigned short idx) noexcept
template<typename Valtype, const unsigned short nCols, const unsigned short nRows>
constexpr Matrix< Valtype, nRows, nCols >	Transposed (const Matrix< Valtype, nCols, nRows > &m) noexcept
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (const SquareMatrix< Valtype, 3 > &m, const Vector< Valtype2 > &v) noexcept -> Vector< decltype(Valtype{} *Valtype2{})>
	Transformation of a Vector by an 3x3 Matrix.
template<typename Valtype, const unsigned short nColsAndRows>
constexpr SquareMatrix< Valtype, nColsAndRows >	Inverted (const SquareMatrix< Valtype, nColsAndRows > &m)
template<typename Valtype, const unsigned short nColsAndRows>
constexpr SquareMatrix< Valtype, nColsAndRows >	Transposed (const SquareMatrix< Valtype, nColsAndRows > &m)
template<typename Valtype, const unsigned short nColsAndRows>
constexpr auto	Determinant (const SquareMatrix< Valtype, nColsAndRows > &m) -> decltype(pow< nColsAndRows >(Valtype{}))
	Determinant of the matrix.
template<typename Valtype, const unsigned short nColsAndRows>
SquareMatrix< Valtype, nColsAndRows >	AdjungatedMatrix (const SquareMatrix< Valtype, nColsAndRows > &m)
	Matrix of adjungated values.
template<typename Valtype1, typename Valtype2>
auto	operator* (const SquareMatrix< Valtype1, 2 > &m, const Vector2D< Valtype2 > &v) noexcept -> Vector2D< decltype(Valtype1{} *Valtype2{})>
template<typename Valtype, typename Valtype2>
auto	operator* (const Transformation< Valtype > &first, const Transformation< Valtype2 > &second) noexcept -> Transformation< decltype(Valtype{} *Valtype2{})>
template<typename Valtype>
bool	Slerp (Transformation< Valtype > &out, const Transformation< Valtype > &inA, const Transformation< Valtype > &inB, Valtype t)
	Spherical interpolates two matrices weighting them by t.
template<typename Valtype, typename ValtypeT>
Frame< Valtype, ValtypeT >	Invert (const Frame< Valtype, ValtypeT > frame)
	Inverts the frame, so that FI * F == Identity.
template<typename Valtype, typename Valtype2>
auto	operator* (const Rotation< Valtype > &first, const Rotation< Valtype2 > &second) noexcept -> Rotation< decltype(Valtype{} *Valtype2{})>
template<typename Valtype, unsigned short nCols, unsigned short nRows>
constexpr Matrix< Valtype, nRows, nCols >	Transposed (const Matrix< Valtype, nCols, nRows > &m) noexcept
template<typename Valtype, unsigned short nCols, unsigned short nRows>
Matrix< Valtype, nCols, nRows >	operator+ (const Matrix< Valtype, nCols, nRows > &first, const Matrix< Valtype, nCols, nRows > &second) noexcept
template<typename Valtype, unsigned short nCols, unsigned short nRows>
Matrix< Valtype, nCols, nRows >	operator- (const Matrix< Valtype, nCols, nRows > &first, const Matrix< Valtype, nCols, nRows > &second) noexcept
template<typename Valtype, unsigned short nCols, unsigned short nRows>
constexpr Matrix< Valtype, nCols, nRows > &	operator+ (Matrix< Valtype, nCols, nRows > &matrix) noexcept
template<typename Valtype, unsigned short nCols, unsigned short nRows>
Matrix< Valtype, nCols, nRows > &	operator- (Matrix< Valtype, nCols, nRows > &matrix) noexcept
template<typename Valtype, unsigned short nColsAndRows>
constexpr SquareMatrix< Valtype, nColsAndRows >	Inverted (const SquareMatrix< Valtype, nColsAndRows > &m)
template<typename Valtype, typename Valtype2>
Position< Valtype > &	spatial_cast (Position< Valtype2 > &from) noexcept
	Cast to Position with different underlying value type.
template<typename Valtype, typename Valtype2>
const Position< Valtype > &	spatial_cast (const Position< Valtype2 > &from) noexcept
	Cast to Position with different underlying value type.
template<typename Valtype>
constexpr size_t	size (const Position< Valtype >) noexcept
template<typename Valtype>
constexpr Position< int >	operator* (const Position< int > &p, Valtype f) noexcept
template<typename Valtype>
constexpr Position< int >	operator* (Valtype f, const Position< int > &p) noexcept
template<typename Valtype>
Position< int > &	operator*= (Position< int > &p, Valtype f) noexcept
template<typename Valtype>
constexpr Position< int >	operator/ (const Position< int > &p, Valtype f) noexcept
template<typename Valtype>
constexpr Position< int > &	operator/= (Position< int > &p, Valtype f) noexcept
template<typename Valtype>
constexpr size_t	size (const Position2D< Valtype >) noexcept
template<typename Valtype>
constexpr Position2D< int >	operator* (const Position2D< int > &p, Valtype f) noexcept
template<typename Valtype>
constexpr Position2D< int >	operator* (Valtype f, const Position2D< int > &p) noexcept
template<typename Valtype>
Position2D< int > &	operator*= (Position2D< int > &p, Valtype f) noexcept
template<typename Valtype>
constexpr Position2D< int >	operator/ (const Position2D< int > &p, Valtype f) noexcept
template<typename Valtype, typename Valtype2>
constexpr Position2D< Valtype > &	operator/= (Position2D< Valtype > &p, Valtype2 f) noexcept
template<typename Valtype>
Position2D< int > &	operator/= (Position2D< int > &p, Valtype f) noexcept
template<typename Valtype>
constexpr size_t	size (const PositionH< Valtype >) noexcept
template<typename Valtype>
bool	Intersect (const Rect< Valtype > &r1, const Rect< Valtype > &r2) noexcept
template<typename Valtype, typename Valtype2>
Vector< Valtype > &	spatial_cast (Vector< Valtype2 > &from) noexcept
	Cast to Vector with different underlying value type.
template<typename Valtype, typename Valtype2>
const Vector< Valtype > &	spatial_cast (const Vector< Valtype2 > &from) noexcept
	Cast to Vector with different underlying value type.
template<typename Valtype>
constexpr bool	Equals (const Vector< Valtype > &v1, const Vector< Valtype > &v2, Valtype epsilon=Valtype{0}) noexcept
	Comparison within some range.
template<typename Valtype>
auto	Normalize (const Vector< Valtype > &v) noexcept -> std::pair< Valtype, Vector< decltype(Valtype{}/Valtype{})> >
	Outer normalizing.
template<typename Valtype>
constexpr size_t	size (const Vector< Valtype >) noexcept
template<typename Valtype>
constexpr Vector< int >	operator* (const Vector< int > &v, Valtype f) noexcept
template<typename Valtype>
constexpr Vector< int >	operator* (Valtype f, const Vector< int > &v) noexcept
template<typename Valtype>
Vector< int > &	operator*= (Vector< int > &v, Valtype f) noexcept
template<typename Valtype>
constexpr Vector< int >	operator/ (const Vector< int > &v, Valtype f) noexcept
template<typename Valtype>
Vector< int > &	operator/= (Vector< int > &v, Valtype f) noexcept
template<typename Valtype, typename Valtype2>
Vector2D< Valtype > &	spatial_cast (Vector2D< Valtype2 > &from) noexcept
	Cast to Vector with different underlying value type.
template<typename Valtype, typename Valtype2>
const Vector2D< Valtype > &	spatial_cast (const Vector2D< Valtype2 > &from) noexcept
	Cast to Vector with different underlying value type.
template<typename Valtype>
auto	Normalize (const Vector2D< Valtype > &v) noexcept -> std::pair< Valtype, Vector2D< decltype(Valtype{}/Valtype{})> >
	Outer normalizing.
template<typename Valtype>
constexpr size_t	size (const Vector2D< Valtype >) noexcept
template<typename Valtype>
constexpr Vector2D< int >	operator* (const Vector2D< int > &v, Valtype f) noexcept
template<typename Valtype>
constexpr Vector2D< int >	operator* (Valtype f, const Vector2D< int > &v) noexcept
template<typename Valtype>
Vector2D< int > &	operator*= (Vector2D< int > &v, Valtype f) noexcept
template<typename Valtype>
constexpr Vector2D< int >	operator/ (const Vector2D< int > &v, Valtype f) noexcept
template<typename Valtype>
Vector2D< int > &	operator/= (Vector2D< int > &v, Valtype f) noexcept
template<typename Valtype, typename ValtypeT = Valtype, typename Valtype2 = Valtype, typename ValtypeT2 = Valtype>
VectorBundle< Valtype, ValtypeT > &	spatial_cast (VectorBundle< Valtype2, ValtypeT2 > &from) noexcept
	Cast to VectorBundle with different underlying value types.
template<typename Valtype, typename ValtypeT = Valtype, typename Valtype2 = Valtype, typename ValtypeT2 = Valtype>
const VectorBundle< Valtype, ValtypeT > &	spatial_cast (const VectorBundle< Valtype2, ValtypeT2 > &from) noexcept
	Cast to VectorBundle with different underlying value types.
template<typename Valtype, typename ValtypeT = Valtype>
VectorBundle1< Valtype, Valtype >	Distance (const VectorBundle1< Valtype, ValtypeT > &b1, const VectorBundle1< Valtype, ValtypeT > &b2) noexcept
template<typename Valtype, typename ValtypeT = Valtype, typename Valtype2 = Valtype, typename ValtypeT2 = Valtype>
VectorBundle2< Valtype, ValtypeT > &	spatial_cast (VectorBundle2< Valtype2, ValtypeT2 > &from) noexcept
	Cast to VectorBundle2 with different underlying value types.
template<typename Valtype, typename ValtypeT = Valtype, typename Valtype2 = Valtype, typename ValtypeT2 = Valtype>
const VectorBundle2< Valtype, ValtypeT > &	spatial_cast (const VectorBundle2< Valtype2, ValtypeT2 > &from) noexcept
	Cast to VectorBundle2 with different underlying value types.
Intersecting
Returns true if the two bodies have a volume in common.
template<typename Valtype>
bool	Intersecting (const Box< Valtype > &box, const Sphere< Valtype > &sphere) noexcept
template<typename Valtype>
bool	Intersecting (const Box< Valtype > &boxA, const Box< Valtype > &boxB) noexcept
Comparison
template<typename Valtype>
constexpr bool	operator== (const Box< Valtype > &b1, const Box< Valtype > &b2) noexcept
template<typename Valtype>
constexpr bool	operator!= (const Box< Valtype > &b1, const Box< Valtype > &b2) noexcept
template<typename Valtype>
constexpr bool	operator== (const PositionH< Valtype > &p1, const PositionH< Valtype > &p2) noexcept
template<typename Valtype>
constexpr bool	operator!= (const PositionH< Valtype > &p1, const PositionH< Valtype > &p2) noexcept
Transformation
Transformation of an element to a parent coordinate system. Parameters frame Frame to transform element to. p Position to get the transformed for. v Vector to get the transformed for. vb VectorBundle to get the transformed for. vb2 VectorBundle2 to get the transformed for. f Frame to get the transformed for. Returns Transformed element.
template<typename Valtype1, typename ValtypeT1, typename Valtype2>
Position< Valtype2 >	operator* (const Frame< Valtype1, ValtypeT1 > &frame, const Position< Valtype2 > &p) noexcept
	Frame operator.
template<typename Valtype1, typename ValtypeT1, typename ValtypeT2>
Vector< ValtypeT2 >	operator* (const Frame< Valtype1, ValtypeT1 > &frame, const Vector< ValtypeT2 > &v) noexcept
	Frame operator.
template<typename Valtype1, typename ValtypeT1, typename Valtype2, typename ValtypeT2>
VectorBundle< Valtype2, ValtypeT2 >	operator* (const Frame< Valtype1, ValtypeT1 > &frame, const VectorBundle< Valtype2, ValtypeT2 > &vb) noexcept
	Frame operator.
template<typename Valtype1, typename ValtypeT1, typename Valtype2, typename ValtypeT2>
VectorBundle2< Valtype2, ValtypeT2 >	operator* (const Frame< Valtype1, ValtypeT1 > &frame, const VectorBundle2< Valtype2, ValtypeT2 > &vb2) noexcept
	Frame operator.
template<typename Valtype1, typename ValtypeT1, typename Valtype2, typename ValtypeT2>
Frame< Valtype2, ValtypeT2 >	operator* (const Frame< Valtype1, ValtypeT1 > &frame, const Frame< Valtype2, ValtypeT2 > &f) noexcept
	Frame operator.
template<typename Valtype1, typename ValtypeT1, typename Valtype2>
Sphere< Valtype2 >	operator* (const Frame< Valtype1, ValtypeT1 > &frame, const Sphere< Valtype2 > &sp) noexcept
	Frame operator.
template<typename Valtype1, typename ValtypeT1, typename Valtype2, typename ValtypeT2>
Frame< Valtype2, ValtypeT2 > &	operator*= (Frame< Valtype1, ValtypeT1 > &frame, const Frame< Valtype2, ValtypeT2 > &f) noexcept
	right side multiplication of f to frame.
Mathematical Operators for Matrix
template<typename Valtype, typename Valtype2, const unsigned short nCols, const unsigned short nRows>
auto	operator* (Valtype skalar, const Matrix< Valtype2, nCols, nRows > &matrix) noexcept -> Matrix< decltype(Valtype{} *Valtype2{}), nCols, nRows >
template<typename Valtype, typename Valtype2, unsigned short nColsFirst_RowsSecond, unsigned short nRowsFirst, unsigned short nColsSecond>
auto	operator* (const Matrix< Valtype, nColsFirst_RowsSecond, nRowsFirst > &first, const Matrix< Valtype2, nColsSecond, nColsFirst_RowsSecond > &second) noexcept -> Matrix< decltype(Valtype{} *Valtype2{}), nColsSecond, nRowsFirst >
template<typename Valtype, typename Valtype2, unsigned short nCols, unsigned short nRows>
Matrix< Valtype, nCols, nRows > &	operator*= (Matrix< Valtype, nCols, nRows > &first, Valtype2 skalar) noexcept
template<typename Valtype, typename Valtype2, unsigned short nCols, unsigned short nRows>
Matrix< Valtype, nCols, nRows > &	operator/= (Matrix< Valtype, nCols, nRows > &first, Valtype2 skalar) noexcept
template<typename Valtype, const unsigned short nCols, const unsigned short nRows>
Matrix< Valtype, nCols, nRows >	operator+ (const Matrix< Valtype, nCols, nRows > &first, const Matrix< Valtype, nCols, nRows > &second) noexcept
template<typename Valtype, const unsigned short nCols, const unsigned short nRows>
Matrix< Valtype, nCols, nRows >	operator- (const Matrix< Valtype, nCols, nRows > &first, const Matrix< Valtype, nCols, nRows > &second) noexcept
template<typename Valtype, const unsigned short nCols, const unsigned short nRows>
constexpr Matrix< Valtype, nCols, nRows > &	operator+ (Matrix< Valtype, nCols, nRows > &matrix) noexcept
template<typename Valtype, const unsigned short nCols, const unsigned short nRows>
Matrix< Valtype, nCols, nRows > &	operator- (Matrix< Valtype, nCols, nRows > &matrix) noexcept
Copy to and from matrix data array
The major column or row is assumed to fill the matrix as contiguous memory.
template<typename Valtype, typename Valtype2, const unsigned short nCols, const unsigned short nRows>
void	copy_column_major (const Matrix< Valtype, nCols, nRows > &source, Valtype2 *target) noexcept
template<typename Valtype, typename Valtype2, const unsigned short nCols, const unsigned short nRows>
void	copy_column_major (const Valtype2 *source, Matrix< Valtype, nCols, nRows > &target) noexcept
template<typename Valtype, typename Valtype2, const unsigned short nCols, const unsigned short nRows>
void	copy_row_major (const Matrix< Valtype, nCols, nRows > &source, Valtype2 *target) noexcept
template<typename Valtype, typename Valtype2, const unsigned short nCols, const unsigned short nRows>
void	copy_row_major (const Valtype2 *source, Matrix< Valtype, nCols, nRows > &target) noexcept
Adjungated
Adjungate value for element
template<typename Valtype, const unsigned short nColsAndRows>
constexpr auto	Adjungated (const SquareMatrix< Valtype, nColsAndRows > &m, unsigned short c, unsigned short r) -> decltype(pow< nColsAndRows-1 >(Valtype{}))
template<typename Valtype>
constexpr auto	Adjungated (const SquareMatrix< Valtype, 1 > &m, unsigned short c, unsigned short r) noexcept -> decltype(pow< 0 >(Valtype{}))
Operators for Position
Algebra for Positions. Most surprises: you ran over a deleted operator? You should try Vector instead. If you really think it would make any sense to add the position of Rome and the position of Moscow to come out with Peking, there most probably is something wrong with your reasoning. To transform a Vector into a Position use Origin3D + Vector. To transform a Position into a Vector use Position - Origin3D. But try to avoid it.
template<typename Valtype>
constexpr Position< Valtype >	operator+ (const Position< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator+ (const Position< Valtype > &p, const Vector< Valtype > &v) noexcept
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator+ (const Vector< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
Position< Valtype > &	operator+= (Position< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
Position< Valtype > &	operator+= (Position< Valtype > &p, const Vector< Valtype > &v) noexcept
	Position operator.
template<typename Valtype>
Vector< Valtype > &	operator+= (Vector< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator+ (const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
constexpr Vector< Valtype >	operator- (const Position< Valtype > &p1, const Position< Valtype > &p2) noexcept
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator- (const Position< Valtype > &p, const Vector< Valtype > &v) noexcept
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator- (const Vector< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
Position< Valtype > &	operator-= (Position< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
Position< Valtype > &	operator-= (Position< Valtype > &p, const Vector< Valtype > &v) noexcept
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator- (const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator* (const Position< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
constexpr auto	operator* (Valtype f, const Position< Valtype > &p) noexcept -> Position< decltype(Valtype{} *Valtype{})>
	Position operator.
template<typename Valtype>
constexpr auto	operator* (const Position< Valtype > &p, Valtype f) noexcept -> Position< decltype(Valtype{} *Valtype{})>
	Position operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (Valtype f, const Position< Valtype2 > &p) noexcept -> Position< decltype(Valtype{} *Valtype2{})>
	Position operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (const Position< Valtype > &p, Valtype2 f) noexcept -> Position< decltype(Valtype{} *Valtype2{})>
	Position operator.
template<typename Valtype, typename Valtype2>
Position< Valtype > &	operator*= (Position< Valtype > &p, Valtype2 f) noexcept
	Position operator.
template<typename Valtype>
Valtype &	operator*= (Valtype &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator% (const Position< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
Position< Valtype > &	operator%= (const Position< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype>
constexpr Valtype	operator/ (const Position< Valtype > &, const Position< Valtype > &)=delete
	Position operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Position< Valtype > &p, Valtype2 f) noexcept -> Position< decltype(Valtype{}/Valtype2{})>
	Position operator.
template<typename Valtype>
constexpr Position< Valtype >	operator/ (Valtype f, const Position< Valtype > &p)=delete
	Position operator.
template<typename Valtype, typename Valtype2>
Position< Valtype > &	operator/= (Position< Valtype > &p, Valtype2 f) noexcept
	Position operator.
template<typename Valtype>
constexpr bool	operator== (const Position< Valtype > &p1, const Position< Valtype > &p2) noexcept
	Position operator.
template<typename Valtype>
constexpr bool	operator!= (const Position< Valtype > &p1, const Position< Valtype > &p2) noexcept
	Position operator.
Operators for Position2D
Algebra for Positions. Most surprises: you ran over a deleted operator? You should try Vector instead. If you really think it would make any sense to add the position of Rome and the position of Moscow to come out with Peking, there most probably is something wrong with your reasoning. To transform a Vector2D into a Position use Origin2D + Vector2D. To transform a Position2D into a Vector use Position2D - Origin2D.
template<typename Valtype>
constexpr Position2D< Valtype >	operator+ (const Position2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
constexpr Position2D< Valtype >	operator+ (const Position2D< Valtype > &p, const Vector2D< Valtype > &v) noexcept
template<typename Valtype>
constexpr Position2D< Valtype >	operator+ (const Vector2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
Position2D< Valtype > &	operator+= (Position2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
Position2D< Valtype > &	operator+= (Position2D< Valtype > &p, const Vector2D< Valtype > &v) noexcept
template<typename Valtype>
Vector2D< Valtype > &	operator+= (Vector2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
constexpr Position2D< Valtype >	operator+ (const Position2D< Valtype > &)=delete
template<typename Valtype>
constexpr Vector2D< Valtype >	operator- (const Position2D< Valtype > &p1, const Position2D< Valtype > &p2) noexcept
template<typename Valtype>
constexpr Position2D< Valtype >	operator- (const Position2D< Valtype > &p, const Vector2D< Valtype > &v) noexcept
template<typename Valtype>
constexpr Position2D< Valtype >	operator- (const Vector2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
Position2D< Valtype > &	operator-= (Position2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
Position2D< Valtype > &	operator-= (Position2D< Valtype > &p, const Vector2D< Valtype > &v) noexcept
template<typename Valtype>
constexpr Position2D< Valtype >	operator- (const Position2D< Valtype > &)=delete
template<typename Valtype>
constexpr Position2D< Valtype >	operator* (const Position2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (const Position2D< Valtype > &p, Valtype2 f) noexcept -> Position2D< decltype(Valtype{} *Valtype2{})>
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (Valtype f, const Position2D< Valtype2 > &p) noexcept -> Position2D< decltype(Valtype{} *Valtype2{})>
template<typename Valtype, typename Valtype2>
Position2D< Valtype > &	operator*= (Position2D< Valtype > &p, const Valtype2 &f) noexcept
template<typename Valtype, typename Valtype2>
Valtype2 &	operator*= (Valtype2 &, const Position2D< Valtype > &)=delete
template<typename Valtype>
constexpr Position2D< Valtype >	operator% (const Position2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
Position2D< Valtype > &	operator%= (const Position2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype>
constexpr Valtype	operator/ (const Position2D< Valtype > &, const Position2D< Valtype > &)=delete
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Position2D< Valtype > &p, Valtype2 f) noexcept -> Position2D< decltype(Valtype{}/Valtype2{})>
template<typename Valtype>
constexpr Position2D< Valtype >	operator/ (Valtype f, const Position2D< Valtype > &p)=delete
template<typename Valtype, typename Valtype2>
Position2D< Valtype > &	operator/= (Position2D< Valtype > &p, const Valtype2 &f) noexcept
template<typename Valtype>
constexpr bool	operator== (const Position2D< Valtype > &p1, const Position2D< Valtype > &p2) noexcept
template<typename Valtype>
constexpr bool	operator!= (const Position2D< Valtype > &p1, const Position2D< Valtype > &p2) noexcept
Mathematical Operators for Rect
template<typename Valtype>
void	operator+= (Rect< Valtype > &r1, const Rect< Valtype > &r2) noexcept
template<typename Valtype>
Rect< Valtype >	operator+ (const Rect< Valtype > &r1, const Rect< Valtype > &r2) noexcept
template<typename Valtype>
constexpr bool	operator== (const Rect< Valtype > &r1, const Rect< Valtype > &r2) noexcept
template<typename Valtype>
constexpr bool	operator!= (const Rect< Valtype > &r1, const Rect< Valtype > &r2) noexcept
Mathematical Operators for Sphere
template<typename Valtype>
bool	operator== (const Sphere< Valtype > a, const Sphere< Valtype > b) noexcept
template<typename Valtype>
bool	operator!= (const Sphere< Valtype > a, const Sphere< Valtype > b) noexcept
template<typename Valtype>
bool	Intersecting (const Sphere< Valtype > &sphereA, const Sphere< Valtype > &sphereB) noexcept
	Do the two spheres intersect?
template<typename Valtype, typename ValtypeT>
bool	Intersecting (const Sphere< Valtype > &sphere, const VectorBundle< Valtype, ValtypeT > &ray) noexcept
	Do the two spheres intersect?
Streaming functions for spat objects
Streams data out and in.
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const Position< Valtype > &p)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, Position< Valtype > &p)
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const Position2D< Valtype > &p)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, Position2D< Valtype > &p)
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const PositionH< Valtype > &p)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, PositionH< Valtype > &p)
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const Vector< Valtype > &v)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, Vector< Valtype > &v)
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const Vector2D< Valtype > &v)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, Vector2D< Valtype > &v)
template<typename Valtype, typename ValtypeT>
std::ostream &	operator<< (std::ostream &os, const VectorBundle< Valtype, ValtypeT > &vb)
template<typename Valtype, typename ValtypeT>
std::istream &	operator>> (std::istream &is, VectorBundle< Valtype, ValtypeT > &vb)
template<typename Valtype, typename ValtypeT>
std::ostream &	operator<< (std::ostream &os, const VectorBundle2< Valtype, ValtypeT > &vb)
template<typename Valtype, typename ValtypeT>
std::istream &	operator>> (std::istream &is, VectorBundle2< Valtype, ValtypeT > &vb)
template<typename Valtype, typename ValtypeT>
std::ostream &	operator<< (std::ostream &os, const Frame< Valtype, ValtypeT > &f)
template<typename Valtype, typename ValtypeT>
std::istream &	operator>> (std::istream &is, Frame< Valtype, ValtypeT > &f)
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const Box< Valtype > &b)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, Box< Valtype > &b)
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const Rect< Valtype > &r)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, Rect< Valtype > &r)
template<typename Valtype>
std::ostream &	operator<< (std::ostream &os, const Sphere< Valtype > &s)
template<typename Valtype>
std::istream &	operator>> (std::istream &is, Sphere< Valtype > &s)
template<typename Valtype, typename ValtypeT>
void	OrthogonalityDump (std::ostream &os, const Frame< Valtype, ValtypeT > &f)
Streaming for Matrix
template<typename Valtype, const unsigned short nCols, const unsigned short nRows>
std::ostream &	operator<< (std::ostream &os, const Matrix< Valtype, nCols, nRows > &m)
template<typename Valtype, const unsigned short nCols, const unsigned short nRows>
std::istream &	operator>> (std::istream &is, Matrix< Valtype, nCols, nRows > &m)
Operators for Vector
Algebra for Vectors.
template<typename Valtype>
constexpr Vector< Valtype >	operator+ (const Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept
	Vector operator.
template<typename Valtype>
Vector< Valtype > &	operator+= (Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept
	Vector operator.
template<typename Valtype>
constexpr Vector< Valtype >	operator+ (const Vector< Valtype > &v) noexcept
	Vector operator.
template<typename Valtype>
constexpr Vector< Valtype >	operator- (const Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept
	Vector operator.
template<typename Valtype>
Vector< Valtype > &	operator-= (Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept
	Vector operator.
template<typename Valtype>
constexpr Vector< Valtype >	operator- (const Vector< Valtype > &v) noexcept
	Vector operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (const Vector< Valtype > &v1, const Vector< Valtype2 > &v2) noexcept -> decltype(Valtype{} *Valtype2{})
	Inner product.
template<typename Valtype>
constexpr auto	operator* (Valtype f, const Vector< Valtype > &v) noexcept -> Vector< decltype(Valtype{} *Valtype{})>
	Vector operator.
template<typename Valtype>
constexpr auto	operator* (const Vector< Valtype > &v, Valtype f) noexcept -> Vector< decltype(Valtype{} *Valtype{})>
	Vector operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (Valtype f, const Vector< Valtype2 > &v) noexcept -> Vector< decltype(Valtype{} *Valtype2{})>
	Vector operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (const Vector< Valtype > &v, Valtype2 f) noexcept -> Vector< decltype(Valtype{} *Valtype2{})>
	Vector operator.
template<typename Valtype, typename Valtype2>
Vector< Valtype > &	operator*= (Vector< Valtype > &v, Valtype2 f) noexcept
	Vector operator.
template<typename Valtype>
Vector< Valtype > &	operator*= (Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept=delete
	Vector operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator% (const Vector< Valtype > &v1, const Vector< Valtype2 > &v2) noexcept -> Vector< decltype(Valtype{} *Valtype2{})>
	Cross product.
template<typename Valtype>
Vector< Valtype > &	operator%= (Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept
	Cross product assignment.
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Vector< Valtype > &, const Vector< Valtype2 > &)=delete
	Vector operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Vector< Valtype > &v, Valtype2 f) noexcept -> Vector< decltype(Valtype{}/Valtype2{})>
	Vector operator.
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Valtype &f, const Vector< Valtype2 > &v)=delete
	Vector operator.
template<typename Valtype, typename Valtype2>
Vector< Valtype > &	operator/= (Vector< Valtype > &v, Valtype2 f) noexcept
	Vector operator.
template<typename Valtype>
constexpr bool	operator== (const Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept
	Vector operator.
template<typename Valtype>
constexpr bool	operator!= (const Vector< Valtype > &v1, const Vector< Valtype > &v2) noexcept
	Vector operator.
Rotate
Rotates Vectors around a rotational axis. Parameters r rotational axis with angle r.Length() in radiants. pVec Pointer to vector array. nVec Number of Vectors in array. vec Reference to Vector to rotate.
template<typename Valtype>
void	Rotate (Vector< Valtype > *pVec, unsigned int nVec, const Vector< Valtype > &r) noexcept
template<typename Valtype>
void	Rotate (std::vector< Vector< Valtype > > &vec, const Vector< Valtype > &r) noexcept
Parallelity
Function return true if the parallel codition is met. 'Ortho' means the vectors are parallel and point in the same direction. 'Anti' means the vectors are parallel but point in different directions. A Null<Valtype> vector is orthoparallel to any and antiparallel to none. Parameters v1 first vector. v2 vector to be compared with the first vector. epsilon angle between the two vectors to be tolerated as 'parallel'. Returns True if the two vectors are parallel, false elsewise.
template<typename Valtype>
constexpr bool	Parallel (const Vector< Valtype > &V1, const Vector< Valtype > &V2, decltype(Valtype{}/Valtype{}) epsilon=std::numeric_limits< decltype(Valtype{}/Valtype{})>::epsilon()) noexcept
template<typename Valtype>
constexpr bool	OrthoParallel (const Vector< Valtype > &V1, const Vector< Valtype > &v2, decltype(Valtype{}/Valtype{}) epsilon=std::numeric_limits< decltype(Valtype{}/Valtype{})>::epsilon()) noexcept
template<typename Valtype>
constexpr bool	AntiParallel (const Vector< Valtype > &V1, const Vector< Valtype > &V2, decltype(Valtype{}/Valtype{}) epsilon=std::numeric_limits< decltype(Valtype{}/Valtype{})>::epsilon()) noexcept
Slerp
Linear Vector interpolation Parameters a,b Vectors to interpolate na,nb normalized vectors to interpolate. t [0,1] interpolation parameter. 0 would be a, 1 would become b.
template<typename Valtype>
Vector< Valtype >	Slerp (const Vector< Valtype > &a, const Vector< Valtype > &b, Valtype t) noexcept
template<typename Valtype>
Vector< Valtype >	SlerpNormals (const Vector< Valtype > &na, const Vector< Valtype > &nb, Valtype t) noexcept
template<typename Valtype>
std::pair< Vector< Valtype >, Vector< Valtype > >	SlerpDNormals (const Vector< Valtype > &na, const Vector< Valtype > &nb, Valtype t) noexcept
Operators for Vector2D
Algebra for 2D Vectors.
template<typename Valtype>
constexpr Vector2D< Valtype >	operator+ (const Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept
	Inner product.
template<typename Valtype>
Vector2D< Valtype > &	operator+= (Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept
	Inner product.
template<typename Valtype>
constexpr Vector2D< Valtype >	operator+ (const Vector2D< Valtype > &v) noexcept
	Inner product.
template<typename Valtype>
constexpr Vector2D< Valtype >	operator- (const Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept
	Inner product.
template<typename Valtype>
Vector2D< Valtype > &	operator-= (Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept
	Inner product.
template<typename Valtype>
constexpr Vector2D< Valtype >	operator- (const Vector2D< Valtype > &v) noexcept
	Inner product.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (const Vector2D< Valtype > &v1, const Vector2D< Valtype2 > &v2) noexcept -> decltype(Valtype{} *Valtype2{})
	Inner product.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (const Vector2D< Valtype > &v, Valtype2 f) noexcept -> Vector2D< decltype(Valtype{} *Valtype2{})>
	Inner product.
template<typename Valtype, typename Valtype2>
constexpr auto	operator* (Valtype f, const Vector2D< Valtype2 > &v) noexcept -> Vector2D< decltype(Valtype{} *Valtype2{})>
	Inner product.
template<typename Valtype, typename Valtype2>
Vector2D< Valtype > &	operator*= (Vector2D< Valtype > &v, const Valtype2 &f) noexcept
	Inner product.
template<typename Valtype>
Vector2D< Valtype > &	operator*= (Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept=delete
	Inner product.
template<typename Valtype>
constexpr Valtype	operator% (const Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept
	Cross product.
template<typename Valtype>
Vector2D< Valtype > &	operator%= (Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2)=delete
	Inner product.
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Vector2D< Valtype > &, const Vector2D< Valtype2 > &)=delete
	Inner product.
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Vector2D< Valtype > &v, Valtype2 f) noexcept -> Vector2D< decltype(Valtype{}/Valtype2{})>
	Inner product.
template<typename Valtype, typename Valtype2>
constexpr auto	operator/ (const Valtype &f, const Vector2D< Valtype2 > &v)=delete
	Inner product.
template<typename Valtype, typename Valtype2>
Vector2D< Valtype > &	operator/= (Vector2D< Valtype > &v, Valtype2 f) noexcept
	Inner product.
template<typename Valtype>
constexpr bool	operator== (const Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept
	Inner product.
template<typename Valtype>
constexpr bool	operator!= (const Vector2D< Valtype > &v1, const Vector2D< Valtype > &v2) noexcept
	Inner product.
Mathematical Operators for VectorBundle
template<typename Valtype, typename ValtypeT>
constexpr bool	operator== (const VectorBundle< Valtype, ValtypeT > &b1, const VectorBundle< Valtype, ValtypeT > &b2) noexcept
	VectorBundle operator.
template<typename Valtype, typename ValtypeT>
constexpr bool	operator!= (const VectorBundle< Valtype, ValtypeT > &b1, const VectorBundle< Valtype, ValtypeT > &b2) noexcept
	VectorBundle operator.
Mathematical Operators for VectorBundle2
template<typename Valtype, typename ValtypeT>
constexpr bool	operator== (const VectorBundle2< Valtype, ValtypeT > &b1, const VectorBundle2< Valtype, ValtypeT > &b2) noexcept
	VectorBundle2 operator.
template<typename Valtype, typename ValtypeT>
constexpr bool	operator!= (const VectorBundle2< Valtype, ValtypeT > &b1, const VectorBundle2< Valtype, ValtypeT > &b2) noexcept
	VectorBundle2 operator.

Variables
template<typename Valtype, typename ValtypeT = Valtype>
constexpr Frame< Valtype, ValtypeT >	Identity { Origin3D<Valtype>, Ex<ValtypeT>, Ey<ValtypeT>, Ez<ValtypeT> }
	Identity frame.
template<typename Valtype>
const Transformation< Valtype >	IdentityTransformation
	Transformation that leaves the transformed object unchanged.
template<typename Valtype>
const Rotation< Valtype >	IdentityRotation
	Rotation that leaves the transformed object unchanged.
template<typename Valtype>
constexpr Position< Valtype >	Origin3D {Valtype{0},Valtype{0},Valtype{0}}
	Origin of coordinate system.
template<typename Valtype>
constexpr Position2D< Valtype >	Origin2D {Valtype{0},Valtype{0}}
	Origin of coordinate system.
Special Vectors
template<typename Valtype>
constexpr Vector< Valtype >	Null {Valtype{0},Valtype{0},Valtype{0}}
template<typename Valtype>
constexpr Vector< Valtype >	Ex {Valtype{1},Valtype{0},Valtype{0}}
template<typename Valtype>
constexpr Vector< Valtype >	Ey {Valtype{0},Valtype{1},Valtype{0}}
template<typename Valtype>
constexpr Vector< Valtype >	Ez {Valtype{0},Valtype{0},Valtype{1}}
template<typename Valtype>
constexpr Vector2D< Valtype >	Null2D {Valtype{0},Valtype{0}}
template<typename Valtype>
constexpr Vector2D< Valtype >	Ex2D {Valtype{1},Valtype{0}}
template<typename Valtype>
constexpr Vector2D< Valtype >	Ey2D {Valtype{0},Valtype{1}}

Detailed Description

The namespace provides classes and methods for spatial computations.

Function Documentation

Column()

template<typename Valtype, const unsigned short nCols>

Vector< Valtype > spat::Column ( const Matrix< Valtype, nCols, 3 > & m, unsigned short idx )

inlineconstexprnoexcept

Returns

The idx column of matrix r as a Vector.

Determinant()

template<typename Valtype, const unsigned short nColsAndRows>

auto spat::Determinant ( const SquareMatrix< Valtype, nColsAndRows > & m ) ->decltype(pow< nColsAndRows >(Valtype{}))

constexpr

Determinant of the matrix.

Returns

Returns the determinant of the matrix

Distance()

template<typename Valtype, typename ValtypeT = Valtype>

VectorBundle1< Valtype, Valtype > spat::Distance ( const VectorBundle1< Valtype, ValtypeT > & b1, const VectorBundle1< Valtype, ValtypeT > & b2 )

noexcept

Returns

the minimal distance of the two lines defined by the two VectorBundles and the point on the first line that is closest to the second line.

Equals()

template<typename Valtype>

bool spat::Equals ( const Vector< Valtype > & v1, const Vector< Valtype > & v2, Valtype epsilon = Valtype{0} )

inlineconstexprnoexcept

Comparison within some range.

The area within two vectors regarded as equal is a sphere with radius epsilon. In case of a unit vector epsilon equals the angle between the two vectors, as long as epsilon is small.

Parameters

v1	Vector to compare.
v2	Vector to compare with.
epsilon	Distance <= wich two vectors are regarded as equal.

Returns

True if positions are nearby each other, else false.

Intersect()

template<typename Valtype>

bool spat::Intersect ( const Rect< Valtype > & r1, const Rect< Valtype > & r2 )

inlinenoexcept

Returns

true if the two rects have a nonzero common area.

Invert()

template<typename Valtype, typename ValtypeT>

Frame< Valtype, ValtypeT > spat::Invert ( const Frame< Valtype, ValtypeT > frame )

inline

Inverts the frame, so that FI * F == Identity.

Template Parameters

Valtype	Value type of the frame's Pos part.
ValtypeT	Value type of the frame's T,N,B part.

Parameters

frame

Frame to invert

Returns

the inverted frame.

Inverted() [1/2]

template<typename Valtype, unsigned short nColsAndRows>

SquareMatrix< Valtype, nColsAndRows > spat::Inverted ( const SquareMatrix< Valtype, nColsAndRows > & m )

inlineconstexpr

Returns

The inverse matrix so that M*I == Identity

Inverted() [2/2]

template<typename Valtype, const unsigned short nColsAndRows>

SquareMatrix< Valtype, nColsAndRows > spat::Inverted ( const SquareMatrix< Valtype, nColsAndRows > & m )

inlineconstexpr

Returns

The inverse matrix so that M*I == Identity

Normalize() [1/3]

template<typename Valtype, typename ValtypeT>

auto spat::Normalize ( const Frame< Valtype, ValtypeT > & f ) ->std::pair< Vector< ValtypeT >, Frame< Valtype, decltype(ValtypeT{}/ValtypeT{})> >

noexcept

Outer normalizing.

Returns

The length of the Vectors as a dimensionated value in a Vector and a Frame with vectors of unit length with dimension One.

Normalize() [2/3]

template<typename Valtype>

auto spat::Normalize ( const Vector2D< Valtype > & v ) ->std::pair< Valtype, Vector2D< decltype(Valtype{}/Valtype{})> >

noexcept

Outer normalizing.

Returns

The length of the Vector as a dimensionated value and a Vector of unit length with dinmensions One.

Normalize() [3/3]

template<typename Valtype>

auto spat::Normalize ( const Vector< Valtype > & v ) ->std::pair< Valtype, Vector< decltype(Valtype{}/Valtype{})> >

noexcept

Outer normalizing.

Returns

The length of the Vector as a dimensionated value and a Vector of unit length with dimension One.

operator!=()

template<typename Valtype, typename ValtypeT = Valtype>

bool spat::operator!= ( const Frame< Valtype, ValtypeT > & frame1, const Frame< Valtype, ValtypeT > & frame2 )

inlineconstexprnoexcept

Comparison.

Returns

true if the two frames are inequal.

operator*=()

template<typename Valtype, typename ValtypeT>

Frame< Valtype, ValtypeT > & spat::operator*= ( Frame< Valtype, ValtypeT > & frame, ValtypeT param )

inlinenoexcept

Scale the vectors of Frame by a factor.

The positional part remains unchanged.

operator==()

template<typename Valtype, typename ValtypeT = Valtype>

bool spat::operator== ( const Frame< Valtype, ValtypeT > & frame1, const Frame< Valtype, ValtypeT > & frame2 )

inlineconstexprnoexcept

Comparison.

Returns

true if the two frames are equal.

Row()

template<typename Valtype, const unsigned short nRows>

Vector< Valtype > spat::Row ( const Matrix< Valtype, 3, nRows > & m, unsigned short idx )

inlineconstexprnoexcept

Returns

The idx row of matrix r as a Vector.

Slerp()

template<typename Valtype>

bool spat::Slerp	(	Transformation< Valtype > &	out,
		const Transformation< Valtype > &	inA,
		const Transformation< Valtype > &	inB,
		Valtype	t )

Spherical interpolates two matrices weighting them by t.

Parameters

out	Result
inA	The matrix
inB	The other matrix
t	Interpolation value between 0 and 1. t is the weight of inB, so for t=1 we get the full matrix B for t=0 A.

Transposed() [1/3]

template<typename Valtype, unsigned short nCols, unsigned short nRows>

Matrix< Valtype, nRows, nCols > spat::Transposed ( const Matrix< Valtype, nCols, nRows > & m )

constexprnoexcept

Returns

The transposed matrix (i.e. rows become columns and vice versa).

Transposed() [2/3]

template<typename Valtype, const unsigned short nCols, const unsigned short nRows>

Matrix< Valtype, nRows, nCols > spat::Transposed ( const Matrix< Valtype, nCols, nRows > & m )

constexprnoexcept

Returns

The transposed matrix (i.e. rows become columns and vice versa).

Transposed() [3/3]

template<typename Valtype, const unsigned short nColsAndRows>

SquareMatrix< Valtype, nColsAndRows > spat::Transposed ( const SquareMatrix< Valtype, nColsAndRows > & m )

inlineconstexpr

Returns

The matrix with changed colums and rows.

Variable Documentation

IdentityRotation

template<typename Valtype>

const Rotation<Valtype> spat::IdentityRotation

Initial value:

{   1,0,0,
                                                0,1,0,
                                                0,0,1 }

Rotation that leaves the transformed object unchanged.

IdentityTransformation

template<typename Valtype>

const Transformation<Valtype> spat::IdentityTransformation

Initial value:

{   
                                                    Valtype{1}, Valtype{0}, Valtype{0}, Valtype{0},
                                                    Valtype{0}, Valtype{1}, Valtype{0}, Valtype{0},
                                                    Valtype{0}, Valtype{0}, Valtype{1}, Valtype{0},
                                                    Valtype{0}, Valtype{0}, Valtype{0}, Valtype{1} }

Transformation that leaves the transformed object unchanged.