template<class T>
Magnum::Math::Matrix3 class

2D transformation matrix

Template parameters
T Underlying data type

Contents

See Operations with matrices and vectors and 2D and 3D transformations for brief introduction.

Base classes

template<std::size_t size, class T>
class Matrix
Square matrix.

Public static functions

static auto translation(const Vector2<T>& vector) -> Matrix3<T> constexpr
2D translation matrix
static auto scaling(const Vector2<T>& vector) -> Matrix3<T> constexpr
2D scaling matrix
static auto rotation(Rad<T> angle) -> Matrix3<T>
2D rotation matrix
static auto reflection(const Vector2<T>& normal) -> Matrix3<T>
2D reflection matrix
static auto shearingX(T amount) -> Matrix3<T> constexpr
2D shearing matrix along X axis
static auto shearingY(T amount) -> Matrix3<T> constexpr
2D shearing matrix along Y axis
static auto projection(const Vector2<T>& size) -> Matrix3<T>
2D projection matrix
static auto from(const Matrix2x2<T>& rotationScaling, const Vector2<T>& translation) -> Matrix3<T> constexpr
Create matrix from rotation/scaling part and translation part.

Constructors, destructors, conversion operators

Matrix3(IdentityInitT = IdentityInit, T value = T{1}) constexpr noexcept
Default constructor.
Matrix3(ZeroInitT) explicit constexpr noexcept
Construct zero-filled matrix.



Matrix3(NoInitT) explicit constexpr noexcept
Construct matrix without initializing the contents.



Matrix3(const Vector3<T>& first, const Vector3<T>& second, const Vector3<T>& third) constexpr noexcept
Construct matrix from column vectors.
Matrix3(T value) explicit constexpr noexcept
Construct matrix with one value for all elements.
template<class U>
Matrix3(const RectangularMatrix<3, 3, U>& other) explicit constexpr noexcept
Construct matrix from another of different type.
template<class U, class V = decltype(Implementation::RectangularMatrixConverter<3, 3, T, U>::from(std::declval<U>()))>
Matrix3(const U& other) explicit constexpr noexcept
Construct matrix from external representation.
Matrix3(const RectangularMatrix<3, 3, T>& other) constexpr noexcept
Copy constructor.

Public functions

auto isRigidTransformation() const -> bool
Check whether the matrix represents rigid transformation.
auto rotationScaling() const -> Matrix2x2<T> constexpr
2D rotation and scaling part of the matrix
auto rotationNormalized() const -> Matrix2x2<T>
2D rotation part of the matrix assuming there is no scaling
auto rotation() const -> Matrix2x2<T>
2D rotation part of the matrix
auto uniformScalingSquared() const -> T
Uniform scaling part of the matrix, squared.
auto uniformScaling() const -> T
Uniform scaling part of the matrix.
auto right() -> Vector2<T>&
Right-pointing 2D vector.
auto right() const -> Vector2<T> constexpr
auto up() -> Vector2<T>&
Up-pointing 2D vector.
auto up() const -> Vector2<T> constexpr
auto translation() -> Vector2<T>&
2D translation part of the matrix
auto translation() const -> Vector2<T> constexpr
auto invertedRigid() const -> Matrix3<T>
Inverted rigid transformation matrix.
auto transformVector(const Vector2<T>& vector) const -> Vector2<T>
Transform 2D vector with the matrix.
auto transformPoint(const Vector2<T>& vector) const -> Vector2<T>
Transform 2D point with the matrix.

Function documentation

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::translation(const Vector2<T>& vector) constexpr

2D translation matrix

Parameters
vector Translation vector
\[ \boldsymbol{A} = \begin{pmatrix} 1 & 0 & v_x \\ 0 & 1 & v_y \\ 0 & 0 & 1 \end{pmatrix} \]

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::scaling(const Vector2<T>& vector) constexpr

2D scaling matrix

Parameters
vector Scaling vector
\[ \boldsymbol{A} = \begin{pmatrix} v_x & 0 & 0 \\ 0 & v_y & 0 \\ 0 & 0 & 1 \end{pmatrix} \]

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::rotation(Rad<T> angle)

2D rotation matrix

Parameters
angle Rotation angle (counterclockwise)
\[ \boldsymbol{A} = \begin{pmatrix} \cos\theta & -\sin\theta & 0 \\ \sin\theta & \cos\theta & 0 \\ 0 & 0 & 1 \end{pmatrix} \]

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::reflection(const Vector2<T>& normal)

2D reflection matrix

Parameters
normal Normal of the line through which to reflect

Expects that the normal is normalized. Reflection along axes can be done in a slightly simpler way also using scaling(), e.g. Matrix3::reflection(Vector2::yAxis()) is equivalent to Matrix3::scaling(Vector2::yScale(-1.0f)).

\[ \boldsymbol{A} = \boldsymbol{I} - 2 \boldsymbol{NN}^T ~~~~~ \boldsymbol{N} = \begin{pmatrix} n_x \\ n_y \end{pmatrix} \]

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::shearingX(T amount) constexpr

2D shearing matrix along X axis

Parameters
amount Shearing amount

Y axis remains unchanged.

\[ \boldsymbol{A} = \begin{pmatrix} 1 & v_x & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \]

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::shearingY(T amount) constexpr

2D shearing matrix along Y axis

Parameters
amount Shearing amount

X axis remains unchanged.

\[ \boldsymbol{A} = \begin{pmatrix} 1 & 0 & 0 \\ v_y & 1 & 0 \\ 0 & 0 & 1 \end{pmatrix} \]

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::projection(const Vector2<T>& size)

2D projection matrix

Parameters
size Size of the view
\[ \boldsymbol{A} = \begin{pmatrix} \frac{2}{s_x} & 0 & 0 \\ 0 & \frac{2}{s_y} & 0 \\ 0 & 0 & 1 \end{pmatrix} \]

template<class T>
static Matrix3<T> Magnum::Math::Matrix3<T>::from(const Matrix2x2<T>& rotationScaling, const Vector2<T>& translation) constexpr

Create matrix from rotation/scaling part and translation part.

Parameters
rotationScaling Rotation/scaling part (upper-left 2x2 matrix)
translation Translation part (first two elements of third column)

template<class T>
Magnum::Math::Matrix3<T>::Matrix3(IdentityInitT = IdentityInit, T value = T{1}) constexpr noexcept

Default constructor.

Creates identity matrix. value allows you to specify value on diagonal.

template<class T> template<class U>
Magnum::Math::Matrix3<T>::Matrix3(const RectangularMatrix<3, 3, U>& other) explicit constexpr noexcept

Construct matrix from another of different type.

Performs only default casting on the values, no rounding or anything else. Example usage:

Matrix2x2<Float> floatingPoint({1.3f, 2.7f},
                               {-15.0f, 7.0f});
Matrix2x2<Byte> integral(floatingPoint);
// integral == {{1, 2}, {-15, 7}}

template<class T>
bool Magnum::Math::Matrix3<T>::isRigidTransformation() const

Check whether the matrix represents rigid transformation.

Rigid transformation consists only of rotation and translation (i.e. no scaling or projection).

template<class T>
Matrix2x2<T> Magnum::Math::Matrix3<T>::rotationScaling() const constexpr

2D rotation and scaling part of the matrix

Upper-left 2x2 part of the matrix.

template<class T>
Matrix2x2<T> Magnum::Math::Matrix3<T>::rotationNormalized() const

2D rotation part of the matrix assuming there is no scaling

Similar to rotationScaling(), but additionally checks that the base vectors are normalized.

template<class T>
Matrix2x2<T> Magnum::Math::Matrix3<T>::rotation() const

2D rotation part of the matrix

Normalized upper-left 2x2 part of the matrix. Expects uniform scaling.

template<class T>
T Magnum::Math::Matrix3<T>::uniformScalingSquared() const

Uniform scaling part of the matrix, squared.

Squared length of vectors in upper-left 2x2 part of the matrix. Expects that the scaling is the same in all axes. Faster alternative to uniformScaling(), because it doesn't compute the square root.

template<class T>
T Magnum::Math::Matrix3<T>::uniformScaling() const

Uniform scaling part of the matrix.

Length of vectors in upper-left 2x2 part of the matrix. Expects that the scaling is the same in all axes. Use faster alternative uniformScalingSquared() where possible.

template<class T>
Vector2<T>& Magnum::Math::Matrix3<T>::right()

Right-pointing 2D vector.

First two elements of first column.

template<class T>
Vector2<T> Magnum::Math::Matrix3<T>::right() const constexpr

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class T>
Vector2<T>& Magnum::Math::Matrix3<T>::up()

Up-pointing 2D vector.

First two elements of second column.

template<class T>
Vector2<T> Magnum::Math::Matrix3<T>::up() const constexpr

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class T>
Vector2<T>& Magnum::Math::Matrix3<T>::translation()

2D translation part of the matrix

First two elements of third column.

template<class T>
Vector2<T> Magnum::Math::Matrix3<T>::translation() const constexpr

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<class T>
Matrix3<T> Magnum::Math::Matrix3<T>::invertedRigid() const

Inverted rigid transformation matrix.

Expects that the matrix represents rigid transformation. Significantly faster than the general algorithm in inverted().

\[ A^{-1} = \begin{pmatrix} (A^{2,2})^T & (A^{2,2})^T \begin{pmatrix} a_{2,0} \\ a_{2,1} \end{pmatrix} \\ \begin{array}{cc} 0 & 0 \end{array} & 1 \end{pmatrix} \]

$ A^{i, j} $ is matrix without i-th row and j-th column, see ij()

template<class T>
Vector2<T> Magnum::Math::Matrix3<T>::transformVector(const Vector2<T>& vector) const

Transform 2D vector with the matrix.

Unlike in transformPoint(), translation is not involved in the transformation.

\[ \boldsymbol v' = \boldsymbol M \begin{pmatrix} v_x \\ v_y \\ 0 \end{pmatrix} \]

template<class T>
Vector2<T> Magnum::Math::Matrix3<T>::transformPoint(const Vector2<T>& vector) const

Transform 2D point with the matrix.

Unlike in transformVector(), translation is also involved in the transformation.

\[ \boldsymbol v' = \boldsymbol M \begin{pmatrix} v_x \\ v_y \\ 1 \end{pmatrix} \]