记录Opencv手眼标定的过程

最新推荐文章于 2024-06-23 13:00:03 发布
最新推荐文章于 2024-06-23 13:00:03 发布
阅读量3.6k 收藏 58
点赞数 4
分类专栏： 手眼标定
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41698305/article/details/110133734
版权 
/// 标定板位姿解算程序
#include <opencv2/opencv.hpp>
#include <iostream>
#include <string>
#include <vector>

using namespace cv;
using namespace std;

/*
@param File_Directory 为文件夹目录
@param FileType 为需要查找的文件类型
@param FilesName 为存放文件名的容器
@other 目前的写法是按1.png,2.png这样来读取的，请按需要修改
*/
void getFilesName(string &File_Directory, string &FileType, vector<string>&FilesName)
{
    int count = 1;//初始图片索引
    while (true) {
        fstream _file;
        string pic_name = File_Directory + "/" + to_string(count) + FileType;
        _file.open(pic_name,ios::in);
        if(!_file) {
            cout<<pic_name<<"没有被创建\n";
            break;
        } else {
            cout<<pic_name<<"已经存在\n";
            FilesName.push_back(pic_name);
        }
        count++;
    }
}

void m_calibration(vector<string> &FilesName, Size board_size, Size square_size, Mat &cameraMatrix, Mat &distCoeffs, vector<Mat> &rvecsMat, vector<Mat> &tvecsMat)
{
    ofstream fout("caliberation_result.txt");                       // 保存标定结果的文件

    cout << "开始提取角点………………" << endl;
    int image_count = 0;                                            // 图像数量
    Size image_size;                                                // 图像的尺寸

    vector<Point2f> image_points;                                   // 缓存每幅图像上检测到的角点
    vector<vector<Point2f>> image_points_seq;                       // 保存检测到的所有角点

    for (int i = 0;i < FilesName.size();i++)
    {
        image_count++;

        // 用于观察检验输出
        cout << "image_count = " << image_count << endl;
        Mat imageInput = imread(FilesName[i]);
        if (image_count == 1)  //读入第一张图片时获取图像宽高信息
        {
            image_size.width = imageInput.cols;
            image_size.height = imageInput.rows;
            cout << "image_size.width = " << image_size.width << endl;
            cout << "image_size.height = " << image_size.height << endl;
        }

        /* 提取角点 */
        bool ok = findChessboardCorners(imageInput, board_size, image_points, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE);
        if (0 == ok)
        {
            cout <<"第"<< image_count <<"张照片提取角点失败，请删除后，重新标定！"<<endl; //找不到角点
            imshow("失败照片", imageInput);
            waitKey(0);
        }
        else
        {
            Mat view_gray;
            cout << "imageInput.channels()=" << imageInput.channels() << endl;
            cvtColor(imageInput, view_gray, CV_RGB2GRAY);

            /* 亚像素精确化 */
            //find4QuadCornerSubpix(view_gray, image_points, Size(5, 5)); //对粗提取的角点进行精确化
            cv::cornerSubPix(view_gray, image_points, cv::Size(11, 11), cv::Size(-1, -1), cv::TermCriteria(CV_TERMCRIT_ITER + CV_TERMCRIT_EPS, 20, 0.01));

            image_points_seq.push_back(image_points);  //保存亚像素角点

            /* 在图像上显示角点位置 */
            drawChessboardCorners(view_gray, board_size, image_points, true);

            //imshow("Camera Calibration", view_gray);//显示图片
            //waitKey(100);//暂停0.1S
        }
    }
    cout << "角点提取完成！！！" << endl;


    /*棋盘三维信息*/
    vector<vector<Point3f>> object_points_seq;                     // 保存标定板上角点的三维坐标

    for (int t = 0;t < image_count;t++)
    {
        vector<Point3f> object_points;
        for (int i = 0;i < board_size.height;i++)
        {
            for (int j = 0;j < board_size.width;j++)
            {
                Point3f realPoint;
                /* 假设标定板放在世界坐标系中z=0的平面上 */
                realPoint.x = i*square_size.width;
                realPoint.y = j*square_size.height;
                realPoint.z = 0;
                object_points.push_back(realPoint);
            }
        }
        object_points_seq.push_back(object_points);
    }

    /* 运行标定函数 */
    double err_first = calibrateCamera(object_points_seq, image_points_seq, image_size, cameraMatrix, distCoeffs, rvecsMat, tvecsMat, CV_CALIB_FIX_K3);
    fout << "重投影误差1：" << err_first << "像素" << endl << endl;
    cout << "标定完成！！！" << endl;


    cout << "开始评价标定结果………………";
    double total_err = 0.0;            // 所有图像的平均误差的总和
    double err = 0.0;                  // 每幅图像的平均误差
    double totalErr = 0.0;
    double totalPoints = 0.0;
    vector<Point2f> image_points_pro;     // 保存重新计算得到的投影点

    for (int i = 0;i < image_count;i++)
    {

        projectPoints(object_points_seq[i], rvecsMat[i], tvecsMat[i], cameraMatrix, distCoeffs, image_points_pro);   //通过得到的摄像机内外参数，对角点的空间三维坐标进行重新投影计算

        err = norm(Mat(image_points_seq[i]), Mat(image_points_pro), NORM_L2);

        totalErr += err*err;
        totalPoints += object_points_seq[i].size();

        err /= object_points_seq[i].size();
        //fout << "第" << i + 1 << "幅图像的平均误差：" << err << "像素" << endl;
        total_err += err;
    }
    fout << "重投影误差2：" << sqrt(totalErr / totalPoints) << "像素" << endl << endl;
    fout << "重投影误差3：" << total_err / image_count << "像素" << endl << endl;


    //保存定标结果
    cout << "开始保存定标结果………………" << endl;
    Mat rotation_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0)); /* 保存每幅图像的旋转矩阵 */
    fout << "相机内参数矩阵：" << endl;
    fout << cameraMatrix << endl << endl;
    fout << "畸变系数：\n";
    fout << distCoeffs << endl << endl << endl;
    for (int i = 0; i < image_count; i++)
    {
        fout << "第" << i + 1 << "幅图像的旋转向量：" << endl;
        fout << rvecsMat[i] << endl;

        /* 将旋转向量转换为相对应的旋转矩阵 */
        Rodrigues(rvecsMat[i], rotation_matrix);
        fout << "第" << i + 1 << "幅图像的旋转矩阵：" << endl;
        fout << rotation_matrix << endl;
        fout << "第" << i + 1 << "幅图像的平移向量：" << endl;
        fout << tvecsMat[i] << endl << endl;
    }
    cout << "定标结果完成保存！！！" << endl;
    fout << endl;
}

void m_undistort(vector<string> &FilesName, Size image_size, Mat &cameraMatrix, Mat &distCoeffs)
{

    Mat mapx = Mat(image_size, CV_32FC1);   //X 坐标重映射参数
    Mat mapy = Mat(image_size, CV_32FC1);   //Y 坐标重映射参数
    Mat R = Mat::eye(3, 3, CV_32F);
    cout << "保存矫正图像" << endl;
    string imageFileName;                  //校正后图像的保存路径
    stringstream StrStm;
    string temp;

    for (int i = 0; i < FilesName.size(); i++)
    {
        Mat imageSource = imread(FilesName[i]);

        Mat newimage = imageSource.clone();

        //方法一：使用initUndistortRectifyMap和remap两个函数配合实现
        //initUndistortRectifyMap(cameraMatrix,distCoeffs,R, Mat(),image_size,CV_32FC1,mapx,mapy);
        //  remap(imageSource,newimage,mapx, mapy, INTER_LINEAR);

        //方法二：不需要转换矩阵的方式，使用undistort函数实现
        undistort(imageSource, newimage, cameraMatrix, distCoeffs);

        StrStm << i + 1;
        StrStm >> temp;
        imageFileName = "矫正后图像//" + temp + "_d.jpg";
        imwrite(imageFileName, newimage);

        StrStm.clear();
        imageFileName.clear();
    }
    std::cout << "保存结束" << endl;
}

int main()
{
    string File_Directory1 = ".";   //文件夹目录1

    string FileType = ".png";    // 需要查找的文件类型

    vector<string>FilesName1;    //存放文件名的容器

    getFilesName(File_Directory1, FileType, FilesName1);   // 标定所用图像文件的路径


    Size board_size = Size(11, 8);                         // 标定板上每行、列的角点数
    Size square_size = Size(30, 30);                       // 实际测量得到的标定板上每个棋盘格的物理尺寸，单位mm

    Mat cameraMatrix = Mat(3, 3, CV_32FC1, Scalar::all(0));        // 摄像机内参数矩阵
    Mat distCoeffs = Mat(1, 5, CV_32FC1, Scalar::all(0));          // 摄像机的5个畸变系数：k1,k2,p1,p2,k3
    vector<Mat> rvecsMat;                                          // 存放所有图像的旋转向量，每一副图像的旋转向量为一个mat
    vector<Mat> tvecsMat;                                          // 存放所有图像的平移向量，每一副图像的平移向量为一个mat

    m_calibration(FilesName1, board_size, square_size, cameraMatrix, distCoeffs, rvecsMat, tvecsMat);

    //m_undistort(FilesName1, image_size, cameraMatrix, distCoeffs);

    return 0;
}
  • 整合各个博客得到的程序(详细注释有空再加)：
//
// Created by ch on 2020/11/25.
//

#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <thread>
#include <ui/robot_feedback.h>
#include <ros/ros.h>
#include <librealsense2/rs.hpp> // Include RealSense Cross Platform API
#include "ClimberKinematics5D.h"
#include <opencv2/core/eigen.hpp>
#include <opencv2/opencv.hpp>   // Include OpenCV API
#include <opencv2/calib3d.hpp>
using namespace std;
using namespace cv;

enum CONTROL_STATUS {RECORD, WAIT, QUIT} CONTROL_FLAG;
bool to_record = false;//交互变量，true->准备记录一组数据
vector<double> ENCODER_DATA(5, 0);//编码器数据，用来计算TCP

void control_thread() {//交互线程，输入1则记录1组数据
    bool to_quit = false;
    while (!to_quit) {
        switch (CONTROL_FLAG) {
            case CONTROL_STATUS::WAIT : {
                int i = 0;
                cout << "Input 1 for record, input 0 for stop recording.\n";
                cin >> i;
                if (i == 0) {
                    CONTROL_FLAG = CONTROL_STATUS::QUIT;
                    break;
                } else if (i == 1) CONTROL_FLAG = CONTROL_STATUS::RECORD;
                break;
            }
            case CONTROL_STATUS::QUIT : to_quit = true; break;
            case CONTROL_STATUS::RECORD : break;
        }
    }
}
void GetEncoderData(const ui::robot_feedbackConstPtr& data) {//ROS回调函数，获取编码器数据
    ENCODER_DATA[0] = data->feedbackPosData[0];
    ENCODER_DATA[1] = data->feedbackPosData[1];
    ENCODER_DATA[2] = data->feedbackPosData[2];
    ENCODER_DATA[3] = data->feedbackPosData[3];
    ENCODER_DATA[4] = data->feedbackPosData[4];
}

void ros_thread() {//ROS线程，如果不另开线程的话,main里面会有两个while(一个是realsense的while， 一个是ros的spin)
    //ros
    ros::NodeHandle n;
    ros::NodeHandle node;
    ros::Subscriber sub = node.subscribe("/low_level/joints_point_feedback", 100, GetEncoderData);
    ros::spin();
}

void m_calibration(vector<string> &FilesName, const Size& board_size, const Size& square_size, Mat &cameraMatrix, Mat &distCoeffs, vector<Mat> &rvecsMat, vector<Mat> &tvecsMat)
{
    ofstream fout("caliberation_result.txt");                       // 保存标定结果的文件

    cout << "开始提取角点………………" << endl;
    int image_count = 0;                                            // 图像数量
    Size image_size;                                                // 图像的尺寸

    vector<Point2f> image_points;                                   // 缓存每幅图像上检测到的角点
    vector<vector<Point2f>> image_points_seq;                       // 保存检测到的所有角点

    for (int i = 0;i < FilesName.size();i++)
    {
        image_count++;

        // 用于观察检验输出
        cout << "image_count = " << image_count << endl;
        Mat imageInput = imread(FilesName[i]);
        if (image_count == 1)  //读入第一张图片时获取图像宽高信息
        {
            image_size.width = imageInput.cols;
            image_size.height = imageInput.rows;
            cout << "image_size.width = " << image_size.width << endl;
            cout << "image_size.height = " << image_size.height << endl;
        }

        /* 提取角点 */
        bool ok = findChessboardCorners(imageInput, board_size, image_points, CALIB_CB_ADAPTIVE_THRESH | CALIB_CB_NORMALIZE_IMAGE);
        if (0 == ok)
        {
            cout <<"第"<< image_count <<"张照片提取角点失败，请删除后，重新标定！"<<endl; //找不到角点
            imshow("失败照片", imageInput);
            waitKey(0);
        }
        else
        {
            Mat view_gray;
            cout << "imageInput.channels()=" << imageInput.channels() << endl;
            cvtColor(imageInput, view_gray, COLOR_RGB2GRAY);

            /* 亚像素精确化 */
            //find4QuadCornerSubpix(view_gray, image_points, Size(5, 5)); //对粗提取的角点进行精确化
            cv::cornerSubPix(view_gray, image_points, cv::Size(11, 11), cv::Size(-1, -1), cv::TermCriteria(TermCriteria::EPS+TermCriteria::COUNT, 20, 0.01));

            image_points_seq.push_back(image_points);  //保存亚像素角点

            /* 在图像上显示角点位置 */
            drawChessboardCorners(view_gray, board_size, image_points, true);

            imshow("Camera Calibration", view_gray);//显示图片
            waitKey(0);//暂停0.1S
        }
    }
    cout << "角点提取完成！！！" << endl;


    /*棋盘三维信息*/
    vector<vector<Point3f>> object_points_seq;                     // 保存标定板上角点的三维坐标

    for (int t = 0;t < image_count;t++)
    {
        vector<Point3f> object_points;
        for (int i = 0;i < board_size.height;i++)
        {
            for (int j = 0;j < board_size.width;j++)
            {
                Point3f realPoint;
                /* 假设标定板放在世界坐标系中z=0的平面上 */
                realPoint.x = i*square_size.width;
                realPoint.y = j*square_size.height;
                realPoint.z = 0;
                object_points.push_back(realPoint);
            }
        }
        object_points_seq.push_back(object_points);
    }

    /* 运行标定函数 */
    double err_first = calibrateCamera(object_points_seq, image_points_seq, image_size, cameraMatrix, distCoeffs, rvecsMat, tvecsMat, CALIB_FIX_K3);
    fout << "重投影误差1：" << err_first << "像素" << endl << endl;
    cout << "标定完成！！！" << endl;


    cout << "开始评价标定结果………………";
    double total_err = 0.0;            // 所有图像的平均误差的总和
    double err = 0.0;                  // 每幅图像的平均误差
    double totalErr = 0.0;
    double totalPoints = 0.0;
    vector<Point2f> image_points_pro;     // 保存重新计算得到的投影点

    for (int i = 0;i < image_count;i++)
    {

        projectPoints(object_points_seq[i], rvecsMat[i], tvecsMat[i], cameraMatrix, distCoeffs, image_points_pro);   //通过得到的摄像机内外参数，对角点的空间三维坐标进行重新投影计算

        err = norm(Mat(image_points_seq[i]), Mat(image_points_pro), NORM_L2);

        totalErr += err*err;
        totalPoints += object_points_seq[i].size();

        err /= object_points_seq[i].size();
        //fout << "第" << i + 1 << "幅图像的平均误差：" << err << "像素" << endl;
        total_err += err;
    }
    fout << "重投影误差2：" << sqrt(totalErr / totalPoints) << "像素" << endl << endl;
    fout << "重投影误差3：" << total_err / image_count << "像素" << endl << endl;


    //保存定标结果
    cout << "开始保存定标结果………………" << endl;
    Mat rotation_matrix = Mat(3, 3, CV_32FC1, Scalar::all(0)); /* 保存每幅图像的旋转矩阵 */
    fout << "相机内参数矩阵：" << endl;
    fout << cameraMatrix << endl << endl;
    fout << "畸变系数：\n";
    fout << distCoeffs << endl << endl << endl;
    for (int i = 0; i < image_count; i++)
    {
        fout << "第" << i + 1 << "幅图像的旋转向量：" << endl;
        fout << rvecsMat[i] << endl;

        /* 将旋转向量转换为相对应的旋转矩阵 */
        Rodrigues(rvecsMat[i], rotation_matrix);
        fout << "第" << i + 1 << "幅图像的旋转矩阵：" << endl;
        fout << rotation_matrix << endl;
        fout << "第" << i + 1 << "幅图像的平移向量：" << endl;
        fout << tvecsMat[i] << endl << endl;
    }
    cout << "定标结果完成保存！！！" << endl;
    fout << endl;
}

/**************************************************
* @brief   将旋转矩阵与平移向量合成为齐次矩阵
* @note
* @param   Mat& R   3*3旋转矩阵
* @param   Mat& T   3*1平移矩阵
* @return  Mat      4*4齐次矩阵
**************************************************/
Mat R_T2HomogeneousMatrix(const Mat& R,const Mat& T)
{
    Mat HomoMtr;
    Mat_<double> R1 = (Mat_<double>(4, 3) <<
                                          R.at<double>(0, 0), R.at<double>(0, 1), R.at<double>(0, 2),
            R.at<double>(1, 0), R.at<double>(1, 1), R.at<double>(1, 2),
            R.at<double>(2, 0), R.at<double>(2, 1), R.at<double>(2, 2),
            0, 0, 0);
    Mat_<double> T1 = (Mat_<double>(4, 1) <<
                                          T.at<double>(0,0),
            T.at<double>(1,0),
            T.at<double>(2,0),
            1);
    cv::hconcat(R1, T1, HomoMtr);		//矩阵拼接
    return HomoMtr;
}

/**************************************************
* @brief    齐次矩阵分解为旋转矩阵与平移矩阵
* @note
* @param	const Mat& HomoMtr  4*4齐次矩阵
* @param	Mat& R              输出旋转矩阵
* @param	Mat& T				输出平移矩阵
* @return
**************************************************/
void HomogeneousMtr2RT(Mat& HomoMtr, Mat& R, Mat& T)
{
    //Mat R_HomoMtr = HomoMtr(Rect(0, 0, 3, 3)); //注意Rect取值
    //Mat T_HomoMtr = HomoMtr(Rect(3, 0, 1, 3));
    //R_HomoMtr.copyTo(R);
    //T_HomoMtr.copyTo(T);
    /*HomoMtr(Rect(0, 0, 3, 3)).copyTo(R);
    HomoMtr(Rect(3, 0, 1, 3)).copyTo(T);*/
    Rect R_rect(0, 0, 3, 3);
    Rect T_rect(3, 0, 1, 3);
    R = HomoMtr(R_rect);
    T = HomoMtr(T_rect);

}

int main(int argc, char * argv[]) try
{
    //realsense initialization
    rs2::colorizer color_map;
    rs2::pipeline pipe;
    pipe.start();

    //other initialization
    ClimbotKinematics *kinematics = new ClimberKinematics5D();//运动学
    std::thread control(control_thread);
    std::thread ros_t(ros_thread);
    vector<Eigen::Matrix4d> TCP_poses;
    vector<string> pic_names;
    int count = 0;

    //capture pictures
    const auto window_name = "Display Image";
    namedWindow(window_name, WINDOW_AUTOSIZE);
    bool to_quit = false;
    while (waitKey(1) < 0 && getWindowProperty(window_name, WND_PROP_AUTOSIZE) >= 0 && !to_quit) {
        rs2::frameset data = pipe.wait_for_frames(); // Wait for next set of frames from the camera
        rs2::frame depth = data.get_depth_frame().apply_filter(color_map);
        rs2::frame rgb = data.get_color_frame();

        const int w = rgb.as<rs2::video_frame>().get_width();
        const int h = rgb.as<rs2::video_frame>().get_height();

        Mat image(Size(w, h), CV_8UC3, (void*)rgb.get_data(), Mat::AUTO_STEP);
        cvtColor(image, image, COLOR_BGR2RGB);

        //record a picture

        switch (CONTROL_FLAG) {
            case CONTROL_STATUS::RECORD : {
                string num_string = to_string(count);
                cv::imwrite("./pose_" + num_string + ".jpg" , image);
                pic_names.emplace_back("./pose_" + num_string + ".jpg");

                auto T = kinematics->GetTransformMatrix(ClimberKinematics5D::G6, ENCODER_DATA);
                TCP_poses.push_back(T);

                ofstream TCP_trasform("./TCP_pose_" + num_string + ".txt", ofstream::out);
                Eigen::Matrix3d R = T.block(0, 0, 3, 3);
                Eigen::Vector3d euler_angles = R.eulerAngles(2, 1, 0);
                TCP_trasform << "Index: " << num_string << endl;
                TCP_trasform << "Fixed X-Y-Z(x/y/z):\n" << euler_angles[0] / PI * 180 << " " << euler_angles[1] / PI * 180 << " " << euler_angles[2] / PI * 180 << endl;
                TCP_trasform << "Position(m):\n" << T(0, 3) / 1000 << " "<< T(1, 3) / 1000 << " " << T(2, 3) / 1000 << endl << endl;
                break;
            }
            case WAIT:
                break;
            case QUIT:
                to_quit = true;
                break;
        }

        count++;

        // Update the window with new data
        imshow(window_name, image);
    }
    //camera calibration and get board pose
    Size board_size = Size(11, 8);                         // 标定板上每行、列的角点数
    Size square_size = Size(25, 25);                       // 实际测量得到的标定板上每个棋盘格的物理尺寸，单位mm
    Mat cameraMatrix = Mat(3, 3, CV_32FC1, Scalar::all(0));        // 摄像机内参数矩阵
    Mat distCoeffs = Mat(1, 5, CV_32FC1, Scalar::all(0));          // 摄像机的5个畸变系数：k1,k2,p1,p2,k3
    vector<Mat> R_target2cam;                                          // 存放所有图像的旋转向量，每一副图像的旋转向量为一个mat
    vector<Mat> t_target2cam;                                          // 存放所有图像的平移向量，每一副图像的平移向量为一个mat
    m_calibration(pic_names, board_size, square_size, cameraMatrix, distCoeffs, R_target2cam, t_target2cam);
    //至此，第2部分完成

    //开始第3部分:矩阵格式转换
    vector<cv::Mat> R_gripper2base, t_gripper2base;
    for (auto& T : TCP_poses) {
        Mat cv_format_tcp_pose, cv_format_tcp_rvec, cv_format_tcp_tvec;
        eigen2cv(T, cv_format_tcp_pose);
        HomogeneousMtr2RT(cv_format_tcp_pose, cv_format_tcp_rvec, cv_format_tcp_tvec);
        R_gripper2base.emplace_back(cv_format_tcp_rvec);
        t_gripper2base.emplace_back(cv_format_tcp_tvec);
    }
    //至此，第3部分完成

    //开始第4部分：手眼标定程序
    cv::Mat R_cam2gripper,T_cam2gripper;
    calibrateHandEye(R_gripper2base,t_gripper2base,R_target2cam,t_target2cam,R_cam2gripper,T_cam2gripper);

    //第五部分：矩阵格式转换
    auto Homo_cam2gripper = R_T2HomogeneousMatrix(R_cam2gripper, T_cam2gripper);
    cout << "Homo_cam2gripper:\n" << Homo_cam2gripper << endl;
    cout << endl << "Finish.";
    return EXIT_SUCCESS;
}
catch (const rs2::error & e)
{
    std::cerr << "RealSense error calling " << e.get_failed_function() << "(" << e.get_failed_args() << "):\n    " << e.what() << std::endl;
    return EXIT_FAILURE;
}
catch (const std::exception& e)
{
    std::cerr << e.what() << std::endl;
    return EXIT_FAILURE;
}
正一番薯
关注
  • 4
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
手眼标定（一）：Opencv4实现手眼标定及手眼系统测试
weixin_42203839的博客
01-08 2万+
Opencv4实现手眼标定及手眼系统测试（一）前言程序环境原理如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 前言 由于项目需要，要在win10环境下实现“眼在...
OpenCV手眼标定（calibrateHandeye()）
热门推荐
hello
03-11 4万+
文章目录说明Code实验效果参考 说明 Code #include <opencv2/opencv.hpp> #include <iostream> #include <math.h> using namespace std; using namespace cv; Mat R_T2HomogeneousMatrix(const Mat& R, co...
【仿真】UR机器人相机标定、立体标定、手眼标定、视觉追踪（双目）
最新发布
cxyhjl的博客
06-23 1168
实现在CoppeliaSim环境中进行手眼标定和目标追踪的一个例子。它主要涉及到机器人、机器视觉和控制算法的编程，使用了Python语言。接下来对该代码的主要类和方法进行解析：1. 导入相关库用于与CoppeliaSim模拟器通过ZeroMQ接口通信。包含Rotation类，用于执行各种旋转和方向变换操作。OpenCV库，用于执行各种图像处理和计算机视觉任务。用于执行各种数学和矩阵运算。用于进行图...
VC2017+OPENCV4.30实现机器人与传感器的手眼标定，亲测可用
06-02
使用VC2017结合OPENCV4.30实现机器人坐标系与传感器坐标系的手眼标定。可以计算出机器人的工具坐标系和传感器坐标系的相对位置关系矩阵。自己亲自测试，好用。
手眼标定实战(二)-基于opencv的Eye to Hand相机标定
向阳而生
08-11 8976
在手眼系统的坐标系理论变换中，从像素坐标到机器人坐标系转换过程中需要经过内参矫正、外参矩阵平移旋转的变换。本章节将进一步讨论手眼系统在标定过程中的应用，如何通过opencv来求解我们需要的内参、外参矩阵参数。 opencv是一个开源的计算机视觉库，封装了很多相机标定所需要用到的算法，因此使用opencv来进行标定将能够极大简化手眼标定的步骤。我们将从代码层面简单剖析手眼标定的步骤以及注意事项。 实现剖析 在眼在手外Eye to Hand安装方式的手眼系统中，标定求解的是相机坐标系到机械臂末端夹具坐标系的变换
python 手眼标定OpenCV手眼标定（calibrateHandeye()）二
weixin_43134049的博客
02-16 1万+
这一章我们来更具上一章的分析，为手眼标定函数calibrateHandEye 准备他那些麻烦的参数 R,T=cv2.calibrateHandEye(R_all_end_to_base_1,T_all_end_to_base_1,R_all_chess_to_cam_1,T_all_chess_to_cam_1)#手眼标定 一.为首的两个机械臂抓手相对于机器人基坐标系的旋转矩阵与平移向量， 即R_all_end_to_base_1,T_all_end_to_base_1, 我们可用通过输入的机械臂提供的6
ROS2机器人手眼标定原理与OpenCV手眼标定（calibrateHandeye())
weixin_47640199的博客
05-19 2574
ROS2机器人手眼标定原理与OpenCV手眼标定（calibrateHandeye())
【MachineVision】Hand-Eye-Calibration
zhy29563
07-23 2200
1. 眼在手上 标定过程 标定板放置在固定位置，机器人变换不同的姿态，相机获取不同姿态下的标定板图像 目标 上图中描述了闭环的坐标系空间关系，包含以下部分： baseHtool^{base}H_{tool}baseHtool​​​​​​ 机器人末端的工具坐标系到机器人基坐标系的变换矩阵​。 可变量 camHtool^{cam}H_{tool}camHtool​ 机器人末端的工具坐标系到相机坐标系的变换矩阵。 不变量 camHcal^{cam}H_{cal}camHcal​​​​​​ 标定板坐标系到
九点标定 opencv 方式实现 手眼标定
10-18
理解并分析这段代码可以帮助你深入理解OpenCV在手眼标定中的应用，以及C++中如何操作OpenCV库来实现这一功能。 总的来说，九点标定是计算机视觉和机器人学中的基础技术，它使得摄像头能够准确地感知周围环境，从而...
经典手眼标定算法C++代码
06-09
经典手眼标定算法C++代码，程序是基于OpenCV 2.0以上版本，下载程序后需要配置OpenCV。工程主要包括三个文件，handeye.h为各种手眼标定的实现，quaternion.h为四元数运算文件，handeye_test.cpp为主程序，测试各手眼...
Python使用OpenCV进行标定
01-20
OpenCV使用棋盘格板进行标定，如下图所示。为了标定相机，我们需要输入一系列三维点和它们对应的二维图像点。在黑白相间的棋盘格上，二维图像点很容易通过角点检测找到。而对于真实世界中的三维点呢？由于我们采集中...
手眼标定C++代码
03-08
手眼标定C++代码，基于OpenCV 2.4.9以上版本，包含assistFunction.cpp辅助函数，createDataSet.cpp创建数据集，handEyeSelf.cpp自己写的标定函数，以及主函数
机器视觉手眼标定详解，有用
03-14
目录 1. 相机固定不动 , 上往下看 引导 机器人 移动 2. 相机固定不动 , 下往上看 3. 相机固定在器人上 相机固定在器人上 ，离旋转中心较近 离旋转中心较近 离旋转中心较近 4. 相机固定在器人上 相机固定在器人上 ，离旋转中心 旋转中心 很远 5. 特殊固定方式 – 分离轴
关于手眼标定的程序
02-26
基于MATLAB程序改的C++代码，能基本计算出正确的位姿，
基于OpenCv的机器人九点标定法
01-10
在机器人领域，手眼标定是一项至关重要的技术，它旨在建立相机坐标系和机械手坐标系之间的精确对应关系，使得机器人能够根据相机捕获的图像准确地执行任务。传统的相机标定通常采用张氏标定法，主要针对相机的几何...
使用 opencv-python进行手眼标定
qq_43607792的博客
11-10 8870
手眼标定整体流程及原理参考b站视频手眼标定-原理与实战，讲的十分详细。 这里完成的是eye-in-hand类型的手眼标定。 import cv2 import numpy as np from math import * import pandas as pd K=np.array([[4283.95148301687,-0.687179973528103,2070.79900757240], [0,4283.71915784510,1514.87274457919],
OpenCV手眼标定（Python版）
handsome_wang5的博客
02-26 2174
通过虚拟的数据进行标定，其中M_target_to_camera需要通过solvepnp获得旋转平移矩阵
opencv 手眼标定
06-21
### 回答1： OpenCV手眼标定是一个基于计算机视觉技术的手眼标定方法。在机器人自主定位和导航方面具有重要的应用价值。 手眼标定是指在机器人工作时，需要同时控制机械臂和相机进行定位测量。如果机器人视觉系统和机械系统是分开的，则需要进行手眼标定。通常情况下，手眼标定是在机器人与相机之间安装一个刚体棱镜来完成的。 Opencv手眼标定的思路是在使用计算机视觉技术对相机图像进行处理的同时，利用机器臂控制相机进行姿态变换，并记录相机各个姿态的转动量和位移量。根据这些数据，就可以计算出机器臂和相机的正确关系，从而实现机器人在3D空间中的定位和导航。 在实现手眼标定的过程中，需要对相机的内参、外参和机械臂的运动学参数进行精确测量，同时需要使用Opencv进行图像处理、特征提取、匹配和姿态估计等相关算法。通过数据的处理和计算，就可以得到机器人与相机之间准确的关系，从而实现精确的机器臂和相机控制。 总之，Opencv手眼标定是一种非常重要的机器人视觉技术，对于机器人的定位和导航具有重要的应用价值，其在工业制造、自主导航、环境监测和安全控制等领域将会有广泛的应用。 ### 回答2： OpenCV手眼标定是一种用于机器人和相机之间的标定方法。它的主要目的是确定机器人坐标系和相机坐标系之间的关系，以此来准确地获取机器人和相机之间的位置和姿态信息。该方法需要使用一系列已知的机器人坐标系和相机坐标系之间的对应点对来确定两个坐标系之间的转换矩阵。 通过手眼标定，我们可以精确测量机器人和相机之间的距离和方向，从而实现精确的机器人运动以及准确的相机视觉。在实际应用中，手眼标定常用于机器人视觉引导、三维重建、自主导航等领域。 OpenCV手眼标定是一种广泛使用的标定方法，具有较高的精度和可靠性。该方法要求精度较高的机器人和相机运动控制，并且需要在标定过程中准确地识别点对。此外，手眼标定需要较长的时间来准备标定数据和计算，因此在实际应用中需要谨慎使用。 总的来说，OpenCV手眼标定是一种精确可靠的机器人和相机之间的标定方法，可以应用于机器人视觉引导、三维重建、自主导航等领域。但是，它需要高精度的机器人和相机运动控制，并且需要谨慎使用以确保准确性。 ### 回答3： OpenCV 手眼标定是一种通过对相机和机械臂进行标定来确定它们之间准确的变换关系的方法。当机械臂需要使用相机进行定位、跟踪或者视觉检测时，这种标定方法非常重要。 手眼标定通常需要进行六次数据采集，其中每次需要采集机械臂基座与末端执行器的位姿关系以及相机手眼变换矩阵。这些数据可以使用不同方法计算得到。例如，可以使用相机外参和机器人关节角来计算相机位姿，同时使用机器人的末端执行器位姿和机器人关节角来计算机器人位姿。 通过这些数据，计算出两个坐标系之间的变换关系。然后，可以使用这些信息来确定机器人末端执行器的位置，并对相机进行校准，从而达到最佳视觉效果。 总之，OpenCV 手眼标定是一种非常有用的技术，能够帮助机械臂和相机之间进行准确的通信和协作。通过标定，机械臂可以更精确地进行定位和控制，同时相机也可以更好地捕捉并处理视觉数据。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值