手眼标定的原理与实现

最新推荐文章于 2024-06-10 19:17:50 发布
最新推荐文章于 2024-06-10 19:17:50 发布
阅读量946 收藏 18
点赞数 22
分类专栏： OpenCV 文章标签： opencv 数码相机 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38589460/article/details/136022218
版权

手眼标定的原理与实现

1、手眼标定原理部分

  1. 手眼标定的核心问题在与求解AX=XB这个方程，只是针对于眼在手上和眼在手外时，A，B，X的定义略有差异。
  2. 这篇文章的下面这张图很形象的说明了手眼标定中眼在手上的问题。
    在这里插入图片描述
  3. 这篇文章很好地解释了手眼标定中眼在手上和眼在手外的问题。
  4. 这篇文章是AX=XB这个方程的另外一种求解方式。
  5. 这篇文章是一个眼在手上的C++代码实现例子。

2、手眼标定实现部分(眼在手上)

  1. 数据类型定义
struct CalibrationInitParams
{
	cv::Size CalibrateBoardSize = cv::Size(11, 8);
	float CalibrateBoardLength = 30;
};

	std::vector<std::vector<double>> mvvRobotPose;

	//内参和畸变
	cv::Mat mintrinsicParam;
	cv::Mat mdistortParam;
	//旋转和平移
	cv::Mat mrotationParam;
	cv::Mat mtranslationParam;
	//单目标定的旋转和平移
	std::vector<cv::Mat> mRvecs, mTvecs;
	//图像大小
	cv::Size mImageSize = cv::Size(0, 0);
	CalibrationInitParams mInitParams;
	
	//标准标定板三维点
	std::vector<cv::Point3f> mvStandardCalibrateBoard;
	//标准标定板三维点 []:图像序号; []:空间三维点
	std::vector<std::vector<cv::Point3f>> mvvStandardCalibrateBoard;
	//[]:图像序号; []:图像二维点
	std::vector<std::vector<cv::Point2f>> mvvCalibrateBoard2DPoints;
  1. 主要实现部分：mvvStandardCalibrateBoard是标定板(例如棋盘格标定板)上的三维点；mvvCalibrateBoard2DPoints是标定板上检测到的二维点；mintrinsicParam是相机的内部参数；mdistortParam是相机的畸变参数；机器人旋转使用的是ZYZ，如果是XYZ的话，需要修改旋转矩阵，参考。
void runCalibrateHandEye(double& error)
{
	//定义手眼标定矩阵
	std::vector<Mat> R_gripper2base;
	std::vector<Mat> t_gripper2base;
	std::vector<Mat> R_target2cam;
	std::vector<Mat> t_target2cam;
	Mat R_cam2gripper = (Mat_<double>(3, 3));
	Mat t_cam2gripper = (Mat_<double>(3, 1));

	std::vector<cv::Mat> vecHg, vecHc;
	for (size_t i = 0; i < mRvecs.size(); i++)//标定板位姿
	{
		cv::Mat Rvec, Tvec;
		Rvec = mRvecs[i].clone();
		Tvec = mTvecs[i].clone();
		cv::solvePnP(mvvStandardCalibrateBoard[i], mvvCalibrateBoard2DPoints[i], mintrinsicParam, mdistortParam, Rvec, Tvec, true, SOLVEPNP_ITERATIVE);
		cv::Rodrigues(Rvec, Rvec);

		R_target2cam.push_back(Rvec);
		t_target2cam.push_back(Tvec);

		cv::Mat tmp = cv::Mat::eye(4, 4, CV_64FC1);
		Tvec.copyTo(tmp({ 3, 0, 1, 3 }));
		Rvec.copyTo(tmp({ 0, 0, 3, 3 }));
		vecHc.push_back(tmp);
	}

	//这里是ZYZ旋转mvvRobotPose保存的是每次拍摄时机器人的位姿，分别是XYZ,AER(alpha,belta,gamma)。数据类型为：std::vector<std::vector<double>> mvvRobotPose
	for (size_t i = 0; i < mvvRobotPose.size(); i++)//探针到机器人位姿
	{
		double angle1 = mvvRobotPose[i][3], angle2 = mvvRobotPose[i][4], angle3 = mvvRobotPose[i][5];
		double r11 = cos(angle1) * cos(angle2) * cos(angle3) - sin(angle1) * sin(angle3);
		double r12 = -cos(angle1) * cos(angle2) * sin(angle3) - sin(angle1) * cos(angle3);
		double r13 = cos(angle1) * sin(angle2);
		double r21 = sin(angle1) * cos(angle2) * cos(angle3) + cos(angle1) * sin(angle3);
		double r22 = -sin(angle1) * cos(angle2) * sin(angle3) + cos(angle1) * cos(angle3);
		double r23 = sin(angle1) * sin(angle2);
		double r31 = -sin(angle2) * cos(angle3);
		double r32 = sin(angle2) * sin(angle3);
		double r33 = cos(angle2);
		cv::Mat ZYZ_matrix = (cv::Mat_<double>(3, 3) << r11, r12, r13, r21, r22, r23, r31, r32, r33);

		//按顺序合成后的旋转矩阵
		if (!isRotatedMatrix(ZYZ_matrix))		//欧拉角特殊情况下会出现死锁
		{
			cout << "Euler Angle convert to RotatedMatrix failed..." << endl;
			std::getchar();
			exit(-1);
		}
		Mat TMat = (Mat_<double>(3, 1) << mvvRobotPose[i][0], mvvRobotPose[i][1], mvvRobotPose[i][2]);
		R_gripper2base.push_back(ZYZ_matrix);
		t_gripper2base.push_back(TMat);

		cv::Mat tmp = cv::Mat::eye(4, 4, CV_64FC1);
		TMat.copyTo(tmp({ 3, 0, 1, 3 }));
		ZYZ_matrix.copyTo(tmp({ 0, 0, 3, 3 }));
		vecHg.push_back(tmp);
	}
	//手眼标定，CALIB_HAND_EYE_TSAI法为11ms，最快
	calibrateHandEye(R_gripper2base, t_gripper2base, R_target2cam, t_target2cam, R_cam2gripper, t_cam2gripper, CALIB_HAND_EYE_TSAI);

	cv::Vec3f angel3 = rotationMatrixToEulerAngles(R_cam2gripper) * 180 / CV_PI;
	std::cout << "绕z轴(前向方向)滚转角：" << angel3[0] << std::endl;
	std::cout << "绕y轴(垂直方向)偏航角：" << angel3[1] << std::endl;
	std::cout << "绕x轴(水平方向)俯仰角：" << angel3[2] << std::endl;
	std::cout << std::endl;

	//vector<Mat> Hgij, Hcij;
	//for (int i = 1; i < vecHg.size(); i++)
	//{
	//	Hgij.push_back(vecHg[i - 1].inv()*vecHg[i]);
	//	Hcij.push_back(vecHc[i - 1] * vecHc[i].inv());
	//}
	cv::Mat Hcg = cv::Mat::eye(4, 4, CV_64FC1);
	//Tsai_HandEye(Hcg, Hgij, Hcij);  //方式二：不调用opencv库函数，直接通过公式计算

	Hcg = R_T2RT(R_cam2gripper, t_cam2gripper);//矩阵合并
	cout << "手眼数据验证：" << endl;
	for (int i = 0; i < vecHc.size(); i++)
	{
		cv::Mat Hcb = vecHg[i] * Hcg * vecHc[i];
		cout << vecHg[i] * Hcg * vecHc[i] << endl << endl;//.inv()
		cv::Point3d data(Hcb.at<double>(0, 3), Hcb.at<double>(1, 3), Hcb.at<double>(2, 3));
		cout << cv::norm(data) << endl << endl;
	}
	
	cout << "标定板在相机中的位姿：" << endl;
	cout << vecHc[1] << endl;
	cout << "手眼系统反演的位姿为：" << endl;
	//用手眼系统预测第一组数据中标定板相对相机的位姿，是否与vecHc[1]相同
	cout << Hcg.inv()* vecHg[1].inv()* vecHg[0] * Hcg*vecHc[0] << endl << endl;

	cout << "----手眼系统测试----" << endl;
	cout << "机械臂下标定板XYZ为：" << endl;
	double aveX = 0.0, aveY = 0.0, aveZ = 0.0;
	std::vector<cv::Mat> vworldPos;
	for (int i = 0; i < vecHc.size(); ++i)
	{
		cv::Mat cheesePos{ 0.0,0.0,0.0,1.0 };//4*1矩阵，单独求机械臂下，标定板的xyz
		cv::Mat worldPos = vecHg[i] * Hcg*vecHc[i] * cheesePos;
		vworldPos.push_back(worldPos);

		aveX = aveX + worldPos.at<double>(0, 0);
		aveY = aveY + worldPos.at<double>(1, 0);
		aveZ = aveZ + worldPos.at<double>(2, 0);
		cout << i << ": " << worldPos.t() << endl;
	}
	cout << endl;
	aveX = aveX / vecHc.size();
	aveY = aveY / vecHc.size();
	aveZ = aveZ / vecHc.size();

	double errX = 0.0, errY = 0.0, errZ = 0.0;
	for (int i = 0; i < vworldPos.size(); i++)
	{
		errX = errX + abs(vworldPos[i].at<double>(0, 0) - aveX);
		errY = errY + abs(vworldPos[i].at<double>(1, 0) - aveY);
		errZ = errZ + abs(vworldPos[i].at<double>(2, 0) - aveZ);
	}
	cout << "X方向的精度：" << errX / vworldPos.size() << endl;
	cout << "Y方向的精度：" << errY / vworldPos.size() << endl;
	cout << "Z方向的精度：" << errZ / vworldPos.size() << endl;

	{
		cv::FileStorage writer("./pose.yaml", cv::FileStorage::WRITE);
		if (!writer.isOpened())
			return;
		writer << "R" << R_cam2gripper;
		writer << "t" << t_cam2gripper;
		writer.release();
	}
};

bool sRotatedMatrix(Mat& R)		//旋转矩阵的转置矩阵是它的逆矩阵，逆矩阵 * 矩阵 = 单位矩阵
{
	Mat temp33 = R({ 0,0,3,3 });	//无论输入是几阶矩阵，均提取它的三阶矩阵
	Mat Rt;
	transpose(temp33, Rt);  //转置矩阵
	Mat shouldBeIdentity = Rt * temp33;//是旋转矩阵则乘积为单位矩阵
	Mat I = Mat::eye(3, 3, shouldBeIdentity.type());

	return cv::norm(I, shouldBeIdentity) < 1e-6;
}

cv::Vec3f rotationMatrixToEulerAngles(cv::Mat &R)
{
	assert(isRotatedMatrix(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;
	}
	return cv::Vec3f(z, y, x);
}

void Tsai_HandEye(Mat& Hcg, vector<Mat> Hgij, vector<Mat> Hcij)
{
	CV_Assert(Hgij.size() == Hcij.size());
	int nStatus = Hgij.size();

	Mat Rgij(3, 3, CV_64FC1);
	Mat Rcij(3, 3, CV_64FC1);

	Mat rgij(3, 1, CV_64FC1);
	Mat rcij(3, 1, CV_64FC1);

	double theta_gij;
	double theta_cij;

	Mat rngij(3, 1, CV_64FC1);
	Mat rncij(3, 1, CV_64FC1);

	Mat Pgij(3, 1, CV_64FC1);
	Mat Pcij(3, 1, CV_64FC1);

	Mat tempA(3, 3, CV_64FC1);
	Mat tempb(3, 1, CV_64FC1);

	Mat A;
	Mat b;
	Mat pinA;

	Mat Pcg_prime(3, 1, CV_64FC1);
	Mat Pcg(3, 1, CV_64FC1);
	Mat PcgTrs(1, 3, CV_64FC1);

	Mat Rcg(3, 3, CV_64FC1);
	Mat eyeM = Mat::eye(3, 3, CV_64FC1);

	Mat Tgij(3, 1, CV_64FC1);
	Mat Tcij(3, 1, CV_64FC1);

	Mat tempAA(3, 3, CV_64FC1);
	Mat tempbb(3, 1, CV_64FC1);

	Mat AA;
	Mat bb;
	Mat pinAA;

	Mat Tcg(3, 1, CV_64FC1);

	for (int i = 0; i < nStatus; i++)
	{
		Hgij[i](Rect(0, 0, 3, 3)).copyTo(Rgij);
		Hcij[i](Rect(0, 0, 3, 3)).copyTo(Rcij);

		Rodrigues(Rgij, rgij);
		Rodrigues(Rcij, rcij);

		theta_gij = norm(rgij);
		theta_cij = norm(rcij);

		rngij = rgij / theta_gij;
		rncij = rcij / theta_cij;

		Pgij = 2 * sin(theta_gij / 2)*rngij;
		Pcij = 2 * sin(theta_cij / 2)*rncij;

		tempA = skew(Pgij + Pcij);
		tempb = Pcij - Pgij;

		A.push_back(tempA);
		b.push_back(tempb);
	}

	//Compute rotation
	invert(A, pinA, DECOMP_SVD);

	Pcg_prime = pinA * b;
	Pcg = 2 * Pcg_prime / sqrt(1 + norm(Pcg_prime) * norm(Pcg_prime));
	PcgTrs = Pcg.t();
	Rcg = (1 - norm(Pcg) * norm(Pcg) / 2) * eyeM + 0.5 * (Pcg * PcgTrs + sqrt(4 - norm(Pcg)*norm(Pcg))*skew(Pcg));

	//Compute Translation 
	for (int i = 0; i < nStatus; i++)
	{
		Hgij[i](Rect(0, 0, 3, 3)).copyTo(Rgij);
		Hcij[i](Rect(0, 0, 3, 3)).copyTo(Rcij);
		Hgij[i](Rect(3, 0, 1, 3)).copyTo(Tgij);
		Hcij[i](Rect(3, 0, 1, 3)).copyTo(Tcij);


		tempAA = Rgij - eyeM;
		tempbb = Rcg * Tcij - Tgij;

		AA.push_back(tempAA);
		bb.push_back(tempbb);
	}

	invert(AA, pinAA, DECOMP_SVD);
	Tcg = pinAA * bb;

	Rcg.copyTo(Hcg(Rect(0, 0, 3, 3)));
	Tcg.copyTo(Hcg(Rect(3, 0, 1, 3)));
	Hcg.at<double>(3, 0) = 0.0;
	Hcg.at<double>(3, 1) = 0.0;
	Hcg.at<double>(3, 2) = 0.0;
	Hcg.at<double>(3, 3) = 1.0;

}

//R和T转RT矩阵
Mat R_T2RT(Mat &R, Mat &T)
{
	Mat RT;
	Mat_<double> R1 = (cv::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.0, 0.0);
	cv::Mat_<double> T1 = (cv::Mat_<double>(4, 1) << T.at<double>(0, 0), T.at<double>(1, 0), T.at<double>(2, 0), 1.0);

	cv::hconcat(R1, T1, RT);//C=A+B左右拼接
	return RT;
}
  1. 标定板三维点构建方式：
	//生成标定板三维点，标定板纵向角点数量mInitParams.CalibrateBoardSize.height,例如(8)
	//标定板横向角点数量mInitParams.CalibrateBoardSize.width，例如(11)
	//标定板一个格子的大小CalibrateBoardLength，例如(15)。
	mvStandardCalibrateBoard.resize(0);
	for (int i = 0; i < mInitParams.CalibrateBoardSize.height; i++)
	{
		for (int j = 0; j < mInitParams.CalibrateBoardSize.width; j++)
		{
			mvStandardCalibrateBoard.push_back(cv::Point3f(float(j * mInitParams.CalibrateBoardLength), float(i * mInitParams.CalibrateBoardLength), 0));
		}
	}
  1. 标定板图像二维点构建方式：
void runCalibrateBoardDetect(const cv::Mat& im, std::vector<cv::Point2f>& FeaturePoints, cv::Rect Roi)
{
	mImageSize = im.size();

	cv::Mat imGray;
	cv::Rect _Roi;
	if (im.channels() != 1)
	{
		if (Roi.width == 0 || Roi.height == 0)
		{
			cv::cvtColor(im, imGray, cv::COLOR_BGR2GRAY);
		}
		else
		{
			_Roi = ChangeRoi(Roi, imGray.rows, imGray.cols);
			cv::cvtColor(im(_Roi), imGray, cv::COLOR_BGR2GRAY);
		}
	}
	else
	{
		if (Roi.width == 0 || Roi.height == 0)
		{
			imGray = im.clone();
		}
		else
		{
			_Roi = ChangeRoi(Roi, imGray.rows, imGray.cols);
			imGray = im(_Roi).clone();
		}
	}

	bool is_found = cv::findChessboardCorners(imGray, mInitParams.CalibrateBoardSize, FeaturePoints);
	if (is_found)
		cv::cornerSubPix(imGray, FeaturePoints, cv::Size(7, 7), cv::Size(-1, -1), cv::TermCriteria(cv::TermCriteria::EPS + cv::TermCriteria::COUNT, 30, 0.1));

	if (is_found)
	{
		if (Roi.width == 0 || Roi.height == 0)
		{
			mvvCalibrateBoard2DPoints.push_back(FeaturePoints);
		}
		else
		{
			for (int i = 0; i < FeaturePoints.size(); i++)
			{
				FeaturePoints[i].x = FeaturePoints[i].x + _Roi.x;
				FeaturePoints[i].y = FeaturePoints[i].y + _Roi.y;
			}
			mvvCalibrateBoard2DPoints.push_back(FeaturePoints);
		}
		mvvStandardCalibrateBoard.push_back(mvStandardCalibrateBoard);
	}
}
  1. 相机内参计算方式：
void runMonoCalobrate(double& error)
{
	if (mvvCalibrateBoard2DPoints.size() < 3)
	{
		std::cout << (std::string("no enough images for camera ") + std::to_string(0)) << std::endl;
		return;
	}
	mRvecs.clear();
	mTvecs.clear();
	error = cv::calibrateCamera(mvvStandardCalibrateBoard, mvvCalibrateBoard2DPoints, mImageSize, mintrinsicParam, mdistortParam, mRvecs, mTvecs);
}

3、提高精度的几个方向

  1. 两次运动的旋转轴的夹角：越大越好
  2. 每次运动的旋转矩阵对应的旋转角度：越大越好
  3. 相机中心到标定板的距离：距离越小越好
  4. 每次运动机械臂末端运动的距离：距离越小越好
  5. 尽量采集多组用于求解的数据。
  6. 使用高精度的相机标定方法。
  7. 尽量提高机械臂的绝对定位精度，如果该条件达不到，至少需要提高相对运动精度。
小落叶不憨
关注
  • 22
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
手眼标定----眼在手上(eye-in-hand)
苏州程序大白的博客
12-18 3016
@TOC 标定之前你可以先拿个怡宝盖子进行测试。 第一步：打开halcon，采集，然后生成代码，显示十字架 第二步:把怡宝盖子放在十字架中心位置，在图像处理，找到怡宝盖子 第三步:找到怡宝盖子然后进行九点标定(眼在外帖子有讲),移动机器手然后分别拍9次照片,记录怡宝盖子坐标和当前机器坐标。这里移动到中心位置的时候记录一下单独记录一下坐标,等下要用。 顺序 第四步:拍完后利用vector_to_hom_mat2d算子求出矩阵,然后在利用write_tuple (HomMat2D, ‘路径’)进行保存。这里
九点标定 opencv 方式实现 手眼标定
10-18
手眼标定是机器人视觉领域中的一个重要概念，它涉及到如何将摄像头捕捉到的二维图像坐标与机器人实际工作空间中的三维坐标进行对应。在自动化生产和智能制造中，这种转换关系对于精确控制机器人的动作至关重要。...
手眼标定—眼在手上（eye-in-hand）基本原理
wmyxfpa的博客
12-28 4350
手眼标定—眼在手上（eye-in-hand）基本原理及标定过程和计算数据获取
手眼标定原理（眼在手上和眼在手外）
hy2014x的博客
06-22 3万+
手眼标定、3D视觉、相机标定、图像处理、机器视觉
手眼标定方法——原理
最新发布
2303_80018785的博客
06-10 1391
眼在手外（eye To hand）: 即相机固定在机械臂以外的地方，主要标定相机和基底坐标系的转换矩阵 眼在手上（eye in hand）： 即相机固定在机械臂末端，主要标定相机和机械臂末端的旋转矩阵
机器人定位测量手眼标定详解[眼在手上手外]
weixin_43925768的博客
02-10 1203
Scara 手眼标定详解[眼在手上][眼在手外]
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...
Halcon：手眼标定——眼在手外与眼在手上
JiYuee Note
09-21 9172
为什么需要九点标定？ 为了得到机械和相机的关系，就好比人的手和眼的关系。我们用手将一个物体放到空间的一个位置，用眼看到这个物体，这也存在两个坐标系，一个是手所在的运动空间的坐标系，一个是视网膜上成像的二维平面坐标系。我们用眼看到一个物体，用手去拿，之所以能够准确地拿到这个物体，是因为我们的神经系统把这两个坐标系准确地关联好了。机械和视觉系统也是这样，相机对工作空间中的物体进行拍照，机械手要想准确地取到这个物体，就必须首先把机械坐标系和视觉坐标系进行准确地关联。九点标定的基本原理： 使用机械手将物体放在工作空
3D相机机器人手眼标定(眼在手上)全过程
jyfwinner的博客
09-29 1万+
3D相机机器人手眼标定(眼在手上)全过程 简述 目前在机器人高层规划中,机器人越来越依赖于摄像头的反馈信息,比如自动打磨,焊接,喷涂的智能规划,或者一些分拣,码垛的规划. 在项目开始前, 第一步要做的一定是给机器人和摄像头进行标定. 那么如何结合机器人标定摄像头就是本片要讨论的问题. 本片接下来就是记录我自己做的标定全过程. 标定摄像头前一定要先标定机器人 手眼标定非常依赖机器人给出的参数,如果参数不准确,一定会影响到标定结果. 而且还很难察觉. 否则,会浪费大量时间在检查摄像头标定步骤中, 却忽略机器人参
线激光器的手眼标定方法
01-24
由于安装等原因，机器人与激光传感器的位置关系是未知的，为了实现精确测量，在测量前需要对机器人与激光器位置关系的求解与校正，即“手眼标定”。传统的手眼标定方法是基于摄像机的标定，但这种方法不适用于线激光...
Halcon SCARA关节机器人手眼标定例程注解.zip_halcom手眼标定_halcon_halcon 手眼标定_halc
07-15
通过Halcon SCARA关节机器人手眼标定例程，开发者可以快速理解和掌握手眼标定的原理与方法。程序中包含的注解对理解每个步骤的作用至关重要，它能帮助用户避免常见的错误，提高标定效率。 总之，Halcon提供的SCARA...
机器人手眼标定Matlab程序（高精度）
12-05
在机器人技术领域，手眼标定是一项至关重要的技术，它涉及到机器人与视觉传感器之间的坐标系对齐。手眼标定的目的是确保机器人能够准确地理解视觉传感器所捕捉的信息，从而进行精确的操作。在这个场景中，我们有一个...
halcon手眼标定
11-08
在自动化领域，手眼标定是一项关键的技术，用于精确地协调机器人（机械手）与视觉系统（通常是相机）之间的坐标系。Halcon是德国MVTec公司开发的一种强大的机器视觉软件，提供了丰富的图像处理和模式识别功能。在这...
手眼标定(eye in hand)-步骤
Bolly_He的博客
06-22 1万+
第一步：明确四个坐标系 base坐标系：base 法兰坐标系: falan 相机坐标系: cam 标定板/物坐标系: cal 第二步：坐标系间的转换关系 A1，A2：已知即为falan坐标系到base坐标系的转换关系，由机器人系统得知（已知） B1,B2：相机坐标系到标定板坐标系的转换关系（相机外参），由相机标定求出；（相当于已知） X：相机坐标系到标定falan坐标系的转换关系，机械手运动过程中保持不变（未知，待求） baseHcal：标定板坐标到base坐标...
Halcon标定系列（3）：我个人总结的“眼在手外“和“眼在手上”的心得笔记
$firecat利白的代码足迹$
06-28 1万+
字面意思，眼代表眼睛，这里指的是我们的工业相机； 手，指的是我们的运动部分，比如机械手或者运动控制系统； 眼在手上，就是相机按照在运动轴上面，跟随运动的某个轴一起运动，这种标定就是图像和机械点一一运动去做标定。 眼在手外，就是相机固定一个位置拍照，机械手或者运动部分不会带动相机，这个时候标定就要一次性拍全视野，然后机械部分再一一针对图像的上点做好对应关系，然后标定。 这两种标定是我们图像和运动部分联合主要的两种标定方法，都可以实现图像转机械运动，就是标定关系不一样而已，结果都是一样的！ 眼在手上就是一个点
手眼标定的两种方式
热门推荐
wzj5530的专栏
08-24 5万+
最近在学习手眼标定，做下笔记，和大家分享下学习经历： 一 手眼标定的两种情形 首先讲一下在工业应用中，手和眼（摄像机）的两种位置关系，第一种是将摄像机（眼）固定在机械手（手）上面，眼随手移动；第二种是摄像机（眼）和机械手（手）分离，眼的位置相对于手是固定的，下面用网上的两张图来说明下： 第一种情况：相机移动 第二种情况：相机固定 从上面两副示意图可以看出，第一种情况中我们
手眼标定详述(坐标系介绍，二维、三维的手眼标定方法@九点法、AX=XB)
m0_52785249的博客
08-04 1万+
写在前面 手眼标定基本分类 手眼标定坐标系 眼在手外（EYE TO HEAD） 眼在手上（EYE IN HEAD） 九点法（二维）- 算法实现流程 AX=XB方法（二维或三维）- 推导 坐标系转换&运算规则 齐次坐标系 实际坐标系转换公式推导 眼在手外 眼在手上 求解 AX=XB方法（二维或三维）- 算法实现流程（总结） 源码相关博文......
手眼标定眼在手上
qq_36786800的博客
08-06 1371
在定位时候，往往希望相机能返回的是机械的世界坐标，而不是相机的的图像坐标。从而间接计算出相机坐标系与机械坐标世界坐标转换矩阵，以镜头中心为参考点。
手眼标定（眼在手上）代码及注意事项
qq_56089536的博客
01-26 1497
本文重点放在了手眼标定的代码以及使用代码的注意事项，虽然网上有很多相关代码，但是个人感觉解释不够清楚或者没有提示需要注意的地方，因此本人希望本篇文章帮助大家少走一些弯路，这也是本人第一次写文章，如果有什么不合适的地方，希望大家多多担待，当然大家有什么问题也可以给我留言，我会尽力解决各位的疑惑。
全自动手眼标定的实现原理
06-10
全自动手眼标定是指使用机器人手臂和相机等设备，对其进行标定，以实现机器人手臂的精准定位和运动控制。其实现原理如下： 1. 建立手眼坐标系：首先需要建立机器人手臂和相机之间的坐标系，以便精准地描述它们之间...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值