Struct nalgebra::geometry::Rotation[−][src]

#[repr(C)]
pub struct Rotation<T: Scalar, const D: usize> { /* fields omitted */ }

Expand description

A rotation matrix.

This is also known as an element of a Special Orthogonal (SO) group. The Rotation type can either represent a 2D or 3D rotation, represented as a matrix. For a rotation based on quaternions, see UnitQuaternion instead.

Note that instead of using the Rotation type in your code directly, you should use one of its aliases: Rotation2, or Rotation3. Though keep in mind that all the documentation of all the methods of these aliases will also appears on this page.

Construction

Identity identity
From a 2D rotation angle new…
From an existing 2D matrix or rotations from_matrix, rotation_between, powf…
From a 3D axis and/or angles new, from_euler_angles, from_axis_angle…
From a 3D eye position and target point look_at, look_at_lh, rotation_between…
From an existing 3D matrix or rotations from_matrix, rotation_between, powf…

Transformation and composition

Note that transforming vectors and points can be done by multiplication, e.g., rotation * point. Composing an rotation with another transformation can also be done by multiplication or division.

3D axis and angle extraction angle, euler_angles, scaled_axis, angle_to…
2D angle extraction angle, angle_to…
Transformation of a vector or a point transform_vector, inverse_transform_point…
Transposition and inversion transpose, inverse…
Interpolation slerp…

Conversion

Conversion to a matrix matrix, to_homogeneous…

Implementations

`impl<T: Scalar, const D: usize> Rotation<T, D>`[src]

`pub fn from_matrix_unchecked(matrix: SMatrix<T, D, D>) -> Self`[src]

Creates a new rotation from the given square matrix.

The matrix squareness is checked but not its orthonormality.

Example

let mat = Matrix3::new(0.8660254, -0.5,      0.0,
                       0.5,       0.8660254, 0.0,
                       0.0,       0.0,       1.0);
let rot = Rotation3::from_matrix_unchecked(mat);

assert_eq!(*rot.matrix(), mat);


let mat = Matrix2::new(0.8660254, -0.5,
                       0.5,       0.8660254);
let rot = Rotation2::from_matrix_unchecked(mat);

assert_eq!(*rot.matrix(), mat);

`impl<T: Scalar, const D: usize> Rotation<T, D>`[src]

Conversion to a matrix

`pub fn matrix(&self) -> &SMatrix<T, D, D>`[src]

A reference to the underlying matrix representation of this rotation.

Example

let rot = Rotation3::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
                            0.5,       0.8660254, 0.0,
                            0.0,       0.0,       1.0);
assert_eq!(*rot.matrix(), expected);


let rot = Rotation2::new(f32::consts::FRAC_PI_6);
let expected = Matrix2::new(0.8660254, -0.5,
                            0.5,       0.8660254);
assert_eq!(*rot.matrix(), expected);

`pub unsafe fn matrix_mut(&mut self) -> &mut SMatrix<T, D, D>`[src]

👎 Deprecated:

Use .matrix_mut_unchecked() instead.

A mutable reference to the underlying matrix representation of this rotation.

`pub fn matrix_mut_unchecked(&mut self) -> &mut SMatrix<T, D, D>`[src]

A mutable reference to the underlying matrix representation of this rotation.

This is suffixed by “_unchecked” because this allows the user to replace the matrix by another one that is non-square, non-inversible, or non-orthonormal. If one of those properties is broken, subsequent method calls may be UB.

`pub fn into_inner(self) -> SMatrix<T, D, D>`[src]

Unwraps the underlying matrix.

Example

let rot = Rotation3::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let mat = rot.into_inner();
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
                            0.5,       0.8660254, 0.0,
                            0.0,       0.0,       1.0);
assert_eq!(mat, expected);


let rot = Rotation2::new(f32::consts::FRAC_PI_6);
let mat = rot.into_inner();
let expected = Matrix2::new(0.8660254, -0.5,
                            0.5,       0.8660254);
assert_eq!(mat, expected);

`pub fn unwrap(self) -> SMatrix<T, D, D>`[src]

👎 Deprecated:

use .into_inner() instead

Unwraps the underlying matrix. Deprecated: Use Rotation::into_inner instead.

`pub fn to_homogeneous( &self ) -> OMatrix<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> where T: Zero + One, Const<D>: DimNameAdd<U1>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

Converts this rotation into its equivalent homogeneous transformation matrix.

This is the same as self.into().

Example

let rot = Rotation3::from_axis_angle(&Vector3::z_axis(), f32::consts::FRAC_PI_6);
let expected = Matrix4::new(0.8660254, -0.5,      0.0, 0.0,
                            0.5,       0.8660254, 0.0, 0.0,
                            0.0,       0.0,       1.0, 0.0,
                            0.0,       0.0,       0.0, 1.0);
assert_eq!(rot.to_homogeneous(), expected);


let rot = Rotation2::new(f32::consts::FRAC_PI_6);
let expected = Matrix3::new(0.8660254, -0.5,      0.0,
                            0.5,       0.8660254, 0.0,
                            0.0,       0.0,       1.0);
assert_eq!(rot.to_homogeneous(), expected);

`impl<T: Scalar, const D: usize> Rotation<T, D>`[src]

Transposition and inversion

`#[must_use = "Did you mean to use transpose_mut()?"] pub fn transpose(&self) -> Self`[src]

Transposes self.

Same as .inverse() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let tr_rot = rot.transpose();
assert_relative_eq!(rot * tr_rot, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let tr_rot = rot.transpose();
assert_relative_eq!(rot * tr_rot, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation2::identity(), epsilon = 1.0e-6);

`#[must_use = "Did you mean to use inverse_mut()?"] pub fn inverse(&self) -> Self`[src]

Inverts self.

Same as .transpose() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let inv = rot.inverse();
assert_relative_eq!(rot * inv, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let inv = rot.inverse();
assert_relative_eq!(rot * inv, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation2::identity(), epsilon = 1.0e-6);

`pub fn transpose_mut(&mut self)`[src]

Transposes self in-place.

Same as .inverse_mut() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let mut tr_rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
tr_rot.transpose_mut();

assert_relative_eq!(rot * tr_rot, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let mut tr_rot = Rotation2::new(1.2);
tr_rot.transpose_mut();

assert_relative_eq!(rot * tr_rot, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(tr_rot * rot, Rotation2::identity(), epsilon = 1.0e-6);

`pub fn inverse_mut(&mut self)`[src]

Inverts self in-place.

Same as .transpose_mut() because the inverse of a rotation matrix is its transform.

Example

let rot = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
let mut inv = Rotation3::new(Vector3::new(1.0, 2.0, 3.0));
inv.inverse_mut();

assert_relative_eq!(rot * inv, Rotation3::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation3::identity(), epsilon = 1.0e-6);

let rot = Rotation2::new(1.2);
let mut inv = Rotation2::new(1.2);
inv.inverse_mut();

assert_relative_eq!(rot * inv, Rotation2::identity(), epsilon = 1.0e-6);
assert_relative_eq!(inv * rot, Rotation2::identity(), epsilon = 1.0e-6);

`impl<T: SimdRealField, const D: usize> Rotation<T, D> where T::Element: SimdRealField,` [src]

Transformation of a vector or a point

`pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D>`[src]

Rotate the given point.

This is the same as the multiplication self * pt.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_point = rot.transform_point(&Point3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);

`pub fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>`[src]

Rotate the given vector.

This is the same as the multiplication self * v.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_vector = rot.transform_vector(&Vector3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_vector, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);

`pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D>`[src]

Rotate the given point by the inverse of this rotation. This may be cheaper than inverting the rotation and then transforming the given point.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_point = rot.inverse_transform_point(&Point3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_point, Point3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);

`pub fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>`[src]

Rotate the given vector by the inverse of this rotation. This may be cheaper than inverting the rotation and then transforming the given vector.

Example

let rot = Rotation3::new(Vector3::y() * f32::consts::FRAC_PI_2);
let transformed_vector = rot.inverse_transform_vector(&Vector3::new(1.0, 2.0, 3.0));

assert_relative_eq!(transformed_vector, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);

`pub fn inverse_transform_unit_vector( &self, v: &Unit<SVector<T, D>> ) -> Unit<SVector<T, D>>`[src]

Rotate the given vector by the inverse of this rotation. This may be cheaper than inverting the rotation and then transforming the given vector.

Example

let rot = Rotation3::new(Vector3::z() * f32::consts::FRAC_PI_2);
let transformed_vector = rot.inverse_transform_unit_vector(&Vector3::x_axis());

assert_relative_eq!(transformed_vector, -Vector3::y_axis(), epsilon = 1.0e-6);

`impl<T, const D: usize> Rotation<T, D> where T: Scalar + Zero + One,` [src]

Identity

`pub fn identity() -> Rotation<T, D>`[src]

Creates a new square identity rotation of the given dimension.

Example

let rot1 = Quaternion::identity();
let rot2 = Quaternion::new(1.0, 2.0, 3.0, 4.0);

assert_eq!(rot1 * rot2, rot2);
assert_eq!(rot2 * rot1, rot2);

`impl<T: Scalar, const D: usize> Rotation<T, D>`[src]

`pub fn cast<To: Scalar>(self) -> Rotation<To, D> where Rotation<To, D>: SupersetOf<Self>,` [src]

Cast the components of self to another type.

Example

let rot = Rotation2::<f64>::identity();
let rot2 = rot.cast::<f32>();
assert_eq!(rot2, Rotation2::<f32>::identity());

`impl<T: SimdRealField> Rotation<T, 2_usize>`[src]

Interpolation

`pub fn slerp(&self, other: &Self, t: T) -> Self where T::Element: SimdRealField,` [src]

Spherical linear interpolation between two rotation matrices.

Examples:


let rot1 = Rotation2::new(std::f32::consts::FRAC_PI_4);
let rot2 = Rotation2::new(-std::f32::consts::PI);

let rot = rot1.slerp(&rot2, 1.0 / 3.0);

assert_relative_eq!(rot.angle(), std::f32::consts::FRAC_PI_2);

`impl<T: SimdRealField> Rotation<T, 3_usize>`[src]

`pub fn slerp(&self, other: &Self, t: T) -> Self where T: RealField,` [src]

Spherical linear interpolation between two rotation matrices.

Panics if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined). Use .try_slerp instead to avoid the panic.

Examples:


let q1 = Rotation3::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0);
let q2 = Rotation3::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0);

let q = q1.slerp(&q2, 1.0 / 3.0);

assert_eq!(q.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));

`pub fn try_slerp(&self, other: &Self, t: T, epsilon: T) -> Option<Self> where T: RealField,` [src]

Computes the spherical linear interpolation between two rotation matrices or returns None if both rotations are approximately 180 degrees apart (in which case the interpolation is not well-defined).

Arguments

self: the first rotation to interpolate from.
other: the second rotation to interpolate toward.
t: the interpolation parameter. Should be between 0 and 1.
epsilon: the value below which the sinus of the angle separating both rotations must be to return None.

`impl<T: SimdRealField> Rotation<T, 2_usize>`[src]

Construction from a 2D rotation angle

`pub fn new(angle: T) -> Self`[src]

Builds a 2 dimensional rotation matrix from an angle in radian.

Example

let rot = Rotation2::new(f32::consts::FRAC_PI_2);

assert_relative_eq!(rot * Point2::new(3.0, 4.0), Point2::new(-4.0, 3.0));

`pub fn from_scaled_axis<SB: Storage<T, U1>>( axisangle: Vector<T, U1, SB> ) -> Self`[src]

Builds a 2 dimensional rotation matrix from an angle in radian wrapped in a 1-dimensional vector.

This is generally used in the context of generic programming. Using the ::new(angle) method instead is more common.

`impl<T: SimdRealField> Rotation<T, 2_usize>`[src]

Construction from an existing 2D matrix or rotations

`pub fn from_basis_unchecked(basis: &[Vector2<T>; 2]) -> Self`[src]

Builds a rotation from a basis assumed to be orthonormal.

In order to get a valid unit-quaternion, the input must be an orthonormal basis, i.e., all vectors are normalized, and the are all orthogonal to each other. These invariants are not checked by this method.

`pub fn from_matrix(m: &Matrix2<T>) -> Self where T: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This is an iterative method. See .from_matrix_eps to provide mover convergence parameters and starting solution. This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

`pub fn from_matrix_eps( m: &Matrix2<T>, eps: T, max_iter: usize, guess: Self ) -> Self where T: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

Parameters

m: the matrix from which the rotational part is to be extracted.
eps: the angular errors tolerated between the current rotation and the optimal one.
max_iter: the maximum number of iterations. Loops indefinitely until convergence if set to 0.
guess: an estimate of the solution. Convergence will be significantly faster if an initial solution close to the actual solution is provided. Can be set to Rotation2::identity() if no other guesses come to mind.

`pub fn rotation_between<SB, SC>( a: &Vector<T, U2, SB>, b: &Vector<T, U2, SC> ) -> Self where T: RealField, SB: Storage<T, U2>, SC: Storage<T, U2>,` [src]

The rotation matrix required to align a and b but with its angle.

This is the rotation R such that (R * a).angle(b) == 0 && (R * a).dot(b).is_positive().

Example

let a = Vector2::new(1.0, 2.0);
let b = Vector2::new(2.0, 1.0);
let rot = Rotation2::rotation_between(&a, &b);
assert_relative_eq!(rot * a, b);
assert_relative_eq!(rot.inverse() * b, a);

`pub fn scaled_rotation_between<SB, SC>( a: &Vector<T, U2, SB>, b: &Vector<T, U2, SC>, s: T ) -> Self where T: RealField, SB: Storage<T, U2>, SC: Storage<T, U2>,` [src]

The smallest rotation needed to make a and b collinear and point toward the same direction, raised to the power s.

Example

let a = Vector2::new(1.0, 2.0);
let b = Vector2::new(2.0, 1.0);
let rot2 = Rotation2::scaled_rotation_between(&a, &b, 0.2);
let rot5 = Rotation2::scaled_rotation_between(&a, &b, 0.5);
assert_relative_eq!(rot2 * rot2 * rot2 * rot2 * rot2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(rot5 * rot5 * a, b, epsilon = 1.0e-6);

`pub fn rotation_to(&self, other: &Self) -> Self`[src]

The rotation matrix needed to make self and other coincide.

The result is such that: self.rotation_to(other) * self == other.

Example

let rot1 = Rotation2::new(0.1);
let rot2 = Rotation2::new(1.7);
let rot_to = rot1.rotation_to(&rot2);

assert_relative_eq!(rot_to * rot1, rot2);
assert_relative_eq!(rot_to.inverse() * rot2, rot1);

`pub fn renormalize(&mut self) where T: RealField,` [src]

Ensure this rotation is an orthonormal rotation matrix. This is useful when repeated computations might cause the matrix from progressively not being orthonormal anymore.

`pub fn powf(&self, n: T) -> Self`[src]

Raise the quaternion to a given floating power, i.e., returns the rotation with the angle of self multiplied by n.

Example

let rot = Rotation2::new(0.78);
let pow = rot.powf(2.0);
assert_relative_eq!(pow.angle(), 2.0 * 0.78);

`impl<T: SimdRealField> Rotation<T, 2_usize>`[src]

2D angle extraction

`pub fn angle(&self) -> T`[src]

The rotation angle.

Example

let rot = Rotation2::new(1.78);
assert_relative_eq!(rot.angle(), 1.78);

`pub fn angle_to(&self, other: &Self) -> T`[src]

The rotation angle needed to make self and other coincide.

Example

let rot1 = Rotation2::new(0.1);
let rot2 = Rotation2::new(1.7);
assert_relative_eq!(rot1.angle_to(&rot2), 1.6);

`pub fn scaled_axis(&self) -> SVector<T, 1>`[src]

The rotation angle returned as a 1-dimensional vector.

This is generally used in the context of generic programming. Using the .angle() method instead is more common.

`impl<T: SimdRealField> Rotation<T, 3_usize> where T::Element: SimdRealField,` [src]

Construction from a 3D axis and/or angles

`pub fn new<SB: Storage<T, U3>>(axisangle: Vector<T, U3, SB>) -> Self`[src]

Builds a 3 dimensional rotation matrix from an axis and an angle.

Arguments

axisangle - A vector representing the rotation. Its magnitude is the amount of rotation in radian. Its direction is the axis of rotation.

Example

let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let rot = Rotation3::new(axisangle);

assert_relative_eq!(rot * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(rot * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(Rotation3::new(Vector3::<f32>::zeros()), Rotation3::identity());

`pub fn from_scaled_axis<SB: Storage<T, U3>>( axisangle: Vector<T, U3, SB> ) -> Self`[src]

Builds a 3D rotation matrix from an axis scaled by the rotation angle.

This is the same as Self::new(axisangle).

Example

let axisangle = Vector3::y() * f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let rot = Rotation3::new(axisangle);

assert_relative_eq!(rot * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(rot * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(Rotation3::from_scaled_axis(Vector3::<f32>::zeros()), Rotation3::identity());

`pub fn from_axis_angle<SB>(axis: &Unit<Vector<T, U3, SB>>, angle: T) -> Self where SB: Storage<T, U3>,` [src]

Builds a 3D rotation matrix from an axis and a rotation angle.

Example

let axis = Vector3::y_axis();
let angle = f32::consts::FRAC_PI_2;
// Point and vector being transformed in the tests.
let pt = Point3::new(4.0, 5.0, 6.0);
let vec = Vector3::new(4.0, 5.0, 6.0);
let rot = Rotation3::from_axis_angle(&axis, angle);

assert_eq!(rot.axis().unwrap(), axis);
assert_eq!(rot.angle(), angle);
assert_relative_eq!(rot * pt, Point3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);
assert_relative_eq!(rot * vec, Vector3::new(6.0, 5.0, -4.0), epsilon = 1.0e-6);

// A zero vector yields an identity.
assert_eq!(Rotation3::from_scaled_axis(Vector3::<f32>::zeros()), Rotation3::identity());

`pub fn from_euler_angles(roll: T, pitch: T, yaw: T) -> Self`[src]

Creates a new rotation from Euler angles.

The primitive rotations are applied in order: 1 roll − 2 pitch − 3 yaw.

Example

let rot = Rotation3::from_euler_angles(0.1, 0.2, 0.3);
let euler = rot.euler_angles();
assert_relative_eq!(euler.0, 0.1, epsilon = 1.0e-6);
assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);

`impl<T: SimdRealField> Rotation<T, 3_usize> where T::Element: SimdRealField,` [src]

Construction from a 3D eye position and target point

`pub fn face_towards<SB, SC>( dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC> ) -> Self where SB: Storage<T, U3>, SC: Storage<T, U3>,` [src]

Creates a rotation that corresponds to the local frame of an observer standing at the origin and looking toward dir.

It maps the z axis to the direction dir.

Arguments

dir - The look direction, that is, direction the matrix z axis will be aligned with.
up - The vertical direction. The only requirement of this parameter is to not be collinear to dir. Non-collinearity is not checked.

Example

let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let rot = Rotation3::face_towards(&dir, &up);
assert_relative_eq!(rot * Vector3::z(), dir.normalize());

`pub fn new_observer_frames<SB, SC>( dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC> ) -> Self where SB: Storage<T, U3>, SC: Storage<T, U3>,` [src]

👎 Deprecated:

renamed to face_towards

Deprecated: Use [Rotation3::face_towards] instead.

`pub fn look_at_rh<SB, SC>( dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC> ) -> Self where SB: Storage<T, U3>, SC: Storage<T, U3>,` [src]

Builds a right-handed look-at view matrix without translation.

It maps the view direction dir to the negative z axis. This conforms to the common notion of right handed look-at matrix from the computer graphics community.

Arguments

dir - The direction toward which the camera looks.
up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to dir.

Example

let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let rot = Rotation3::look_at_rh(&dir, &up);
assert_relative_eq!(rot * dir.normalize(), -Vector3::z());

`pub fn look_at_lh<SB, SC>( dir: &Vector<T, U3, SB>, up: &Vector<T, U3, SC> ) -> Self where SB: Storage<T, U3>, SC: Storage<T, U3>,` [src]

Builds a left-handed look-at view matrix without translation.

It maps the view direction dir to the positive z axis. This conforms to the common notion of left handed look-at matrix from the computer graphics community.

Arguments

dir - The direction toward which the camera looks.
up - A vector approximately aligned with required the vertical axis. The only requirement of this parameter is to not be collinear to dir.

Example

let dir = Vector3::new(1.0, 2.0, 3.0);
let up = Vector3::y();

let rot = Rotation3::look_at_lh(&dir, &up);
assert_relative_eq!(rot * dir.normalize(), Vector3::z());

`impl<T: SimdRealField> Rotation<T, 3_usize> where T::Element: SimdRealField,` [src]

Construction from an existing 3D matrix or rotations

`pub fn rotation_between<SB, SC>( a: &Vector<T, U3, SB>, b: &Vector<T, U3, SC> ) -> Option<Self> where T: RealField, SB: Storage<T, U3>, SC: Storage<T, U3>,` [src]

The rotation matrix required to align a and b but with its angle.

This is the rotation R such that (R * a).angle(b) == 0 && (R * a).dot(b).is_positive().

Example

let a = Vector3::new(1.0, 2.0, 3.0);
let b = Vector3::new(3.0, 1.0, 2.0);
let rot = Rotation3::rotation_between(&a, &b).unwrap();
assert_relative_eq!(rot * a, b, epsilon = 1.0e-6);
assert_relative_eq!(rot.inverse() * b, a, epsilon = 1.0e-6);

`pub fn scaled_rotation_between<SB, SC>( a: &Vector<T, U3, SB>, b: &Vector<T, U3, SC>, n: T ) -> Option<Self> where T: RealField, SB: Storage<T, U3>, SC: Storage<T, U3>,` [src]

The smallest rotation needed to make a and b collinear and point toward the same direction, raised to the power s.

Example

let a = Vector3::new(1.0, 2.0, 3.0);
let b = Vector3::new(3.0, 1.0, 2.0);
let rot2 = Rotation3::scaled_rotation_between(&a, &b, 0.2).unwrap();
let rot5 = Rotation3::scaled_rotation_between(&a, &b, 0.5).unwrap();
assert_relative_eq!(rot2 * rot2 * rot2 * rot2 * rot2 * a, b, epsilon = 1.0e-6);
assert_relative_eq!(rot5 * rot5 * a, b, epsilon = 1.0e-6);

`pub fn rotation_to(&self, other: &Self) -> Self`[src]

The rotation matrix needed to make self and other coincide.

The result is such that: self.rotation_to(other) * self == other.

Example

let rot1 = Rotation3::from_axis_angle(&Vector3::y_axis(), 1.0);
let rot2 = Rotation3::from_axis_angle(&Vector3::x_axis(), 0.1);
let rot_to = rot1.rotation_to(&rot2);
assert_relative_eq!(rot_to * rot1, rot2, epsilon = 1.0e-6);

`pub fn powf(&self, n: T) -> Self where T: RealField,` [src]

Raise the quaternion to a given floating power, i.e., returns the rotation with the same axis as self and an angle equal to self.angle() multiplied by n.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = Rotation3::from_axis_angle(&axis, angle);
let pow = rot.powf(2.0);
assert_relative_eq!(pow.axis().unwrap(), axis, epsilon = 1.0e-6);
assert_eq!(pow.angle(), 2.4);

`pub fn from_basis_unchecked(basis: &[Vector3<T>; 3]) -> Self`[src]

Builds a rotation from a basis assumed to be orthonormal.

In order to get a valid unit-quaternion, the input must be an orthonormal basis, i.e., all vectors are normalized, and the are all orthogonal to each other. These invariants are not checked by this method.

`pub fn from_matrix(m: &Matrix3<T>) -> Self where T: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This is an iterative method. See .from_matrix_eps to provide mover convergence parameters and starting solution. This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

`pub fn from_matrix_eps( m: &Matrix3<T>, eps: T, max_iter: usize, guess: Self ) -> Self where T: RealField,` [src]

Builds a rotation matrix by extracting the rotation part of the given transformation m.

This implements “A Robust Method to Extract the Rotational Part of Deformations” by Müller et al.

Parameters

m: the matrix from which the rotational part is to be extracted.
eps: the angular errors tolerated between the current rotation and the optimal one.
max_iter: the maximum number of iterations. Loops indefinitely until convergence if set to 0.
guess: a guess of the solution. Convergence will be significantly faster if an initial solution close to the actual solution is provided. Can be set to Rotation3::identity() if no other guesses come to mind.

`pub fn renormalize(&mut self) where T: RealField,` [src]

Ensure this rotation is an orthonormal rotation matrix. This is useful when repeated computations might cause the matrix from progressively not being orthonormal anymore.

`impl<T: SimdRealField> Rotation<T, 3_usize>`[src]

3D axis and angle extraction

`pub fn angle(&self) -> T`[src]

The rotation angle in [0; pi].

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let rot = Rotation3::from_axis_angle(&axis, 1.78);
assert_relative_eq!(rot.angle(), 1.78);

`pub fn axis(&self) -> Option<Unit<Vector3<T>>> where T: RealField,` [src]

The rotation axis. Returns None if the rotation angle is zero or PI.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = Rotation3::from_axis_angle(&axis, angle);
assert_relative_eq!(rot.axis().unwrap(), axis);

// Case with a zero angle.
let rot = Rotation3::from_axis_angle(&axis, 0.0);
assert!(rot.axis().is_none());

`pub fn scaled_axis(&self) -> Vector3<T> where T: RealField,` [src]

The rotation axis multiplied by the rotation angle.

Example

let axisangle = Vector3::new(0.1, 0.2, 0.3);
let rot = Rotation3::new(axisangle);
assert_relative_eq!(rot.scaled_axis(), axisangle, epsilon = 1.0e-6);

`pub fn axis_angle(&self) -> Option<(Unit<Vector3<T>>, T)> where T: RealField,` [src]

The rotation axis and angle in ]0, pi] of this unit quaternion.

Returns None if the angle is zero.

Example

let axis = Unit::new_normalize(Vector3::new(1.0, 2.0, 3.0));
let angle = 1.2;
let rot = Rotation3::from_axis_angle(&axis, angle);
let axis_angle = rot.axis_angle().unwrap();
assert_relative_eq!(axis_angle.0, axis);
assert_relative_eq!(axis_angle.1, angle);

// Case with a zero angle.
let rot = Rotation3::from_axis_angle(&axis, 0.0);
assert!(rot.axis_angle().is_none());

`pub fn angle_to(&self, other: &Self) -> T where T::Element: SimdRealField,` [src]

The rotation angle needed to make self and other coincide.

Example

let rot1 = Rotation3::from_axis_angle(&Vector3::y_axis(), 1.0);
let rot2 = Rotation3::from_axis_angle(&Vector3::x_axis(), 0.1);
assert_relative_eq!(rot1.angle_to(&rot2), 1.0045657, epsilon = 1.0e-6);

`pub fn to_euler_angles(&self) -> (T, T, T) where T: RealField,` [src]

👎 Deprecated:

This is renamed to use .euler_angles().

Creates Euler angles from a rotation.

The angles are produced in the form (roll, pitch, yaw).

`pub fn euler_angles(&self) -> (T, T, T) where T: RealField,` [src]

Euler angles corresponding to this rotation from a rotation.

The angles are produced in the form (roll, pitch, yaw).

Example

let rot = Rotation3::from_euler_angles(0.1, 0.2, 0.3);
let euler = rot.euler_angles();
assert_relative_eq!(euler.0, 0.1, epsilon = 1.0e-6);
assert_relative_eq!(euler.1, 0.2, epsilon = 1.0e-6);
assert_relative_eq!(euler.2, 0.3, epsilon = 1.0e-6);

Trait Implementations

`impl<T, const D: usize> AbsDiffEq<Rotation<T, D>> for Rotation<T, D> where T: Scalar + AbsDiffEq, T::Epsilon: Copy,` [src]

`type Epsilon = T::Epsilon`

Used for specifying relative comparisons.

`fn default_epsilon() -> Self::Epsilon`[src]

The default tolerance to use when testing values that are close together. Read more

`fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool`[src]

A test for equality that uses the absolute difference to compute the approximate equality of two numbers. Read more

`fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool`[src]

The inverse of AbsDiffEq::abs_diff_eq.

`impl<T: SimdRealField, const D: usize> AbstractRotation<T, D> for Rotation<T, D> where T::Element: SimdRealField,` [src]

`fn identity() -> Self`[src]

The rotation identity.

`fn inverse(&self) -> Self`[src]

The rotation inverse.

`fn inverse_mut(&mut self)`[src]

Change self to its inverse.

`fn transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>`[src]

Apply the rotation to the given vector.

`fn transform_point(&self, p: &Point<T, D>) -> Point<T, D>`[src]

Apply the rotation to the given point.

`fn inverse_transform_vector(&self, v: &SVector<T, D>) -> SVector<T, D>`[src]

Apply the inverse rotation to the given vector.

`fn inverse_transform_unit_vector( &self, v: &Unit<SVector<T, D>> ) -> Unit<SVector<T, D>>`[src]

Apply the inverse rotation to the given unit vector.

`fn inverse_transform_point(&self, p: &Point<T, D>) -> Point<T, D>`[src]

Apply the inverse rotation to the given point.

`impl<T: Scalar, const D: usize> Clone for Rotation<T, D> where <DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: Clone,` [src]

`fn clone(&self) -> Self`[src]

Returns a copy of the value. Read more

`fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from source. Read more

`impl<T: Debug + Scalar, const D: usize> Debug for Rotation<T, D>`[src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

Formats the value using the given formatter. Read more

`impl<T, const D: usize> Display for Rotation<T, D> where T: RealField + Display,` [src]

`fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

Formats the value using the given formatter. Read more

`impl<'b, T: SimdRealField, const D: usize> Div<&'b Isometry<T, Rotation<T, D>, D>> for Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Isometry<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField, const D: usize> Div<&'b Isometry<T, Rotation<T, D>, D>> for &'a Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Isometry<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField> Div<&'b Rotation<T, 2_usize>> for UnitComplex<T> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, 2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField> Div<&'b Rotation<T, 2_usize>> for &'a UnitComplex<T> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, 2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField> Div<&'b Rotation<T, 3_usize>> for &'a UnitQuaternion<T> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, 3>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField> Div<&'b Rotation<T, 3_usize>> for UnitQuaternion<T> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, 3>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T, const D: usize> Div<&'b Rotation<T, D>> for Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`type Output = Rotation<T, D>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T, const D: usize> Div<&'b Rotation<T, D>> for &'a Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`type Output = Rotation<T, D>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField, const D: usize> Div<&'b Rotation<T, D>> for Isometry<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField, const D: usize> Div<&'b Rotation<T, D>> for &'a Isometry<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField, const D: usize> Div<&'b Rotation<T, D>> for Similarity<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField, const D: usize> Div<&'b Rotation<T, D>> for &'a Similarity<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T, C, const D: usize> Div<&'b Rotation<T, D>> for Transform<T, C, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T, C, const D: usize> Div<&'b Rotation<T, D>> for &'a Transform<T, C, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T, R1, C1, SA, const D2: usize> Div<&'b Rotation<T, D2>> for Matrix<T, R1, C1, SA> where T: Scalar + Zero + One + ClosedAdd + ClosedMul, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,` [src]

`type Output = OMatrix<T, R1, Const<D2>>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Rotation<T, D2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T, R1, C1, SA, const D2: usize> Div<&'b Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where T: Scalar + Zero + One + ClosedAdd + ClosedMul, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,` [src]

`type Output = OMatrix<T, R1, Const<D2>>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Rotation<T, D2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField, const D: usize> Div<&'b Similarity<T, Rotation<T, D>, D>> for Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Similarity<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField, const D: usize> Div<&'b Similarity<T, Rotation<T, D>, D>> for &'a Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: &'b Similarity<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T, C, const D: usize> Div<&'b Transform<T, C, D>> for Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Transform<T, C, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T, C, const D: usize> Div<&'b Transform<T, C, D>> for &'a Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b Transform<T, C, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField> Div<&'b Unit<Complex<T>>> for Rotation<T, 2> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b UnitComplex<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField> Div<&'b Unit<Complex<T>>> for &'a Rotation<T, 2> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b UnitComplex<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, 'b, T: SimdRealField> Div<&'b Unit<Quaternion<T>>> for &'a Rotation<T, 3> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b UnitQuaternion<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField> Div<&'b Unit<Quaternion<T>>> for Rotation<T, 3> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: &'b UnitQuaternion<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField, const D: usize> Div<Isometry<T, Rotation<T, D>, D>> for Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: Isometry<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField, const D: usize> Div<Isometry<T, Rotation<T, D>, D>> for &'a Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: Isometry<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField> Div<Rotation<T, 2_usize>> for UnitComplex<T> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, 2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField> Div<Rotation<T, 2_usize>> for &'a UnitComplex<T> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, 2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField> Div<Rotation<T, 3_usize>> for &'a UnitQuaternion<T> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, 3>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField> Div<Rotation<T, 3_usize>> for UnitQuaternion<T> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, 3>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T, const D: usize> Div<Rotation<T, D>> for Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`type Output = Rotation<T, D>`

The resulting type after applying the / operator.

`fn div(self, right: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T, const D: usize> Div<Rotation<T, D>> for &'a Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`type Output = Rotation<T, D>`

The resulting type after applying the / operator.

`fn div(self, right: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField, const D: usize> Div<Rotation<T, D>> for Isometry<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField, const D: usize> Div<Rotation<T, D>> for &'a Isometry<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Isometry<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField, const D: usize> Div<Rotation<T, D>> for Similarity<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField, const D: usize> Div<Rotation<T, D>> for &'a Similarity<T, Rotation<T, D>, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T, C, const D: usize> Div<Rotation<T, D>> for Transform<T, C, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T, C, const D: usize> Div<Rotation<T, D>> for &'a Transform<T, C, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Rotation<T, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T, R1, C1, SA, const D2: usize> Div<Rotation<T, D2>> for Matrix<T, R1, C1, SA> where T: Scalar + Zero + One + ClosedAdd + ClosedMul, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,` [src]

`type Output = OMatrix<T, R1, Const<D2>>`

The resulting type after applying the / operator.

`fn div(self, right: Rotation<T, D2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T, R1, C1, SA, const D2: usize> Div<Rotation<T, D2>> for &'a Matrix<T, R1, C1, SA> where T: Scalar + Zero + One + ClosedAdd + ClosedMul, R1: Dim, C1: Dim, SA: Storage<T, R1, C1>, DefaultAllocator: Allocator<T, R1, Const<D2>>, ShapeConstraint: AreMultipliable<R1, C1, Const<D2>, Const<D2>>,` [src]

`type Output = OMatrix<T, R1, Const<D2>>`

The resulting type after applying the / operator.

`fn div(self, right: Rotation<T, D2>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField, const D: usize> Div<Similarity<T, Rotation<T, D>, D>> for Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: Similarity<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField, const D: usize> Div<Similarity<T, Rotation<T, D>, D>> for &'a Rotation<T, D> where T::Element: SimdRealField,` [src]

`type Output = Similarity<T, Rotation<T, D>, D>`

The resulting type after applying the / operator.

`fn div(self, right: Similarity<T, Rotation<T, D>, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T, C, const D: usize> Div<Transform<T, C, D>> for Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Transform<T, C, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T, C, const D: usize> Div<Transform<T, C, D>> for &'a Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategoryMul<TAffine>, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`type Output = Transform<T, C::Representative, D>`

The resulting type after applying the / operator.

`fn div(self, rhs: Transform<T, C, D>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField> Div<Unit<Complex<T>>> for Rotation<T, 2> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: UnitComplex<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField> Div<Unit<Complex<T>>> for &'a Rotation<T, 2> where T::Element: SimdRealField,` [src]

`type Output = UnitComplex<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: UnitComplex<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'a, T: SimdRealField> Div<Unit<Quaternion<T>>> for &'a Rotation<T, 3> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: UnitQuaternion<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<T: SimdRealField> Div<Unit<Quaternion<T>>> for Rotation<T, 3> where T::Element: SimdRealField,` [src]

`type Output = UnitQuaternion<T>`

The resulting type after applying the / operator.

`fn div(self, rhs: UnitQuaternion<T>) -> Self::Output`[src]

Performs the / operation. Read more

`impl<'b, T: SimdRealField> DivAssign<&'b Rotation<T, 2_usize>> for UnitComplex<T> where T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: &'b Rotation<T, 2>)`[src]

Performs the /= operation. Read more

`impl<'b, T: SimdRealField> DivAssign<&'b Rotation<T, 3_usize>> for UnitQuaternion<T> where T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: &'b Rotation<T, 3>)`[src]

Performs the /= operation. Read more

`impl<'b, T, const R1: usize, const C1: usize> DivAssign<&'b Rotation<T, C1>> for SMatrix<T, R1, C1> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`fn div_assign(&mut self, right: &'b Rotation<T, C1>)`[src]

Performs the /= operation. Read more

`impl<'b, T, const D: usize> DivAssign<&'b Rotation<T, D>> for Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`fn div_assign(&mut self, right: &'b Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<'b, T, const D: usize> DivAssign<&'b Rotation<T, D>> for Isometry<T, Rotation<T, D>, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField, T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: &'b Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<'b, T, const D: usize> DivAssign<&'b Rotation<T, D>> for Similarity<T, Rotation<T, D>, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField, T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: &'b Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<'b, T, C, const D: usize> DivAssign<&'b Rotation<T, D>> for Transform<T, C, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategory, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`fn div_assign(&mut self, rhs: &'b Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<'b, T: SimdRealField> DivAssign<&'b Unit<Complex<T>>> for Rotation<T, 2> where T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: &'b UnitComplex<T>)`[src]

Performs the /= operation. Read more

`impl<T: SimdRealField> DivAssign<Rotation<T, 2_usize>> for UnitComplex<T> where T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: Rotation<T, 2>)`[src]

Performs the /= operation. Read more

`impl<T: SimdRealField> DivAssign<Rotation<T, 3_usize>> for UnitQuaternion<T> where T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: Rotation<T, 3>)`[src]

Performs the /= operation. Read more

`impl<T, const R1: usize, const C1: usize> DivAssign<Rotation<T, C1>> for SMatrix<T, R1, C1> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`fn div_assign(&mut self, right: Rotation<T, C1>)`[src]

Performs the /= operation. Read more

`impl<T, const D: usize> DivAssign<Rotation<T, D>> for Rotation<T, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul,` [src]

`fn div_assign(&mut self, right: Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<T, const D: usize> DivAssign<Rotation<T, D>> for Isometry<T, Rotation<T, D>, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField, T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<T, const D: usize> DivAssign<Rotation<T, D>> for Similarity<T, Rotation<T, D>, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + SimdRealField, T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<T, C, const D: usize> DivAssign<Rotation<T, D>> for Transform<T, C, D> where T: Scalar + Zero + One + ClosedAdd + ClosedMul + RealField, Const<D>: DimNameAdd<U1>, C: TCategory, DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>,` [src]

`fn div_assign(&mut self, rhs: Rotation<T, D>)`[src]

Performs the /= operation. Read more

`impl<T: SimdRealField> DivAssign<Unit<Complex<T>>> for Rotation<T, 2> where T::Element: SimdRealField,` [src]

`fn div_assign(&mut self, rhs: UnitComplex<T>)`[src]

Performs the /= operation. Read more

`impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 16]> for Rotation<T, D> where T: From<[<T as SimdValue>::Element; 16]>, T::Element: Scalar + Copy,` [src]

`fn from(arr: [Rotation<T::Element, D>; 16]) -> Self`[src]

Performs the conversion.

`impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 2]> for Rotation<T, D> where T: From<[<T as SimdValue>::Element; 2]>, T::Element: Scalar + Copy,` [src]

`fn from(arr: [Rotation<T::Element, D>; 2]) -> Self`[src]

Performs the conversion.

`impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 4]> for Rotation<T, D> where T: From<[<T as SimdValue>::Element; 4]>, T::Element: Scalar + Copy,` [src]

`fn from(arr: [Rotation<T::Element, D>; 4]) -> Self`[src]

Performs the conversion.

`impl<T: Scalar + PrimitiveSimdValue, const D: usize> From<[Rotation<<T as SimdValue>::Element, D>; 8]> for Rotation<T, D> where T: From<[<T as SimdValue>::Element; 8]>, T::Element: Scalar + Copy,` [src]

`fn from(arr: [Rotation<T::Element, D>; 8]) -> Self`[src]

Performs the conversion.

`impl<T: RealField> From<Rotation<T, 2_usize>> for Matrix3<T>`[src]

`fn from(q: Rotation2<T>) -> Self`[src]

Performs the conversion.

`impl<T: RealField> From<Rotation<T, 2_usize>> for Matrix2<T>`[src]

`fn from(q: Rotation2<T>) -> Self`[src]

Performs the conversion.

`impl<T: SimdRealField> From<Rotation<T, 2_usize>> for UnitComplex<T> where T::Element: SimdRealField,` [src]

`fn from(q: Rotation2<T>) -> Self`[src]

Performs the conversion.

`impl<T: RealField> From<Rotation<T, 3_usize>> for Matrix4<T>`[src]

`fn from(q: Rotation3<T>) -> Self`[src]

Performs the conversion.

`impl<T: RealField> From<Rotation<T, 3_usize>> for Matrix3<T>`[src]

`fn from(q: Rotation3<T>) -> Self`[src]

Performs the conversion.

`impl<T: SimdRealField> From<Rotation<T, 3_usize>> for UnitQuaternion<T> where T::Element: SimdRealField,` [src]

`fn from(q: Rotation3<T>) -> Self`[src]

Performs the conversion.

`impl<T: Scalar + Hash, const D: usize> Hash for Rotation<T, D> where <DefaultAllocator as Allocator<T, Const<D>, Const<D>>>::Buffer: Hash,` [src]

`fn hash<H: Hasher>(&self, state: &mut H)`[src]

Feeds this value into the given Hasher. Read more

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` 1.3.0 [src]

Feeds a slice of this type into the given Hasher. Read more

`impl<T: Scalar, const D: usize> Index<(usize, usize)> for Rotation<T, D>`[src]

`type Output = T`

The returned type after indexing.