Struct SE2 

pub struct SE2 { /* private fields */ }

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

Stored as a flat SVector<f64, 3> = [tx, ty, θ] for contiguous memory compatible with zero-copy faer views.

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 = 3

Representation size - size of the underlying data representation

pub fn identity() -> SE2

Get the identity element of the group.

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

Get the identity matrix for Jacobians.

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.

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 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

const NAME: &'static str = "SE2"

Human-readable name for serialization and logging.

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 as_param_slice(&self) -> &[f64]

Returns the manifold parameters as a contiguous flat slice.

fn as_param_slice_mut(&mut self) -> &mut [f64]

Mutably borrows the raw parameter storage for in-place retraction updates.

fn from_param_slice(s: &[f64]) -> SE2

Constructs from a raw parameter slice (same layout as as_param_slice).

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

Equality operator ==.

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

Inequality operator !=.

impl RerunConvert2D for SE2

Available on crate feature visualization only.

fn to_rerun_vec2d(&self) -> Vec2D

Extract the 2D translation component as a Rerun Vec2D.

fn to_rerun_points2d(&self) -> Points2D

Convert this SE2 pose to a single point in Rerun Points2D format.

fn to_rerun_arrows2d(&self) -> Arrows2D

Convert this SE2 pose to coordinate frame arrows in Rerun.

fn to_rerun_transform_3d(&self) -> Transform3D

Convert this SE2 pose to a 3D transform at the z=0 plane.

impl StructuralPartialEq for SE2

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 as_slice(&self) -> &[f64]

Borrows the raw tangent data as a flat slice. Zero allocation.

fn from_slice(s: &[f64]) -> SE2Tangent

Constructs from a raw slice (same layout as as_slice).

fn is_dynamic() -> bool

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