Showing posts with label Special Orthogonal Group. Show all posts
Showing posts with label Special Orthogonal Group. Show all posts

Thursday, September 26, 2024

Introduction to SE3 Lie Groups in Python

Target audience: Advanced
Estimated reading time: 5'

After years of feeling daunted by Lie groups and algebras, I finally took the plunge into exploring these fascinating smooth manifolds. This article offers an introduction to the widely-used 3D Special Euclidean group (SE3).
Contents
       Lie manifolds
       Geomstats
       Components
       Inversion
       Composition
References
Appendix
Follow me on LinkedIn

What you will learn:  How to calculate an element of the 3D Special Euclidean group (SE3) from a given rotation matrix and translation vector in the tangent space, including the implementation of operations for computing the inverse and composition of SE3 group elements.

Notes

  • This post is a follow up on articles related to differential geometry and geometry learning [ref 1, 23 and 4] and introduction to 3-dimension Special Orthogonal group [ref 5].
  • Environments: Python 3.11,  Matplotlib 3.9, Geomstats 2.8.0, Numpy 2.1.2
  • Source code is available at  Github.com/patnicolas/Data_Exploration/Lie
  • To enhance the readability of the algorithm implementations, we have omitted non-essential code elements like error checking, comments, exceptions, validation of class and method arguments, scoping qualifiers, and import statement.

Disclaimer : A thorough tutorial and explanation of Lie groups, Lie algebras, and geometric priors for deep learning models is beyond the scope of this article. Instead, the following sections concentrate on experiments involving key elements and operations on Lie groups using the Geomstats Python library [ref 6].

Overview

Lie manifolds

smooth manifold is a topological space that locally resembles Euclidean space and allows for smooth (infinitely differentiable) transitions between local coordinate systems. This structure allows for the use of calculus on the manifold. 

The tangent space at a point on a manifold is the set of tangent vectors at that point, like a line tangent to a circle or a plane tangent to a surface.
Tangent vectors can act as directional derivatives, where you can apply specific formulas to characterize these derivatives.

Fig. 1 Manifold with tangent space and exponential/logarithm maps

In differential geometry, a Lie group is a mathematical structure that combines the properties of both a group and a smooth manifold. It allows for the application of both algebraic and geometric techniques. As a group, it has an operation (like multiplication) that satisfies certain axioms (closure, associativity, identity, and invertibility) [ref 7].
A 'real' Lie group is a set G with two structures: G is a group and G is a (smooth, real) manifold. These structures agree in the following sense: multiplication (a.k.a. product or composition) and inversion are smooth maps.
A morphism of Lie groups is a smooth map which also preserves the group operation: f(gh) = f(g)f(h) and f(1) = 1.
Fig. 2 Manifold with tangent space and identity and group element 
(Courtesy A. Kirillov Jr Department of Mathematics SUNY at Stony Brook)

Special Euclidean Group

The Euclidean group is a subset of the broader affine transformation group. It contains the translational and orthogonal groups as subgroups. Any element of SE(n) can be represented as a combination of a translation and an orthogonal transformation, where the translation B can either precede or follow the orthogonal transformation A,
The 3-dimension Special Euclidean group (SE3) is described as a 4x4 matrix as 
equation

A previous article, Special Orthogonal Lie group SO3 introduced the 3-dimension Special Orthogonal Lie group (SO3). How SE3 group differs from SO3?


Geomstats

Geomstats is a free, open-source Python library designed for conducting machine learning on data situated on nonlinear manifolds, an area known as Geometric Learning. This library offers object-oriented, thoroughly unit-tested features for fundamental manifolds, operations, and learning algorithms, compatible with various execution environments, including NumPyPyTorch, and TensorFlow (Overview Geomstats library).

The library is structured into two principal components:
  • geometry: This part provides an object-oriented framework for crucial concepts in differential geometry, such as exponential and logarithm maps, parallel transport, tangent vectors, geodesics, and Riemannian metrics.
  • learning: This section includes statistics and machine learning algorithms tailored for manifold data, building upon the scikit-learn framework.


Evaluation

The purpose of this section is to demonstrate that the inverse of a SE3 element and the composition of two SE3 elements belong to SE3 manifold. 

Components

We adopt the same object-oriented approach as used with the Special Orthogonal Group to describe the components and operations on the SE(3) manifold. The LieSE3Group class encapsulates the definition of the Special Euclidean group and its associated operations.
We specify three constructors:
  • __init__: Default constructor that create a new element in the SE3 manifold, group_element, using a 4x4 matrix as rotation+translation matrix on the tangent space.
  • build_from_numpyAlternative constructor with a 3x3 Numpy array list for the rotation matrix and 1x3 Numpy array for the translation vector on the tangent space 
  • build_from_vec: Alternative constructor with a 9 elements list for rotation matrix and a 3 elements list as translation vector on the tangent space 
import geomstats.backend as gs
from geomstats.geometry.special_euclidean import SpecialEuclidean



class LieSE3Group(object):
   dim = 3
   # Lie group as defined in Geomstats library
   lie_group = SpecialEuclidean(n=dim, point_type='matrix', epsilon=0.15, equip=False)
  
   # Support conversion of rotation matrix and translation vector to 4x4 matrix
   extend_rotation = np.array([[0.0, 0.0, 0.0]])
   extend_translation = np.array([[1.0]])

   
# Default constructor with 4x4 matrix on tangent space as argument
   def __init__(self, se3_element: np.array) -> None:
      self.se3_element = se3_element
      # Apply the exponential map to generate a point on the SE3 manifold
      self.group_element = LieSE3Group.lie_group.exp(self.se3_element)


  # Constructor with 3x3 numpy array for rotation matrix and  
  # 1x3 numpy array as translation vector on the tangent space 
  @classmethod
  def build_from_numpy(cls, rot_matrix: np.array, trans_matrix: np.array) -> Self:
      rotation_matrix = gs.array(rot_matrix)
      translation_matrix = gs.array(trans_matrix)
      se3_element = LieSE3Group.__build_se3_matrix(rotation_matrix, translation_matrix)
      
      return cls(se3_element)



  # Constructor with a 9 elements list for rotation matrix and  a
  # 3 elements list as translation vector on the tangent space 
@classmethod def build_from_vec(cls, rot_matrix: List[float], trans_vector: List[float]) -> Self: np_rotation_matrix = np.reshape(rot_matrix, (3, 3)) np_translation_matrix = LieSE3Group.__convert_to_matrix(trans_vector) return LieSE3Group.build_from_numpy(np_rotation_matrix, np_translation_matrix)

The method build_from_numpy invoked the private static method, __build_se3_matrix to build the 4x4 numpy array from the 3x3 rotation matrix and 1x3 translation vector. Its implemented is included in the appendix.


The generation of point on SE3 manifold uses a rotation around Z axis (rot_matrix) and a translation along each of the 3 axis (trans_vector).

rot_matrix = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]
trans_vector = [0.5, 0.3, 0.4]
print(f'\nRotation matrix:\n{np.reshape(rot_matrix, (3, 3))}')
print(f'Translation vector: {trans_vector}')

lie_se3_group = LieSE3Group.build_from_vec(rot_matrix, trans_vector)
print(lie_se3_group)
lie_se3_group.visualize_all(rot_matrix, trans_vector)

Output:
Rotation matrix:
[[ 1.  0.  0.]
 [ 0.  0. -1.]
 [ 0.  1.  0.]]

Translation vector: [0.5, 0.8, 0.6]
SE3 tangent space:
[[ 1.0  0.0  0.0  0.5]
 [ 0.0  0.0 -1.0  0.8]
 [ 0.0  1.0  0.0  0.6]
 [ 0.0  0.0  0.0  1.0]]
SE3 point:
[[ 2.718   0.000   0.000   1.359]
 [ 0.000   0.540  -0.841   0.806]
 [ 0.000   0.841   0.540   1.440]
 [ 0.000   0.000   0.000   2.718]]

The following plots illustrates the two inputs (rotation matrix and translation vector) on the tangent space and the resulting point on the SE3 manifold.



Fig 1. Visualization of 3x3 rotation matrix and 1x3 translation vector on SE3

Fig 2. Visualization of 4x4 matrix (point) on  SE3 manifold


Inversion

Let's validate that the inverse of an element on SE3 Lie group belongs to a SE3 group. The implementation, LieSE3Group method inverse, relies on the SpecialEuclidean.inverse method of Geomstats library.


def inverse(self) -> Self:
    inverse_group_point = LieSE3Group.lie_group.inverse(self.group_element)
    return LieSE3Group(inverse_group_point)


We reuse the 3x3 orthogonal rotation around Z axis (rot_matrix) with a new translation vector [0.5, 0.8, 0.6] on the SE3 tangent space to generate point on the manifold and its inverse.

rot_matrix = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]
trans_vector = [0.5, 0.8, 0.6]
lie_se3_group = LieSE3Group.build_from_vec(rot_matrix, trans_vector)
   
inv_lie_se3_group = lie_se3_group.inverse()
print(f'\nSE3 element\n{lie_se3_group}\nInverse\n{inv_lie_se3_group}')
lie_se3_group.visualize(inv_lie_se3_group.group_element, 'Inverse')

Input
SE3 tangent space:
[[ 1.0  0.0  0.0  0.5]
 [ 0.0  0.0 -1.0  0.8]
 [ 0.0  1.0  0.0  0.6]
 [ 0.0  0.0  0.0  1.0]]

SE3 point:
[[ 2.718   0.000   0.000   1.359]
 [ 0.000   0.540  -0.841   0.806]
 [ 0.000   0.841   0.540   1.440]
 [ 0.000   0.000   0.000   2.718]]

Inverse SE3 point
[[ 15.154    0.000   0.000  -26.738]
 [   0.000    1.143   1.279    -3.307]
 [   0.000   -1.279   1.143     1.125]
 [   0.000    0.000   0.000     2.718]]

The inverse on the SE3 manifold is visualizes in the following heatmap.

Fig 3. Visualization of inverse of a 4x4 matrix (point) on  SE3 manifold

Composition

The second key property of a Lie group on a manifold is that the composition of two group elements also belongs to the group. The product method in the LieSE3Group class performs this operation by composing the current 4x4 SE(3) matrix with another SE(3) element (denoted as lie_se3_group).


def product(self, lie_se3_group: Self) -> Self:
     composed_group_point = LieSE3Group.lie_group.compose(
                 self.group_element,  
                 lie_se3_group.group_element)
     return LieSE3Group(composed_group_element)


First test
Let's compose this SE3 element with itself.

rot_matrix = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]
trans_vector = [0.5, 0.8, 0.6]
se3_group = LieSE3Group.build_from_vec(rot_matrix, trans_vector)

# Composition of the same matrix
se3_group_product = se3_group.product(se3_group)
print(f'\nComposed SE3 point:\:{se3_group_product}')

SE3 tangent space:
[[ 7.389   0.000    0.000   7.389 ]
 [ 0.000  -0.416   -0.909   1.417]
 [ 0.000   0.909   -0.416    5.372]
 [ 0.000   0.000    0.000    7.389]]
Composed SE3 point:
[[ 1618.174    0.000     0.000  119568.075]
 [       0.000  40.518  -52.045       162.141]
 [       0.000  52.045   40.518        113.238]
 [       0.000    0.000     0.000      1618.174 ]]

Fig 4. Visualization of the composition of a 4x4 matrix (SE3 manifold point) with itself


Second test:
We compose a combine 3x3 rotation matrix (rotation around z axis) rot1_matrix and translation vector trans1_vector = [0.5, 0.8. 0.6] with a 3x3 rotation matrix (x axis), rot2_matrix and translation vector trans2_vector = [0.1, -0.3, 0.3].

rot1_matrix = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]
trans1_vector = [0.5, 0.8, 0.6]
se3_group1 = LieSE3Group.build_from_vec(rot1_matrix, trans1_vector)
print(f'\nFirst SE3 matrix:{se3_group1}')

rot2_matrix = [0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]
trans2_vector = [0.1, -0.3, 0.3]
se3_group2 = LieSE3Group.build_from_vec(rot2_matrix, trans2_vector)
print(f'\nSecond SE3 matrix:{se3_group2}')

se3_composed_group = se3_group1.product(se3_group1)
print(f'\nComposed SE3 matrix:{se3_composed_group}')

First SE3 matrix:
SE3 tangent space:
[[ 1.   0.   0.   0.5]
 [ 0.   0.  -1.   0.8]
 [ 0.   1.   0.   0.6]
 [ 0.   0.   0.   1. ]]
SE3 point:
[[ 2.718   0.000   0.000  1.359 ]
 [ 0.000   0.540  -0.841  0.806 ]
 [ 0.000   0.841   0.540  1.440 ]
 [ 0.000   0.000   0.000   2.718 ]]

Second SE3 matrix:
SE3 tangent space:
[[ 0.  -1.   0.   0.1]
 [ 1.   0.   0.  -0.3]
 [ 0.   0.   1.   0.3]
 [ 0.   0.   0.   1. ]]
SE3 point:
[[ 0.540  -0.841   0.000   0.351 ]
 [ 0.841   0.540   0.000  -0.386 ]
 [ 0.000   0.000   2.718   0.815 ]
 [ 0.000   0.000   0.000   2.718 ]]

Composed SE3 matrix:
SE3 tangent space:
[[ 7.389   0.000   0.000   7.389 ]
 [ 0.000  -0.416  -0.909  1.417 ]
 [ 0.000   0.909  -0.416   5.372 ]
 [ 0.000   0.000   0.000   7.389 ]]
SE3 point:
[[ 1618.177    0.000   0.000  11956.808 ]
 [       0.000    0.405  -0.520     162.141 ]
 [       0.000    0.520   0.405    1132.388 ]
 [       0.000    0.000   0.000    1618.177 ]]

The following diagram visualizes the two input SE3 group elements used in the composition, se3_group1, se3_group2  and the resulting SE3 element, se3_composed_group.

Fig 5. Visualization of two SE3 4x4 matrices input to composition

Fig 6. Visualization of the composition of two SE3 4x4 matrices

References




----------------------------------
Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning. 
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning", Packt Publishing ISBN 978-1-78712-238-3 and Geometric Learning in Python Newsletter on LinkedIn.



Appendix

A simple class method to build a 4 x 4 matrix on SE3 tangent space, from a 3x3 rotation matrix and 1x3 translation vector.

@staticmethod
def __build_se3_matrix(rot_matrix: np.array, trans_matrix: np.array) -> np.array:
   extended_rot = np.concatenate([rot_matrix, LieSE3Group.extend_rotation], axis=0)
   extended_trans = np.concatenate([trans_matrix.T, LieSE3Group.extend_translation])
   
   return np.concatenate([extended_rot, extended_trans], axis=1)



Thursday, September 5, 2024

Operations on SO3 Lie Groups in Python

Target audience: Advanced
Estimated reading time: 5'
Lie groups play a crucial role in Geometric Deep Learning by modeling symmetries such as rotation, translation, and scaling. This enables non-linear models to generalize effectively for tasks like object detection and transformations in generative models.


Table of contents
       Lie manifolds
       Why Lie groups
       Implementation
       Inverse rotation
       Composition
Follow me on LinkedIn

What you will learn:  How to implement and evaluate key operations on 3-dimension Special Orthogonal Lie Group.

Notes

  • This post is a follow up on articles related to differential geometry and geometry learning [ref 1, 2, 3 and 4]
  • Environments: Python 3.11,  Matplotlib 3.9, Geomstats 2.8.0
  • Source code is available at  Github.com/patnicolas/Data_Exploration/Lie
  • To enhance the readability of the algorithm implementations, we have omitted non-essential code elements like error checking, comments, exceptions, validation of class and method arguments, scoping qualifiers, and import statement.

Disclaimer : A thorough tutorial and explanation of Lie groups, Lie algebras, and geometric priors for deep learning models is beyond the scope of this article. Instead, the following sections concentrate on experiments involving key elements and operations on Lie groups using the Geomstats Python library [ref 5].
 

Overview

Let's start with some basic definitions

Lie manifolds

A smooth manifold is a topological space that locally resembles Euclidean space and allows for smooth (infinitely differentiable) transitions between local coordinate systems. This structure allows for the use of calculus on the manifold. 

The tangent space at a point on a manifold is the set of tangent vectors at that point, like a line tangent to a circle or a plane tangent to a surface.
Tangent vectors can act as directional derivatives, where you can apply specific formulas to characterize these derivatives.

Fig. 1 Manifold with tangent space and exponential/logarithm maps

In differential geometry, a Lie group is a mathematical structure that combines the properties of both a group and a smooth manifold. It allows for the application of both algebraic and geometric techniques. As a group, it has an operation (like multiplication) that satisfies certain axioms (closure, associativity, identity, and invertibility) [ref 6].
A 'real' Lie group is a set G with two structures: G is a group and G is a (smooth, real) manifold. These structures agree in the following sense: multiplication (a.k.a. product or composition) and inversion are smooth maps.
A morphism of Lie groups is a smooth map which also preserves the group operation: f(gh) = f(g)f(h) and f(1) = 1.
Fig. 2 Manifold with tangent space and identity and group element 
(Courtesy A. Kirillov Jr Department of Mathematics SUNY at Stony Brook)

Why Lie groups

Lie groups have numerous practical applications in various fields:
  • Physics: They describe symmetries in classical mechanics, quantum mechanics, and relativity. 
  • Robotics: Lie groups model the motion of robots, particularly in the context of rotation and translation (using groups like SO(3) and SE(3)).
  • Control Theory: Lie groups are used in the analysis and design of control systems, especially in systems with rotational or symmetrical behavior.
  • Computer Vision: They help in image processing and 3D vision, especially in tasks involving rotations and transformations.
  • Differential Equations: Lie groups are instrumental in solving differential equations by leveraging symmetry properties.
In term of machine learning...
  • Geometric Deep Learning: Lie groups help capture rotational, translational, or scaling symmetries, making models more efficient and generalizable in tasks like image recognition and 3D object detection.
  • Generative Models: Lie groups allow for more structured latent spaces, enabling better control over transformations in generative models like GANs and VAEs.
  • Reinforcement Learning: They are used to model continuous action spaces, improving control over robotic systems.
  • Optimization: Lie groups help design efficient optimization techniques on curved spaces, like Riemannian manifolds.

Examples of Lie groups

Group of Invertible 2 x 2 matrices of real values
equation

Group of Invertible 2 x 2 matrices of complex values
equation

Group of Invertible 3 x 3 matrices of real values
equation

Special Unitary group 2 x 2 matrices with determinant 1
equation

Special Unitary group 3 x 3 matrices with determinant 1
equation

Special Orthogonal (3D rotation, 2x2 matrices) group
equation

Special Orthogonal (3D rotation, 3x3 matrices) group
equation

Special Euclidean group
equation


Special Orthogonal Group

The Special Orthogonal Group in 3 dimensions, SO(3) is the group of all rotation matrices in 3 spatial dimensions.
It can be defined by 3 rotation elements for each of the axis of rotation x, y, and z.


equation

equation

equation


Implementation

Geomstats is a free, open-source Python library designed for conducting machine learning on data situated on nonlinear manifolds, an area known as Geometric Learning. This library offers object-oriented, thoroughly unit-tested features for fundamental manifolds, operations, and learning algorithms, compatible with various execution environments, including NumPyPyTorch, and TensorFlow (Overview Geomstats library).

The library is structured into two principal components:
  • geometry: This part provides an object-oriented framework for crucial concepts in differential geometry, such as exponential and logarithm maps, parallel transport, tangent vectors, geodesics, and Riemannian metrics.
  • learning: This section includes statistics and machine learning algorithms tailored for manifold data, building upon the scikit-learn framework.


First let's wrap the element of a point or matrix into a class, SO3Point with the following attributes:
  • group_element Point on the manifold
  • base_point on the manifold (Identity if undefined)
  • description which describes the rotation matrix
from dataclasses import dataclass

@dataclass
class SO3Point:
    group_element: np.array
    base_point: np.array                # Default identity matrix
    descriptor: AnyStr

Secondly, let's build a class ,LieSO3Group, that encapsulates the definition of the Special orthogonal group of dimension 3 and its related operations.
We specify two constructors:
  • __init__: Default constructor that create a new element in the SO3 manifold, group_element, using a tangent vector (3x3 rotation matrix) tgt_vector and identity, base_point.
  • build: Alternative constructor for which the tangent vector is a 9- element list and a tuple as base point.
import geomstats.backend as gs
from geomstats.geometry.special_orthogonal import SpecialOrthogonal


class LieSO3Group(object):
    dim = 3
    # Lie group as defined in Geomstats library
    lie_group =  SpecialOrthogonal(n=dim, point_type='vector', equip=False)
    identity = gs.eye(dim)     # Define identity


    def __init__(self, tgt_vector: np.array, base_point: np.array = identity) -> None
        self.tangent_vec = gs.array(tgt_vector)

        # Exp. a left-invariant vector field from a base point
        self.group_element = LieSO3Group.lie_group.exp(self.tangent_vec, base_point)
        self.base_point = base_point


    @classmethod
    def build(cls, tgt_vector: List[float], base_point: List[float] = None) -> Self:
        np_input = np.reshape(tgt_vector, (3, 3))
        np_point = np.reshape(base_point, (3, 3)) if base_point is not None 
                          else LieSO3Group.identity

        return cls(tgt_vector=np_input, base_point=np_point)


We use the constructors of the LieSO3Group class to generate two points on the SO3 manifold, so3_point1 and so3_point2. These points are represented as vectors in 3-dimensional Euclidean space for visualization purposes.

The first point use the identity as base point for the tangent space of rotation of 90 degrees around X axis:
[[ 1.  0.  0.]
 [ 0.  0. -1.]
 [ 0.  1.  0.]]
The second SO3 point used the same tangent vector with a base 
[[ 0.  -1.  0.]
 [ 1.   0.  0.]
 [ 0.   0.  1.]]

so3_tangent_vec = [1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]

# First rotation matrix +90 degrees around X-axis with identity as base point
so3_group = LieSO3Group.build(so3_tangent_vec)
so3_point1 = SO3Point(
     group_element=so3_group.group_element,
     base_point=LieSO3Group.identity,
     descriptor='SO3 point from tangent vector\n[1 0 0]\n[0 0 -1]\n[0 1 0]\nBase point: Identity')

# Same rotation matrix with another rotation matrix 90 degrees around
# Y-axis for base point
base_point = [0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]
so3_group2 = LieSO3Group.build(so3_tangent_vec, base_point)
so3_point2 = SO3Point(
     group_element=so3_group2.group_element,
     base_point=base_point,
     descriptor='Same SO3 point\nBase point:\n[0 -1 0]\n[0 0 0]\n[0 0 1]')

LieSO3Group.visualize_all([so3_point1, so3_point2])

so3_point1:
[[ 2.00   0.00   0.00]                                      [[2  0   0]
 [ 0.00   0.93 -0.99]       approximation of      [0  1  -1]
 [ 0.00   0.99  0.93]]                                       [0  1   1]]

so3_point2:
[[ 0.99  -0.93  0.00]                                       [[1 -1   0]
 [ 0.93   0.00 -0.99]        approximation of     [1   0  -1]
 [ 0.00   0.99  0.93]]                                       [0   1   1]

The code for the visualization methods are available on Github at LieSO3Group

Fig. 3 Visualization of SO3 group element at identity vs. arbitrary base point


Inverse rotation

The first operation to illustrate is the inverse rotation using Geomstats library. It is implemented by the LieSO3Group method inverse.

def inverse(self) -> Self:
    inverse_group_element = LieSO3Group.lie_group.inverse(self.group_element)
    return LieSO3Group(inverse_group_element)

For simplicity sake, we create a SO3 group element at identity and visualize its inverse on the same base point.

# Original rotation matrix +90 degrees around X-axis with identity as base point
\so3_tangent_vec = [1.0 0.0,0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0]

so3_group = LieSO3Group.build(so3_tangent_vec)
so3_point = SO3Point(
     group_element=so3_group.group_element,
     base_point=LieSO3Group.identity,
     descriptor='SO3 point from tangent vector\n[1 0 0]\n[0 0 -1]\n[0 1 0]\nBase point: Identity')
       
 # Inverse SO3 rotation matrix
so3_inv_group = so3_group.inverse()

inv_so3_point = SO3Point(
     group_element=so3_inv_group.group_element,
     base_point=LieSO3Group.identity,
     descriptor='SO3 inverse point')

As expected, the inverse of an SO3 group element represents the inverse rotation in 3-dimensional space. This would not hold true if the base point were not the identity element.

Original SO3 point
[[ 2.00    0.00     0.00]
 [ 0.00    0.93   -0.99]
 [ 0.00    0.99    0.93]]
SO3 Inverse point:
[[-1.00  0.00  0.00]
 [ 0.00  0.00  0.93]
 [ 0.00 -0.93  0.00]]

Fig. 4 Visualization of the inverse of SO3 element at identity

Composition

As previously mentioned, a smooth manifold with the structure of a Lie group ensures that the product (or composition) of two elements also belongs to the manifold. The following LieSO3Group method, product, utilizes the `compose method of Geomstats library.

def product(self, lie_so3_group: Self) -> Self:
     composed_group_point = LieSO3Group.lie_group.compose(self.group_element lie_so3_group.group_element)
     return LieSO3Group(composed_group_element)


In this initial test, we use the rotation matrix of 90 degrees around Z-axes as the second component for the composition.

# Second SO3 rotation matrix +90 degree along Z-axis
so3_tangent_vec2 = [0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]
so3_group2 = LieSO3Group.build(tgt_vector=so3_tangent_vec2)
so3_point2 = SO3Point(
      group_element=so3_group2.group_element,
      base_point=LieSO3Group.identity
      descriptor='SO3 point from tangent vector\n[0 -1 0]\n[1  0 0]\n[0  0 1]\nBase point: Identity')

# Composition of two rotation matrices SO3 group
so3_group_product = so3_group.product(so3_group2)
    

Composition of rotation matrix +90 degrees along X-axis with  rotation matrix +90 degrees along Z-axis:
[[-2.11   0.62   0.96]
 [ 1.52   1.74 -1.52 ]
 [-0.96  -0.62 -2.11 ]]

As expected, the composition produces an anti-symmetric matrix


Fig. 5 Visualization of the composition of a SO3 group element with its inverse at identity


The second evaluation consists of composing the initial SO3 group element (90 degrees rotation along X axis) with identity matrix.
[[-1.28   0.00    0.00 ]
 [-0.96  -2.11    0.62]
 [-0.96  -0.62  -2.11]]

Fig. 6  Visualization of the composition of two SO3 group elements at identity

References




----------------------------------
Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning. 
He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning", Packt Publishing ISBN 978-1-78712-238-3 and Geometric Learning in Python Newsletter on LinkedIn.