旋转矩阵求解欧拉角Python实现

最新推荐文章于 2024-07-30 17:23:09 发布
最新推荐文章于 2024-07-30 17:23:09 发布
阅读量4.3k 收藏 33
点赞数 14
分类专栏： Python 机器人 文章标签： python 矩阵
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DrGene/article/details/121084553
版权

旋转矩阵求解欧拉角Python实现

笔者在外实习过程中，发现公司使用的不同的工业机器人默认欧拉角顺规有所不同，应部门组长要求，写一个输入3*3旋转矩阵，输出12种不同的动系欧拉角与12种不同的静系欧拉角的程序进行验证。
在此记录，希望能够帮助遇到相同问题的同学~

基本知识

绕静系与动系旋转

绕静系旋转：每次旋转，相对第一次旋转之前的初始的坐标系进行旋转；
绕动系旋转：每次旋转，相对上一次旋转之后的得到的坐标系进行旋转。

静系动系与左乘右乘

绕静系进行旋转，新的旋转对应的矩阵乘在旧的旋转矩阵的左边；
绕动系进行旋转，新的旋转对应的矩阵乘在旧的旋转矩阵的右边。

旋转矩阵连乘的两种理解

给定一定的姿态变换，其可由一系列的旋转得到，对应一系列的旋转矩阵连乘。
在得到旋转矩阵连乘公式，例如：Rx(α) * Ry(β) * Rz(γ)，
其有以下两种理解方式：
1.每次绕静系旋转
依次绕 Z 转 γ，绕 Y 转 β，绕 X 转 α。
2.每次绕动系旋转
依次绕 X 转 α，绕 Y 转 β，绕 Z 转 γ。
两种旋转得到的结果等效，即静动转变，顺序相反，角度不变。

文件目录

Root
|__ r2euler_self.py
|__ r2euler_sci.py
|__ RotationMatrix.txt

RotationMatrix.txt文件中保存了一个旋转矩阵

  0.8137977 -0.3839980  0.4362096
  0.4698463  0.8764841 -0.1049763
 -0.3420202  0.2903810  0.8937008

其对应的ZYX动系欧拉角 = xyz静系欧拉角 = pi/6, pi/9, pi/10

实现方式

使用矩阵方程手动求解

笔者的计算方法是：根据动系欧拉角的12种不同顺规对应的旋转矩阵建立矩阵方程，反解动系欧拉角。
其中，考虑到了第二次旋转角度的特殊值的情况，有以下求解12种不同的动系欧拉角的求解程序。
另外，静系欧拉角，根据其与动系欧拉角的对应关系进行求解。

"""
FileName: r2euler_self.py
File to caluculate euler from rotation matrix
Method of using basic matrix equations
Input str in upper -- intrinsic
Input str in lower -- extrinsic
"""


import math
import numpy as np
from scipy.spatial.transform import Rotation as R


def r2euler(R, type):
    R = np.array(R)
    type = str(type).upper()
    err = float(0.001)

    if np.shape(R) != (3,3):
        print("The size of R matrix is wrong")
        sys.exit(0)
    else:
        pass


    if type == "XYZ":
        # R[0,2]/sqrt((R[1,2])**2 + (R[2,2])**2) == sin(beta)/|cos(beta)| 
        # ==> beta (-pi/2, pi/2)
        beta = math.atan2(R[0,2], math.sqrt((R[1,2])**2 + (R[2,2])**2))

        if beta >= math.pi/2-err and beta <= math.pi/2+err:
            beta = math.pi/2
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[1,0], R[1,1])
        elif beta >= -(math.pi/2)-err and beta <= -(math.pi/2)+err:
            beta = -math.pi/2
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[1,0], R[1,1])
        else:
            alpha = math.atan2(-(R[1,2])/(math.cos(beta)),(R[2,2])/(math.cos(beta)))
            gamma = math.atan2(-(R[0,1])/(math.cos(beta)), (R[0,0])/(math.cos(beta)))


    elif type == "XZY":
        # -R[0,1]/sqrt((R[1,1])**2 + (R[2,1])**2) == sin(beta)/|cos(beta)|
        # ==> beta (-pi/2, pi/2)
        beta = math.atan2(-R[0,1], math.sqrt((R[1,1])**2 + (R[2,1])**2))

        if beta >= math.pi/2-err and beta <= math.pi/2+err:
            beta = math.pi/2
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[1,2], R[1,0])
        elif beta >= -(math.pi/2)-err and beta <= -(math.pi/2)+err:
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[1,2], -R[1,0])
        else:
            alpha = math.atan2((R[2,1])/(math.cos(beta)), (R[1,1])/(math.cos(beta)))
            gamma = math.atan2((R[0,2])/(math.cos(beta)), (R[0,0])/(math.cos(beta)))


    elif type == "YXZ":
        # -R[1,2]/sqrt(R[0,2]**2 + R[2,2]**2) == sin(beta)/|cos(beta)|
        # ==> beta (-pi/2, pi/2)
        beta = math.atan2(-R[1,2], math.sqrt((R[0,2])**2 + (R[2,2])**2))

        if beta >= math.pi/2-err and beta <= math.pi/2+err:
            beta = math.pi/2
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,1], R[0,0])
        elif beta >= -(math.pi/2)-err and beta <= -(math.pi/2)+err:
            beta = -math.pi/2
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,1], R[0,0])
        else:
            alpha = math.atan2((R[0,2])/(math.cos(beta)), (R[2,2])/(math.cos(beta)))
            gamma = math.atan2((R[1,0])/(math.cos(beta)), (R[1,1])/(math.cos(beta)))


    elif type == "YZX":
        # R[1,0]/sqrt(R[0,0]**2 + R[2,0]**2) == sin(beta)/|cos(beta)|
        # ==> beta (-pi/2, pi/2)
        beta = math.atan2(R[1,0], math.sqrt((R[0,0])**2 + (R[2,0])**2))

        if beta >= math.pi/2-err and beta <= math.pi/2+err:
            beta = math.pi/2
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,2], -R[0,1])
        elif beta >= -(math.pi/2)-err and beta <= -(math.pi/2)+err:
            beta = -math.pi/2
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,2], R[0,1])
        else:
            alpha = math.atan2(-(R[2,0])/(math.cos(beta)), (R[0,0])/(math.cos(beta)))
            gamma = math.atan2(-(R[1,2])/(math.cos(beta)), (R[1,1])/(math.cos(beta)))


    elif type == "ZXY":
        # R[2,1]/sqrt(R[0,1]**2 + R[1,1]**2) == sin(beta)/|cos(beta)|
        # ==> beta (-pi/2, pi/2)
        beta = math.atan2(R[2,1], math.sqrt((R[0,1])**2 + (R[1,1])**2))

        if beta >= math.pi/2-err and beta <= math.pi/2+err:
            beta = math.pi/2
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,2], R[0,0])
        elif beta >= -(math.pi/2)-err and beta <= -(math.pi/2)+err:
            beta = -math.pi/2
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,2], R[0,0])
        else:
            alpha = math.atan2(-(R[0,1])/(math.cos(beta)), (R[1,1])/(math.cos(beta)))
            gamma = math.atan2(-(R[2,0])/(math.cos(beta)), (R[2,2])/(math.cos(beta)))


    elif type == "ZYX":
        # -R[2,0]/sqrt(R[0,0]**2 + R[1,0]**2) == sin(beta)/|cos(beta)| 
        # ==> beta (-pi/2, pi/2)
        beta = math.atan2(-R[2,0], math.sqrt((R[0,0])**2 + (R[1,0])**2))

        if beta >= math.pi/2-err and beta <= math.pi/2+err:
            beta = math.pi/2
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,1], R[1,2])
        elif beta >= -(math.pi/2)-err and beta <= -(math.pi/2)+err:
            beta = -math.pi/2
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,1], -R[1,2])
        else:
            alpha = math.atan2((R[1,0])/(math.cos(beta)), (R[0,0])/(math.cos(beta)))
            gamma = math.atan2((R[2,1])/(math.cos(beta)), (R[2,2])/(math.cos(beta)))
    

    elif type == "XYX":
        # sqrt(R[0,1]**2 + R[0,2]**2)/R[0,0] == |sin(beta)|/cos(beta)
        # ==> beta (0, pi)
        beta = math.atan2(math.sqrt((R[0,1])**2 + (R[0,2])**2), R[0,0])
        if beta >= 0.0-err and beta <= 0.0+err:
            beta = 0.0
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[1,2], R[1,1])
        elif beta >= math.pi-err and beta <= math.pi+err:
            beta = math.pi
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[1,2], R[1,1])
        else:
            alpha = math.atan2((R[1,0])/(math.sin(beta)), -(R[2,0])/(math.sin(beta)))
            gamma = math.atan2((R[0,1])/(math.sin(beta)), (R[0,2])/(math.sin(beta)))


    elif type == "XZX":
        # sqrt(R[1,0]**2 + R[2,0]**2)/R[0,0] == |sin(beta)|/cos(beta)
        # ==> beta (0, pi)
        beta = math.atan2(math.sqrt((R[1,0])**2 + (R[2,0])**2), R[0,0])
        if beta >= 0.0-err and beta <= 0.0+err:
            beta = 0.0
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[1,2], R[1,1])
        elif beta >= math.pi-err and beta <= math.pi+err:
            beta = math.pi
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[1,2], -R[1,1])
        else:
            alpha = math.atan2((R[2,0])/(math.sin(beta)), (R[1,0])/(math.sin(beta)))
            gamma = math.atan2((R[0,2])/(math.sin(beta)), -(R[0,1])/(math.sin(beta)))


    elif type == "YXY":
        # sqrt(R[0,1]**2 + R[2,1]**2)/R[1,1] == |sin(beta)|/cos(beta)
        # ==> beta(0, pi)
        beta = math.atan2(math.sqrt((R[0,1])**2 + (R[2,1])**2), R[1,1])
        if beta >= 0.0-err and beta <= 0.0+err:
            beta = 0.0
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,2], R[0,0])
        elif beta >= math.pi-err and beta <= math.pi+err:
            beta = math.pi
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,2], R[0,0])
        else:
            alpha = math.atan2((R[0,1])/(math.sin(beta)), (R[2,1])/(math.sin(beta)))
            gamma = math.atan2((R[1,0])/(math.sin(beta)), -(R[1,2])/(math.sin(beta)))


    elif type == "YZY":
        # sqrt(R[0,1]**2 + R[2,1]**2)/R[1,1] == |sin(beta)|/cos(beta)
        # ==> beta(0, pi)
        beta = math.atan2(math.sqrt((R[0,1])**2 + (R[2,1])**2), R[1,1])
        if beta >= 0.0-err and beta <= 0.0+err:
            beta = 0.0
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,2], R[0,0])
        elif beta >= math.pi-err and beta <= math.pi+err:
            beta = math.pi
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,2], -R[0,0])
        else:
            alpha = math.atan2((R[2,1])/(math.sin(beta)), -(R[0,1])/(math.sin(beta)))
            gamma = math.atan2((R[1,2])/(math.sin(beta)), (R[1,0])/(math.sin(beta)))


    elif type == "ZXZ":
        # sqrt(R[0,2]**2 + R[1,2]**2)/R[2,2] == |sin(beta)|/cos(beta)
        # ==> beta(0, pi)
        beta = math.atan2(math.sqrt((R[0,2])**2 + (R[1,2])**2), R[2,2])
        if beta >= 0.0-err and beta <= 0.0+err:
            beta = 0.0
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,1], R[0,0])
        elif beta >= math.pi-err and beta <= math.pi+err:
            beta = math.pi
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,1], R[0,0])
        else:
            alpha = math.atan2((R[0,2])/(math.sin(beta)), -(R[1,2])/(math.sin(beta)))
            gamma = math.atan2((R[2,0])/(math.sin(beta)), (R[2,1])/(math.sin(beta)))


    elif type == "ZYZ":
        # sqrt(R[0,2]**2 + R[1,2]**2)/R[2,2] == |sin(beta)|/cos(beta)
        # ==> beta(0, pi)
        beta = math.atan2(math.sqrt((R[0,2])**2 + (R[1,2])**2), R[2,2])
        if beta >= 0.0-err and beta <= 0.0+err:
            beta = 0.0
            # alpha + gamma is fixed
            alpha = 0.0
            gamma = math.atan2(-R[0,1], R[0,0])
        elif beta >= math.pi+err and beta <= math.pi+err:
            beta = math.pi
            # alpha - gamma is fixed
            alpha = 0.0
            gamma = math.atan2(R[0,1], -R[0,0])
        else:
            alpha = math.atan2((R[1,2])/(math.sin(beta)), (R[0,2])/(math.sin(beta)))
            gamma = math.atan2((R[2,1])/(math.sin(beta)), -(R[2,0])/(math.sin(beta)))

    return alpha, beta, gamma


if __name__ == "__main__":
    RM = np.loadtxt ('RotationMatrix.txt')
    print("Upper -- intrinsic\nLower -- extrinsic")

    euler_type = str(input("Please input the type of euler angle...\n"))

    if euler_type.isupper():
        angle_0, angle_1, angle_2 = r2euler(RM, euler_type)
        print("Intrinsic")
        print("Angle about {} is {}".format(euler_type[0], angle_0))
        print("Angle about {} is {}".format(euler_type[1], angle_1))
        print("Angle about {} is {}".format(euler_type[2], angle_2))
    elif euler_type.islower():
        angle_0, angle_1, angle_2 = r2euler(RM, euler_type.upper()[::-1])[::-1]
        print("extrinsic")
        print("Angle about {} is {}".format(euler_type[0], angle_0))
        print("Angle about {} is {}".format(euler_type[1], angle_1))
        print("Angle about {} is {}".format(euler_type[2], angle_2))
    else:
        pass

通过实际计算，能够找到大致的规律：

  1. 第二次旋转角度有重要的影响：
    对于ABC型的欧拉角旋转方式：
    第二次旋转角度为theta_B2 = ±pi/2时，会导致第一、三次旋转同向或反向，即theta_A1 ± thetaC_3 = 定值，具体需要根据右手定则判断。

    对于ABA型的欧拉角旋转方式：
    第二次旋转角度为theta_B2 = 0时，导致第一、三次旋转同向，theta_A1 + thetaA_3 = 定值
    第二次旋转角度为theta_B2 = pi时，导致第一、三次旋转反向，theta_A1 - thetaA_3 = 定值

  2. 计算思路为：
    先计算第二次旋转角度theta_2：
    (1) 找到theta_2的正弦/余弦
    (2) theta_2与其余一角的两个方程，求平方和，开方得到余弦/正弦的绝对值）
    (3) 使用四象限反正切函数 atan2(y,x)求解theta_2的值，其中绝对值对应了取值范围
    (4) 判断theta_2是否是特殊值，若是，其余两角和/差为定值，令一者为0，求解。
    (5) 若不是特殊值，使用其余角与theta_2正弦/余弦的乘积的矩阵元素进行求解，分别得到其余角的正弦/余弦。
    (6) 使用四象限反正切函数 atan2(y,x)求解其余角的值。

SCIPY库求解

scipy库中具有旋转矩阵相关的强大库函数，使用很方便！
动系欧拉角、静系欧拉角、四元数等等都可以求
比在学校的时候用Matlab手写好太多了[手动苦涩]

scipy求解旋转矩阵相关模块参考文档

其中，需要注意输入参数euler_type的大写与小写。
大写表示绕动系（内旋、intrinsic rotations），矩阵右乘；
小写表示绕静系（外旋、extrinsic rotations），矩阵左乘。

"""
FileName: r2euler_sci.py
File to caluculate euler from rotation matrix
Method of using package scipy
"""

import numpy as np
from scipy.spatial.transform import Rotation as R


if __name__ == "__main__":
    RM = np.loadtxt ('RotationMatrix.txt')
    euler_type = str(input("Please input the type of euler angle...\n"))
    
    sciangle_0, sciangle_1, sciangle_2 = R.from_matrix(RM).as_euler(euler_type)
    # Upper word means a rotate about self coordinate (intrinsic rotations)
    # Lower word means a rotate about world coordinate (extrinsic rotations)

    print("Angle about {} is {}".format(euler_type[0], sciangle_0))
    print("Angle about {} is {}".format(euler_type[1], sciangle_1))
    print("Angle about {} is {}".format(euler_type[2], sciangle_2))

在线计算网站

如果只需要临时进行少量的数值计算，使用界面的网站更加直观~
3D Rotation Converter

总结

以上是笔者在求解欧拉角的实现方法，希望能对各位同学有所帮助。
请路过的大佬多多指点~

爬虫虫爬虫虫爬爬爬
关注
  • 14
    点赞
  • 踩
  • 33
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python 欧拉角、四元数、旋转矩阵的相互转换
点云侠的博客
07-25 4422
欧拉角、四元数、旋转矩阵的相互转换python实现
机械臂正运动学程序，两种实现方式，robotics工具箱和转换矩阵
07-09
这个过程涉及到了欧拉角、四元数、旋转矩阵和向量的运算。例如，可以先计算每个关节的旋转矩阵，然后通过矩阵乘法连接它们，最后得到末端执行器的位置和姿态。 接下来，我们讨论Robotics Toolbox的实现。Robotics ...
python实现四元数、欧拉角、旋转矩阵、旋转向量的相互转换
热门推荐
cg1135217680的博客
04-12 1万+
python实现四元数、欧拉角、旋转矩阵、旋转向量的相互转换
欧拉角与旋转矩阵之间的相互转化（推导和Python代码）
Shen Mu Xin's Blog
05-16 749
表示三维空间中的旋转可以有多种表示的方法（旋转矩阵，欧拉角，四元素，轴角，李群李代数）。欧拉角表示法，分别是指定了三个角度yaw，roll，pitch，分别是绕z轴，x轴，y轴的转动的角度。
旋转矩阵和欧拉角
lyyiangang的博客
12-14 6555
参考Computing Euler angles from a rotation matrix 旋转矩阵转换为欧拉角参考代码 #Ref: https://www.learnopencv.com/rotation-matrix-to-euler-angles/ def isRotationMatrix(R): ''' checks if a matrix is a valid rotation matrix(whether orthogonal or not) ''' Rt = n.
根据相机旋转矩阵求解三个轴的旋转角/欧拉角/姿态角 或 旋转矩阵与欧拉角（Euler Angles）之间的相互转换，以及python和C++代码实现
求真、务实
04-21 9986
根据相机旋转矩阵求解三个轴的旋转角/欧拉角/姿态角 或 旋转矩阵与欧拉角（Euler Angles）之间的相互转换，以及python和C++代码实现1 旋转矩阵转换为欧拉角（Euler Angles）2 欧拉角转换为旋转矩阵 相机标定过程中，我们会得到一个3x3的旋转矩阵，下面是我们把旋转矩阵与欧拉角之间的相互转换： 1 旋转矩阵转换为欧拉角（Euler Angles） 1、旋转矩阵是一个3x3的矩阵，如下： R=(r11r12r13r21r22r23r31r32r33) R=\left(\begin{a
旋转矩阵的几种python函数实现方法
weixin_55477961的博客
09-19 1431
1、旋转矩阵定义——欧拉角可以看出x-y-z内旋等价于z-y-x外旋。参考这个函数很好用，支持很多旋转表达形式（欧拉角，旋转向量，旋转矩阵，修正的Rodrigues参数，四元数）之间的转换，用的比较多的欧拉角和旋转矩阵之间的转换，但也踩了 一些坑。这里 'xyz' 表示旋转轴的顺序，，例如：R.from_euler('xyz', euler, degrees=True)，它等价于 rx = euler[0]，ry = euler[1]，rz = euler[2]，R = Rz*Ry*Rx；
旋转矩阵与欧拉角互转
reason的博客
06-06 1万+
参考：https://www.learnopencv.com/rotation-matrix-to-euler-angles/ 一般用Z-Y-X欧拉角，它对应于yaw偏航，pitch俯仰和roll滚转。 欧拉角 -> 旋转矩阵 C++代码： // Calculates rotation matrix given euler angles. Mat eulerAngles...
从旋转矩阵到欧拉角
大橙子的博客
05-10 6643
摄影测量中，R转角系统一般是以y轴为主轴，但是在很多代码中，发现R的定义很多，据自己需求。 工业标准中一般采用Z-X-Y转角系统，先绕x旋转，再绕y,最后是Z。即如下所示。 这是一位外国小哥从solvepnp求得的R来分解欧拉角，和上图求欧拉角方式一样，只是roll,pitch,yaw多了负号 _, rVec, tVec = cv2.solvePnP(objectPoints, ...
Python - 欧拉角 - 四元素 - 旋转矩阵
西瓜柚子先生的博客
12-19 5485
Python 计算欧拉角，四元素，旋转矩阵之间的转换 欧拉角(roll, pitch, yaw) 滚转角Φ（roll）：围绕X轴旋转的角度 俯仰角θ（pitch）：围绕Y轴旋转的角度 偏航角ψ（yaw）：围绕Z轴旋转的角度 描述物体在参考坐标系下的姿态，物体绕参考坐标系三个坐标轴(x, y, z轴）的旋转角度。 四元数(q0, q1, q2, q3) q=q0 + q1 * i + q2 * j + q3 * k 描述物体在参考坐标系下的姿态，等效为物体绕某一转轴旋转一定的角度。 其中 q0, q1, q2
车辆姿态表达：旋转矩阵、欧拉角、四元数的转换以及eigen、matlab、pathon方法实现
阿川_LiDAR的博客
09-04 3446
旋转矩阵、欧拉角、四元数主要用于表示坐标系中的旋转关系，通过三者之间的转换可以减小一些算法的复杂度。 本文主要概述旋转矩阵、欧拉角、四元数的基本理论、三者之间的转换关系以及三者转换在eigen、matlab和pathon上的方法实现。对于两个三维点p1、p2： p1(x1,y1,z1),p2(x2,y2,z2) p_1\left(x_1, y_1, z_1\right),p_2\left(x_2, y_2, z_2\right) p1​(x1​,y1​,z1​),p2​(x2​,y2​,z2​) 由点p1经
计算puma560机器人的正运动学和逆运动学-python-源码
10-02
在Python中实现正运动学，我们需要定义每个关节的旋转中心、连杆长度以及连杆之间的关系。然后，可以使用一系列矩阵运算（如旋转和平移矩阵）来转换这些关节角度为笛卡尔坐标。这通常涉及使用numpy库进行线性代数...
Python库 | scikit_kinematics-0.8.6-py2.py3-none-any.whl
02-19
6. **旋转表示**：`scikit_kinematics`支持多种旋转表示，如欧拉角、四元数和旋转矩阵，方便用户根据需求选择合适的方式进行操作。 **二、与其他库的关联** `scikit_kinematics`虽然与著名的机器学习库`scikit-...
pepperInverseKinematics:胡椒机器人的逆运动学计算
04-12
本主题主要围绕胡椒机器人逆运动学的Python实现进行详细探讨。 首先，了解逆运动学的基本概念。逆运动学是机器人学中的一个分支，其目标是从笛卡尔坐标系（XYZ空间）中的一个点找到机器人关节空间的一组解，这些解...
matlab资源 使用动画演示在Python中实现的双连杆机械臂（2自由度）的简单控制 仅供学习参考用代码.zip
10-18
7. **Python编程**：利用numpy进行矩阵运算，pandas处理数据，以及可能的scipy库进行数值求解，这些都是实现上述功能的基础。 8. **实时更新与仿真**：通过循环结构，不断更新关节角度和计算新的位置，实现机械臂的...
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 970
详细解说数据分析pandas库中的常用方法
【Python】pandas：排序、重复值、缺省值处理、合并、分组
最新发布
yannan20190313的博客
07-30 474
【Python】pandas：排序（sort_index,sort_values）、重复值（duplicated,drop_duplicates,value_counts,nunique）、缺省值处理（isna,isnull,notna,notnull,fillna,dropna,replace）、合并（join,merge,append,concat）、分组（groupby）
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1064
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
旋转矩阵转欧拉角python代码
05-11
以下是将旋转矩阵转换为欧拉角的Python代码： ```python import math import numpy as np def rotation_matrix_to_euler_angles(R): """ 将旋转矩阵转换为欧拉角（yaw，pitch，roll）。 输入：旋转矩阵 R（3x3...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值