欧拉角、旋转向量和旋转矩阵的相互转换

最新推荐文章于 2023-08-28 16:06:05 发布
最新推荐文章于 2023-08-28 16:06:05 发布
阅读量1.8k 收藏 20
点赞数 1
分类专栏： 程序数学 文章标签： python 线性代数
原文链接：https://www.jianshu.com/p/5e130c04a602
版权

欧拉角转旋转矩阵

对于两个三维点 ，由点经过旋转矩阵旋转到，则有：

 任何一个旋转可以表示为依次绕着三个旋转轴旋三个角度的组合。这三个角度称为欧拉角。 对于在三维空间里的一个参考系，任何坐标系的取向，都可以用三个欧拉角来表现，如下图（蓝色是起始坐标系，而红色的是旋转之后的坐标系） ：

 

 

因此欧拉角转旋转矩阵如下：


则可以如下表示欧拉角：


以下代码用来实现旋转矩阵和欧拉角之间的相互变换。
C++语言：

Mat eulerAnglesToRotationMatrix(Vec3f &theta)
{
    // Calculate rotation about x axis
    Mat R_x = (Mat_<double>(3,3) <<
        1,       0,              0,
        0,       cos(theta[0]),   -sin(theta[0]),
        0,       sin(theta[0]),   cos(theta[0])
    );
    // Calculate rotation about y axis
    Mat R_y = (Mat_<double>(3,3) <<
        cos(theta[1]),    0,      sin(theta[1]),
        0,               1,      0,
        -sin(theta[1]),   0,      cos(theta[1])
    );
    // Calculate rotation about z axis
    Mat R_z = (Mat_<double>(3,3) <<
        cos(theta[2]),    -sin(theta[2]),      0,
        sin(theta[2]),    cos(theta[2]),       0,
        0,               0,                  1
    );
    // Combined rotation matrix
    Mat R = R_z * R_y * R_x;
    return R;
}
Vec3f rotationMatrixToEulerAngles(Mat &R)
{
    float sy = sqrt(R.at<double>(0,0) * R.at<double>(0,0) +  R.at<double>(1,0) * R.at<double>(1,0) );
    bool singular = sy < 1e-6; // If
    float x, y, z;
    if (!singular)
    {
        x = atan2(R.at<double>(2,1) , R.at<double>(2,2));
        y = atan2(-R.at<double>(2,0), sy);
        z = atan2(R.at<double>(1,0), R.at<double>(0,0));
    }
    else
    {
        x = atan2(-R.at<double>(1,2), R.at<double>(1,1));
        y = atan2(-R.at<double>(2,0), sy);
        z = 0;
    }
    #if 1
    x = x*180.0f/3.141592653589793f;
    y = y*180.0f/3.141592653589793f;
    z = z*180.0f/3.141592653589793f;
    #endif
    return Vec3f(x, y, z);
}

Python语言实现：

def rotationMatrixToEulerAngles(rvecs):
    R = np.zeros((3, 3), dtype=np.float64)
    cv2.Rodrigues(rvecs, R)
    sy = math.sqrt(R[0,0] * R[0,0] +  R[1,0] * R[1,0])
    singular = sy < 1e-6
    if  not singular:
        x = math.atan2(R[2,1] , R[2,2])
        y = math.atan2(-R[2,0], sy)
        z = math.atan2(R[1,0], R[0,0])
    else :
        x = math.atan2(-R[1,2], R[1,1])
        y = math.atan2(-R[2,0], sy)
        z = 0
    #print('dst:', R)
    x = x*180.0/3.141592653589793
    y = y*180.0/3.141592653589793
    z = z*180.0/3.141592653589793
    return x,y,z
def eulerAnglesToRotationMatrix(angles1) :
    theta = np.zeros((3, 1), dtype=np.float64)
    theta[0] = angles1[0]*3.141592653589793/180.0
    theta[1] = angles1[1]*3.141592653589793/180.0
    theta[2] = angles1[2]*3.141592653589793/180.0
    R_x = np.array([[1,         0,                  0                   ],
                    [0,         math.cos(theta[0]), -math.sin(theta[0]) ],
                    [0,         math.sin(theta[0]), math.cos(theta[0])  ]
                    ])
    R_y = np.array([[math.cos(theta[1]),    0,      math.sin(theta[1])  ],
                    [0,                     1,      0                   ],
                    [-math.sin(theta[1]),   0,      math.cos(theta[1])  ]
                    ])
    R_z = np.array([[math.cos(theta[2]),    -math.sin(theta[2]),    0],
                    [math.sin(theta[2]),    math.cos(theta[2]),     0],
                    [0,                     0,                      1]
                    ])
    R = np.dot(R_z, np.dot( R_y, R_x ))
    sy = math.sqrt(R[0,0] * R[0,0] +  R[1,0] * R[1,0])
    singular = sy < 1e-6
    if  not singular:
        x = math.atan2(R[2,1] , R[2,2])
        y = math.atan2(-R[2,0], sy)
        z = math.atan2(R[1,0], R[0,0])
    else :
        x = math.atan2(-R[1,2], R[1,1])
        y = math.atan2(-R[2,0], sy)
        z = 0
    #print('dst:', R)
    x = x*180.0/3.141592653589793
    y = y*180.0/3.141592653589793
    z = z*180.0/3.141592653589793
    #rvecs = np.zeros((1, 1, 3), dtype=np.float64)
    #rvecs,_ = cv2.Rodrigues(R, rvecstmp)
    return x,y,z

旋转矩阵与旋转向量

处理三维旋转问题时，通常采用旋转矩阵的方式来描述。一个向量乘以旋转矩阵等价于向量以某种方式进行旋转。除了采用旋转矩阵描述外，还可以用旋转向量来描述旋转，旋转向量的长度（模）表示绕轴逆时针旋转的角度（弧度）。
旋转向量与旋转矩阵可以通过罗德里格斯（Rodrigues）变换进行转换。

其中：norm为求向量的模。
反变换也可以很容易的通过如下公式实现：


以下代码用来实现旋转向量到旋转矩阵及旋转矩阵到旋转向量的转换：

        r_vec[0]=(double)(rotation_vectors[i](0));
        r_vec[1]=(double)(rotation_vectors[i](1));
        r_vec[2]=(double)(rotation_vectors[i](2));
        
        cvInitMatHeader(pr_vec,1,3,CV_64FC1,r_vec,CV_AUTOSTEP);
        cvInitMatHeader(pR_matrix,3,3,CV_64FC1,R_matrix,CV_AUTOSTEP);
        
        cvRodrigues2(pr_vec, pR_matrix, 0);//从旋转向量求旋转矩阵
        
        cvRodrigues2(pR_matrix, pnew_vec, 0);//从旋转矩阵求旋转向量
        Mat rotation_vec_tmp(pnew_vec->rows,pnew_vec->cols,pnew_vec->type,pnew_vec->data.fl);
        
        //cvMat转Mat
        Mat rotation_matrix_tmp(pR_matrix->rows,pR_matrix->cols,pR_matrix->type,pR_matrix->data.fl);
        //eulerAngles = rotationMatrixToEulerAngles(rotation_matrix_tmp, 0);
        //rotation_matrix_tmp = eulerAnglesToRotationMatrix(eulerAngles);
        eulerAngles = rotationMatrixToEulerAngles(rotation_matrix_tmp, 1);//0表示输出为弧度，否则表示输出为角度

对应的python代码如下：

    R = np.zeros((3, 3), dtype=np.float64)
    cv2.Rodrigues(rvecs, R)
    rvecs = np.zeros((1, 1, 3), dtype=np.float64)
    rvecs,_ = cv2.Rodrigues(R, rvecstmp)

相互转换的完整代码

完整的测试C++程序如下：

#include <iostream>
#include <sstream>
#include <time.h>
#include <stdio.h>
#include <fstream>
#include <cmath>

#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/calib3d/calib3d.hpp>
#include <opencv2/highgui/highgui.hpp>

using namespace cv;
using namespace std;

// Calculates rotation matrix given euler angles.
Mat eulerAnglesToRotationMatrix(Vec3f &theta)
{
    // Calculate rotation about x axis
    Mat R_x = (Mat_<double>(3,3) <<
        1,       0,              0,
        0,       cos(theta[0]),   -sin(theta[0]),
        0,       sin(theta[0]),   cos(theta[0])
    );
    // Calculate rotation about y axis
    Mat R_y = (Mat_<double>(3,3) <<
        cos(theta[1]),    0,      sin(theta[1]),
        0,               1,      0,
        -sin(theta[1]),   0,      cos(theta[1])
    );
    // Calculate rotation about z axis
    Mat R_z = (Mat_<double>(3,3) <<
        cos(theta[2]),    -sin(theta[2]),      0,
        sin(theta[2]),    cos(theta[2]),       0,
        0,               0,                  1
    );
    // Combined rotation matrix
    Mat R = R_z * R_y * R_x;
    return R;
}

// Checks if a matrix is a valid rotation matrix.
bool isRotationMatrix(Mat &R)
{
    Mat Rt;
    transpose(R, Rt);
    Mat shouldBeIdentity = Rt * R;
    Mat I = Mat::eye(3,3, shouldBeIdentity.type());
    return  norm(I, shouldBeIdentity) < 1e-6;
}
 
// Calculates rotation matrix to euler angles
// The result is the same as MATLAB except the order
// of the euler angles ( x and z are swapped ).
Vec3f rotationMatrixToEulerAngles(Mat &R)
{
    //assert(isRotationMatrix(R));
    float sy = sqrt(R.at<double>(0,0) * R.at<double>(0,0) +  R.at<double>(1,0) * R.at<double>(1,0) );
    bool singular = sy < 1e-6; // If
    float x, y, z;
    if (!singular)
    {
        x = atan2(R.at<double>(2,1) , R.at<double>(2,2));
        y = atan2(-R.at<double>(2,0), sy);
        z = atan2(R.at<double>(1,0), R.at<double>(0,0));
    }
    else
    {
        x = atan2(-R.at<double>(1,2), R.at<double>(1,1));
        y = atan2(-R.at<double>(2,0), sy);
        z = 0;
    }
    #if 1
    x = x*180.0f/3.141592653589793f;
    y = y*180.0f/3.141592653589793f;
    z = z*180.0f/3.141592653589793f;
    #endif
    return Vec3f(x, y, z);
}

int main()
{
    //Mat rotation_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0)); /* 保存每幅图像的旋转矩阵 */
    Vec3f eulerAngles;
    
    int i;
    //double r_vec[3]={-2.100418,-2.167796,0.273330};[[0.78520514][0.0233998 ][0.00969251
    double r_vec[3]={0.78520514,0.0233998,0.00969251};//eulerAngles[45,1,1]
    double R_matrix[9];
    //CvMat *pr_vec;
    //CvMat *pR_matrix;
    CvMat *pr_vec = cvCreateMat(1,3,CV_64FC1);
    CvMat *pR_matrix = cvCreateMat(3,3,CV_64FC1);
    cvInitMatHeader(pr_vec, 1, 3, CV_64FC1, r_vec, CV_AUTOSTEP);
    cvInitMatHeader(pR_matrix, 3, 3, CV_64FC1, R_matrix, CV_AUTOSTEP);
    cvRodrigues2(pr_vec, pR_matrix, 0);
    Mat rotation_matrix(pR_matrix->rows,pR_matrix->cols,pR_matrix->type,pR_matrix->data.fl);
    eulerAngles = rotationMatrixToEulerAngles(rotation_matrix);
    cout << "pR_matrix = " << endl;
    cout << rotation_matrix << endl;
    cout << "eulerAngles = " << endl;
    cout << eulerAngles << endl;
    
    Mat_<double> r_l = (Mat_<double>(3, 1) << 0.78520514,0.0233998,0.00969251);//左摄像机的旋转向量
    Mat R_L;
    Rodrigues(r_l, R_L);
    eulerAngles = rotationMatrixToEulerAngles(R_L);
    cout << "R_L = " << endl;
    cout << R_L << endl;
    cout << "eulerAngles = " << endl;
    cout << eulerAngles << endl;
    eulerAngles(0) = 90.0;
    eulerAngles(1) = 0.0;
    eulerAngles(2) = 0.0;
    //cvRodrigues2(&pr_vec,&pR_matrix,0);
    return 0;
}

以下makefile用来在linux平台下编译成可执行文件，将它放在makefile的文件中，在终端中输入make即可完成编译：


SOURCE  := $(wildcard ./test_euler.cpp)
#wildcard把指定目录 ./ 下的所有后缀是cpp的文件全部展开。
DIR     := $(notdir $(SOURCE))
#notdir把展开的文件去除掉路径信息
OBJS    := $(patsubst %.cpp,%.o,$(DIR))
#patsubst把$(DIR)中的变量符合后缀是.cpp的全部替换成.o，

# target you can change test to what you want
TARGET  := test
$(CC) = gcc
$(CXX) = g++

#ifeq ($(CC),aarch64-linux-gcc)
#else ifeq ($(findstring arm-poky-linux-gnueabi-gcc,$(CC)), arm-poky-linux-gnueabi-gcc)

LDFLAGS := -L. -L$(SDKTARGETSYSROOT)/usr/lib 
INCLUDE := -I$(SDKTARGETSYSROOT)/usr/include/ -L./lib
LIBS    :=   -lm -lopencv_core -lopencv_highgui \
            -lopencv_imgproc -lopencv_calib3d -lopencv_imgcodecs \
            -lopencv_flann -lopencv_videoio -ljpeg


DEFINES := -Wl,-rpath=./lib

CFLAGS  := -g -Wall $(DEFINES) $(INCLUDE)

CXXFLAGS:= $(CFLAGS)

all : $(TARGET)

$(TARGET) : $(OBJS)
    $(CXX) $(CXXFLAGS) -o $@ $(OBJS) $(LDFLAGS) $(LIBS)
    echo $(CC) $(TARGET) ok

objs : $(OBJS)

rebuild: clean everything

clean :
    rm -rf *.o
    rm -rf $(TARGET)

完整的测试Python程序如下：

#!/usr/bin/env python3
# coding:utf-8

import cv2
import numpy as np
import time
import threading
import os
import re    
import subprocess
import random
import math

# Calculates Rotation Matrix given euler angles.
def eulerAnglesToRotationMatrix(angles1) :
    theta = np.zeros((3, 1), dtype=np.float64)
    theta[0] = angles1[0]*3.141592653589793/180.0
    theta[1] = angles1[1]*3.141592653589793/180.0
    theta[2] = angles1[2]*3.141592653589793/180.0
    R_x = np.array([[1,         0,                  0                   ],
                    [0,         math.cos(theta[0]), -math.sin(theta[0]) ],
                    [0,         math.sin(theta[0]), math.cos(theta[0])  ]
                    ])
    R_y = np.array([[math.cos(theta[1]),    0,      math.sin(theta[1])  ],
                    [0,                     1,      0                   ],
                    [-math.sin(theta[1]),   0,      math.cos(theta[1])  ]
                    ])
    R_z = np.array([[math.cos(theta[2]),    -math.sin(theta[2]),    0],
                    [math.sin(theta[2]),    math.cos(theta[2]),     0],
                    [0,                     0,                      1]
                    ])
    R = np.dot(R_z, np.dot( R_y, R_x ))
    sy = math.sqrt(R[0,0] * R[0,0] +  R[1,0] * R[1,0])
    singular = sy < 1e-6
    if  not singular:
        x = math.atan2(R[2,1] , R[2,2])
        y = math.atan2(-R[2,0], sy)
        z = math.atan2(R[1,0], R[0,0])
    else :
        x = math.atan2(-R[1,2], R[1,1])
        y = math.atan2(-R[2,0], sy)
        z = 0
    #print('dst:', R)
    x = x*180.0/3.141592653589793
    y = y*180.0/3.141592653589793
    z = z*180.0/3.141592653589793
    rvecstmp = np.zeros((1, 1, 3), dtype=np.float64)
    rvecs,_ = cv2.Rodrigues(R, rvecstmp)
    #print()
    return R,rvecs,x,y,z

def rotationMatrixToEulerAngles(rvecs):
    R = np.zeros((3, 3), dtype=np.float64)
    cv2.Rodrigues(rvecs, R)
    sy = math.sqrt(R[2,1] * R[2,1] +  R[2,2] * R[2,2])
    sz = math.sqrt(R[0,0] * R[0,0] +  R[1,0] * R[1,0])
    print('sy=',sy, 'sz=', sz)
    singular = sy < 1e-6
    if  not singular:
        x = math.atan2(R[2,1] , R[2,2])
        y = math.atan2(-R[2,0], sy)
        z = math.atan2(R[1,0], R[0,0])
    else :
        x = math.atan2(-R[1,2], R[1,1])
        y = math.atan2(-R[2,0], sy)
        z = 0
    #print('dst:', R)
    x = x*180.0/3.141592653589793
    y = y*180.0/3.141592653589793
    z = z*180.0/3.141592653589793
    return x,y,z

if __name__=='__main__':
    eulerAngles = np.zeros((3, 1), dtype=np.float64)
    eulerAngles[0] = 15.0
    eulerAngles[1] = 25.0
    eulerAngles[2] = 35.0
    R,rvecstmp,x,y,z = eulerAnglesToRotationMatrix(eulerAngles)
    print('输入欧拉角：\n', eulerAngles)
    print('旋转转矩：\n', R)
    #rvecstmp[0] = -2.100418
    #rvecstmp[1] = -2.167796
    #rvecstmp[2] = 0.273330 0.75467396][-0.00747155][ 0.00896453
    #rvecstmp[0] = 0.75467396
    #rvecstmp[1] = -0.00747155
    #rvecstmp[2] = 0.00896453
    
    print('旋转向量：\n', rvecstmp)
    print('计算后的欧拉角：\n', rotationMatrixToEulerAngles(rvecstmp))

原文： 欧拉角、旋转向量和旋转矩阵的相互转换 - 简书

VirtualCreator
关注
  • 1
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
欧拉角xyz转zyz，旋转矩阵
01-16
欧拉角xyz计算旋转矩阵，再转为欧拉角zyz方式...................................................................................
程序：四元数欧拉角旋转向量旋转矩阵变换transform.cpp
06-26
代码！！！！重要！！！！ 学习中关于机器人领域中四元数、欧拉角、旋转矩阵、旋转向量的相互转换关系总结，整理加深记忆。 每一个都有相互转换关系，并注释
欧拉角与旋转矩阵的转换关系
陋室逢雨
10-16 4万+
欧拉角因为其奇异性，虽然在优化和插值的不会使用，但是当我们对别人描述一个旋转的过程是怎么样的时候，欧拉角还是很有用的，比如，做无人机姿态控制的时候使用的就是欧拉角，但是搞明白欧拉角是怎么回事确实是一件头疼的事，所以就写下了这篇总结，希望对大家理解欧拉角有所帮助 需要区分每次旋转是绕固定轴旋转的，还是绕旋转之后的轴旋转的，如果不特殊指明，下面的讨论都是指：绕旋转之后的轴旋转的。不要局限于表示旋...
四元数和旋转矩阵相互转化的算法实现
11-27
讲述四元数和旋转矩阵之间相互转化的学术论文：首先介绍了四元数和旋转矩阵在实现向量旋转中的应用,在此基础上,根据游戏开发的实际需要,讨论了四元数和旋转矩阵之间的相互转化关系。最后,重点分析了由旋转矩阵到四元数的转换算法,并按照计算机程序设计的特殊要求设计了程序。
vins中旋转矩阵 四元数 转 欧拉角的方法
01-06
1、旋转矩阵或四元数 到 欧拉角的方法. Utility::R2ypr和.eulerAngles(2,1,0)都可以，但是单位不同！ （1）Utility::R2ypr(q_array[i – j].toRotationMatrix())          输出的是：yaw pitch roll 的vector3d向量，单位是度数，（正负180） （2）q_array[i – j].toRotationMatrix().eulerAngles(2,1,0)          输出的是：yaw pitch roll 的vector3d向量，单位是rad，（正负3.14） cout<<仅仅为了
旋转向量（旋转矩阵）与欧拉角
cangqiongxiaoye的博客
02-19 4808
旋转向量（旋转矩阵）与欧拉角，这里相互转换的方法是： 旋转向量-->旋转矩阵-->欧拉角 旋转矩阵-->欧拉角 一、旋转向量-->旋转矩阵-->欧拉角 SO(3)的旋转矩阵有9个量，但是只有3个自由度，同理SE(3)有16个量，但是也只有6个自由度。在实际的旋转中，任意的旋转都可用一个旋转轴和一个旋转角来表示，我们使用一个向量，方向与旋转轴一致，长度等于旋转角，这样只需要一个三维向量即可描述旋转。对于SE(3),用一个旋转向量和一个平移向量即可表达，恰好自由度为6.如果
第三讲，旋转向量和欧拉角
最新发布
kaszxc的博客
08-28 836
​ 三维旋转是一个三维流形，想要无奇异性地表达它，用三个量是不够的。我们用复数集 C 表示复平面上的向量，而复数的乘法则 能表示复平面上的旋转：例如，乘上复数 i 相当于逆时针把一个复向量旋转 90 度。类似 的，在表达三维空间旋转时，也有一种类似于复数的代数：四元数（Quaternion）。​ 欧拉角的一个重大缺点是会碰到著名的万向锁问题：在俯仰角为 ±90◦ 时，第一次旋转与第三次旋转将使用同一个轴，使得系统丢失了一个自由度（由三次 旋转变成了两次旋转）。反之，若它的实部为 0，称之为虚四元数。
【入门】（一）旋转向量与旋转矩阵
qq_28602183的博客
10-27 8751
目录 一、基本概念  二、转换公式 三、应用场景 一、基本概念 旋转向量为三维向量表示形式，用旋转向量表示旋转变换，可以将其方向为旋转轴方向，模为旋转角度。三维空间的旋转变换为绕任意轴r旋转角，可以分解为分别绕X,Y,Z轴旋转角，将绕坐标轴旋转表达为矩阵形式有： 图源：https://blog.csdn.net/hongbin_xu/article/details/7892900...
旋转向量和旋转矩阵的互转换
u013341645的博客
08-29 7882
处理矩阵三维转换时，通常采用旋转矩阵，但是旋转变换其实只有三个自由度，用旋转向量表达时更为简洁。因此，需要实现从旋转向量和旋转矩阵之间的互转换。 旋转向量和旋转矩阵之间可以通过罗德里格斯公式进行转换：将旋转向量转换为旋转矩阵： R=cosθI+(1−cosθ)nnT+sinθn∧{R\bf}=\cos\theta{I\bf}+(1-\cos\theta){n\bf}{n\bf^T}+\sin\t
一、旋转矩阵，旋转向量，单位四元数的相互转换总结
qq_37219127的博客
08-21 2718
本文非常详尽的推导了旋转矩阵，旋转向量，单位四元数的相互转换，并用表格总结了公式。
matlab欧拉角算旋转矩阵代码-RobEx03_FANUC-URDF:机器人课程练习@UniSA
06-17
TF，计算平移向量、旋转矩阵、欧拉角和轴角表示。 通过与手动/MATLAB 计算进行比较来验证结果。 特别是机器人型号为 FANUC M-20iA：请参考以下文档了解更多信息： 第 1 点 导出 Fanuc 机器人的 DH 参数。 DH 参数可...
OpenCV学习笔记（一）——旋转向量与旋转矩阵相互转化
woaixiangrikui的专栏
12-20 4723
从今天开始，把自己学习OpenCV的心得记录下来，以系列的形式贴到博客中，以期交流与备查之用，笔记内容主要偏向于算法的理解。     处理三维旋转问题时，通常采用旋转矩阵的方式来描述。一个向量乘以旋转矩阵等价于向量以某种方式进行旋转。除了采用旋转矩阵描述外，还可以用旋转向量来描述旋转，旋转向量的长度（模）表示绕轴逆时针旋转的角度（弧度）。旋转向量与旋转矩阵可以通过罗德里格斯（Rodrigues）变
从旋转向量到欧拉角的六种计算方法
outbreakrmb的博客
07-30 2328
利用SolvePNP解出旋转向量，旋转向量通过罗德里格斯公式解出旋转矩阵，然后通过下面六种公式计算即可，欧拉角有十二种，六种是相对于自身参考系，六种是相对于惯性参考系，这里是相对于惯性参考系的......
旋转向量与欧拉角 罗德里格斯公式（Rodrigues's Formula）
Bettyshasha的专栏
02-25 5559
旋转向量 旋转矩阵表达方式 旋转矩阵描述旋转，变换矩阵描述一个6自由度的三维刚体运动。但存在如下缺点： SO(3)的旋转矩阵有9个量，但一次旋转只有3个自由度。因此这种表达方式是冗余的。同理，变换矩阵16个量表达了6个自由度的变换，也不够紧凑。 旋转矩阵自身带有约束：它必须是个正交矩阵，且行列式为1。变换矩阵也是如此。当想要估计或优化一个旋转矩阵/变换矩阵时，这些约束会使得求解变得困难。 外...
旋转转换
weixin_41169280的博客
05-12 246
1、旋转向量 #include <vector> #include <Eigen/Core> #include <Eigen/Geometry> #include <opencv2/opencv.hpp> // 1. Eigen 实现 // 旋转向量转旋转矩阵 Eigen::Vector3d rvec (r_x, r_y, r_z); double n_norm = rvec.norm(); Eigen::Angl
欧拉角与旋转矩阵之间的转化公式及原理
热门推荐
loongkingwhat的博客
09-25 4万+
1.背景说明 首先，说明几点需要注意的问题： a.左手坐标系与右手坐标系：既然是在坐标系中进行变换，首先就要了解坐标系的类别。同样的数据在左手坐标系和右手坐标系会有不同的呈现结果。所以，所有涉及到坐标系的问题，不说明基于左手坐标系还是右手坐标系就有可能带着小白走弯路。下面的文章将分别讨论在右手坐标系和左手坐标系下的两套转换。 b.欧拉角顺规：欧拉角定义了一组物体的旋转次序，绕某个轴旋转多少度。很多...
四元数、欧拉角、旋转矩阵、旋转向量之间的转换
泠山的博客
02-09 6198
Eigen 中四元数、欧拉角、旋转矩阵、旋转向量之间的转换
【自动驾驶】欧拉角和旋转矩阵之间的转换
u011754972的博客
01-13 8384
欧拉角和旋转矩阵之间的转换 在使用Eigen时，经常会遇到旋转矩阵，旋转向量，四元数，欧拉角之间的两两相互转换。这里最常见、最容易出错的是欧拉角和旋转矩阵之间的相互转换。下面就欧拉角和旋转矩阵之间的转换进行详细分析。 图1 旋转顺序Z-Y-X，正方向内旋 1. 欧拉角（1）欧拉角的叫法：欧拉角的叫法不固定，跟坐标轴的定义强相关。在图1中，假设X是车头，Y是车左方，Z是车上方，那么绕X轴旋转得到的是roll，绕Y轴旋转得到的是pitch，绕Z轴得到的是yaw。在图1中，假设Y是车
SLAM学习之路（三）--旋转向量与欧拉角
weixin_45617478的博客
03-29 2948
一、旋转向量 发明目的：希望有一种方式可以紧凑地描述旋转和平移，如用一个三维向量表达旋转，用六维向量表达变换。 任意坐标系的旋转，都可以用一个旋转轴和一个旋转角刻画。可以使用一个向量，其方向与旋转轴一致，而长度等于旋转角，这种向量称为旋转向量（或称轴角） ps：旋转向量就是下章要介绍的李代数 旋转向量到旋转矩阵，可以由罗德里格斯公式推导 二、欧拉角 欧拉角，并不是一个角，而是使用三个分离的转角来描...
欧拉角与旋转RT矩阵的相互转换
03-26
欧拉角和旋转RT矩阵是描述物体在空间中旋转的两种方式。在一些应用领域中，需要将欧拉角转换成旋转RT矩阵或者将旋转RT矩阵转换成欧拉角。 下面给出欧拉角和旋转RT矩阵的相互转换方法： 1. 欧拉角转旋转RT矩阵 将欧拉角转换成旋转RT矩阵的方法通常采用以下步骤： (1) 计算绕Z轴旋转的旋转矩阵Rz，绕Y轴旋转的旋转矩阵Ry，绕X轴旋转的旋转矩阵Rx。 (2) 计算旋转矩阵RT = Rz * Ry * Rx。 例如，如果给定欧拉角α、β、γ，则旋转矩阵RT可以计算为： $$ RT = R_z(\gamma)R_y(\beta)R_x(\alpha) $$ 其中，Rz、Ry和Rx分别是绕Z轴、Y轴和X轴旋转的旋转矩阵。 2. 旋转RT矩阵转欧拉角 将旋转RT矩阵转换成欧拉角的方法有多种。以下是其中一种可能的方法： (1) 求出旋转矩阵RT的第三列向量（即旋转后的z轴方向），其模长为cosθ。 (2) 求出第三列向量在xoy平面上的投影，记为V1。 (3) 分别计算绕x轴和z轴的旋转角度α和γ，使得旋转矩阵Rz(Rx(θ)V1)Ry(β)Rz(γ)的第三列向量与RT的第三列向量相同。 (4) 计算β的值：β = arccos(RT[0][2]/cosθ)或β = -arccos(RT[0][2]/cosθ)，取决于sinβ的正负号。 其中RT[0][2]是矩阵RT的第一行第三列元素，cosθ是矩阵RT的第三列向量长度。 总结一下，欧拉角与旋转RT矩阵的相互转换方法是比较复杂的，需要根据具体情况选用适合的方法进行转换。同时，在进行相关计算时，需要注意数值计算的精度问题，以避免误差的积累。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值