Struct SE2 

pub struct SE2 { /* private fields */ }

SE(2) group element representing rigid body transformations in 2D.

Represented as a combination of 2D rotation and Vector2 translation.

Implementations

impl SE2

pub const DIM: usize = 2

Space dimension - dimension of the ambient space that the group acts on

pub const DOF: usize = 3

Degrees of freedom - dimension of the tangent space

pub const REP_SIZE: usize = 4

Representation size - size of the underlying data representation

pub fn identity() -> SE2

Get the identity element of the group.

Returns the neutral element e such that e ∘ g = g ∘ e = g for any group element g.

pub fn jacobian_identity() -> Matrix<f64, Const<3>, Const<3>, ArrayStorage<f64, 3, 3>>

Get the identity matrix for Jacobians.

Returns the identity matrix in the appropriate dimension for Jacobian computations.

pub fn new( translation: Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>, rotation: Unit<Complex<f64>>, ) -> SE2

Create a new SE2 element from translation and rotation.

Arguments

• translation - Translation vector [x, y]
• rotation - Unit complex number representing rotation

pub fn from_xy_angle(x: f64, y: f64, theta: f64) -> SE2

Create SE2 from translation components and angle.

pub fn from_xy_complex(x: f64, y: f64, real: f64, imag: f64) -> SE2

Create SE2 from translation components and complex rotation.

pub fn from_isometry(isometry: Isometry<f64, Unit<Complex<f64>>, 2>) -> SE2

Create SE2 directly from an Isometry2.

pub fn from_translation_so2( translation: Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>, rotation: SO2, ) -> SE2

Create SE2 from Vector2 and SO2 components.

pub fn translation( &self, ) -> Matrix<f64, Const<2>, Const<1>, ArrayStorage<f64, 2, 1>>

Get the translation part as a Vector2.

pub fn rotation_complex(&self) -> Unit<Complex<f64>>

Get the rotation part as UnitComplex.

pub fn rotation_angle(&self) -> f64

Get the rotation angle.

pub fn rotation_so2(&self) -> SO2

Get the rotation part as SO2.

pub fn isometry(&self) -> Isometry<f64, Unit<Complex<f64>>, 2>

Get as an Isometry2 (convenience method).

pub fn matrix(&self) -> Matrix<f64, Const<3>, Const<3>, ArrayStorage<f64, 3, 3>>

Get the transformation matrix (3x3 homogeneous matrix).

pub fn rotation_matrix( &self, ) -> Matrix<f64, Const<2>, Const<2>, ArrayStorage<f64, 2, 2>>

Get the rotation matrix (2x2).

pub fn x(&self) -> f64

Get the x component of translation.

pub fn y(&self) -> f64

Get the y component of translation.

pub fn real(&self) -> f64

Get the real part of the complex rotation.

pub fn imag(&self) -> f64

Get the imaginary part of the complex rotation.

pub fn angle(&self) -> f64

Get the rotation angle in radians.

Trait Implementations

impl Clone for SE2

fn clone(&self) -> SE2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Display for SE2

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

Formats the value using the given formatter.

impl From<Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>> for SE2

fn from(data: Matrix<f64, Dyn, Const<1>, VecStorage<f64, Dyn, Const<1>>>) -> SE2

Converts to this type from the input type.

impl LieGroup for SE2

fn inverse( &self, jacobian: Option<&mut <SE2 as LieGroup>::JacobianMatrix>, ) -> SE2

Get the inverse.

Arguments

• jacobian - Optional Jacobian matrix of the inverse wrt this.

Notes

For SE(2): g^{-1} = [R^T, -R^T * t; 0, 1]

fn compose( &self, other: &SE2, jacobian_self: Option<&mut <SE2 as LieGroup>::JacobianMatrix>, jacobian_other: Option<&mut <SE2 as LieGroup>::JacobianMatrix>, ) -> SE2

Composition of this and another SE2 element.

fn log( &self, jacobian: Option<&mut <SE2 as LieGroup>::JacobianMatrix>, ) -> <SE2 as LieGroup>::TangentVector

Get the SE2 corresponding Lie algebra element in vector form.

fn vee(&self) -> <SE2 as LieGroup>::TangentVector

Vee operator: log(g)^∨.

Maps a group element g ∈ G to its tangent vector log(g)^∨ ∈ 𝔤. For SE(2), this is the same as log().

fn is_approx(&self, other: &SE2, tolerance: f64) -> bool

Check if the element is approximately equal to another element.

Arguments

• other - The other element to compare with
• tolerance - The tolerance for the comparison

type TangentVector = SE2Tangent

The tangent space vector type

type JacobianMatrix = Matrix<f64, Const<3>, Const<3>, ArrayStorage<f64, 3, 3>>

The Jacobian matrix type

type LieAlgebra = Matrix<f64, Const<3>, Const<3>, ArrayStorage<f64, 3, 3>>

Associated Lie algebra type

fn act( &self, vector: &Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>, jacobian_self: Option<&mut <SE2 as LieGroup>::JacobianMatrix>, jacobian_vector: Option<&mut Matrix<f64, Const<3>, Const<3>, ArrayStorage<f64, 3, 3>>>, ) -> Matrix<f64, Const<3>, Const<1>, ArrayStorage<f64, 3, 1>>

Act on a vector v: g ⊙ v.

fn adjoint(&self) -> <SE2 as LieGroup>::JacobianMatrix

Adjoint matrix Ad(g).

fn random() -> SE2

Generate a random element (useful for testing and initialization).

fn jacobian_identity() -> <SE2 as LieGroup>::JacobianMatrix

Get the identity matrix for Jacobians.

fn zero_jacobian() -> <SE2 as LieGroup>::JacobianMatrix

Get a zero Jacobian matrix.

fn normalize(&mut self)

Normalize/project the element to the manifold.

fn is_valid(&self, tolerance: f64) -> bool

Check if the element is approximately on the manifold.

fn right_plus( &self, tangent: &Self::TangentVector, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_tangent: Option<&mut Self::JacobianMatrix>, ) -> Self

Right plus operation: g ⊞ φ = g ∘ exp(φ^∧).

fn right_minus( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self::TangentVector

Right minus operation: g₁ ⊟ g₂ = log(g₂⁻¹ ∘ g₁)^∨.

fn left_plus( &self, tangent: &Self::TangentVector, jacobian_tangent: Option<&mut Self::JacobianMatrix>, jacobian_self: Option<&mut Self::JacobianMatrix>, ) -> Self

Left plus operation: φ ⊞ g = exp(φ^∧) ∘ g.

fn left_minus( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self::TangentVector

Left minus operation: g₁ ⊟ g₂ = log(g₁ ∘ g₂⁻¹)^∨.

fn plus( &self, tangent: &Self::TangentVector, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_tangent: Option<&mut Self::JacobianMatrix>, ) -> Self

Convenience method for right_plus. Equivalent to g ⊞ φ.

fn minus( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self::TangentVector

Convenience method for right_minus. Equivalent to g₁ ⊟ g₂.

fn between( &self, other: &Self, jacobian_self: Option<&mut Self::JacobianMatrix>, jacobian_other: Option<&mut Self::JacobianMatrix>, ) -> Self

Compute g₁⁻¹ ∘ g₂ (relative transformation).

fn tangent_dim(&self) -> usize

Get the dimension of the tangent space for this manifold element.

impl PartialEq for SE2

fn eq(&self, other: &SE2) -> 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 Tangent<SE2> for SE2Tangent

const DIM: usize = 3

Dimension of the tangent space

fn exp(&self, jacobian: Option<&mut <SE2 as LieGroup>::JacobianMatrix>) -> SE2

Get the SE2 element.

fn right_jacobian(&self) -> <SE2 as LieGroup>::JacobianMatrix

Right Jacobian Jr.

fn left_jacobian(&self) -> <SE2 as LieGroup>::JacobianMatrix

Left Jacobian Jl.

fn right_jacobian_inv(&self) -> <SE2 as LieGroup>::JacobianMatrix

Inverse of right Jacobian Jr⁻¹.

fn left_jacobian_inv(&self) -> <SE2 as LieGroup>::JacobianMatrix

Inverse of left Jacobian Jl⁻¹.

fn hat(&self) -> <SE2 as LieGroup>::LieAlgebra

Hat operator: φ^∧ (vector to matrix).

fn zero() -> <SE2 as LieGroup>::TangentVector

Zero tangent vector.

fn random() -> <SE2 as LieGroup>::TangentVector

Random tangent vector (useful for testing).

fn is_zero(&self, tolerance: f64) -> bool

Check if the tangent vector is approximately zero.

fn normalize(&mut self)

Normalize the tangent vector to unit norm.

fn normalized(&self) -> <SE2 as LieGroup>::TangentVector

Return a unit tangent vector in the same direction.

fn small_adj(&self) -> <SE2 as LieGroup>::JacobianMatrix

Small adjoint matrix for SE(2).

For SE(2), the small adjoint involves the angular component.

fn lie_bracket(&self, other: &SE2Tangent) -> <SE2 as LieGroup>::TangentVector

Lie bracket for SE(2).

Computes the Lie bracket [this, other] = this.small_adj() * other.

fn is_approx(&self, other: &SE2Tangent, tolerance: f64) -> bool

Check if this tangent vector is approximately equal to another.

Arguments

• other - The other tangent vector to compare with
• tolerance - The tolerance for the comparison

fn generator(&self, i: usize) -> <SE2 as LieGroup>::LieAlgebra

Get the ith generator of the SE(2) Lie algebra.

Arguments

• i - Index of the generator (0, 1, or 2 for SE(2))

Returns

The generator matrix

fn is_dynamic() -> bool

Whether this tangent type has dynamic (runtime-determined) dimension.

impl StructuralPartialEq for SE2