《ROS中级课程》第19课 tf2之四元数基础

四元数基础

参考资料：https://docs.ros.org/en/iron/Tutorials/Intermediate/Tf2/Quaternion-Fundamentals.html。

目标

学习ROS2中四元素的基本用法。

背景

四元数表示方位信息，比旋转矩阵要更准确。四元数在分析涉及三维旋转的情况非常有效，被广泛用于机器人领域、量子力学、计算机视觉和3D动画。

前置条件

四元数组成

ROS2使用四元数来跟踪和应用旋转。一个四元数有4个组成部分(x, y, z, w)。在ROS2中，w是最后一位，但在其他库如Eigen中，w却是放在第一位。

不产生x/y/z轴旋转的常用单位四元数是(0,0,0,1)，可以通过以下方式创建：

#include <tf2/LinearMath/Quaternion.h>
...

tf2::Quaternion q;
// Create a quaternion from roll/pitch/yaw in radians (0, 0, 0)
q.setRPY(0, 0, 0);
// Print the quaternion components (0, 0, 0, 1)
RCLCPP_INFO(this->get_logger(), "%f %f %f %f",
            q.x(), q.y(), q.z(), q.w());

四元数的大小应该总是1。如果数值错误导致四元数的大小不是1，ROS 2将打印警告。避免这些警告，请规范化四元数：

q.normalize();

ROS2中的四元数类型

ROS2使用两种四元数数据类型：tf2::Quaternion和geometry_msgs::msg::Quaternion，这两种类型是等价的，可以使用tf2_geometry_msgs方法来转换：

C++版本：

#include <tf2_geometry_msgs/tf2_geometry_msgs.hpp>
...

tf2::Quaternion tf2_quat, tf2_quat_from_msg;
tf2_quat.setRPY(roll, pitch, yaw);
// Convert tf2::Quaternion to geometry_msgs::msg::Quaternion
geometry_msgs::msg::Quaternion msg_quat = tf2::toMsg(tf2_quat);

// Convert geometry_msgs::msg::Quaternion to tf2::Quaternion
tf2::convert(msg_quat, tf2_quat_from_msg);
// or
tf2::fromMsg(msg_quat, tf2_quat_from_msg);

Python版本：

from geometry_msgs.msg import Quaternion
...

# Create a list of floats, which is compatible with tf2
# Quaternion methods
quat_tf = [0.0, 1.0, 0.0, 0.0]

# Convert a list to geometry_msgs.msg.Quaternion
msg_quat = Quaternion(x=quat_tf[0], y=quat_tf[1], z=quat_tf[2], w=quat_tf[3])

四元数操作

1、在RPY下思考，然后再转换成四元数

我们很容易想象关于轴线的旋转，但很难想象四元数中的旋转。建议基于RPY来计算目标转换，RPY即绕X轴旋转的横滚角roll、绕Y轴旋转的俯仰角pitch和绕Z轴旋转的偏航角yaw，然后再转换成四元数：

# quaternion_from_euler method is available in turtle_tf2_py/turtle_tf2_py/turtle_tf2_broadcaster.py
q = quaternion_from_euler(1.5707, 0, -1.5707)
print(f'The quaternion representation is x: {q[0]} y: {q[1]} z: {q[2]} w: {q[3]}.')

2、应用四元数旋转

要将一个四元数的旋转应用于一个姿态，只需将姿态的前一个四元数乘以代表所需旋转的四元数。这个乘法的顺序很重要，即所需旋转的四元数×姿态的四元数。

C++版本：

#include <tf2_geometry_msgs/tf2_geometry_msgs.hpp>
...

tf2::Quaternion q_orig, q_rot, q_new;

q_orig.setRPY(0.0, 0.0, 0.0);
// Rotate the previous pose by 180* about X
q_rot.setRPY(3.14159, 0.0, 0.0);
q_new = q_rot * q_orig;
q_new.normalize();

Python版本：

q_orig = quaternion_from_euler(0, 0, 0)
# Rotate the previous pose by 180* about X
q_rot = quaternion_from_euler(3.14159, 0, 0)
q_new = quaternion_multiply(q_rot, q_orig)

3、反转四元数

反转四元数的一种简单方法是取w分量为负：

q[3] = -q[3]

4、相关旋转

假设你有两个四元数来自同一个坐标系，q_1和q_2。你想找到q_1到q_2的相对旋转q_r该怎么做？

首先，q_1到q_2的旋转有如下关系：

q_2 = q_r * q_1

那么，q_r就等于q_2×q_1的逆：

q_r = q_2 * q_1_inverse

Python版本的旋转矩阵计算方式如下：

def quaternion_multiply(q0, q1):
    """
    Multiplies two quaternions.

    Input
    :param q0: A 4 element array containing the first quaternion (q01, q11, q21, q31)
    :param q1: A 4 element array containing the second quaternion (q02, q12, q22, q32)

    Output
    :return: A 4 element array containing the final quaternion (q03,q13,q23,q33)

    """
    # Extract the values from q0
    w0 = q0[0]
    x0 = q0[1]
    y0 = q0[2]
    z0 = q0[3]

    # Extract the values from q1
    w1 = q1[0]
    x1 = q1[1]
    y1 = q1[2]
    z1 = q1[3]

    # Computer the product of the two quaternions, term by term
    q0q1_w = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1
    q0q1_x = w0 * x1 + x0 * w1 + y0 * z1 - z0 * y1
    q0q1_y = w0 * y1 - x0 * z1 + y0 * w1 + z0 * x1
    q0q1_z = w0 * z1 + x0 * y1 - y0 * x1 + z0 * w1

    # Create a 4 element array containing the final quaternion
    final_quaternion = np.array([q0q1_w, q0q1_x, q0q1_y, q0q1_z])

    # Return a 4 element array containing the final quaternion (q02,q12,q22,q32)
    return final_quaternion

q1_inv[0] = prev_pose.pose.orientation.x
q1_inv[1] = prev_pose.pose.orientation.y
q1_inv[2] = prev_pose.pose.orientation.z
q1_inv[3] = -prev_pose.pose.orientation.w # Negate for inverse

q2[0] = current_pose.pose.orientation.x
q2[1] = current_pose.pose.orientation.y
q2[2] = current_pose.pose.orientation.z
q2[3] = current_pose.pose.orientation.w

qr = quaternion_multiply(q2, q1_inv)

总结

本节课学习了四元数的基本概念以及相关的数学操作，如逆矩阵和旋转矩阵。还学习了两种不同类型间的四元数类型的转换。