symforce.ops.lie_group_ops module¶
- class LieGroupOps[source]¶
Bases:
GroupOps
API for Lie groups.
A Lie group is a group that is also a differentiable manifold, with the property that the group operations are compatible with the smooth structure.
A manifold is a topological space that locally resembles Euclidean space near each point. More precisely, each point of an n-dimensional manifold has a neighbourhood that is homeomorphic to the Euclidean space of dimension n.
A differentiable manifold is a type of manifold that is locally similar enough to a linear space to allow one to do calculus. Any manifold can be described by a collection of charts, also known as an atlas. One may then apply ideas from calculus while working within the individual charts, since each chart lies within a linear space to which the usual rules of calculus apply. If the charts are suitably compatible (namely, the transition from one chart to another is differentiable), then computations done in one chart are valid in any other differentiable chart.
References
- static tangent_dim(a)[source]¶
Size of the element’s tangent space, aka the degrees of freedom it represents. The storage_dim is the higher dimensional space in which this manifold is embedded. For example SO3 could be a tangent_dim of 3 with a storage_dim of 4 if storing quaternions, or 9 if storing rotation matrices. For vector spaces they are equal.
- Parameters:
a (
Union
[Any
,Type
]) –- Return type:
int
- static from_tangent(a, vec, epsilon=0.0)[source]¶
Mapping from the tangent space approximation at identity into a group element of type a. For most manifold types this is implemented as the exponential map.
This method does not rely on the value of a, only the type.
- Parameters:
a (
Union
[Any
,Type
]) –vec (
Sequence
[float
]) – Tangent space perturbationepsilon (
float
) – Small number to avoid singularity
- Returns:
Valid group element that approximates vec around identity.
- Return type:
Element
- static to_tangent(a, epsilon=0.0)[source]¶
Mapping from this element to the tangent space approximation at identity.
- Parameters:
a (
Any
) –epsilon (
float
) – Small number to avoid singularity
- Returns:
Tangent space perturbation around identity that approximates a.
- Return type:
list
- static retract(a, vec, epsilon=0.0)[source]¶
Apply a tangent space perturbation vec to the group element a. Often used in optimization to update nonlinear values from an update step in the tangent space.
Implementation is simply compose(a, from_tangent(vec)).
- Parameters:
a (
Any
) –vec (
Sequence
[float
]) –epsilon (
float
) – Small number to avoid singularity
- Returns:
Group element that conceptually represents “a + vec”
- Return type:
Element
- static local_coordinates(a, b, epsilon=0.0)[source]¶
Computes a tangent space perturbation around a to produce b. Often used in optimization to minimize the distance between two group elements.
Implementation is simply to_tangent(between(a, b)).
- Parameters:
a (
Any
) –b (
Any
) –epsilon (
float
) – Small number to avoid singularity
- Returns:
Tangent space perturbation that conceptually represents “b - a”
- Return type:
list
- static interpolate(a, b, alpha, epsilon=0.0)[source]¶
Interpolates between self and b.
Implementation is to take the perturbation between self and b in tangent space (local_coordinates) and add a scaled version of that to self (retract).
- Parameters:
a (
Any
) –b (
Any
) –alpha (
float
) – ratio between a and b - 0 is a, 1 is b. Note that this variable is not clamped between 0 and 1 in this function.epsilon (
float
) – Small number to avoid singularity
- Returns:
Interpolated group element
- Return type:
Element