opencv相机内参标定和与halcon内参的转换

已于 2022-12-19 17:27:02 修改
阅读量1.1k 收藏 8
点赞数 2
文章标签： opencv 计算机视觉 人工智能
于 2022-12-19 17:06:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46021786/article/details/128374651
版权

opencv摄像机内参标定&halcon内参与opencv内参相互转换

opencv摄像机内参标定

下面展示一些 内联代码片。

// 内参标定
var foo = 'bar';

//内参标定

#include <iostream>
#include <sstream>
#include <string>
#include <ctime>
#include <cstdio>

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

using namespace cv;
using namespace std;
//此处省略各种头文件
using namespace cv;
using namespace std;
//此处省略help()函数
enum {
	DETECTION = 0, CAPTURING = 1, CALIBRATED = 2
};
enum Pattern {
	CHESSBOARD, CIRCLES_GRID, ASYMMETRIC_CIRCLES_GRID
};

//计算重投影误差函数
static double computeReprojectionErrors(const vector<vector<Point3f> >& objectPoints,const vector<vector<Point2f> >& imagePoints,
	const vector<Mat>& rvecs, const vector<Mat>& tvecs,const Mat& cameraMatrix, const Mat& distCoeffs,vector<float>& perViewErrors)
{
	vector<Point2f> imagePoints2;
	size_t totalPoints = 0;
	double totalErr = 0, err;
	perViewErrors.resize(objectPoints.size());

	
	return std::sqrt(totalErr / totalPoints);
	//此处省略...
}

static void calcChessboardCorners(Size boardSize, float squareSize, vector<Point3f>& corners)
{
	corners.clear();
	for (int i = 0; i < boardSize.height; ++i)
		for (int j = 0; j < boardSize.width; ++j)
			corners.push_back(Point3f(j*squareSize, i*squareSize, 0));		
	//省略...
	//本文中用到的标定板，在该函数中的参数为：boardSize.width=7,boardSize.height=7,squareSize=0.025(此处单位为米)
}
//执行标定，包括计算重投影误差
static bool runCalibration(vector<vector<Point2f> > imagePoints,
	Size imageSize, Size boardSize, 
	float squareSize, float aspectRatio,
	int flags, Mat& cameraMatrix, Mat& distCoeffs,
	vector<Mat>& rvecs, vector<Mat>& tvecs,
	vector<float>& reprojErrs,
	double& totalAvgErr)
{
	vector<Point3f> newObjPoints;
	//! [fixed_aspect]
	cameraMatrix = Mat::eye(3, 3, CV_64F);
	if (CALIB_FIX_ASPECT_RATIO)
		cameraMatrix.at<double>(0, 0) = aspectRatio;
	//! [fixed_aspect]
	
		distCoeffs = Mat::zeros(8, 1, CV_64F);

	cout << "New board corners: " << endl;
	cout << newObjPoints[0] << endl;
	cout << newObjPoints[boardSize.width - 1] << endl;
	cout << newObjPoints[boardSize.width * (boardSize.height - 1)] << endl;
	cout << newObjPoints.back() << endl;
	cout << "Re-projection error reported by calibrateCamera: " << rms << endl;
	bool ok = checkRange(cameraMatrix) && checkRange(distCoeffs);
	bool isw = false;
	objectPoints.clear();
	objectPoints.resize(imagePoints.size(), newObjPoints);
	totalAvgErr = computeReprojectionErrors(objectPoints, imagePoints, rvecs, tvecs, cameraMatrix,
		distCoeffs, reprojErrs);
	//省略...
	return true;
}

//读取字符串
static bool readStringList(const string& filename, vector<string>& l)
{
	l.resize(0);
	FileStorage fs(filename, FileStorage::READ);
	if (!fs.isOpened())
		return false;
	FileNode n = fs["images"];
	if (n.type() != FileNode::SEQ)
		return false;
	FileNodeIterator it = n.begin(), it_end = n.end();
	for (; it != it_end; ++it)
		l.push_back((string)*it);
	return true;
}

//运行并保存
static bool runAndSave(const string& outputFilename,
	const vector<vector<Point2f> >& imagePoints,
	Size imageSize, Size boardSize, Pattern patternType, float squareSize,
	float aspectRatio, int flags, Mat& cameraMatrix,
	Mat& distCoeffs, bool writeExtrinsics, bool writePoints)
{
	vector<Mat> rvecs, tvecs;
	vector<float> reprojErrs;
	double totalAvgErr = 0;
	vector<Point3f> newObjPoints;

	bool ok = runCalibration(imagePoints, imageSize, boardSize, squareSize, aspectRatio, flags, cameraMatrix, distCoeffs, rvecs, tvecs,	reprojErrs,totalAvgErr);
	cout << (ok ? "Calibration succeeded" : "Calibration failed")
		<< ". avg re projection error = " << totalAvgErr << endl;

	FileStorage fs(outputFilename, FileStorage::WRITE);

	time_t tm;
	time(&tm);
	struct tm *t2 = localtime(&tm);
	char buf[1024];
	strftime(buf, sizeof(buf), "%c", t2);

	fs << "calibration_time" << buf;

	if (!rvecs.empty() || !reprojErrs.empty())
		fs << "nr_of_frames" << (int)std::max(rvecs.size(), reprojErrs.size());
	fs << "image_width" << imageSize.width;
	fs << "image_height" << imageSize.height;
	fs << "board_width" << boardSize.width;
	fs << "board_height" << boardSize.height;
	fs << "square_size" << squareSize;

	std::stringstream flagsStringStream;
	bool flag = true;
	flagsStringStream << "flags:"
		<< (flag & CALIB_USE_INTRINSIC_GUESS ? " +use_intrinsic_guess" : "")
		<< (flag & CALIB_FIX_ASPECT_RATIO ? " +fix_aspectRatio" : "")
		<< (flag & CALIB_FIX_PRINCIPAL_POINT ? " +fix_principal_point" : "")
		<< (flag & CALIB_ZERO_TANGENT_DIST ? " +zero_tangent_dist" : "")
		<< (flag & CALIB_FIX_K1 ? " +fix_k1" : "")
		<< (flag & CALIB_FIX_K2 ? " +fix_k2" : "")
		<< (flag & CALIB_FIX_K3 ? " +fix_k3" : "")
		<< (flag & CALIB_FIX_K4 ? " +fix_k4" : "")
		<< (flag & CALIB_FIX_K5 ? " +fix_k5" : "");

	fs.writeComment(flagsStringStream.str());

	fs << "camera_matrix" << cameraMatrix;
	fs << "distortion_coefficients" << distCoeffs;

	fs << "avg_reprojection_error" << totalAvgErr;
	if ( !reprojErrs.empty())
		fs << "per_view_reprojection_errors" << Mat(reprojErrs);

	if (!rvecs.empty() && !tvecs.empty())
	{
		CV_Assert(rvecs[0].type() == tvecs[0].type());
		Mat bigmat((int)rvecs.size(), 6, CV_MAKETYPE(rvecs[0].type(), 1));
		bool needReshapeR = rvecs[0].depth() != 1 ? true : false;
		bool needReshapeT = tvecs[0].depth() != 1 ? true : false;

		for (size_t i = 0; i < rvecs.size(); i++)
		{
			Mat r = bigmat(Range(int(i), int(i + 1)), Range(0, 3));
			Mat t = bigmat(Range(int(i), int(i + 1)), Range(3, 6));

			if (needReshapeR)
				rvecs[i].reshape(1, 1).copyTo(r);
			else
			{
				//*.t() is MatExpr (not Mat) so we can use assignment operator
				CV_Assert(rvecs[i].rows == 3 && rvecs[i].cols == 1);
				r = rvecs[i].t();
			}

			if (needReshapeT)
				tvecs[i].reshape(1, 1).copyTo(t);
			else
			{
				CV_Assert(tvecs[i].rows == 3 && tvecs[i].cols == 1);
				t = tvecs[i].t();
			}
		}
		fs.writeComment("a set of 6-tuples (rotation vector + translation vector) for each view");
		fs << "extrinsic_parameters" << bigmat;
	}

	if (writePoints && !imagePoints.empty())
	{
		Mat imagePtMat((int)imagePoints.size(), (int)imagePoints[0].size(), CV_32FC2);
		for (size_t i = 0; i < imagePoints.size(); i++)
		{
			Mat r = imagePtMat.row(int(i)).reshape(2, imagePtMat.cols);
			Mat imgpti(imagePoints[i]);
			imgpti.copyTo(r);
		}
		fs << "image_points" << imagePtMat;
	}

	if (!newObjPoints.empty())
	{
		fs << "grid_points" << newObjPoints;
	}
	return true;
}

int main(int argc, char** argv)
{
	cout << argc << endl;
	for (size_t i = 0; i < argc; i++)
	{
		cout << argv[i] << endl;
	}

	Size boardSize, imageSize;
	float squareSize, aspectRatio;
	Mat cameraMatrix = Mat::eye(3, 3, CV_64F), distCoeffs;
	string outputFilename;
	string inputFilename = "";

	int i, nframes;
	bool writeExtrinsics, writePoints;
	bool undistortImage = false;
	int flags = 0;
	VideoCapture capture;
	bool flipVertical;
	bool showUndistorted;
	bool videofile;
	int delay;
	clock_t prevTimestamp = 0;
	int mode = DETECTION;
	int cameraId = 0;
	vector<vector<Point2f> > imagePoints;
	vector<string> imageList;
	Pattern pattern = CIRCLES_GRID;//标定图案类型，对称圆形图案
	boardSize.width = parser.get<int>("w");
	boardSize.height = parser.get<int>("h");
	if (parser.has("pt"))
	{
		string val = parser.get<string>("pt");
		if (val == "circles")
			pattern = CIRCLES_GRID;
		else if (val == "acircles")
			pattern = ASYMMETRIC_CIRCLES_GRID;
		else if (val == "chessboard")
			pattern = CHESSBOARD;
		else
			return fprintf(stderr, "Invalid pattern type: must be chessboard or circles\n"), -1;
	}
	squareSize = parser.get<float>("s");
	nframes = parser.get<int>("n");
	aspectRatio = parser.get<float>("a");
	delay = parser.get<int>("d");
	writePoints = parser.has("op");
	writeExtrinsics = parser.has("oe");
	if (parser.has("a"))
		flags |= CALIB_FIX_ASPECT_RATIO;
	if (parser.has("zt"))
		flags |= CALIB_ZERO_TANGENT_DIST;
	if (parser.has("p"))
		flags |= CALIB_FIX_PRINCIPAL_POINT;
	flipVertical = parser.has("v");
	videofile = parser.has("V");
	if (parser.has("o"))
		outputFilename = parser.get<string>("o");
	showUndistorted = parser.has("su");
	if (isdigit(parser.get<string>("input_data")[0]))
		cameraId = parser.get<int>("input_data");
	else
		inputFilename = parser.get<string>("input_data");

	if (!parser.check())
	{
		parser.printErrors();
		return -1;
	}
	if (squareSize <= 0)
		return fprintf(stderr, "Invalid board square width\n"), -1;
	if (nframes <= 3)
		return printf("Invalid number of images\n"), -1;
	if (aspectRatio <= 0)
		return printf("Invalid aspect ratio\n"), -1;
	if (delay <= 0)
		return printf("Invalid delay\n"), -1;
	if (boardSize.width <= 0)
		return fprintf(stderr, "Invalid board width\n"), -1;
	if (boardSize.height <= 0)
		return fprintf(stderr, "Invalid board height\n"), -1;

	if (!inputFilename.empty())
	{
		if (!videofile && readStringList(inputFilename, imageList))
			mode = CAPTURING;
		else
			capture.open(inputFilename);
	}
	else
		capture.open(cameraId);

	if (!capture.isOpened() && imageList.empty())
		return fprintf(stderr, "Could not initialize video (%d) capture\n", cameraId), -2;

	if (!imageList.empty())
		nframes = (int)imageList.size();

	namedWindow("Image View",WINDOW_AUTOSIZE);
	
	for (i = 0;; i++)
	{
		Mat view, viewGray;
		bool blink = false;		
		if (i < (int)imageList.size())
		{
			view = imread(imageList[i], 1);
			cvtColor(view, viewGray, COLOR_BGR2GRAY);
		}
		else
		{
			break;
		}
		imageSize = view.size();
		vector<Point2f> pointbuf;
		bool found;
		imagePoints.push_back(pointbuf);		
		if (found)
			drawChessboardCorners(view, boardSize, Mat(pointbuf), found);//在原图中绘制找到的圆心点，图4为其中的一幅图

		string msg = mode == CAPTURING ? "100/100" :
			mode == CALIBRATED ? "Calibrated" : "Press 'g' to start";
		int baseLine = 0;
		Size textSize = getTextSize(msg, 1, 1, 1, &baseLine);
		Point textOrigin(view.cols - 2 * textSize.width - 10, view.rows - 2 * baseLine - 10);

		/*if (mode == CAPTURING)
		{
			if (undistortImage)
				msg = format("%d/%d Undist", (int)imagePoints.size(), nframes);
			else
				msg = format("%d/%d", (int)imagePoints.size(), nframes);
		}*/

		putText(view, msg, textOrigin, 1, 1,
			mode != CALIBRATED ? Scalar(0, 0, 255) : Scalar(0, 255, 0));

		if (blink)
			bitwise_not(view, view);

		if (mode == CALIBRATED && undistortImage)
		{
			Mat temp = view.clone();
			undistort(temp, view, cameraMatrix, distCoeffs);
		}

		imshow("Image View", view);
		char key = (char)waitKey(capture.isOpened() ? 50 : 500);

		if (key == 27)
			break;

		if (key == 'u' && mode == CALIBRATED)
			undistortImage = !undistortImage;

		if (capture.isOpened() && key == 'g')
		{
			mode = CAPTURING;
			imagePoints.clear();
		}	

		if (imagePoints.size() >= (unsigned)nframes)
		{
			if (runAndSave(outputFilename, imagePoints, imageSize, boardSize, pattern, squareSize, aspectRatio, flags, cameraMatrix, distCoeffs, writeExtrinsics, writePoints))
				mode = CALIBRATED;
			else
				mode = DETECTION;
		}
	}
	//畸变矫正
	/*if (!capture.isOpened() && !showUndistorted)
	{
		Mat view, rview, map1, map2;		
		initUndistortRectifyMap(cameraMatrix, distCoeffs, Mat(),getOptimalNewCameraMatrix(cameraMatrix, distCoeffs, imageSize, 1, imageSize, 0),imageSize, CV_16SC2, map1, map2);

		for (size_t i = 0; i < imageList.size(); i++)
		{
			view = imread(imageList[i], IMREAD_COLOR);
			if (view.empty())
				continue;
			remap(view, rview, map1, map2, INTER_LINEAR);
			imshow("Image View", rview);
			char c = (char)waitKey();		
		}
		
		
	}*/

	return 0;
}

halcon内参和opencv内参标定结果
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述xiamian

halcon内参与opencv内参相互转换

opencv_fx = halcon_f / sx *1000
opencv_fy = halcon_f / sy *1000

在这里插入图片描述opencv的内参矩阵，其中f是焦距，dx是单个像元的宽，dy是单个像元的高，u0是中心点X坐标，v0是中心点Y坐标（对应halcon标定的参数）

链接: [link](https://pan.baidu.com/s/1ukJ87D820tR6m7xzlvR66w /)
提取码：q5nu

alwanZ
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
opencv标定halcon的圆点标定板
03-04
本文主要围绕"opencv标定halcon的圆点标定板"这一主题，深入探讨相机标定的过程、原理以及使用到的关键技术。 相机标定的目标是获得相机的内参矩阵和外参，内参矩阵包括焦距、主点坐标等，外参则包含了相机的位置和...
halcon和opencv内参标定结果的关系
u011129278的博客
12-29 1356
1、halcon相机内参标定的结果 CameraParameters=[f（m），Kappa，Sx（m），Sy（m），Cx，Cy，width，Height] 2、opencv相机内参标定的结果 3、两者之间的关系 参考：https://www.pianshen.com/article/51301367667/ https://stackoverflow.com/questions/58606394/halcon-to-opencv-distortion-coefficients-c...
opencv和C++使用Halcon标定的相机内参和外参,将图像坐标转为世界坐标
weixin_52033229的博客
04-03 1173
下式为像素坐标pixel与世界坐标world的转换公式，右侧第一个矩阵为相机内参数矩阵，第二个矩阵为相机外参数矩阵。假设图像坐标已知，同时相机内参数矩阵通过标定已获取，还需计算比例系数s和外参数矩阵。dx：像素x方向宽度，单位毫米；（1）计算参数s和旋转平移矩阵，需要输入一系列的世界坐标系的点及其对应的图像坐标系的点。相机中有四个坐标系，分别为world，camera，image，pixel。s为比例系数, M为相机内参数矩阵，R为旋转矩阵，t为平移矩阵，f/dx：使用像素来描述x轴方向的焦距的长度。
Opencv之生成Halcon标定板
ancy的博客
12-22 442
代码展示: # -*- coding:utf-8 -*- import cv2 import numpy as np class HalconBoard: def __init__(self, pattern_size_hw, resolution_mm): self._pattern_size_hw = pattern_size_hw self._resolution_mm = resolution_mm self._object_point
halcon 相机内参标定
weixin_46822296的博客
09-19 57
待写。
halcon与opencv图像类型转换
m0_51133195的博客
07-22 402
HImage和Mat类型转换，支持灰度图和RGB彩图。
关于halcon内参转OpenCV内参
weixin_37966295的博客
07-31 824
这样转靠谱吗？ 废话不多，先上代码 void CCeresProblem::halconToCvParam(HTuple camParam, cv::Mat &cvParam, cv::Mat &D) { D = (cv::Mat_<double>(1, 5) << 0, 0, 0, 0, 0); cvParam = (cv::Mat_<double>(3, 3) << 0, 0, 0, 0, 0, 0, 0, 0, 0); HT
双目相机标定结果应用——测三维坐标
03-30
双目相机的标定过程主要包括相机内参标定和外参标定。内参标定涉及相机的光学特性，如焦距、主点坐标等，通常通过拍摄棋盘格图案并进行优化得到。外参标定则关注相机之间的相对位置和姿态，这通常需要在已知坐标系下...
C# 实现Halcon标定助手源代码
01-31
Halcon的标定助手主要功能包括平面标定、三维标定、多视图标定等，通过计算相机的内参和外参，消除因镜头畸变、透视效应等因素导致的图像失真。这些参数对于精确地定位和测量物体在真实世界中的位置至关重要。 二、...
HC050-2标定版描述文件及标定版ps文件
最新发布
05-17
3. **相机标定**：相机标定是确定相机内参和外参的过程，目的是将像素坐标系转换为真实世界坐标系，消除镜头畸变，提高图像质量和测量精度。相机内参包括焦距、主点坐标和畸变系数，外参则是相机相对于世界坐标系的...
相机标定棋盘格图片下载（可直接打印使用）
11-23
常见的棋盘格尺寸有多种，本压缩包提供的是26mm和15mm两种，适应不同的应用场景和相机分辨率。 3. **opencv与matlab标定** - **opencv**：OpenCV是一个开源的计算机视觉库，其中包含了方便的相机标定函数`cv::...
opencv使用Halcon标定的相机内参和外参
南北粉面馆
05-15 3327
由于opencv开源的性质，所以一些细节做的不好，在标定细节上面不够完善，因此Halcon标定的结果明显优于opencv等开源标定包。 这里存在一个问题，就是如何把Halcon标定的结果输入到opencv中或者大部分开源体系的相机包。 这里给出我的经验，有些也是蒙的，因为详细了解要推导矫正公式。 先上一张标定结果图 ...
halcon学习和实践（从halcon转化为opencv）
嵌入式-老费，一个分享专业嵌入式知识的blog
09-01 2628
【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 halcon本身还是商业软件，从学习的角度来使用无可厚非，但是如果用在商业上面，那么就必须要获得halcon的授权，这是底线。那么既然学了halcon，又不愿意支付高额的费用，那么只有两条路了。第一个就是自己写一个image的库，另外一个就是寻找开源库，opencv就是其中的一种。......
相机标定参数格式Halcon转Opencv
qq_39629280的博客
04-12 3278
一、Opencv相机标定格式： 内参矩阵： 或 内参矩阵参数含义： f：焦距，单位毫米；dx：像素x方向宽度，单位毫米；1/dx:x方向1mm内有多少个像素； f/dx：使用像素来描述x轴方向的焦距的长度 f/dy：使用像素来描述y轴方向的焦距的长度 u0,v0为主点的实际位置，单位也是毫米。 畸变格式为：k1,k2,p1,p2,k3。 外参数:1*3的平移矩阵，3*3的旋转矩阵 二、Halcon格式 注意：k为畸变参数，当为五个的时候顺序是k1,k2,k3,p1,p2。（ope.
相机标定-机器视觉基础（理论推导、Halcon和OpenCV相机标定）
beyond951的博客
08-20 5713
相机标定是获得目标工件精准坐标信息的基础。首先，必须进行相机内参标定，构建一个模型消除图像畸变；其次，需要对相机和机器人的映射关系进行手眼标定，构建一个模型将图像坐标系上的点映射到世界坐标系。主要分为背景知识、相机内外参模型推导、编程代码实现三个部分。
Halcon的相机内参外参的标定
xunmizhengzha的博客
11-09 1186
halcon标定相机内参只能使用方向标定板和圆点标定板。并且方向标定板可也可用性极高。
OpenCv联合Halcon
yun15593225991的博客
11-23 140
本片文章主要说明了弧度与角度互相转换的方式，采用了C++语法，希望对你有所帮助。
相机标定张正友、opencv和halcon对比（1）
hao1183716597的专栏
11-29 1915
说了这么多到底有什么用呢，对于普通镜头，我们可以了解到标定出的焦距其实是主距。而对于其他镜头，我认为关键是初始值的选取，尤其是沙姆标定中，我们可以基于镜头参数，推导出理论初始值进行标定，然后控制标定的结果在理想的范围内是非常关键的。注意这里用的是halcon中的模型转换，opencv中的并没有说明它的模型怎么定义的，但我们用halcon的模型去套用应该也是没问题的。
Halcon标定参数（畸变系数）转OpenCV标定数据
LucasZhang‘s Blog
10-21 3399
标定板的质量对标定精度影响也是非常大的，我手上有一个陶瓷的Halcon原点标定板，使用Halcon标定效果很好。但由于想转用OpenCV开发，且不想放弃已有的图像数据，因此想将Halcon标定的数据(内参、外参，畸变系数)，转换到OpenCV中。 当然，其参数不是一一对应的（也就是说，Halcon中的畸变系数与OpenCV中的畸变系数并不一一对应，按照官方的说法是其求解的畸变参数的形式是不一样的。一个是由校正前到校正后求解得到，一个是由校正后到校正前求解得到）。 依据Stack Overflow中的数据，写
opencv相机标定标定板图像
06-06
相机标定指的是将相机的内参和外参确定下来，以便将相机采集到的图像转换为三维坐标系中的实际物体。 在OpenCV中，相机标定通常使用标定板图像来进行。标定板图像是一个特殊的图像，通常是由一个黑白方格组成的平面...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值