四元数与旋转矩阵

已于 2022-09-18 11:37:13 修改
阅读量2.7w 收藏 247
点赞数 25
文章标签： 矩阵 matlab 线性代数
于 2021-08-12 10:49:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gyxx1998/article/details/119636130
版权

01 什么是四元数

02 四元数与旋转矩阵、欧拉角

这里主要参考的是 右手系转左手系、旋转矩阵转四元数、四元数的两种表达（Hamilton/JPL)（这篇文章很棒，需要认真看哦~）

网上关于四元数有左手右手两种表达方式，有些地方标明了是在什么坐标系下的公式，而大多数地方是没有的。

所以如果“四元数转旋转矩阵”和“旋转矩阵转四元数”分别采用了在不同坐标系下的转换公式，将会出错。

在右手、左手坐标系下建立的四元数表示方式分别叫做四元数的两种表达：Hamilton/JPL

这两种表达的区别如下：
在这里插入图片描述
Hamilton对应右手系，JPL对应左手系

定义的差异直接导致计算公式的不同，但实际应用中只要统一标准应该问题不大。

Eigen ，Matlab ，ROS、Google Ceres Solver等都使用Hamilton四元数，而JPL则多用于航空航天领域。

2.1 公式（四元数与旋转矩阵）

Hamilton和JPL这两种表达，基本上就是相差一个符号的正负

2.1.1 四元数转旋转矩阵

Hamilton表达：
在这里插入图片描述

JPL表达：
在这里插入图片描述

2.1.1 旋转矩阵转四元数

Hamilton表达：

r 11 r11 r11等为姿态旋转矩阵中的元素

在这里插入图片描述
JPL表达：
在这里插入图片描述

2.2 公式（四元数与欧拉角）

在这里使用的是Hamilton（右手系）的
在这里插入图片描述

03 编程

3.1 c++

3.1.1 Hamilton表达

参考 基于OpenCV的四元数、旋转矩阵和欧拉角互相转换

  • 四元数转旋转矩阵
void getRotation(double *Quaternion, double *rt_mat)
{
  rt_mat[0] = 1 - 2 * (Quaternion[2] * Quaternion[2]) - 2 * (Quaternion[3] * Quaternion[3]);
  rt_mat[1] = 2 * Quaternion[1] * Quaternion[2] - 2 * Quaternion[0] * Quaternion[3];
  rt_mat[2] = 2 * Quaternion[1] * Quaternion[3] + 2 * Quaternion[0] * Quaternion[2];
  rt_mat[3] = 2 * Quaternion[1] * Quaternion[2] + 2 * Quaternion[0] * Quaternion[3];
  rt_mat[4] = 1 - 2 * (Quaternion[1] * Quaternion[1]) - 2 * (Quaternion[3] * Quaternion[3]);
  rt_mat[5] = 2 * Quaternion[2] * Quaternion[3] - 2 * Quaternion[0] * Quaternion[1];
  rt_mat[6] = 2 * Quaternion[1] * Quaternion[3] - 2 * Quaternion[0] * Quaternion[2];
  rt_mat[7] = 2 * Quaternion[2] * Quaternion[3] + 2 * Quaternion[0] * Quaternion[1];
  rt_mat[8] = 1 - 2 * (Quaternion[1] * Quaternion[1]) - 2 * (Quaternion[2] * Quaternion[2]);
}
  • 旋转矩阵转四元数
void getQuaternion(Mat R, double Q[])
{
    double trace = R.at<double>(0,0) + R.at<double>(1,1) + R.at<double>(2,2);
 
    if (trace > 0.0) 
    {
        double s = sqrt(trace + 1.0);
        Q[3] = (s * 0.5);
        s = 0.5 / s;
        Q[0] = ((R.at<double>(2,1) - R.at<double>(1,2)) * s);
        Q[1] = ((R.at<double>(0,2) - R.at<double>(2,0)) * s);
        Q[2] = ((R.at<double>(1,0) - R.at<double>(0,1)) * s);
    } 
    
    else 
    {
        int i = R.at<double>(0,0) < R.at<double>(1,1) ? (R.at<double>(1,1) < R.at<double>(2,2) ? 2 : 1) : (R.at<double>(0,0) < R.at<double>(2,2) ? 2 : 0); 
        int j = (i + 1) % 3;  
        int k = (i + 2) % 3;

        double s = sqrt(R.at<double>(i, i) - R.at<double>(j,j) - R.at<double>(k,k) + 1.0);
        Q[i] = s * 0.5;
        s = 0.5 / s;

        Q[3] = (R.at<double>(k,j) - R.at<double>(j,k)) * s;
        Q[j] = (R.at<double>(j,i) + R.at<double>(i,j)) * s;
        Q[k] = (R.at<double>(k,i) + R.at<double>(i,k)) * s;
    }
}

3.1.1 JPL表达

参考：从旋转矩阵到四元数

  • 旋转矩阵转四元数
void getQuaternion(cv::Mat R, double Q[])//JPL
{
	double m11=R.at<double>(0,0), m12 = R.at<double>(0, 1), m13 = R.at<double>(0, 2);
	double m21 = R.at<double>(1, 0), m22 = R.at<double>(1, 1), m23 = R.at<double>(1, 2);
	double m31 = R.at<double>(2, 0), m32 = R.at<double>(2, 1), m33 = R.at<double>(2, 2);

	double w, x, y, z;

	//探测四元数中最大的项 
	double fourWSquaredMinusl = m11 + m22 + m33;
	double fourXSquaredMinusl = m11 - m22 - m33;
	double fourYSquaredMinusl = m22 - m11 - m33;
	double fourZSquaredMinusl = m33 - m11 - m22;

	int biggestIndex = 0;
	double fourBiggestSqureMinus1 = fourWSquaredMinusl;
	if (fourXSquaredMinusl > fourBiggestSqureMinus1) {
		fourBiggestSqureMinus1 = fourXSquaredMinusl;
		biggestIndex = 1;
	}
	if (fourYSquaredMinusl > fourBiggestSqureMinus1) {
		fourBiggestSqureMinus1 = fourYSquaredMinusl;
		biggestIndex = 2;
	}
	if (fourZSquaredMinusl > fourBiggestSqureMinus1) {
		fourBiggestSqureMinus1 = fourZSquaredMinusl;
		biggestIndex = 3;
	}

	//计算平方根和除法 
	double biggestVal = sqrt(fourBiggestSqureMinus1 + 1.0f) * 0.5f;
	double mult = 0.25f / biggestVal;

	//计算四元数的值
	switch (biggestIndex) {
	case 0:
		w = biggestVal;
		x = (m23 - m32) * mult;
		y = (m31 - m13) * mult;
		z = (m12 - m21) * mult;
		break;
	case 1:
		x = biggestVal;
		w = (m23 - m32) * mult;
		y = (m12 + m21) * mult;
		z = (m31 + m13) * mult;
		break;
	case 2:
		y = biggestVal;
		w = (m31 - m13) * mult;
		x = (m12 + m21) * mult;
		z = (m23 + m32) * mult;
		break;
	case 3:
		z = biggestVal;
		w = (m12 - m21) * mult;
		x = (m31 + m13) * mult;
		y = (m23 + m32) * mult;
		break;
	}
	Q[0] = x;
	Q[1] = y;
	Q[2] = z;
	Q[3] = w;
}

3.2 matlab

3.2.1 Hamilton表达

  • 四元数转旋转矩阵
function r=q2rot(q)
%   q是从控制器或示教器中读取的向量[q1 q2 q3 q4]；
    w=q(1);
    x=q(2);
    y=q(3);
    z=q(4);

    r=zeros(3,3);
    r(1,1)=1-2*y*y-2*z*z;
    r(1,2)=2*x*y+2*w*z;
    r(1,3)=2*x*z-2*w*y;

    r(2,1)=2*x*y-2*w*z;
    r(2,2)=1-2*x*x-2*z*z;
    r(2,3)=2*z*y+2*w*x;

    r(3,1)=2*x*z+2*w*y;
    r(3,2)=2*y*z-2*w*x;
    r(3,3)=1-2*x*x-2*y*y;
    r=r';
end
  • 欧拉角转旋转矩阵
function H = Eular2Rot( EX,EY,EZ,TransVector )
%   EX,EY,EZ,TransVector是机器手坐标系（或工具坐标系）在基坐标系（世界坐标系或者工件坐标系也可）里面的位置和姿态变换参数，需要从机器人控制器或示教盒中读取
%   EX--机器手坐标系绕基坐标系的X轴旋转欧拉角 
%   EY--绕Y轴旋转欧拉角 
%   EZ--绕Z轴旋转欧拉角
%   TransVector--机器手坐标系原点相对基坐标系的平移向量:3x1
    a=EX/180 *pi;
    b=EY/180 *pi;
    r=EZ/180 *pi;
    Rx=[1 0 0;0 cos(a) -sin(a);0 sin(a) cos(a)];
    Ry=[cos(b) 0 sin(b);0 1 0;-sin(b) 0 cos(b)];
    Rz=[cos(r) -sin(r) 0;sin(r) cos(r) 0;0 0 1];
    R=Rz*Ry*Rx;
    H=[R TransVector;0 0 0 1];
end

3.3 python

3.3.1 Hamilton表达和JPL表达

from math import pi, sqrt
import numpy as np

# 注：Hamilton为右手系
#    JPL     为左手系

def quat_to_pos_matrix_hm(p_x, p_y, p_z, x, y, z, w):
    # 创建位姿矩阵，写入位置
    T = np.matrix([[0, 0, 0, p_x], [0, 0, 0, p_y], [0, 0, 0, p_z], [0, 0, 0, 1]])
    T[0, 0] = 1 - 2 * pow(y, 2) - 2 * pow(z, 2)
    T[0, 1] = 2 * (x * y - w * z)
    T[0, 2] = 2 * (x * z + w * y)

    T[1, 0] = 2 * (x * y + w * z)
    T[1, 1] = 1 - 2 * pow(x, 2) - 2 * pow(z, 2)
    T[1, 2] = 2 * (y * z - w * x)

    T[2, 0] = 2 * (x * z - w * y)
    T[2, 1] = 2 * (y * z + w * x)
    T[2, 2] = 1 - 2 * pow(x, 2) - 2 * pow(y, 2)
    return T
    # return T.tolist()


def quat_to_pos_matrix_JPL(p_x, p_y, p_z, x, y, z, w):
    # 创建位姿矩阵，写入位置
    T = np.matrix([[0, 0, 0, p_x], [0, 0, 0, p_y], [0, 0, 0, p_z], [0, 0, 0, 1]])
    T[0, 0] = 1 - 2 * pow(y, 2) - 2 * pow(z, 2)
    T[0, 1] = 2 * (x * y + w * z)
    T[0, 2] = 2 * (x * z - w * y)

    T[1, 0] = 2 * (x * y - w * z)
    T[1, 1] = 1 - 2 * pow(x, 2) - 2 * pow(z, 2)
    T[1, 2] = 2 * (y * z + w * x)

    T[2, 0] = 2 * (x * z + w * y)
    T[2, 1] = 2 * (y * z - w * x)
    T[2, 2] = 1 - 2 * pow(x, 2) - 2 * pow(y, 2)
    return T
    # return T.tolist()


def pos_matrix_to_quat_hm(T):
    r11 = T[0, 0]
    r12 = T[0, 1]
    r13 = T[0, 2]
    r21 = T[1, 0]
    r22 = T[1, 1]
    r23 = T[1, 2]
    r31 = T[2, 0]
    r32 = T[2, 1]
    r33 = T[2, 2]
    w = (1 / 2) * sqrt(1 + r11 + r22 + r33)
    x = (r32 - r23) / (4 * w)
    y = (r13 - r31) / (4 * w)
    z = (r21 - r12) / (4 * w)
    return x, y, z, w


def pos_matrix_to_quat_JPL(T):
    r11 = T[0, 0]
    r12 = T[0, 1]
    r13 = T[0, 2]
    r21 = T[1, 0]
    r22 = T[1, 1]
    r23 = T[1, 2]
    r31 = T[2, 0]
    r32 = T[2, 1]
    r33 = T[2, 2]
    w = (1 / 2) * sqrt(1 + r11 + r22 + r33)
    x = (r23 - r32) / (4 * w)
    y = (r31 - r13) / (4 * w)
    z = (r12 - r21) / (4 * w)
    return x, y, z, w


if __name__ == "__main__":
    # position:
    p_x = 0.0
    p_y = 0.0881141967773
    p_z = -0.0655107116699

    # orientation:
    x = -0.181168104759
    y = -0.0779586342595
    z = -0.385540513457
    w = 0.901365121161

    T_hm = quat_to_pos_matrix_hm(p_x, p_y, p_z, x, y, z, w)
    print("T_hm")
    print(T_hm)

    T_JPL = quat_to_pos_matrix_JPL(p_x, p_y, p_z, x, y, z, w)
    print("T_JPL")
    print(T_JPL)

    x, y, z, w = pos_matrix_to_quat_hm(T_hm,)
    print("q_hm")
    print(x, y, z, w)

    x, y, z, w = pos_matrix_to_quat_JPL(T_JPL)
    print("q_JPL")
    print(x, y, z, w)

    TT1 = np.matrix([[0.6906, 0.7233, -0.0008, p_x], [-0.6668, 0.6371, 0.3867, p_y], [0.2802, -0.2665, 0.9222, p_z], [0, 0, 0, 1]])
    x, y, z, w = pos_matrix_to_quat_hm(TT1)
    print("q")
    print(x, y, z, w)

3.3.2 python的一些语法

3.3.2.1 ptyhon计算平方

方法一：使用内置模块

>>> import math 
>>> math.pow(12, 2)     # 求平方
144.0

方法二：使用表达式

>>> 12 ** 2             # 求平方
144

方法三：使用内置函数

>>> pow(12, 2)          # 求平方
144
3.3.2.2 ptyhon计算平方根

方法一：

num_sqrt = num ** 0.5

方法二：

import cmath
 
num_sqrt = cmath.sqrt(num)
3.3.2.3 矩阵定义和访问 & 矩阵和列表的转换
import numpy as np
# 定义
T = np.matrix([[1,0,0,0],[0,1,-1,0],[0,1,1,0],[0,0,0,1]])
# 访问
a = T[0, 0]

# 转为list
T2 = T.tolist()
# 转为list的访问
a = T[0][0]

注意:

矩阵的访问是T[0, 0]
把矩阵转为list的访问是T[0][0]

矩阵转换为列表 L=M.tolist()
列表转换为矩阵 M=mat(L)

矩阵、数组、列表的两两转换参考：https://blog.csdn.net/m0_37477175/article/details/72828311

04 有关四元数和旋转矩阵相互转换的一些参考

四元数 q = s + x i + y j + z k q=s+xi+yj+zk q=s+xi+yj+zk
构造纯四元数后（即 p ′ = q p q − 1 p' = q p q^{-1} p′=qpq−1）

在这里插入图片描述
或
在这里插入图片描述
在这里插入图片描述

冰激凌啊
关注
  • 25
    点赞
  • 踩
  • 247
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
四元数和旋转矩阵相互转化的算法实现
11-27
讲述四元数和旋转矩阵之间相互转化的学术论文：首先介绍了四元数和旋转矩阵在实现向量旋转中的应用,在此基础上,根据游戏开发的实际需要,讨论了四元数和旋转矩阵之间的相互转化关系。最后,重点分析了由旋转矩阵到四元数的转换算法,并按照计算机程序设计的特殊要求设计了程序。
「 SLAM lesson-3.6 」用四元数表示旋转，四元数到旋转矩阵的转换
Robot_Starscream的博客
12-04 3709
结合高翔老师的著作《视觉SLAM十四讲：从理论到实践》，加上小白的工程经验共同完成。建议作为笔记功能反复使用。 1.用四元数表示旋转 把三维空间点用一个虚四元数来描述： 这相当于我们把四元数的三个虚部与空间中的三个轴相对应。，用四元数 q 表示这个旋转： 那么，旋转后的点......
四元数与旋转矩阵之间的关系
longteng_guo的博客
07-08 6074
在这里的旋转矩阵指的是坐标变换的旋转矩阵。 若矩阵与四元数均表示由坐标系G变换至用坐标系L进行表达。 则 因为某点P绕某轴旋转角后在坐标系中的坐标值，等于，保持点在空间中不动，将坐标系绕此轴旋转角度后，点在新坐标系中的坐标值。 而用四元数进行旋转操作时，是顺时针旋转为正方向。 假设坐标系G绕轴逆时针旋转角与坐标系L重合，则对应的四元数为 一、由四元数转换为坐标变换旋转矩阵的关系如下所示。经推导可得相互转换关系如下：(右乘) 下面进行证明： 本旋转矩阵可以用Rodrigues' 旋转矩
使用 RT 矩阵进行 3D 点云变换详解（基于 PCL 和 Eigen 库）
最新发布
人人都懂物联网
05-22 1213
在 3D 点云处理中，RT 矩阵是一个常用的工具，用于对点云进行旋转和平移操作。本文将详细介绍 RT 矩阵的概念，并通过一个示例程序演示如何基于 PCL 和 Eigen 库将一帧点云进行矩阵变换再输出。
【学习总结】四元数、旋转矩阵与欧拉角之间的转换
larrydong的博客
09-17 2294
本文仅用于做个人记录和速查。 其中四元数是Hamilton形式，q0是实部，q1:3是虚部； 欧拉角是XYZ欧拉角，即先绕Z轴旋转 ψ\psiψ，然后绕旋转后的Y轴旋转 θ\thetaθ，最后沿X轴旋转 ϕ\phiϕ。即 R=R1(ϕ)R2(θ)R3(ψ)R=R_1(\phi)R_2(\theta)R_3(\psi)R=R1​(ϕ)R2​(θ)R3​(ψ) 四元数和旋转矩阵 四元数转旋转矩阵 旋转矩阵转四元数 利用上面旋转矩阵的对角线，即可计算出相应的四元数。 欧拉角和旋转矩阵 旋转矩阵
四元数和旋转矩阵相互转换
qq_27390023的博客
02-04 225
【代码】四元数和旋转矩阵相互转换。
矩阵旋转、欧拉角旋转、四元数旋转的优缺点
Hannah1221的博客
07-29 2597
一、矩阵旋转： 优点：旋转轴可以是任意向量 缺点：旋转其实只需要知道一个向量+一个角度(共4个信息值)，但矩阵却用了16个元素(矩阵法消耗时间和内存) 二、欧拉角旋转 优点：容易理解，形象直观；表示更方便，只需要三个值(分别对应x、y、z轴的旋转角度) 缺点：欧拉角这种方法是要按照一个固定的坐标轴的顺序旋转的，因此不同的顺序会造成不同结果；欧拉角旋转会造成万向锁现象，这种现...
从四元数到旋转矩阵
热门推荐
loongkingwhat的博客
03-12 3万+
旋转矩阵和四元数都是描述三维空间中位姿的方式，此文将讨论如何从四元数计算出旋转。 背景介绍 旋转矩阵和四元数之间的变换需要依据以下公式1 公式1： 绕任意轴n旋转θ的旋转矩阵 公式1的具体推导过程可以参见知乎文章。 注意公式1中的基本条件：①旋转的正方向由左手法则判定 ②任意轴n处于左手坐标系中。 公式2： 绕任意轴n旋转θ的四元数 要想从四元数求得旋转矩阵，即需要用矩阵中的元素m11、m12...
【机器人】四元数与旋转矩阵的转换关系
浪漫至死不渝
11-24 3226
导语：最近在项目上没有多大进展，就没得啥文章可写，这周末看了一下姿态轨迹规划的文章，对姿态的插补有点感兴趣，于是就先看看相关的文章，发现用四元数表示姿态然后来进行姿态的插补非常方便，这里对四元数与常规的旋转矩阵的转换做一下总结。 四元数转换为旋转矩阵 旋转矩阵转换为四元数 ...
如何将四元数转换为旋转矩阵
weixin_39939185的博客
12-05 1684
​ 四元数是表示物体在三维空间中的方向和旋转的几种数学方法之一。另一种方法是使用基于欧拉角的旋转矩阵，即滚动、俯仰和偏航，就像的封面图片。 通常使用四元数代替欧拉角旋转矩阵，因为“与旋转矩阵相比，它们更紧凑、数值更稳定且更高效” 请注意，四元数仅描述坐标系（即 3D 空间中的某个对象）绕任意轴的旋转，但它不会告诉您有关该对象位置的任何信息。
【机器人学】四元数与旋转矩阵的相互转换
木小易的博客
05-23 7544
1. 从四元数到旋转矩阵 为了将角位移从四元数形式转换到矩阵形式，可以利用以下矩阵，它能计算绕任意轴的旋转： R(n,θ)=[p′q′r′]=[nx2(1−cosθ)+cosθnxny(1−cosθ)+nzsinθnxnz(1−cosθ)+nysinθnxny(1−cosθ)−nzsinθny2(1−cosθ)+cosθnynz(1−cosθ)+nxsinθnxnz(1−cosθ)+nysinθnynz(1−cosθ)−nxsinθnz2(1−cosθ)+cosθ](1) R(n,\theta)= \be
四元数和旋转矩阵
05-20 2万+
Quaternion(四元数) Quaternion 的定义 四元数一般定义如下：     q=w+xi+yj+zk 其中 w,x,y,z是实数。同时，有:     i*i=-1     j*j=-1     k*k=-1 四元数也可以表示为：     q=[w,v] 其中v=(x,y,z)是矢量，w是标量，虽然v是矢量，但不能简单的理解为3D空间的矢量，它是4维空间中的的
四元数与旋转矩阵详细推导过程
11-06
四元数与旋转矩阵详细推导过程 在了解四元数（Quaternion）与三维旋转之间的关系之前，我们需要了解复数（Complex Number）的一些性质，以及它与二维旋转之间的关系。四元数的许多性质在很多层面上都与复数非常类似...
四元数与旋转矩阵1
08-08
任意向量绕旋转轴单位向量旋转角度，可用四元数表示： 有旋转矩阵计算四元数若 限定，有，求得 若 因为,所以至少有一个大于0即当中最大的大于0，因此根
python将四元数变换为旋转矩阵的实例
01-21
# 写上用四元数表示的orientation和xyz表示的position orientation = {'y': -0.6971278819736084, 'x': -0.716556549511624, 'z': -0.010016582945017661, 'w': 0.02142651612120239} position = {'y': -0....
四元数、欧拉角、旋转矩阵之间如何相互转换？
【cacrle】的博客
02-27 1196
在研究机器人运动时，会用到惯性测量单元采集姿态数据，获取的姿态数据主要是四元数，一般不直接获取三轴欧拉角，因欧拉角插值（插值是因多传感器数据采集频率不一致，若要融合数据，必须根据时间进行插值）困难，相比下之下，四元数插值（球面插值）较简单。在将采集的四元数经插值处理完成后，因它无法直接使用，若要观察姿态变化情况，可以将四元数转为易理解的欧拉角观察角度姿态变化情况；若要用于坐标变换，可以将四元数转为易计算的旋转矩阵去变换其他传感器数据在空间的姿态。
从旋转矩阵到四元数
loongkingwhat的博客
03-13 2万+
在文章：从四元数计算旋转矩阵的基础上，现在来考虑从旋转矩阵到四元数的计算。 从四元数(w,x,y,z)计算旋转矩阵 从旋转矩阵计算四元数 为了从旋转矩阵中求出相应的四元数，可以直接利用上述已经求得的矩阵。 计算方法一： 计算对角线元素之和即可求的 w 值： 同理可以计算 x,y,z 的值： ！！！重点提醒！！！ 上述的计算方式是存在不完整性的，因为四元数所有分量的计算都是通过开方所得，...
关于万向锁(Gimbal lock)问题的理解及解决
罗伯特祥的博客
09-08 1万+
1. Gimbal lock的理解 万向锁（Gimbal lock）： 一旦选择±90°作为pitch角，就会导致第一次旋转和第三次旋转等价，整个旋转表示系统被限制在只能绕竖直轴旋转，丢失了一个表示维度。 对于万向锁的问题，只有在动态欧拉角中出现，而静态欧拉角不存在万向锁的问题！！！ 静态： 即绕世界坐标系三个轴的旋转，由于物体旋转过程中坐标轴保持静止，所以称为静态，此时各个变换顺序的旋转矩阵是左乘的 动态： 即绕物体坐标系三个轴的旋转，由于物体旋转过程中坐标轴随着物体做相同的转动，所以称为动态，此时各个
四元数转换为一个旋转矩阵
小秋 AI SLAM 入门实战教程
07-09 577
这是一个用于将四元数转换为旋转矩阵的程序，使用了Eigen库来处理数学运算和OpenCV库来存储和输出结果。它首先创建一个四元数，表示绕Z轴旋转90度的旋转。四元数是一种扩展复数，用于表示和操作三维空间中的旋转。总的来说，这个程序的目的是展示如何在C++中使用Eigen和OpenCV库来处理四元数和旋转矩阵的转换。方法：这个方法接受一个包含四元数的向量，然后使用Eigen的。方法：这个方法将Eigen的3x3矩阵转换为OpenCV的。最后，它打印出旋转矩阵的值。类将四元数转换为3x3的旋转矩阵。
matlab 四元数与旋转矩阵转换
05-30
在 MATLAB 中，可以使用 `quaternion` 类和 `rotm2quat`、`quat2rotm` 函数实现四元数和旋转矩阵之间的转换。 1. 将旋转矩阵转换为四元数： ```matlab R = [1, 0, 0; 0, cos(pi/4), -sin(pi/4); 0, sin(pi/4), cos(pi/4)]; % 以 x 轴为轴旋转 45 度的旋转矩阵 q = rotm2quat(R) % 将旋转矩阵转换为四元数 ``` 其中，`rotm2quat` 函数将旋转矩阵转换为四元数，返回值 `q` 是一个四元数对象。 2. 将四元数转换为旋转矩阵： ```matlab q = quaternion(cos(pi/8), sin(pi/8), 0, 0); % 以 x 轴为轴旋转 45 度的四元数 R = quat2rotm(q) % 将四元数转换为旋转矩阵 ``` 其中，`quat2rotm` 函数将四元数转换为旋转矩阵，返回值 `R` 是一个 $3\times3$ 的旋转矩阵。 需要注意的是，`quaternion` 类和 `rotm2quat`、`quat2rotm` 函数需要 MATLAB R2017a 或更高版本支持。如果使用的是较早版本的 MATLAB，可以使用 `spinCalc` 函数实现四元数和旋转矩阵之间的转换。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值