Template Class RxSO2

Defined in File rxso2.hpp

Inheritance Relationships

Base Type

public Sophus::RxSO2Base< RxSO2< Scalar_, Options > > (Template Class RxSO2Base)

Class Documentation

template<class Scalar_, int Options> class RxSO2 : public Sophus::RxSO2Base<RxSO2<Scalar_, Options>>

RxSO2 using storage; derived from RxSO2Base.

Public Types

using Base = RxSO2Base<RxSO2<Scalar_, Options>>

using Scalar = Scalar_

using Transformation = typename Base::Transformation

using Point = typename Base::Point

using HomogeneousPoint = typename Base::HomogeneousPoint

using Tangent = typename Base::Tangent

using Adjoint = typename Base::Adjoint

using ComplexMember = Eigen::Matrix<Scalar, 2, 1, Options>

Public Functions

SOPHUS_FUNC RxSO2 & operator= (RxSO2 const &other)=default: Define copy-assignment operator explicitly. The definition of implicit copy assignment operator is deprecated in presence of a user-declared copy constructor (-Wdeprecated-copy in clang >= 13).

inline EIGEN_MAKE_ALIGNED_OPERATOR_NEW SOPHUS_FUNC RxSO2 (): Default constructor initializes complex number to identity rotation and scale to 1.

SOPHUS_FUNC RxSO2(RxSO2 const &other) = default: Copy constructor

template<class OtherDerived> inline SOPHUS_FUNC RxSO2(RxSO2Base<OtherDerived> const &other): Copy-like constructor from OtherDerived.

inline explicit SOPHUS_FUNC RxSO2(Transformation const &sR)

Constructor from scaled rotation matrix

Precondition: rotation matrix need to be scaled orthogonal with determinant of s^2.

inline SOPHUS_FUNC RxSO2(Scalar const &scale, Transformation const &R)

Constructor from scale factor and rotation matrix R.

Precondition: Rotation matrix R must to be orthogonal with determinant of 1 and scale must not to be close to either zero or infinity.

inline SOPHUS_FUNC RxSO2(Scalar const &scale, SO2<Scalar> const &so2)

Constructor from scale factor and SO2

Precondition: scale must not be close to either zero or infinity.

inline explicit SOPHUS_FUNC RxSO2(Vector2<Scalar> const &z)

Constructor from complex number.

Precondition: complex number must not be close to either zero or infinity

inline explicit SOPHUS_FUNC RxSO2(Scalar const &real, Scalar const &imag)

Constructor from complex number.

Precondition: complex number must not be close to either zero or infinity.

inline SOPHUS_FUNC ComplexMember const & complex () const: Accessor of complex.

Public Static Functions

static inline SOPHUS_FUNC Sophus::Matrix< Scalar, num_parameters, DoF > Dx_exp_x (Tangent const &a): Returns derivative of exp(x) wrt. x

static inline SOPHUS_FUNC Sophus::Matrix< Scalar, num_parameters, DoF > Dx_exp_x_at_0 (): Returns derivative of exp(x) wrt. x_i at x=0.

static inline SOPHUS_FUNC Sophus::Matrix< Scalar, 2, DoF > Dx_exp_x_times_point_at_0 (Point const &point): Returns derivative of exp(x) * p wrt. x_i at x=0.

static inline SOPHUS_FUNC Transformation Dxi_exp_x_matrix_at_0 (int i): Returns derivative of exp(x).matrix() wrt. x_i at x=0.

static inline SOPHUS_FUNC RxSO2< Scalar > exp (Tangent const &a)

Group exponential

This functions takes in an element of tangent space (= rotation angle plus logarithm of scale) and returns the corresponding element of the group RxSO2.

To be more specific, this function computes expmat(hat(theta)) with expmat(.) being the matrix exponential and hat(.) being the hat()-operator of RSO2.

static inline SOPHUS_FUNC Transformation generator (int i)

Returns the ith infinitesimal generators of R+ x SO(2).

The infinitesimal generators of RxSO2 are:

      |  0 -1 |
G_0 = |  1  0 |

      |  1  0 |
G_1 = |  0  1 |

Precondition: i must be 0, or 1.

static inline SOPHUS_FUNC Transformation hat (Tangent const &a)

hat-operator

It takes in the 2-vector representation a (= rotation angle plus logarithm of scale) and returns the corresponding matrix representation of Lie algebra element.

Formally, the hat()-operator of RxSO2 is defined as

hat(.): R^2 -> R^{2x2}, hat(a) = sum_i a_i * G_i (for i=0,1,2)

with G_i being the ith infinitesimal generator of RxSO2.

The corresponding inverse is the vee()-operator, see below.

static inline SOPHUS_FUNC Tangent lieBracket (Tangent const &, Tangent const &)

Lie bracket

It computes the Lie bracket of RxSO(2). To be more specific, it computes

[omega_1, omega_2]_rxso2 := vee([hat(omega_1), hat(omega_2)])

with [A,B] := AB-BA being the matrix commutator, hat(.) the hat()-operator and vee(.) the vee()-operator of RxSO2.

template<class UniformRandomBitGenerator> static inline RxSO2 sampleUniform(UniformRandomBitGenerator &generator)

Draw uniform sample from RxSO(2) manifold.

The scale factor is drawn uniformly in log2-space from [-1, 1], hence the scale is in [0.5, 2)].

static inline SOPHUS_FUNC Tangent vee (Transformation const &Omega)

vee-operator

It takes the 2x2-matrix representation Omega and maps it to the corresponding vector representation of Lie algebra.

This is the inverse of the hat()-operator, see above.

Precondition: Omega must have the following structure:

           |  d -x |
           |  x  d |

Public Static Attributes

static constexpr int DoF = Base::DoF

static constexpr int num_parameters = Base::num_parameters

Protected Functions

inline SOPHUS_FUNC ComplexMember & complex_nonconst ()

Protected Attributes

ComplexMember complex_

Friends

friend class RxSO2Base< RxSO2< Scalar_, Options > >