Python+OpenCV实战:手把手教你实现机械臂与相机的坐标转换(眼在手上)

在工业自动化、机器人抓取和精密装配领域,让机械臂“看见”并准确理解视觉信息,是实现智能化操作的核心。想象一下,你通过相机识别到一个零件的位置,但机械臂却抓了个空——这往往不是机械臂的精度问题,而是“眼睛”(相机)和“手”(机械臂末端)之间的坐标系没有对齐。这就是手眼标定要解决的根本问题。对于“眼在手上”这种将相机固定在机械臂末端的配置,其优势在于视野随机械臂移动,灵活性高,但坐标转换的数学关系也更为直接和关键。

本文面向的是正在或即将在项目中集成视觉引导功能的工业自动化开发者、机器人工程师以及相关领域的研究者。如果你曾为如何将相机识别到的三维坐标,精准转换为机械臂基坐标系下的可执行坐标而困扰,那么接下来的内容将为你提供一套清晰、可落地的Python+OpenCV解决方案。我们将绕过复杂的理论推导,聚焦于代码实现和工程实践,从坐标系定义、标定数据采集,到最终的坐标转换与验证,一步步构建完整的流程。

1. 坐标系迷局:理解“眼在手上”的坐标链

在开始写代码之前,我们必须先厘清整个系统中涉及的几个核心坐标系,以及它们之间的转换关系。这是所有后续操作的基石。

在一个典型的“眼在手上”系统中,我们主要关心四个坐标系:

  • 相机坐标系 {C}:以相机光学中心为原点,Z轴沿光轴向前,X轴向右,Y轴向下。这是相机“看到”的世界的直接描述。
  • 机械臂末端坐标系 {E}:通常定义在机械臂末端法兰盘的中心。机械臂控制器给出的位置和姿态,通常是该坐标系相对于基坐标系的值。
  • 机械臂基坐标系 {B}:固定在机械臂底座,是整个机械臂运动的参考原点。
  • 标定板坐标系 {M}(或目标物体坐标系):在标定阶段,我们使用一个已知图案(如棋盘格)的标定板。其坐标系定义在标定板的某个角点上。

“眼在手上”手眼标定的目标,就是求解相机坐标系 {C} 到机械臂末端坐标系 {E} 的固定变换关系,我们称之为 手眼矩阵 X。一旦得到 X,对于任何在相机坐标系下观测到的点 P_c,我们都能通过两次变换将其转换到机械臂基坐标系 {B}:

  1. {C} → {E}:利用手眼矩阵 X,将点转换到末端坐标系:P_e = X · P_c。
  2. {E} → {B}:利用机械臂控制器实时反馈的末端位姿(即 {E} 相对于 {B} 的变换矩阵 T_be),将点转换到基坐标系:P_b = T_be · P_e。

整个坐标转换链可以清晰地表示为:P_b = T_be · X · P_c。

提示:这里的变换矩阵都是4x4的齐次变换矩阵,它同时包含了旋转(3x3矩阵R)和平移(3x1向量t)信息,形式为 [[R, t], [0, 0, 0, 1]]。使用齐次坐标是为了方便用统一的矩阵乘法表示旋转和平移。

为了求解手眼矩阵 X,我们需要借助一个中间桥梁——标定板。通过让机械臂带着相机移动到多个不同的位姿,拍摄静止的标定板,我们可以建立一组经典的 AX = XB 方程。其中:

  • A:表示机械臂末端在两个不同位姿间的相对运动变换(从 {E_i} 到 {E_j}),可以从机械臂控制器读取。
  • B:表示相机在两个不同位姿下观测到的标定板的相对运动变换(从 {M_i} 到 {M_j}),可以通过相机标定和图像识别算法计算得出。
  • X:就是我们要求解的手眼矩阵(从 {C} 到 {E})。

通过收集多组(通常>10组)A和B,我们就可以求解出唯一的X。OpenCV的 cv2.calibrateHandEye 函数封装了求解AX=XB的算法(如Tsai-Lenz方法),这正是我们实现自动标定的利器。

2. 实战准备:环境搭建与数据采集

理论清晰后,我们进入实战环节。首先,确保你的开发环境已经就绪。

2.1 安装必要的Python库

我们将主要依赖 numpy 进行矩阵运算,opencv-python 进行图像处理和手眼标定计算。建议使用虚拟环境进行管理。

# 创建并激活虚拟环境(可选)
python -m venv handeye_env
source handeye_env/bin/activate  # Linux/Mac
# handeye_env\Scripts\activate  # Windows

# 安装核心库
pip install numpy opencv-python opencv-contrib-python

如果你的机械臂提供Python SDK(如UR、Franka、Dobot等),也需要一并安装。这里我们假设你已通过某种方式(如Socket、ROS或厂商SDK)能够获取机械臂末端的位姿。

2.2 设计标定数据采集流程

可靠的数据是成功标定的前提。以下是数据采集的关键步骤:

  1. 固定标定板:将棋盘格标定板(例如9x6的内角点)放置在一个平整、稳固且光照良好的位置。确保它在机械臂整个运动范围内都能被相机清晰拍摄到。
  2. 规划机械臂位姿:规划10-20个不同的机械臂末端位姿。这些位姿应满足:
    • 姿态多样性:末端姿态(旋转)应有显著变化,避免所有姿态过于相似。
    • 平移覆盖:在相机视野内,末端位置也应有所变化。
    • 标定板可见:在每个位姿下,标定板必须完整出现在相机视野中,且图像清晰不模糊。
  3. 同步采集数据:对于每一个规划好的位姿 i:
    • 控制机械臂精确运动到该位姿。
    • 从机械臂控制器读取末端执行器在基坐标系下的位姿 T_be_i(一个4x4齐次变换矩阵,或能转换为该矩阵的位置和欧拉角/四元数)。
    • 触发相机拍摄一张包含完整标定板的图像 img_i。
    • 关键点:必须确保读取的位姿与拍摄的图像是严格对应的。任何延迟或错位都会引入误差。

为了便于后续处理,建议将每次采集的数据(图像和对应的位姿)保存下来。我们可以定义一个简单的数据结构来组织一次采集的数据点:

import numpy as np
import json

class CalibrationDataPoint:
    def __init__(self, pose_id, image_path, T_base_end):
        """
        初始化一个标定数据点。
        :param pose_id: 位姿ID
        :param image_path: 保存的图像文件路径
        :param T_base_end: 4x4 numpy数组,机械臂末端在基坐标系下的齐次变换矩阵
        """
        self.pose_id = pose_id
        self.image_path = image_path
        self.T_base_end = T_base_end  # 从基座{B}到末端{E}的变换
        # 后续会计算并存储相机外参
        self.rvec = None  # 旋转向量 (标定板到相机)
        self.tvec = None  # 平移向量 (标定板到相机)

# 示例:创建一个数据点列表并保存
data_points = []
# ... 在循环采集过程中 ...
# T_be = 从机械臂获取的4x4矩阵
# image = 拍摄的图像
# cv2.imwrite(f'calib_img_{i}.png', image)
# dp = CalibrationDataPoint(i, f'calib_img_{i}.png', T_be)
# data_points.append(dp)

# 保存数据点到JSON文件(注意:numpy数组需要特殊处理)
def save_data_points(data_points, filename='calibration_data.json'):
    data_to_save = []
    for dp in data_points:
        data_to_save.append({
            'pose_id': dp.pose_id,
            'image_path': dp.image_path,
            'T_base_end': dp.T_base_end.tolist()  # 转换为列表
        })
    with open(filename, 'w') as f:
        json.dump(data_to_save, f, indent=4)

3. 核心算法实现:从图像到位姿,再到手眼矩阵

数据采集完成后,我们就可以进入核心的计算环节。这个过程分为三步:计算每个图像中标定板相对于相机的位姿(B),计算机械臂末端相对运动的位姿(A),最后调用OpenCV求解X。

3.1 计算相机相对于标定板的位姿(B)

这一步利用相机内参和已知的标定板物理尺寸,通过PnP(Perspective-n-Point)算法求解。

首先,你需要进行相机内参标定,获得相机矩阵和畸变系数。假设你已经通过OpenCV的 cv2.calibrateCamera 完成了内参标定,并得到了以下参数:

# 示例:相机内参和畸变系数 (需要替换为你自己相机的实际值)
camera_matrix = np.array([[fx, 0,  cx],
                           [0,  fy, cy],
                           [0,  0,  1]], dtype=np.float32)
dist_coeffs = np.array([k1, k2, p1, p2, k3], dtype=np.float32)  # 径向和切向畸变

接着,我们为每个采集的图像计算标定板位姿:

import cv2
import glob

def compute_board_poses(data_points, camera_matrix, dist_coeffs, pattern_size=(9, 6), square_size=0.025):
    """
    为所有数据点计算标定板到相机的变换 (B_i)。
    :param data_points: CalibrationDataPoint 对象列表
    :param camera_matrix: 3x3相机内参矩阵
    :param dist_coeffs: 畸变系数向量
    :param pattern_size: 标定板内角点网格尺寸 (width, height)
    :param square_size: 标定板方格的实际物理尺寸 (米)
    :return: 更新了rvec和tvec的data_points列表
    """
    # 准备标定板在世界坐标系(假设Z=0)中的3D角点坐标
    objp = np.zeros((pattern_size[0] * pattern_size[1], 3), np.float32)
    objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2)
    objp *= square_size  # 乘以实际尺寸

    for dp in data_points:
        img = cv2.imread(dp.image_path)
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

        # 查找棋盘格角点
        ret, corners = cv2.findChessboardCorners(gray, pattern_size, None)

        if ret:
            # 亚像素级角点精确化
            criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
            corners_refined = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)

            # 使用solvePnP计算旋转向量(rvec)和平移向量(tvec)
            # 这得到了从标定板坐标系{M}到相机坐标系{C}的变换:T_cam_marker
            ret_val, rvec, tvec = cv2.solvePnP(objp, corners_refined, camera_matrix, dist_coeffs)

            if ret_val:
                dp.rvec = rvec
                dp.tvec = tvec
                print(f"Pose {dp.pose_id}: 成功检测到角点并计算位姿。")
            else:
                print(f"警告: Pose {dp.pose_id}: solvePnP 失败。")
        else:
            print(f"错误: Pose {dp.pose_id}: 未找到棋盘格角点!图像路径: {dp.image_path}")
    return data_points

函数 cv2.solvePnP 返回的 rvec 和 tvec 构成了从标定板坐标系 {M} 到相机坐标系 {C} 的变换 T_cm。注意,在AX=XB方程中,我们需要的B是相机在两个位姿间观察到的标定板的相对运动,即 B = T_cm_j^{-1} * T_cm_i。我们将在下一步统一计算。

3.2 构建A和B矩阵,并求解手眼矩阵X

现在,我们有了每个位姿下:

  • A_i:机械臂末端在基坐标系下的位姿 T_be_i(从数据点读取)。
  • B_i:标定板在相机坐标系下的位姿 T_cm_i(由 rvec_i, tvec_i 转换而来)。

我们需要计算相对运动。对于每一对位姿 (i, j),其中 j = i+1:

  • A_ij = T_be_j^{-1} * T_be_i。这表示从位姿i到位姿j,末端坐标系{E}的相对运动。
  • B_ij = T_cm_j^{-1} * T_cm_i。这表示从位姿i到位姿j,相机观察到的标定板坐标系的相对运动。由于标定板固定不动,这个运动实际上反映了相机自身的运动。

根据AX=XB理论,对于每一对有效的位姿,都有 A_ij * X = X * B_ij。我们将所有配对得到的A_ij和B_ij收集起来,送入OpenCV求解。

def compute_hand_eye_matrix(data_points):
    """
    计算手眼矩阵 X (从相机{C}到机械臂末端{E}的变换)。
    :param data_points: 已计算rvec, tvec的CalibrationDataPoint对象列表
    :return: 4x4手眼矩阵 X
    """
    # 用于存储A_ij和B_ij的列表
    R_gripper2base = []
    t_gripper2base = []
    R_target2cam = []
    t_target2cam = []

    # 首先,将所有位姿的变换矩阵计算并存储起来,避免重复计算
    T_base_end_list = [dp.T_base_end for dp in data_points]  # A_i
    T_cam_marker_list = []
    for dp in data_points:
        if dp.rvec is not None and dp.tvec is not None:
            R_cm, _ = cv2.Rodrigues(dp.rvec)  # 旋转向量转旋转矩阵
            T_cm = np.eye(4)
            T_cm[:3, :3] = R_cm
            T_cm[:3, 3] = dp.tvec.flatten()
            T_cam_marker_list.append(T_cm)  # B_i
        else:
            # 如果某个位姿没有有效数据,则跳过该位姿的所有配对
            T_cam_marker_list.append(None)

    n = len(data_points)
    valid_pairs = 0
    for i in range(n):
        if T_cam_marker_list[i] is None:
            continue
        for j in range(i+1, n):  # 与后续所有位姿配对
            if T_cam_marker_list[j] is None:
                continue

            # 计算相对运动 A_ij = T_be_j^{-1} * T_be_i
            T_be_i = T_base_end_list[i]
            T_be_j = T_base_end_list[j]
            # 注意:我们存储的是 T_base_end,即{B}->{E}。
            # 相对运动是 {E_i} -> {E_j},即 T_ei_ej = T_be_j^{-1} * T_be_i
            T_ei_ej = np.linalg.inv(T_be_j) @ T_be_i
            R_A = T_ei_ej[:3, :3]
            t_A = T_ei_ej[:3, 3]

            # 计算相对运动 B_ij = T_cm_j^{-1} * T_cm_i
            T_cm_i = T_cam_marker_list[i]
            T_cm_j = T_cam_marker_list[j]
            T_ci_cj = np.linalg.inv(T_cm_j) @ T_cm_i  # {C_i} -> {C_j}
            R_B = T_ci_cj[:3, :3]
            t_B = T_ci_cj[:3, 3]

            R_gripper2base.append(R_A)
            t_gripper2base.append(t_A)
            R_target2cam.append(R_B)
            t_target2cam.append(t_B)
            valid_pairs += 1

    print(f"共使用 {valid_pairs} 对有效位姿进行标定。")

    if valid_pairs < 2:
        raise ValueError("有效位姿对数量不足,无法进行手眼标定。至少需要2对。")

    # 调用OpenCV的calibrateHandEye函数求解X
    # 注意函数参数命名:gripper2base 是机械臂末端的运动 (A), target2cam 是相机观察到的运动 (B)
    R_cam2gripper, t_cam2gripper = cv2.calibrateHandEye(
        R_gripper2base, t_gripper2base,
        R_target2cam, t_target2cam,
        method=cv2.CALIB_HAND_EYE_TSAI  # 也可尝试 CALIB_HAND_EYE_PARK, CALIB_HAND_EYE_HORAUD 等
    )

    # 构建4x4齐次变换矩阵 X (从相机{C}到末端{E})
    X = np.eye(4)
    X[:3, :3] = R_cam2gripper
    X[:3, 3] = t_cam2gripper.flatten()

    return X

cv2.calibrateHandEye 函数是OpenCV中实现手眼标定的核心。它接受多组旋转矩阵和平移向量列表,并返回从相机到机械臂末端的旋转矩阵和平移向量。我们提供了几种求解方法,CALIB_HAND_EYE_TSAI 是其中经典且稳定的一种。

3.3 坐标转换函数的实现

得到手眼矩阵 X 后,我们就可以编写将相机坐标系下的点转换到机械臂基坐标系的函数了。这需要结合实时获取的机械臂末端位姿 T_be。

def transform_camera_to_base(point_camera, hand_eye_matrix, T_base_end):
    """
    将相机坐标系下的点转换到机械臂基坐标系。
    :param point_camera: 3x1 numpy数组,相机坐标系下的点 [x, y, z]
    :param hand_eye_matrix: 4x4 numpy数组,手眼矩阵 X (相机->末端)
    :param T_base_end: 4x4 numpy数组,当前末端在基坐标系下的位姿 (基座->末端)
    :return: 3x1 numpy数组,基坐标系下的点 [x, y, z]
    """
    # 1. 将点转换为齐次坐标
    point_cam_hom = np.append(point_camera, 1.0)

    # 2. 转换到机械臂末端坐标系: P_end = X * P_cam
    point_end_hom = hand_eye_matrix @ point_cam_hom
    point_end = point_end_hom[:3]  # 取前三个元素,得到非齐次坐标

    # 3. 转换到机械臂基坐标系: P_base = T_base_end * P_end
    # 注意:T_base_end 是将末端坐标系的点转换到基坐标系的矩阵
    point_end_hom_for_base = np.append(point_end, 1.0)
    point_base_hom = T_base_end @ point_end_hom_for_base
    point_base = point_base_hom[:3]

    return point_base

# 示例用法
if __name__ == "__main__":
    # 假设我们通过前面的标定得到了手眼矩阵X
    X = np.array([[ 0.707, -0.707,  0.001,  0.050],
                  [ 0.707,  0.707,  0.002, -0.020],
                  [-0.002,  0.001,  1.000,  0.100],
                  [ 0.000,  0.000,  0.000,  1.000]])

    # 假设当前机械臂末端位姿 (从控制器读取)
    T_be_current = np.array([[ 0.866, -0.500,  0.000,  0.500],
                             [ 0.500,  0.866,  0.000,  0.200],
                             [ 0.000,  0.000,  1.000,  0.300],
                             [ 0.000,  0.000,  0.000,  1.000]])

    # 相机识别到的某个目标点的坐标 (单位: 米)
    point_in_camera = np.array([0.1, 0.05, 0.8])

    # 转换到基坐标系
    point_in_base = transform_camera_to_base(point_in_camera, X, T_be_current)
    print(f"相机坐标系下的点: {point_in_camera}")
    print(f"转换到基坐标系下的点: {point_in_base}")

4. 精度验证与误差分析

标定完成后,绝不能直接用于生产。必须进行严格的验证,评估标定精度是否满足应用需求。

4.1 重投影误差验证

一种常用的验证方法是重投影误差。我们使用标定得到的手眼矩阵 X 和每个位姿的机械臂位姿 T_be_i,将标定板的3D角点(在世界坐标系中)先转换到相机坐标系,再投影到图像像素坐标系,与图像中实际检测到的角点像素坐标进行比较。

def evaluate_reprojection_error(data_points, hand_eye_matrix, camera_matrix, dist_coeffs, pattern_size=(9,6), square_size=0.025):
    """
    计算并评估手眼标定的重投影误差。
    :return: 平均重投影误差 (像素)
    """
    # 生成标定板3D角点世界坐标
    objp = np.zeros((pattern_size[0] * pattern_size[1], 3), np.float32)
    objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2)
    objp *= square_size

    total_error = 0
    total_points = 0
    errors_per_image = []

    for dp in data_points:
        if dp.rvec is None or dp.tvec is None:
            continue

        # 理论推导:标定板角点在基坐标系下的位置?
        # 实际上,我们通过相机观测和机械臂位姿,可以有两种路径计算角点在图像上的投影:
        # 路径1: 世界角点 -> (通过标定板外参) -> 相机坐标系 -> 投影到像素。这是我们已知的ground truth投影点。
        # 路径2: 世界角点 -> (通过手眼矩阵X和机械臂位姿T_be) -> 基坐标系 -> ??? 这里无法直接投影。
        # 因此,对于“眼在手上”,更直接的验证是“手眼一致性”验证。

        # 我们换一种方式:利用标定结果,计算相机在基坐标系下的位姿,然后反投影。
        # 已知: T_base_end, X (cam->end), T_cam_marker (从solvePnP得到)
        # 可以计算标定板在基坐标系下的位姿: T_base_marker = T_base_end * X * T_cam_marker
        # 然后,用计算出的 T_base_marker 和相机内参,将角点投影到图像,与检测到的角点比较。

        # 计算 T_cam_marker
        R_cm, _ = cv2.Rodrigues(dp.rvec)
        T_cm = np.eye(4)
        T_cm[:3, :3] = R_cm
        T_cm[:3, 3] = dp.tvec.flatten()

        # 计算 T_base_marker_estimated
        T_base_end = dp.T_base_end
        T_base_marker_est = T_base_end @ hand_eye_matrix @ T_cm

        # 从 T_base_marker_est 中提取旋转和平移,用于投影
        rvec_est, _ = cv2.Rodrigues(T_base_marker_est[:3, :3])
        tvec_est = T_base_marker_est[:3, 3]

        # 将世界角点投影到图像
        img_points_projected, _ = cv2.projectPoints(objp, rvec_est, tvec_est, camera_matrix, dist_coeffs)
        img_points_projected = img_points_projected.reshape(-1, 2)

        # 读取该图像实际检测到的角点
        img = cv2.imread(dp.image_path)
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        ret, corners = cv2.findChessboardCorners(gray, pattern_size, None)
        if not ret:
            continue
        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
        corners_refined = cv2.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
        img_points_detected = corners_refined.reshape(-1, 2)

        # 计算该图像的重投影误差
        error = np.linalg.norm(img_points_projected - img_points_detected, axis=1).mean()
        errors_per_image.append(error)
        total_error += error * len(objp)
        total_points += len(objp)

        # 可选:可视化投影点与检测点
        # img_display = cv2.drawChessboardCorners(img.copy(), pattern_size, corners_refined, ret)
        # for i, (proj, det) in enumerate(zip(img_points_projected, img_points_detected)):
        #     cv2.circle(img_display, tuple(proj.astype(int)), 3, (0, 255, 0), -1) # 绿色:投影点
        #     cv2.circle(img_display, tuple(det.astype(int)), 5, (0, 0, 255), 1)   # 红色圈:检测点
        # cv2.imshow(f'Reprojection Check Pose {dp.pose_id}', img_display)
        # cv2.waitKey(300)
        # cv2.destroyAllWindows()

    mean_error = total_error / total_points if total_points > 0 else float('inf')
    print(f"平均重投影误差: {mean_error:.4f} 像素")
    print(f"各图像误差: {errors_per_image}")
    return mean_error, errors_per_image

理想情况下,平均重投影误差应小于1个像素。如果误差较大(例如>2像素),可能需要检查标定板角点检测精度、机械臂位姿读数准确性、或者增加标定位姿的多样性。

4.2 实际抓取测试

最直接的验证是在真实场景中进行抓取测试。选择一个已知尺寸的物体,用相机识别其中心点坐标,利用标定结果转换到基坐标系,然后控制机械臂移动到该点上方进行抓取。观察抓取的成功率和位置偏差。

影响标定精度的关键因素:

  • 机械臂绝对定位精度:这是误差的主要来源之一。确保机械臂经过良好的零点标定和DH参数校准。
  • 相机内参标定精度:使用高精度标定板和足够多的图像进行相机内参标定。
  • 标定板角点检测精度:使用 cv2.cornerSubPix 进行亚像素级优化,并确保标定板图像清晰、光照均匀。
  • 数据采集的位姿多样性:位姿变化要足够大,覆盖相机视野的不同区域和不同的末端姿态,以提供充分的约束。
  • 数据量:通常需要15-20组以上的有效数据对。
  • 机械臂与相机的刚性连接:确保在标定和运行过程中,相机相对于末端没有发生移动或振动。

4.3 常见问题与调试技巧

在实际操作中,你可能会遇到以下问题:

  • 标定结果不稳定,每次运行差异大:

    • 检查:角点检测是否稳定?尝试显示每一帧检测到的角点,观察是否有误检或抖动。
    • 检查:机械臂到位后是否充分稳定?在发送拍照指令前,增加短暂延时(如0.5秒)。
    • 检查:标定板是否在部分图像中发生了严重畸变或部分遮挡?
  • 重投影误差尚可,但实际抓取偏差大:

    • 检查:手眼矩阵 X 的平移部分单位是否为米?确保相机内参标定和机械臂位姿使用的单位一致(通常是米)。
    • 检查:坐标转换链是否正确?特别是矩阵乘法的顺序和求逆操作。再次核对 P_b = T_be * X * P_c 这一公式。
    • 进行末端工具坐标系(TCP)标定:如果你的抓取器或工具中心点(TCP)与机械臂末端法兰中心不重合,还需要进行TCP标定,并在最终坐标转换中考虑进去。
  • OpenCV的 calibrateHandEye 返回的结果明显不合理(例如旋转矩阵不是正交阵,平移量巨大):

    • 检查:构建A和B矩阵时,相对运动的计算是否正确?确保使用的是 T_ei_ej = inv(T_be_j) @ T_be_i 和 T_ci_cj = inv(T_cm_j) @ T_cm_i。
    • 尝试不同的求解方法:将 cv2.CALIB_HAND_EYE_TSAI 替换为 cv2.CALIB_HAND_EYE_PARK 或 cv2.CALIB_HAND_EYE_HORAUD,看结果是否改善。
    • 验证输入数据:打印出几对A和B矩阵,检查它们的旋转部分是否近似为单位阵(对于很小的运动)或合理的旋转矩阵,平移量是否在合理范围内。

手眼标定是机器人视觉集成中一道必须跨越的门槛。它连接了感知与执行,其精度直接决定了整个系统的性能上限。通过本文的步骤,你应当能够搭建起一套完整的、基于Python和OpenCV的“眼在手上”手眼标定系统。从环境准备、数据采集,到核心算法实现与精度验证,我们覆盖了工程实践中的主要环节。记住,理论是骨架,而细节决定成败。多花时间在数据采集的质量控制上,严谨地验证每一个中间结果,你的机械臂就能真正拥有一双“慧眼”,精准地完成视觉引导下的各种任务。在实际项目中,你可能还需要将此流程封装成更友好的GUI工具,或者与你的机器人控制系统深度集成,但这套核心的数学原理和代码框架,将是所有工作的坚实基础。

Logo

聚焦RDK与具身智能,汇集机器人开发教程、开源案例和技术交流

更多推荐