pub struct Basis2<S> { /* private fields */ }
Expand description
A two-dimensional rotation matrix.
The matrix is guaranteed to be orthogonal, so some operations can be
implemented more efficiently than the implementations for math::Matrix2
. To
enforce orthogonality at the type level the operations have been restricted
to a subset of those implemented on Matrix2
.
Example
Suppose we want to rotate a vector that lies in the x-y plane by some angle. We can accomplish this quite easily with a two-dimensional rotation matrix:
use cgmath::Rad;
use cgmath::Vector2;
use cgmath::{Matrix, Matrix2};
use cgmath::{Rotation, Rotation2, Basis2};
use cgmath::UlpsEq;
use std::f64;
// For simplicity, we will rotate the unit x vector to the unit y vector --
// so the angle is 90 degrees, or π/2.
let unit_x: Vector2<f64> = Vector2::unit_x();
let rot: Basis2<f64> = Rotation2::from_angle(Rad(0.5f64 * f64::consts::PI));
// Rotate the vector using the two-dimensional rotation matrix:
let unit_y = rot.rotate_vector(unit_x);
// Since sin(π/2) may not be exactly zero due to rounding errors, we can
// use approx's assert_ulps_eq!() feature to show that it is close enough.
// assert_ulps_eq!(&unit_y, &Vector2::unit_y()); // TODO: Figure out how to use this
// This is exactly equivalent to using the raw matrix itself:
let unit_y2: Matrix2<_> = rot.into();
let unit_y2 = unit_y2 * unit_x;
assert_eq!(unit_y2, unit_y);
// Note that we can also concatenate rotations:
let rot_half: Basis2<f64> = Rotation2::from_angle(Rad(0.25f64 * f64::consts::PI));
let unit_y3 = (rot_half * rot_half).rotate_vector(unit_x);
// assert_ulps_eq!(&unit_y3, &unit_y2); // TODO: Figure out how to use this
Implementations§
Trait Implementations§
source§impl<S: BaseFloat> AbsDiffEq<Basis2<S>> for Basis2<S>
impl<S: BaseFloat> AbsDiffEq<Basis2<S>> for Basis2<S>
source§fn default_epsilon() -> S::Epsilon
fn default_epsilon() -> S::Epsilon
The default tolerance to use when testing values that are close together. Read more
source§fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool
fn abs_diff_eq(&self, other: &Self, epsilon: S::Epsilon) -> bool
A test for equality that uses the absolute difference to compute the approximate
equality of two numbers.
source§fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool
The inverse of
AbsDiffEq::abs_diff_eq
.source§impl<S: PartialEq> PartialEq<Basis2<S>> for Basis2<S>
impl<S: PartialEq> PartialEq<Basis2<S>> for Basis2<S>
source§impl<S: BaseFloat> RelativeEq<Basis2<S>> for Basis2<S>
impl<S: BaseFloat> RelativeEq<Basis2<S>> for Basis2<S>
source§fn default_max_relative() -> S::Epsilon
fn default_max_relative() -> S::Epsilon
The default relative tolerance for testing values that are far-apart. Read more
source§fn relative_eq(
&self,
other: &Self,
epsilon: S::Epsilon,
max_relative: S::Epsilon
) -> bool
fn relative_eq( &self, other: &Self, epsilon: S::Epsilon, max_relative: S::Epsilon ) -> bool
A test for equality that uses a relative comparison if the values are far apart.
source§fn relative_ne(
&self,
other: &Rhs,
epsilon: Self::Epsilon,
max_relative: Self::Epsilon
) -> bool
fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon ) -> bool
The inverse of
RelativeEq::relative_eq
.source§impl<S: BaseFloat> Rotation for Basis2<S>
impl<S: BaseFloat> Rotation for Basis2<S>
type Space = Point2<S>
source§fn look_at(dir: Vector2<S>, up: Vector2<S>) -> Basis2<S>
fn look_at(dir: Vector2<S>, up: Vector2<S>) -> Basis2<S>
Create a rotation to a given direction with an ‘up’ vector.
source§fn between_vectors(a: Vector2<S>, b: Vector2<S>) -> Basis2<S>
fn between_vectors(a: Vector2<S>, b: Vector2<S>) -> Basis2<S>
Create a shortest rotation to transform vector ‘a’ into ‘b’.
Both given vectors are assumed to have unit length.
source§fn rotate_vector(&self, vec: Vector2<S>) -> Vector2<S>
fn rotate_vector(&self, vec: Vector2<S>) -> Vector2<S>
Rotate a vector using this rotation.
source§fn invert(&self) -> Basis2<S>
fn invert(&self) -> Basis2<S>
Create a new rotation which “un-does” this rotation. That is,
r * r.invert()
is the identity.source§fn rotate_point(&self, point: Self::Space) -> Self::Space
fn rotate_point(&self, point: Self::Space) -> Self::Space
Rotate a point using this rotation, by converting it to its
representation as a vector.
source§impl<S: BaseFloat> UlpsEq<Basis2<S>> for Basis2<S>
impl<S: BaseFloat> UlpsEq<Basis2<S>> for Basis2<S>
impl<S: Copy> Copy for Basis2<S>
impl<S> StructuralPartialEq for Basis2<S>
Auto Trait Implementations§
impl<S> RefUnwindSafe for Basis2<S>where S: RefUnwindSafe,
impl<S> Send for Basis2<S>where S: Send,
impl<S> Sync for Basis2<S>where S: Sync,
impl<S> Unpin for Basis2<S>where S: Unpin,
impl<S> UnwindSafe for Basis2<S>where S: UnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more