File rot3.h¶

namespace sym

Typedefs

using Rot3d = Rot3<double>¶

using Rot3f = Rot3<float>¶

template<typename ScalarType> class Rot3

#include <rot3.h>

Autogenerated C++ implementation of symforce.geo.rot3.Rot3.

Group of three-dimensional orthogonal matrices with determinant +1, representing rotations in 3D space. Backed by a quaternion with (x, y, z, w) storage.

Public Types

using Scalar = ScalarType

using Self = Rot3<Scalar>

using DataVec = Eigen::Matrix<Scalar, 4, 1>

using TangentVec = Eigen::Matrix<Scalar, 3, 1>

using SelfJacobian = Eigen::Matrix<Scalar, 3, 3>

using Vector3 = Eigen::Matrix<Scalar, 3, 1>

Public Functions

inline explicit Rot3(const DataVec &data, const bool normalize = true)

Construct from data vec

Parameters:: normalize – Project to the manifold on construction. This ensures numerical stability as this constructor is called after each codegen operation. Constructing from a normalized vector may be faster, e.g. with FromStorage.

inline Rot3()

inline const DataVec &Data() const

inline Eigen::Quaternion<Scalar> Quaternion() const

inline explicit Rot3(const Eigen::Quaternion<Scalar> &q)

inline Eigen::AngleAxis<Scalar> AngleAxis() const

inline explicit Rot3(const Eigen::AngleAxis<Scalar> &aa)

inline Rot3 ToPositiveReal() const

const Vector3 ComposeWithPoint(const Vector3 &right) const: Left-multiplication. Either rotation concatenation or point transform.

const Scalar ToTangentNorm(const Scalar epsilon) const

Returns the norm of the tangent vector corresponding to this rotation

This is equal to the angle that should be rotated through to get this Rot3, in radians. Using this function directly is usually more efficient than computing the norm of the tangent vector, both in symbolic and generated code; by default, symbolic APIs will not automatically simplify to this

const Eigen::Matrix<Scalar, 3, 3> ToRotationMatrix() const: Converts to a rotation matrix

const Vector3 ToYawPitchRoll() const

Compute the yaw, pitch, and roll Euler angles in radians of this rotation

Euler angles are subject to gimbal lock: https://en.wikipedia.org/wiki/Gimbal_lock

This means that when the pitch is close to +/- pi/2, the yaw and roll angles are not uniquely defined, so the returned values are not unique in this case.

Returns: Scalar: Yaw angle [radians] Scalar: Pitch angle [radians] Scalar: Roll angle [radians]

inline void ToStorage(Scalar *const vec) const

inline Self Inverse() const

inline Self Compose(const Self &b) const

inline Vector3 Compose(const Vector3 &point) const

inline Self Between(const Self &b) const

inline Self InverseWithJacobian(SelfJacobian *const res_D_a = nullptr) const

inline Self ComposeWithJacobians(const Self &b, SelfJacobian *const res_D_a = nullptr, SelfJacobian *const res_D_b = nullptr) const

inline Self BetweenWithJacobians(const Self &b, SelfJacobian *const res_D_a = nullptr, SelfJacobian *const res_D_b = nullptr) const

template<typename Other> inline auto operator*(const Other &b) const -> decltype(Compose(b))

inline TangentVec ToTangent(const Scalar epsilon = kDefaultEpsilon<Scalar>) const

inline Self Retract(const TangentVec &vec, const Scalar epsilon = kDefaultEpsilon<Scalar>) const

inline TangentVec LocalCoordinates(const Self &b, const Scalar epsilon = kDefaultEpsilon<Scalar>) const

inline Self Interpolate(const Self b, const Scalar alpha, const Scalar epsilon = kDefaultEpsilon<Scalar>) const

inline bool IsApprox(const Self &b, const Scalar tol) const

template<typename ToScalar> inline Rot3<ToScalar> Cast() const

inline bool operator==(const Rot3 &rhs) const

inline bool operator!=(const Rot3 &rhs) const

Public Static Functions

static inline Rot3 FromQuaternion(const Eigen::Quaternion<Scalar> &q)

static inline Rot3 FromAngleAxis(const Eigen::AngleAxis<Scalar> &aa)

static inline Rot3 FromAngleAxis(const Scalar angle, const Vector3 &axis)

static inline Rot3 FromRotationMatrix(const Eigen::Matrix<Scalar, 3, 3> &mat)

template<typename Generator> static inline Rot3 Random(Generator &gen)

static const sym::Rot3<Scalar> RandomFromUniformSamples(const Scalar u1, const Scalar u2, const Scalar u3): Generate a random element of SO3 from three variables uniformly sampled in [0, 1].

static const sym::Rot3<Scalar> FromYawPitchRoll(const Scalar yaw, const Scalar pitch, const Scalar roll): Construct from yaw, pitch, and roll Euler angles in radians

static const sym::Rot3<Scalar> FromYaw(const Scalar yaw): Construct from yaw angle in radians

static const sym::Rot3<Scalar> FromPitch(const Scalar pitch): Construct from pitch angle in radians

static const sym::Rot3<Scalar> FromRoll(const Scalar roll): Construct from roll angle in radians

static const sym::Rot3<Scalar> FromYawPitchRoll(const Vector3 &ypr)

This function was autogenerated from a symbolic function. Do not modify by hand.

Symbolic function: <lambda>

Args: ypr: Matrix31

Outputs: res: Rot3

static const sym::Rot3<Scalar> FromTwoUnitVectors(const Vector3 &a, const Vector3 &b, const Scalar epsilon)

Return a rotation that transforms a to b. Both inputs are three-vectors that are expected to be normalized.

Reference: http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors

static inline constexpr int32_t StorageDim()

static inline Rot3 FromStorage(const Scalar *const vec)

static inline Self Identity()

static inline constexpr int32_t TangentDim()

static inline Self FromTangent(const TangentVec &vec, const Scalar epsilon = kDefaultEpsilon<Scalar>)

Protected Attributes

DataVec data_¶