Struct Skew3

pub struct Skew3(pub Vector3<f64>);

Contains a member of the lie algebra so(3), a representation of the tangent space of 3d rotation. This is also known as the lie algebra of the 3d rotation group SO(3).

This is only intended to be used in optimization problems where it is desirable to have unconstranied variables representing the degrees of freedom of the rotation. In all other cases, a rotation matrix should be used to store rotations, since the conversion to and from a rotation matrix is non-trivial.

Tuple Fields

0: Vector3<f64>

Implementations

impl Skew3

pub fn rotation(self) -> Rotation3<f64>

Converts the Skew3 to a Rotation3 matrix.

pub fn vee(mat: Matrix3<f64>) -> Self

This converts a matrix in skew-symmetric form into a Skew3.

Warning: Does no check to ensure matrix is actually skew-symmetric.

pub fn hat(self) -> Matrix3<f64>

This converts the Skew3 into its skew-symmetric matrix form.

pub fn hat2(self) -> Matrix3<f64>

This converts the Skew3 into its squared skew-symmetric matrix form efficiently.

pub fn bracket(self, rhs: Self) -> Self

Computes the lie bracket [self, rhs].

pub fn jacobian_input(self) -> Matrix4<f64>

The jacobian of the output of a rotation in respect to the input of a rotation.

y = R * x

dy/dx = R

The formula is pretty simple and is just the rotation matrix created from the exponential map of this so(3) element into SO(3). The result is converted to homogeneous form (by adding a new dimension with a 1 in the diagonal) so that it is compatible with homogeneous coordinates.

If you have the rotation matrix already, please use the rotation matrix itself rather than calling this method. Calling this method will waste time converting the Skew3 back into a Rotation3, which is non-trivial.

pub fn jacobian_self(y: Vector3<f64>) -> Matrix3<f64>

The jacobian of the output of a rotation in respect to the rotation itself.

y = R * x

dy/dR = -hat(y)

The derivative is purely based on the current output vector, and thus doesn’t take self.

Note that when working with homogeneous projective coordinates, only the first three components (the bearing) are relevant, hence the resulting matrix is a Matrix3.

Trait Implementations

impl AsMut<Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3>>::Buffer>> for Skew3

fn as_mut(&mut self) -> &mut Vector3<f64>

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3>>::Buffer>> for Skew3

fn as_ref(&self) -> &Vector3<f64>

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Skew3

fn clone(&self) -> Skew3

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Skew3

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

Formats the value using the given formatter.

impl Deref for Skew3

type Target = Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3>>::Buffer>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Skew3

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl From<Matrix<f64, U3, U1, <DefaultAllocator as Allocator<f64, U3>>::Buffer>> for Skew3

fn from(original: Vector3<f64>) -> Skew3

Converts to this type from the input type.

impl From<Rotation<f64, U3>> for Skew3

This is the log map.

fn from(r: Rotation3<f64>) -> Self

Converts to this type from the input type.

impl From<Skew3> for Vector3<f64>

fn from(original: Skew3) -> Self

Converts to this type from the input type.

impl From<Skew3> for Rotation3<f64>

This is the exponential map.

fn from(w: Skew3) -> Self

Converts to this type from the input type.

impl PartialEq for Skew3

fn eq(&self, other: &Skew3) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Skew3

fn partial_cmp(&self, other: &Skew3) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Skew3

impl StructuralPartialEq for Skew3