Class for representing and managing rotations in three-dimensional space. More...

#include <rotation_lib.h>

Collaboration diagram for MoveG::Rotation:

Public Member Functions
	Rotation ()
	Default constructor.

	Rotation (const Rotation &other)
	Copy constructor.

	Rotation (Rotation &&other) noexcept
	Move constructor for the Rotation class.

	Rotation (const Eigen::Matrix3d &rotation_matrix)
	Constructor from rotation matrix.

	Rotation (const Eigen::Quaterniond &quaternion)
	Constructor from quaternion.

	Rotation (const Eigen::AngleAxisd &angle_axis)
	Constructor from axis-angle.

	Rotation (double angle1, double angle2, double angle3, bool intrinsic=true, const std::string &sequence="ZYX", bool degree=false)
	Constructor from Euler angles.

	~Rotation ()=default
	Default destructor.

Eigen::Matrix3d	toRotationMatrix () const
	Converts the rotation to a rotation matrix.

Eigen::Quaterniond	toQuaternion () const
	Converts the rotation to a quaternion.

Eigen::AngleAxisd	toAngleAxis () const
	Converts the rotation to an axis-angle representation.

Eigen::Vector3d	toEulerAngles (bool intrinsic=true, const std::string &sequence="ZYX") const
	Converts the rotation to Euler angles.

Rotation	operator* (const Rotation &other) const
	Composition of two rotations.

Rotation &	operator= (const Rotation &other)
	Assignment operator.

Rotation &	operator= (Rotation &&other) noexcept
	Move assignment operator.

Static Public Member Functions
static Rotation	fromRotationMatrix (const Eigen::Matrix3d &rotation_matrix)
	Creates a rotation from a rotation matrix.

static Rotation	fromQuaternion (const Eigen::Quaterniond &quaternion)
	Creates a rotation from a quaternion.

static Rotation	fromAngleAxis (const Eigen::AngleAxisd &angle_axis)
	Creates a rotation from an axis-angle representation.

static Rotation	fromEulerAngles (double angle1, double angle2, double angle3, bool intrinsic=true, const std::string &sequence="XYZ", bool degree=false)
	Creates a rotation from Euler angles.

static double	normalizeAngle (double angle)
	Normalizes an angle to the range [-π, π].

static double	normalizeAngleRange (double angle, double minVal, double maxVal)
	Normalizes an angle to a specified range.

static Eigen::Vector3d	normalizeEulerAngles (const Eigen::Vector3d &angles)
	Normalizes Euler angles to the range [-π, π].

static Eigen::Quaterniond	quaternion_difference (const Eigen::Quaterniond &a, const Eigen::Quaterniond &b)
	Calculates the difference between two quaternions.

static Eigen::Quaterniond	quaternion_negation (const Eigen::Quaterniond &v)
	Negates the quaternion.

static Eigen::Quaterniond	scalar_product (const Eigen::Quaterniond &v, double t)
	Calculates the scalar product of a quaternion by a scalar.

static Eigen::Quaterniond	quaternion_minus (const Eigen::Quaterniond &v1, const Eigen::Quaterniond &v0)
	Calculates the difference between two quaternions (v1 - v0).

static Eigen::Quaterniond	quaternion_plus (const Eigen::Quaterniond &v1, const Eigen::Quaterniond &v0)
	Calculates the sum of two quaternions.

static double	deg2rad (double degree)
	Converts degrees to radians.

static double	rad2deg (double radian)
	Converts radians to degrees.

static Eigen::Matrix3d	rotationX (double angle)
	Rotation matrix for a rotation around the X axis.

static Eigen::Matrix3d	rotationY (double angle)
	Rotation matrix for a rotation around the Y axis.

static Eigen::Matrix3d	rotationZ (double angle)
	Rotation matrix for a rotation around the Z axis.

static Eigen::Matrix3d	matrixS (const Eigen::Vector3d &omega)
	Calculates the S matrix.

static Eigen::Matrix3d	matrixR_dot (const Eigen::Matrix3d &R, const Eigen::Matrix3d &S)
	Calculates the R_dot matrix.

static Eigen::Matrix3d	matrixR_dot (const Eigen::Matrix3d &R, const Eigen::Vector3d &omega)
	Calculates the R_dot matrix from an angular velocity vector.

static Eigen::Matrix3d	matrixT (const Eigen::Vector3d &angles, const std::string &sequence)
	Calculates the T matrix.

Static Private Member Functions
static Eigen::AngleAxisd	angleAxis (char axis, double angle)
	Creates an axis-angle representation.

static int	axisToIndex (char axis)
	Converts an axis character to index.

static int	checkSequence (const std::string &sequence)
	Checks the validity of the Euler angle sequence.

Private Attributes
Eigen::Quaterniond	q
	Internal representation of rotation via quaternion.

Friends
std::ostream &	operator<< (std::ostream &os, const Rotation &rotation)
	Outputs the rotation to a stream in quaternion format.

Detailed Description

Class for representing and managing rotations in three-dimensional space.

This class supports various rotation representations, including rotation matrices, quaternions, axis-angle, and Euler angles. It also allows composition of rotations.

Definition at line 50 of file rotation_lib.h.

Constructor & Destructor Documentation

◆ Rotation() [1/7]

MoveG::Rotation::Rotation ( )

Default constructor.

Initializes the rotation as identity.

Definition at line 17 of file rotation_lib.cpp.

                   : q(Eigen::Quaterniond::Identity())
{
}

Referenced by fromAngleAxis(), fromEulerAngles(), fromQuaternion(), fromRotationMatrix(), and operator*().

Here is the caller graph for this function:

◆ Rotation() [2/7]

MoveG::Rotation::Rotation ( const Rotation & other )

Copy constructor.

Parameters

other Another rotation to copy.

Definition at line 22 of file rotation_lib.cpp.

                                        : q(other.q)
{
}

◆ Rotation() [3/7]

MoveG::Rotation::Rotation ( Rotation && other )

noexcept

Move constructor for the Rotation class.

This constructor allows the creation of a Rotation object by transferring the resources from another Rotation object. It is marked as noexcept to indicate that it does not throw exceptions.

Parameters

other The Rotation object to be moved.

Definition at line 27 of file rotation_lib.cpp.

                                            : q(std::move(other.q))
{
}

◆ Rotation() [4/7]

MoveG::Rotation::Rotation ( const Eigen::Matrix3d & rotation_matrix )

Constructor from rotation matrix.

Parameters

rotation_matrix 3x3 rotation matrix.

Definition at line 32 of file rotation_lib.cpp.

                                                       : q(Eigen::Quaterniond(rotation_matrix))
{
}

◆ Rotation() [5/7]

MoveG::Rotation::Rotation ( const Eigen::Quaterniond & quaternion )

Constructor from quaternion.

Parameters

quaternion Quaternion representing the rotation.

Definition at line 37 of file rotation_lib.cpp.

                                                     : q(quaternion.normalized())
{
}

◆ Rotation() [6/7]

MoveG::Rotation::Rotation ( const Eigen::AngleAxisd & angle_axis )

Constructor from axis-angle.

Parameters

angle_axis Axis-angle representation of the rotation.

Definition at line 42 of file rotation_lib.cpp.

                                                    : q(Eigen::Quaterniond(angle_axis))
{
}

◆ Rotation() [7/7]

MoveG::Rotation::Rotation	(	double	angle1,
		double	angle2,
		double	angle3,
		bool	intrinsic = `true`,
		const std::string &	sequence = `"ZYX"`,
		bool	degree = `false`
	)

Constructor from Euler angles.

Parameters

angle1	First Euler angle.
angle2	Second Euler angle.
angle3	Third Euler angle.
intrinsic	If true, uses intrinsic rotations; otherwise, extrinsic.
sequence	Sequence of axes (e.g., "ZYX").
degree	If true, angles are in degrees; otherwise, in radians.

Definition at line 47 of file rotation_lib.cpp.

    : q(Eigen::Quaterniond::Identity())
{
    checkSequence(sequence);
 
    if (degree)
    {
        angle1 = deg2rad(angle1);
        angle2 = deg2rad(angle2);
        angle3 = deg2rad(angle3);
    }
 
    const Eigen::AngleAxisd aa1 = angleAxis(sequence[0], angle1);
    const Eigen::AngleAxisd aa2 = angleAxis(sequence[1], angle2);
    const Eigen::AngleAxisd aa3 = angleAxis(sequence[2], angle3);
 
    if (intrinsic)
    {
        // For intrinsic rotations, multiply in the order q3 * q2 * q1
        q = Eigen::Quaterniond(aa3) * Eigen::Quaterniond(aa2) * Eigen::Quaterniond(aa1);
    }
    else
    {
        // For extrinsic rotations, multiply in the order q1 * q2 * q3
        q = Eigen::Quaterniond(aa1) * Eigen::Quaterniond(aa2) * Eigen::Quaterniond(aa3);
    }
 
    q.normalize();
}

References angleAxis(), checkSequence(), deg2rad(), and q.

Here is the call graph for this function:

◆ ~Rotation()

MoveG::Rotation::~Rotation ( )

default

Default destructor.

Member Function Documentation

◆ angleAxis()

Eigen::AngleAxisd MoveG::Rotation::angleAxis	(	char	axis,
		double	angle
	)

staticprivate

Creates an axis-angle representation.

Parameters

axis	Rotation axis ('X', 'Y', 'Z' or lowercase).
angle	Rotation angle in radians.

Returns: Axis-angle representation.

Definition at line 234 of file rotation_lib.cpp.

{
    switch (axis)
    {
    case 'X':
    case 'x':
        return Eigen::AngleAxisd(angle, Eigen::Vector3d::UnitX());
    case 'Y':
    case 'y':
        return Eigen::AngleAxisd(angle, Eigen::Vector3d::UnitY());
    case 'Z':
    case 'z':
        return Eigen::AngleAxisd(angle, Eigen::Vector3d::UnitZ());
    default:
        throw std::invalid_argument("Invalid axis. Valid axes are 'X', 'Y', or 'Z'.");
    }
}

Referenced by Rotation().

Here is the caller graph for this function:

◆ axisToIndex()

int MoveG::Rotation::axisToIndex ( char axis )

staticprivate

Converts an axis character to index.

Parameters

axis	Rotation axis ('X', 'Y', 'Z' or lowercase).

Returns: Index corresponding to the axis (0 for X, 1 for Y, 2 for Z).

Exceptions

std::invalid_argument If the axis is not valid.

Definition at line 253 of file rotation_lib.cpp.

{
    switch (axis)
    {
    case 'X':
    case 'x':
        return 0;
    case 'Y':
    case 'y':
        return 1;
    case 'Z':
    case 'z':
        return 2;
    default:
        throw std::invalid_argument("Invalid axis. Valid axes are 'X', 'Y', or 'Z'.");
    }
}

Referenced by toEulerAngles().

Here is the caller graph for this function:

◆ checkSequence()

int MoveG::Rotation::checkSequence ( const std::string & sequence )

staticprivate

Checks the validity of the Euler angle sequence.

Parameters

sequence Sequence of axes (e.g., "XYZ").

Returns: Integer value (always 1 if valid).

Exceptions

std::invalid_argument If the sequence is not valid.

Definition at line 272 of file rotation_lib.cpp.

{
    if (sequence.length() != 3 || sequence.find_first_not_of("XYZxyz") != std::string::npos)
    {
        throw std::invalid_argument("The axis sequence must be a string of three characters "
                                    "from 'X', 'Y', and 'Z' or 'x', 'y', and 'z'.");
    }
    return 1;
}

Referenced by matrixT(), Rotation(), and toEulerAngles().

Here is the caller graph for this function:

◆ deg2rad()

double MoveG::Rotation::deg2rad ( double degree )

static

Converts degrees to radians.

Parameters

degree Angle in degrees.

Returns: Angle in radians.

Definition at line 283 of file rotation_lib.cpp.

{
    return degree * M_PI / 180.0;
}

Referenced by main(), and Rotation().

Here is the caller graph for this function:

◆ fromAngleAxis()

Rotation MoveG::Rotation::fromAngleAxis ( const Eigen::AngleAxisd & angle_axis )

static

Creates a rotation from an axis-angle representation.

Parameters

angle_axis Axis-angle representation of the rotation.

Returns: Rotation object.

Definition at line 93 of file rotation_lib.cpp.

{
    return Rotation(angle_axis);
}

References Rotation().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fromEulerAngles()

Rotation MoveG::Rotation::fromEulerAngles	(	double	angle1,
		double	angle2,
		double	angle3,
		bool	intrinsic = `true`,
		const std::string &	sequence = `"XYZ"`,
		bool	degree = `false`
	)

static

Creates a rotation from Euler angles.

Parameters

angle1	First Euler angle.
angle2	Second Euler angle.
angle3	Third Euler angle.
intrinsic	If true, uses intrinsic rotations; otherwise, extrinsic.
sequence	Sequence of axes (e.g., "XYZ").
degree	If true, angles are in degrees; otherwise, in radians.

Returns: Rotation object.

Definition at line 98 of file rotation_lib.cpp.

{
    return Rotation(angle1, angle2, angle3, intrinsic, sequence, degree);
}

References Rotation().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fromQuaternion()

Rotation MoveG::Rotation::fromQuaternion ( const Eigen::Quaterniond & quaternion )

static

Creates a rotation from a quaternion.

Parameters

quaternion Quaternion representing the rotation.

Returns: Rotation object.

Definition at line 88 of file rotation_lib.cpp.

{
    return Rotation(quaternion.normalized());
}

References Rotation().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ fromRotationMatrix()

Rotation MoveG::Rotation::fromRotationMatrix ( const Eigen::Matrix3d & rotation_matrix )

static

Creates a rotation from a rotation matrix.

Static methods to define a rotation Static methods allow creating a rotation without having to instantiate an object.

Example: Rotation rot = Rotation::fromEulerAngles(0, 0, 0, true, "XYZ", false); Otherwise you would have to do:

Rotation rot; rot = rot.fromEulerAngles(0, 0, 0, true, "XYZ", false);

Parameters

rotation_matrix 3x3 rotation matrix.

Returns: Rotation object.

Definition at line 83 of file rotation_lib.cpp.

{
    return Rotation(rotation_matrix);
}

References Rotation().

Here is the call graph for this function:

◆ matrixR_dot() [1/2]

Eigen::Matrix3d MoveG::Rotation::matrixR_dot	(	const Eigen::Matrix3d &	R,
		const Eigen::Matrix3d &	S
	)

static

Calculates the R_dot matrix.

Parameters

R	Rotation matrix.
S	S matrix.

Returns: R_dot matrix

Definition at line 353 of file rotation_lib.cpp.

{
    return S * R;
}

Referenced by main(), and matrixR_dot().

Here is the caller graph for this function:

◆ matrixR_dot() [2/2]

Eigen::Matrix3d MoveG::Rotation::matrixR_dot	(	const Eigen::Matrix3d &	R,
		const Eigen::Vector3d &	omega
	)

static

Calculates the R_dot matrix from an angular velocity vector.

Parameters

R	Rotation matrix.
omega	Angular velocity vector.

Returns: R_dot matrix

Definition at line 358 of file rotation_lib.cpp.

{
    const Eigen::Matrix3d S = matrixS(omega);
    return matrixR_dot(R, S);
}

References matrixR_dot(), and matrixS().

Here is the call graph for this function:

◆ matrixS()

Eigen::Matrix3d MoveG::Rotation::matrixS ( const Eigen::Vector3d & omega )

static

Calculates the S matrix.

Parameters

omega Angular velocity vector. (Different from Euler angle velocities)

Returns: S matrix

Definition at line 345 of file rotation_lib.cpp.

{
    Eigen::Matrix3d S = Eigen::Matrix3d::Zero();
    S << 0, -omega.z(), omega.y(), omega.z(), 0, -omega.x(), -omega.y(), omega.x(), 0;
    return S;
}

Referenced by main(), and matrixR_dot().

Here is the caller graph for this function:

◆ matrixT()

Eigen::Matrix3d MoveG::Rotation::matrixT	(	const Eigen::Vector3d &	angles,
		const std::string &	sequence
	)

static

Calculates the T matrix.

Parameters

angles	Euler angles vector.
sequence	Sequence of axes (e.g., "ZYX", "ZYZ").

Returns: T matrix

Exceptions

std::runtime_error If the matrix is singular (determinant near zero)

Definition at line 364 of file rotation_lib.cpp.

{
    checkSequence(sequence);
 
    Eigen::Matrix3d T = Eigen::Matrix3d::Zero();
 
    std::array<Eigen::Vector3d, 3> theta;
 
    for (std::size_t i = 0; i < 3; ++i)
    {
        const char c = sequence[i];
        switch (c)
        {
        case 'X':
        case 'x':
            theta[i] = Eigen::Vector3d::UnitX();
            break;
        case 'Y':
        case 'y':
            theta[i] = Eigen::Vector3d::UnitY();
            break;
        case 'Z':
        case 'z':
            theta[i] = Eigen::Vector3d::UnitZ();
            break;
        default:
            break;
        }
    }
 
    T.col(0) = theta[0];
 
    Eigen::Matrix3d R = Eigen::Matrix3d::Identity();
 
    for (std::size_t i = 0; i < 2; ++i)
    {
        Eigen::Matrix3d Ri;
 
        const char c = sequence[i];
        switch (c)
        {
        case 'X':
        case 'x':
            Ri = Rotation::rotationX(angles[static_cast<Eigen::Index>(i)]);
            break;
        case 'Y':
        case 'y':
            Ri = Rotation::rotationY(angles[static_cast<Eigen::Index>(i)]);
            break;
        case 'Z':
        case 'z':
            Ri = Rotation::rotationZ(angles[static_cast<Eigen::Index>(i)]);
            break;
        default:
            Ri = Eigen::Matrix3d::Identity();
            break;
        }
 
        R *= Ri;
        T.col(static_cast<Eigen::Index>(i + 1)) = R * theta[i + 1];
    }
 
    // Check if it is singular and so the determinant is near zero
    if (std::abs(T.determinant()) < 1e-6)
    {
        std::cerr << "WARNING: The matrix is singular\n";
        throw std::runtime_error("Matrix T is singular, which may cause numerical instability.");
    }
 
    return T;
}

References checkSequence(), rotationX(), rotationY(), and rotationZ().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ normalizeAngle()

double MoveG::Rotation::normalizeAngle ( double angle )

static

Normalizes an angle to the range [-π, π].

Parameters

angle Angle in radians

Returns: Normalized angle in radians within the range [-π, π]

Definition at line 182 of file rotation_lib.cpp.

{
    // Use fmod to get the remainder of division by 2π
    angle = std::fmod(angle, 2 * M_PI);
 
    // Adjust to the range [-π, π]
    if (angle > M_PI)
    {
        angle -= 2 * M_PI;
    }
    else if (angle < -M_PI)
    {
        angle += 2 * M_PI;
    }
 
    return angle;
}

Referenced by main(), and normalizeEulerAngles().

Here is the caller graph for this function:

◆ normalizeAngleRange()

double MoveG::Rotation::normalizeAngleRange	(	double	angle,
		double	minVal,
		double	maxVal
	)

static

Normalizes an angle to a specified range.

Parameters

angle	Angle in radians
minVal	Lower bound of the range
maxVal	Upper bound of the range

Returns: Normalized angle in radians within the specified range

Definition at line 201 of file rotation_lib.cpp.

{
    const double width = maxVal - minVal;
 
    // Validate range width
    if (width <= 0)
    {
        throw std::invalid_argument("Invalid range: maxVal must be greater than minVal");
    }
 
    // Get a value in range [0, width) using modulo
    const double offsetAngle = std::fmod(angle - minVal, width);
 
    // Handle negative angles
    if (offsetAngle < 0)
    {
        return offsetAngle + maxVal;
    }
    else
    {
        return offsetAngle + minVal;
    }
}

◆ normalizeEulerAngles()

Eigen::Vector3d MoveG::Rotation::normalizeEulerAngles ( const Eigen::Vector3d & angles )

static

Normalizes Euler angles to the range [-π, π].

Parameters

angles Vector of Euler angles in radians

Returns: Vector of normalized Euler angles in radians

Definition at line 226 of file rotation_lib.cpp.

{
    return Eigen::Vector3d(normalizeAngle(angles.x()),
                           normalizeAngle(angles.y()),
                           normalizeAngle(angles.z()));
}

References normalizeAngle().

Here is the call graph for this function:

◆ operator*()

Rotation MoveG::Rotation::operator* ( const Rotation & other ) const

Composition of two rotations.

Parameters

other Rotation to compose with.

Returns: New rotation resulting from the composition.

Definition at line 152 of file rotation_lib.cpp.

{
    return Rotation(q * other.q);
}

References q, and Rotation().

Here is the call graph for this function:

◆ operator=() [1/2]

Rotation & MoveG::Rotation::operator= ( const Rotation & other )

Assignment operator.

Parameters

other Rotation to assign.

Returns: Reference to the current object.

Definition at line 157 of file rotation_lib.cpp.

{
    if (this != &other)
    {
        q = other.q;
    }
    return *this;
}

References q.

◆ operator=() [2/2]

Rotation & MoveG::Rotation::operator= ( Rotation && other )

noexcept

Move assignment operator.

Parameters

other Rotation to assign.

Returns: Reference to the current object.

Definition at line 166 of file rotation_lib.cpp.

{
    q = std::move(other.q);
    return *this;
}

◆ quaternion_difference()

Eigen::Quaterniond MoveG::Rotation::quaternion_difference	(	const Eigen::Quaterniond &	a,
		const Eigen::Quaterniond &	b
	)

static

Calculates the difference between two quaternions.

Parameters

a	Reference quaternion.
b	Quaternion to subtract.

Returns: Quaternion resulting from the difference.

Definition at line 294 of file rotation_lib.cpp.

{
    return a.inverse() * b;
}

◆ quaternion_minus()

Eigen::Quaterniond MoveG::Rotation::quaternion_minus	(	const Eigen::Quaterniond &	v1,
		const Eigen::Quaterniond &	v0
	)

static

Calculates the difference between two quaternions (v1 - v0).

Parameters

v1	First quaternion.
v0	Second quaternion.

Returns: Quaternion resulting from the subtraction.

Definition at line 310 of file rotation_lib.cpp.

{
    return Eigen::Quaterniond(v1.w() - v0.w(), v1.x() - v0.x(), v1.y() - v0.y(), v1.z() - v0.z());
}

◆ quaternion_negation()

Eigen::Quaterniond MoveG::Rotation::quaternion_negation ( const Eigen::Quaterniond & v )

static

Negates the quaternion.

Parameters

v	Quaternion to negate.

Returns: Negated quaternion.

Definition at line 300 of file rotation_lib.cpp.

{
    return Eigen::Quaterniond(-v.w(), -v.x(), -v.y(), -v.z());
}

◆ quaternion_plus()

Eigen::Quaterniond MoveG::Rotation::quaternion_plus	(	const Eigen::Quaterniond &	v1,
		const Eigen::Quaterniond &	v0
	)

static

Calculates the sum of two quaternions.

Parameters

v1	First quaternion.
v0	Second quaternion.

Returns: Quaternion resulting from the addition.

Definition at line 316 of file rotation_lib.cpp.

{
    return Eigen::Quaterniond(v1.w() + v0.w(), v1.x() + v0.x(), v1.y() + v0.y(), v1.z() + v0.z());
}

◆ rad2deg()

double MoveG::Rotation::rad2deg ( double radian )

static

Converts radians to degrees.

Parameters

radian Angle in radians.

Returns: Angle in degrees.

Definition at line 289 of file rotation_lib.cpp.

{
    return radian * 180.0 / M_PI;
}

Referenced by main(), and printEulerAngles().

Here is the caller graph for this function:

◆ rotationX()

Eigen::Matrix3d MoveG::Rotation::rotationX ( double angle )

static

Rotation matrix for a rotation around the X axis.

Parameters

angle Rotation angle in radians.

Returns: 3x3 rotation matrix.

Definition at line 323 of file rotation_lib.cpp.

{
    Eigen::Matrix3d rot = Eigen::Matrix3d::Identity();
    rot << 1, 0, 0, 0, cos(angle), -sin(angle), 0, sin(angle), cos(angle);
    return rot;
}

Referenced by main(), and matrixT().

Here is the caller graph for this function:

◆ rotationY()

Eigen::Matrix3d MoveG::Rotation::rotationY ( double angle )

static

Rotation matrix for a rotation around the Y axis.

Parameters

angle Rotation angle in radians.

Returns: 3x3 rotation matrix.

Definition at line 330 of file rotation_lib.cpp.

{
    Eigen::Matrix3d rot = Eigen::Matrix3d::Identity();
    rot << cos(angle), 0, sin(angle), 0, 1, 0, -sin(angle), 0, cos(angle);
    return rot;
}

Referenced by main(), and matrixT().

Here is the caller graph for this function:

◆ rotationZ()

Eigen::Matrix3d MoveG::Rotation::rotationZ ( double angle )

static

Rotation matrix for a rotation around the Z axis.

Parameters

angle Rotation angle in radians.

Returns: 3x3 rotation matrix.

Definition at line 337 of file rotation_lib.cpp.

{
    Eigen::Matrix3d rot = Eigen::Matrix3d::Identity();
    rot << cos(angle), -sin(angle), 0, sin(angle), cos(angle), 0, 0, 0, 1;
    return rot;
}

Referenced by main(), and matrixT().

Here is the caller graph for this function:

◆ scalar_product()

Eigen::Quaterniond MoveG::Rotation::scalar_product	(	const Eigen::Quaterniond &	v,
		double	t
	)

static

Calculates the scalar product of a quaternion by a scalar.

Parameters

v	Quaternion to scale.
t	Scale to multiply by.

Returns: Scaled quaternion.

Definition at line 305 of file rotation_lib.cpp.

{
    return Eigen::Quaterniond(t * v.w(), t * v.x(), t * v.y(), t * v.z());
}

◆ toAngleAxis()

Eigen::AngleAxisd MoveG::Rotation::toAngleAxis ( ) const

Converts the rotation to an axis-angle representation.

Returns: Axis-angle representation of the rotation.

Definition at line 121 of file rotation_lib.cpp.

{
    return Eigen::AngleAxisd(q);
}

References q.

Referenced by main().

Here is the caller graph for this function:

◆ toEulerAngles()

Eigen::Vector3d MoveG::Rotation::toEulerAngles	(	bool	intrinsic = `true`,
		const std::string &	sequence = `"ZYX"`
	)		const

Converts the rotation to Euler angles.

Parameters

intrinsic	If true, uses intrinsic rotations; otherwise, extrinsic.
sequence	Sequence of axes (e.g., "ZYX").

Returns: Vector containing the three Euler angles.

Definition at line 127 of file rotation_lib.cpp.

{
    checkSequence(sequence);
 
    const int a0 = axisToIndex(sequence[0]);
    const int a1 = axisToIndex(sequence[1]);
    const int a2 = axisToIndex(sequence[2]);
 
    Eigen::Vector3d angles = Eigen::Vector3d::Zero();
 
    if (intrinsic)
    {
        // For intrinsic rotations, reverse the order of axes
        angles = q.toRotationMatrix().eulerAngles(a2, a1, a0).reverse();
    }
    else
    {
        // For extrinsic rotations, use the axes as they are
        angles = q.toRotationMatrix().eulerAngles(a0, a1, a2);
    }
 
    return angles;
}

References axisToIndex(), checkSequence(), and q.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ toQuaternion()

Eigen::Quaterniond MoveG::Rotation::toQuaternion ( ) const

Converts the rotation to a quaternion.

Returns: Quaternion representing the rotation.

Definition at line 115 of file rotation_lib.cpp.

{
    return q;
}

References q.

Referenced by main().

Here is the caller graph for this function:

◆ toRotationMatrix()

Eigen::Matrix3d MoveG::Rotation::toRotationMatrix ( ) const

Converts the rotation to a rotation matrix.

Returns: 3x3 rotation matrix.

Definition at line 109 of file rotation_lib.cpp.

{
    return q.toRotationMatrix();
}

References q.

Referenced by main().

Here is the caller graph for this function:

Friends And Related Symbol Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const Rotation &	rotation
	)

friend

Outputs the rotation to a stream in quaternion format.

Parameters

os	Stream to output to.
rotation	Rotation to output.

Returns: Reference to the output stream.

Definition at line 173 of file rotation_lib.cpp.

{
    Eigen::Quaterniond quat = rotation.toQuaternion();
    os << "Rotation (quaternion x,y,z,w): [" << quat.x() << ", " << quat.y() << ", " << quat.z()
       << ", " << quat.w() << "]";
    return os;
}

Member Data Documentation

◆ q

Eigen::Quaterniond MoveG::Rotation::q

private

Internal representation of rotation via quaternion.

Definition at line 370 of file rotation_lib.h.

Referenced by operator*(), operator=(), Rotation(), toAngleAxis(), toEulerAngles(), toQuaternion(), and toRotationMatrix().

The documentation for this class was generated from the following files:

/home/runner/work/MoveG/MoveG/src/MoveG_Lib/rotation_lib.h
/home/runner/work/MoveG/MoveG/src/MoveG_Lib/rotation_lib.cpp

Public Member Functions

Static Public Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ Rotation() [1/7]

◆ Rotation() [2/7]

◆ Rotation() [3/7]

◆ Rotation() [4/7]

◆ Rotation() [5/7]

◆ Rotation() [6/7]

◆ Rotation() [7/7]

◆ ~Rotation()

Member Function Documentation

◆ angleAxis()

◆ axisToIndex()

◆ checkSequence()

◆ deg2rad()

◆ fromAngleAxis()

◆ fromEulerAngles()

◆ fromQuaternion()

◆ fromRotationMatrix()

◆ matrixR_dot() [1/2]

◆ matrixR_dot() [2/2]

◆ matrixS()

◆ matrixT()

◆ normalizeAngle()

◆ normalizeAngleRange()

◆ normalizeEulerAngles()

◆ operator*()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ quaternion_difference()

◆ quaternion_minus()

◆ quaternion_negation()

◆ quaternion_plus()

◆ rad2deg()

◆ rotationX()

◆ rotationY()

◆ rotationZ()

◆ scalar_product()

◆ toAngleAxis()

◆ toEulerAngles()

◆ toQuaternion()

◆ toRotationMatrix()

Friends And Related Symbol Documentation

◆ operator<<

Member Data Documentation

◆ q