鱼眼摄像头 单目标定 双目标定

最新推荐文章于 2021-12-26 00:00:00 发布
最新推荐文章于 2021-12-26 00:00:00 发布
阅读量926 收藏 6
点赞数
分类专栏： C++ Tools 数字图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haithink/article/details/103315405
版权
C++ 同时被 3 个专栏收录
56 篇文章 0 订阅
订阅专栏
Tools
31 篇文章 0 订阅
订阅专栏
数字图像处理
12 篇文章 1 订阅
订阅专栏

准确地说是 使用鱼眼模型 对摄像头进行单目和双目标定
直接贴代码如下， 如果是 非鱼眼， 把相关函数名 和相关入参改下就可以了， 代码中处于 注释状态

2019-12-7 21:47:07
后续又思考了一下，OpenCV鱼眼模型应该参考的是 《A Generic Camera Model and Calibration Method for Conventional, Wide-Angle, and Fish-Eye Lenses》。 那既然是通用模型， 对一般相机也能用，也就是说 拿到一个相机，直接用鱼眼模型来标定。。。这个后面验证一下。


#include <opencv2/opencv.hpp>
#include <iostream>
#include <dirent.h>
#include <fstream>

using namespace std;

bool hasEnding (std::string const &fullString, std::string const &ending) {
    if (fullString.length() >= ending.length()) {
        return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending));
    } else {
        return false;
    }
}

// 扩展名必须为 jpg或者 png
void getImgNames(const char* imgsFolderL, const char* imgsFolderR, std::vector<std::string> &imgNamesL,
		std::vector<std::string> &imgNamesR)
{
	DIR* dp;
	struct dirent* dirp;
	dp = opendir(imgsFolderL);
	if(dp == NULL)
	{
		std::cout << "open directory error: " << imgsFolderL << std::endl;
	}

	while((dirp = readdir(dp)) != NULL)
	{
		std::string filename = dirp->d_name;
		if(filename.at(0) == '.')
		{
			continue;
		} else if(!hasEnding(filename, ".jpg") || !hasEnding(filename, ".png")) {
			continue;
		}

		filename = "/" + filename;
		std::cout << (imgsFolderL + filename) << std::endl;
		std::cout << (imgsFolderR + filename) << std::endl;
		imgNamesL.push_back(imgsFolderL + filename);
		imgNamesR.push_back(imgsFolderR + filename);
	}
	closedir(dp);

}

static bool saveCameraParams(const std::string &filename, int &leftHeight, int &leftWidth, 
		cv::Mat &leftD, cv::Mat &leftK, cv::Mat &leftR, cv::Mat leftP,
		int &rightHeight, int &rightWidth, cv::Mat &rightD, cv::Mat &rightK, cv::Mat &rightR, cv::Mat &rightP, cv::Mat &trans, cv::Mat& Trl)
{
	std::ofstream fs(filename.c_str());
	if(!fs.is_open())
	{
		return false;
	}
	/* std::time_t tt; */
	/* std::time(&tt); */
	/* struct tm *t2 = localtime(&tt); */
	/* char buf[1024]; */
	/* std::strftime(buf, sizeof(buf), "%c", t2); */

	/* std::string str = "1.0"; */
	fs << "%YAML:1.0" << std::endl;
	fs << std::endl;
	fs << "#-----------------------------------------" << std::endl;
	fs << "# Camera Parameters. Adjust them!" << std::endl;
	fs << "#-----------------------------------------" << std::endl;
	fs << std::endl;
	/* fs << "#calibration_time " << buf << std::endl; */
	fs << std::endl;
	fs << "Camera.fx: " << leftP.ptr<double>(0)[0] << std::endl;
	fs << "Camera.fy: " << leftP.ptr<double>(1)[1] << std::endl;
	fs << "Camera.cx: " << leftP.ptr<double>(0)[2] << std::endl;
	fs << "Camera.cy: " << leftP.ptr<double>(1)[2] << std::endl;
	fs << std::endl;
	fs << "Camera.k1: " << 0.0 << std::endl;
	fs << "Camera.k2: " << 0.0 << std::endl;
	fs << "Camera.p1: " << 0.0 << std::endl;
	fs << "Camera.p2: " << 0.0 << std::endl;
	fs << std::endl;
	fs << "Camera.width: " << leftWidth << std::endl;
	fs << "Camera.height: " << leftHeight << std::endl;
	fs << std::endl;
	fs << "#Camera frames per second" << std::endl;
	fs << "Camera.fps: " << 20 << std::endl;
	fs << std::endl;
	fs << "#stereo baseline × Camera.fx" << std::endl;
	float bf = std::fabs(trans.ptr<double>(0)[0] * leftP.ptr<double>(0)[0]);
	fs << "Camera.bf: " << bf << std::endl; 
	fs << std::endl;
	fs << "# Color order of image (0 BGR, 1 RGB, It is ignored if images are grayscale)" << std::endl;
	fs << "Camera.RGB: " << 1 << std::endl;
	fs << std::endl;
	fs << "# Close/Far threshold. Baseline times." << std::endl;
	fs << "ThDepth: " << 35 << std::endl;
	fs << std::endl;
	fs << "#-------------------------------------------" << std::endl;
	fs << "#Stereo Rectification. Camera.fx, Camera.fy must be the same as in LEFT.P" << std::endl;
	fs << "#-------------------------------------------" << std::endl;
	fs << std::endl;
	fs << "LEFT.height: " << leftHeight << std::endl;
	fs << "LEFT.width: " << leftWidth << std::endl;
	fs << "LEFT.D: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 1 << std::endl;
	fs << "    cols: " << 5 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << leftD << std::endl;

	cv::Mat rowLeftK = leftK.reshape(0, 1);
	fs << "LEFT.K: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 3 << std::endl;
	fs << "    cols: " << 3 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << rowLeftK << std::endl;

	cv::Mat rowLeftR = leftR.reshape(0, 1);
	fs << "LEFT.R: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 3 << std::endl;
	fs << "    cols: " << 3 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << rowLeftR << std::endl;

	cv::Mat rowLeftP = leftP.reshape(0, 1);
	fs << "LEFT.P: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 3 << std::endl;
	fs << "    cols: " << 4 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << rowLeftP << std::endl;
	fs << std::endl;
	fs << "RIGHT.height: " << rightHeight << std::endl;
	fs << "RIGHT.width: " << rightWidth << std::endl;
	fs << "RIGHT.D: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 1 << std::endl;
	fs << "    cols: " << 5 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << rightD << std::endl;

	cv::Mat rowRightK = rightK.reshape(0, 1);
	fs << "RIGHT.K: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 3 << std::endl;
	fs << "    cols: " << 3 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << rowRightK << std::endl;

	cv::Mat rowRightR = rightR.reshape(0, 1);
	fs << "RIGHT.R: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 3 << std::endl;
	fs << "    cols: " << 3 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << rowRightR << std::endl;

	cv::Mat rowRightP = rightP.reshape(0, 1);
	fs << "RIGHT.P: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 3 << std::endl;
	fs << "    cols: " << 4 << std::endl;
	fs << "    dt: " << 'd' << std::endl;
	fs << "    data: " << rowRightP << std::endl;
	fs << std::endl;
	fs << "#-------------------------------------------" << std::endl;
	fs << "#ORB Parameters" << std::endl;
	fs << "#-------------------------------------------" << std::endl;
	fs << std::endl;
	fs << "ORBextractor.nFeatures: " << 1200 << std::endl;
	fs << "ORBextractor.scaleFactor: " << 1.2 << std::endl;
	fs << "ORBextractor.nLevels: " << 8 << std::endl;
	fs << "ORBextractor.iniThFAST: " << 20 << std::endl;
	fs << "ORBextractor.minThFAST: " << 7 << std::endl;
	fs << std::endl;
	fs << "#-------------------------------------------" << std::endl;
	fs << "#Viewer Parameters" << std::endl;
	fs << "#-------------------------------------------" << std::endl;
	fs << std::endl;
	fs << "bUseViewer: " << 0 << std::endl;
	fs << "Viewer.KeyFrameSize: " << 0.05 << std::endl;
	fs << "Viewer.KeyFrameLineWidth: " << 1 << std::endl;
	fs << "Viewer.GraphLineWidth: " << 0.9 << std::endl;
	fs << "Viewer.PointSize: " << 2 << std::endl;
	fs << "Viewer.CameraSize: " << 0.08 << std::endl;
	fs << "Viewer.CameraLineWidth: " << 3 << std::endl;
	fs << "Viewer.ViewpointX: " << 0 << std::endl;
	fs << "Viewer.ViewpointY: " << -0.7 << std::endl;
	fs << "Viewer.ViewpointZ: " << -1.8 << std::endl;
	fs << "Viewer.ViewpointF: " << 500 << std::endl;

	cv::Mat rowTrl = Trl.reshape(0, 1);
	fs << "############" << std::endl;
	fs << "#the extrinsic params from left camera to right camera !" << std::endl;
	fs << "#Or the extrinsic params from left to the main camera in VIO project!" << std::endl;
	fs << "LEFT.RIGHT: !!opencv-matrix" << std::endl;
	fs << "    rows: " << 4 << std::endl;
	fs << "    cols: " << 4 << std::endl;
	fs << "    dt: " << 'f' << std::endl;
	fs << "    data: " << rowTrl << std::endl;
	fs << std::endl;


	std::cout << "saved the parameters in " << filename << std::endl;
	return true;
}



cv::Mat RPY2mat(double roll, double pitch, double yaw)
{
	cv::Mat m(3, 3, CV_64FC1);

	double cr = std::cos(roll);
	double sr = std::sin(roll);
	double cp = std::cos(pitch);
	double sp = std::sin(pitch);
	double cy = std::cos(yaw);
	double sy = std::sin(yaw);

	m.ptr<double>(0)[0] = cy * cp;
	m.ptr<double>(0)[1] = cy * sp * sr - sy * cr;
	m.ptr<double>(0)[2] = cy * sp * cr + sy * sr;
	m.ptr<double>(1)[0] = sy * cp;
	m.ptr<double>(1)[1] = sy * sp * sr + cy * cr;
	m.ptr<double>(1)[2] = sy * sp * cr - cy * sr;
	m.ptr<double>(2)[0] = - sp;
	m.ptr<double>(2)[1] = cp * sr;
	m.ptr<double>(2)[2] = cp * cr;
	 return m.clone();
}

void mat2RPY(const cv::Mat &m, double& roll, double& pitch, double& yaw)
{
	roll = std::atan2(m.ptr<double>(2)[1], m.ptr<double>(2)[2]);
	pitch = std::atan2(-m.ptr<double>(2)[0], std::sqrt(m.ptr<double>(2)[1] * m.ptr<double>(2)[1] + m.ptr<double>(2)[2] * m.ptr<double>(2)[2]));
	yaw = std::atan2(m.ptr<double>(1)[0], m.ptr<double>(0)[0]);
}

int main(int argc, char *argv[])
{
	//argv[1]: 左相机图片所在的文件夹的路径
	//argv[2]: 右相机图片所在的文件夹的路径
	//要求左右两张图片的名字是一样的
	std::vector<std::string> imgNamesL, imgNamesR;
	getImgNames(argv[1], argv[2], imgNamesL, imgNamesR);

	const int board_w = 7;
	const int board_h = 5;
	const int NPoints = board_w * board_h;
	const float boardSize = 0.034;
	cv::Size chessBoardSize = cv::Size(board_w, board_h);
	std::vector<cv::Point3f> object;
	for( int j = 0; j < NPoints; j++ )
	{
		object.push_back(cv::Point3f((j % board_w) * boardSize, (j / board_w) * boardSize, 0));
	}

	std::vector<std::vector<cv::Point3f> > objectv;
	std::vector<std::vector<cv::Point2f> > imagevL, imagevR;
	int height, width;
	cv::Mat imageL, grayImageL, imageR, grayImageR;
	std::vector<cv::Mat> imgsL, imgsR;
	for( int i = 0; i < (int)imgNamesL.size(); i++ )
	{
		imageL = cv::imread(imgNamesL[i]);
		imageR = cv::imread(imgNamesR[i]);
		imgsL.push_back(imageL);
		imgsR.push_back(imageR);
		if(imageL.empty())
		{
			std::cout << imgNamesL[i] << " is empty!" << std::endl;
			break;
		}
		if(imageR.empty())
		{
			std::cout << imgNamesR[i] << " is empty!" << std::endl;
		}
		height = imageL.rows;
		width = imageL.cols;
		
		if(imageL.channels() == 3)
		{
			cv::cvtColor(imageL, grayImageL, CV_BGR2GRAY);
		}
		if(imageR.channels() == 3)
		{
			cv::cvtColor(imageR, grayImageR, CV_BGR2GRAY);
		}

		IplImage tempgrayL = grayImageL;
		IplImage tempgrayR = grayImageR;

		bool findchessboardL = cvCheckChessboard(&tempgrayL, chessBoardSize);
		bool findchessboardR = cvCheckChessboard(&tempgrayR, chessBoardSize);
		std::vector<cv::Point2f> tempCornersL, tempCornersR;
		if(findchessboardL && findchessboardR)
		{
			bool find_corners_resultL = cv::findChessboardCorners(grayImageL, chessBoardSize, tempCornersL, 3);
			bool find_corners_resultR = cv::findChessboardCorners(grayImageR, chessBoardSize, tempCornersR, 3);
			if(find_corners_resultL && find_corners_resultR)
			{
				std::cout << "Capture " << imgNamesL[i] << std::endl;
				cv::cornerSubPix(grayImageL, tempCornersL, cv::Size(5, 5), cv::Size(-1, -1), cv::TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
				cv::cornerSubPix(grayImageR, tempCornersR, cv::Size(5, 5), cv::Size(-1, -1), cv::TermCriteria(CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1));
				cv::drawChessboardCorners(imageL, chessBoardSize, tempCornersL, find_corners_resultL);
				cv::drawChessboardCorners(imageR, chessBoardSize, tempCornersR, find_corners_resultR);
				cv::imshow("L", imageL);
				cv::imshow("R", imageR);
				cv::waitKey();

				objectv.push_back(object);
				imagevL.push_back(tempCornersL);
				imagevR.push_back(tempCornersR);
			}
			else
			{
				std::cout << "find_corners_resultL: " << find_corners_resultL << " find_corners_resultR: " << find_corners_resultR << std::endl;
				cv::imshow("L", imageL);
				cv::imshow("R", imageR);
				cv::waitKey();
			}
		}
		else
		{
			std::cout << "findchessboardL: " << findchessboardL << " findchessboardR: " << findchessboardR << std::endl;
			cv::imshow("L", imageL);
			cv::imshow("R", imageR);
			cv::waitKey();
		}

		tempCornersL.clear();
		tempCornersR.clear();
	}

	//标定左右两个相机的内参
	std::vector<cv::Mat> rvecsL, tvecsL, rvecsR, tvecsR;
	cv::Mat intrinsicL, distortionL, intrinsicR, distortionR;
	//double errL = cv::calibrateCamera(objectv, imagevL, cv::Size(width, height), intrinsicL, distortionL, rvecsL, tvecsL);

	 int flag = 0; flag |= cv::fisheye::CALIB_RECOMPUTE_EXTRINSIC; 
	 //flag |= cv::fisheye::CALIB_CHECK_COND; 
	 flag |= cv::fisheye::CALIB_FIX_SKEW; 
	 //flag |= cv::fisheye::CALIB_USE_INTRINSIC_GUESS;

	double errL =  cv::fisheye::calibrate(objectv, imagevL, cv::Size(width, height), intrinsicL, 
	 distortionL, cv::noArray(), cv::noArray(), flag, cv::TermCriteria(3, 20, 1e-6)); 

	//  cv::Mat mapx, mapy;
    // cv::Mat corrected;
	// cv::Size corrected_size(width, height);
	//  cv::fisheye::initUndistortRectifyMap(intrinsicL, distortionL, cv::Matx33d::eye(), intrinsicL, 
	//  corrected_size, CV_16SC2, mapx, mapy); 


	std::cout << "左相机内参-------------------------" << std::endl;
	std::cout << "errL: " << errL << std::endl;
	std::cout << "intrinsicL: " << std::endl;
	std::cout << intrinsicL << std::endl;
	std::cout << "distortionL: " << std::endl;
	std::cout << distortionL << std::endl;

	std::cout << "右相机内参-------------------------" << std::endl;
	//double errR = cv::calibrateCamera(objectv, imagevR, cv::Size(width, height), intrinsicR, distortionR, rvecsR, tvecsR);

	double errR = cv::fisheye::calibrate(objectv, imagevR, cv::Size(width, height), intrinsicR, 
	 distortionR, cv::noArray(), cv::noArray(), flag, cv::TermCriteria(3, 20, 1e-6)); 
	std::cout << "errR: " << errR << std::endl;
	std::cout << "intrinsicR: " << std::endl;
	std::cout << intrinsicR << std::endl;
	std::cout << "distortionR: " << std::endl;
	std::cout << distortionR << std::endl;


	//标定左右两个相机之间的外参
	cv::Mat E, F, R, t;
	cv::Size imgSize(width, height);
	
	//double errLR = cv::stereoCalibrate(objectv, imagevL, imagevR, intrinsicL, distortionL, intrinsicR, distortionR, 
	//imgSize, R, t, E, F);
	double errLR = cv::fisheye::stereoCalibrate(objectv, imagevL, imagevR, 
	intrinsicL, distortionL, intrinsicR, distortionR, imgSize,R, t);

	std::cout << "外参--------------------------------" << std::endl;
	std::cout << "errLR: " << errLR << std::endl;
	std::cout << "R: " << std::endl;
	std::cout << R << std::endl;
	std::cout << "t: " << std::endl;
	std::cout << t << std::endl;


	//立体校正
	cv::Mat Rl, Rr, Pl, Pr, Q;
	//cv::stereoRectify(intrinsicL, distortionL, intrinsicR, distortionR, imgSize, R, t, Rl, Rr, Pl, Pr, Q);
	cv::fisheye::stereoRectify(intrinsicL, distortionL, intrinsicR, distortionR, imgSize,
	 R, t, Rl, Rr, Pl, Pr, Q,
	cv::CALIB_ZERO_DISPARITY,imgSize);

	cv::Mat Trl = cv::Mat::eye(4, 4, CV_64FC1);
	R.copyTo(Trl.rowRange(0, 3).colRange(0, 3));
	t.copyTo(Trl.rowRange(0, 3).col(3));

	std::string fileName = "stereoRectify.yaml";
	saveCameraParams(fileName, height, width, distortionL, intrinsicL, Rl, Pl, 
			height, width, distortionR, intrinsicR, Rr, Pr, t, Trl);


	cv::Mat lmapx, lmapy, rmapx, rmapy;
	//cv::initUndistortRectifyMap(intrinsicL, distortionL, Rl, Pl, imgSize, CV_32F, lmapx, lmapy);
	//cv::initUndistortRectifyMap(intrinsicR, distortionR, Rr, Pr, imgSize, CV_32F, rmapx, rmapy);

	cv::fisheye::initUndistortRectifyMap(intrinsicL, distortionL, Rl, Pl, imgSize, CV_32F, lmapx, lmapy);
	cv::fisheye::initUndistortRectifyMap(intrinsicR, distortionR, Rr, Pr, imgSize, CV_32F, rmapx, rmapy);

	int num = 0;
	cv::Mat imLeftRect, imRightRect;
	while(num < (int)imgsL.size())
	{
		cv::Mat imgL = imgsL[num];
		cv::Mat imgR = imgsR[num];
		if(imgL.empty() || imgR.empty())
		{
			break;
		}
		cv::remap(imgL, imLeftRect, lmapx, lmapy, cv::INTER_LINEAR);
		cv::remap(imgR, imRightRect, rmapx, rmapy, cv::INTER_LINEAR);

		cv::Mat imgRectShow;
		imgRectShow.create(height, width * 2, CV_8UC3);

		imLeftRect.copyTo(imgRectShow.rowRange(0, height).colRange(0, width));
		imRightRect.copyTo(imgRectShow.rowRange(0, height).colRange(width, 2*width));

		int allLineNum = 20;
		for( int lineNum = 0; lineNum < allLineNum; lineNum++ )
		{
			cv::Point2f pt1(0, lineNum * 20);
			cv::Point2f pt2(imgRectShow.cols-1,lineNum * 20);

			cv::line(imgRectShow, pt1, pt2, cv::Scalar(0, 0, 255));
		}
		cv::imshow("imgRectShow", imgRectShow);
		cv::waitKey(0);
		
		num++;
	}
	return 0;
}
pangdawa
关注
专栏目录
双目标定（三）标定流程（含矫正）
一只飞鱼的博客
05-16 9337
1.采集 1.1标定板的制作。 大小：应当使得标定板在图像中占比尽可能大一些。占图像长度比例应当超过1/3；如果实在无法保证标定板占图像比例比较大如果占比比较小，则需要尽可能多采集一些图像。 平：标定板应当尽可能使理想平面。如果要求不是非常严格（比如重投影误差0.3即可），也可以用纸板（一般的标定板厂商做得即为此类）；如果标定精度要求比较高，则需要用硬度较高的材料做标定板，在该标定板上打...
matlab鱼眼镜头，普通镜头，单目双目相机标定校正（四）
rjszcb的博客
07-05 6065
1、打开软件，找到工具箱 有两个，一个是单个镜头标定，一个是双镜头标定，所以我们选第一个 2、导入图图片 一、参数设置 一、校正前 二、校正后 三、校正前 四、校正后 五、导出参数 通过show ，可以切换校正前后的效果图像，导出参数看erport ...
针孔、鱼眼相机标定，包括单目和双目标定demo
07-01
针孔、鱼眼相机标定，包括单目和双目标定demo， 基于OpenCV和C++。
双目测距系列（二）鱼眼镜头双目标定及测距
ltshan139的专栏
04-19 5354
前言 这几天把基于opencv C++ api将鱼眼镜头的双目标定以及测距功能实现完毕，效果还可以，至少对齐得非常棒。 这里把其流程及其关键函数在这里总结一下。 对于双目标定而言，opencv一共支持两种模型：普通针孔相机模型和鱼眼相机模型fisheye。后者是opencv3.0后才开始支持的。从使用角度讲，它俩主要差别就在于畸变系数不一样。 双目测距流程一共分为四大步：标定，对齐，匹配以及...
OpenCV双目鱼眼相机标定
xxxlinttp的博客
06-15 3642
手头有一个双目鱼眼相机，虽然厂家SDK里提供了相应的参数，但中间发现一点小问题，索性自己重新标定一下。单个摄像头的鱼眼标定在MATLAB工具箱中就有，但双目标定却是没有。找了一下OpenCV中（应该是3.0以后版本的）有相应的标定函数Fisheye camera model，就参照着其源文件sample下的stereo_calib.cpp改动了一下。 标定的逻辑很简单，先是提取角点，每一帧都需人工...
双目鱼眼标定工具编写思考
tuuzhang的博客
10-17 518
这一个多礼拜一直在为标定工具的数据传输选择而烦恼。本来服务器端工程和客户端工程师基于TCP/IP协议进行传输，对图像采集的实时传输也能满足需求。但是当拿到客户的原型机的时候却发现原型机只有一个microUSB口，没有任何接口，更不用说网口了。 再过半个月后就要交付工具，着突如其来的变化弄得我措手不及，修改工程是不可能了。试了一下改用WiFi传输，结果发现由于采集的图像是yuv格式，没有经过压缩编
使用ros标定鱼眼相机
南北粉面馆
03-01 860
首先来张标定板，这个板子网上找的费尽，早就应该百度云盘备份一下了 https://pan.baidu.com/s/1gvro0wS-kF_atpIOTWAyAw 提取码: 7pew 其他参考其他教程
相机标定-相机内参标定+双目标定-支持多种相机模型+多种标定板-项目源码-优质项目分享.zip
04-10
总的来说，这个项目涵盖了相机标定的核心内容，从基础的单目内参标定到复杂的双目标定，同时考虑了不同相机模型的处理，是学习和研究计算机视觉的理想资料。对于开发者来说，这是一次难得的机会，可以深入理解并实践...
3d线结构光的单目标定理论知识
最新发布
05-14
### 3D线结构光的单目标定理论知识 #### 一、引言 在3D视觉技术领域，单目标定是一项重要的基础工作，旨在纠正传感器本身的误差，从而提高测量精度。本文将深入探讨3D线结构光技术中的单目标定原理及其应用场景。 ...
鱼眼摄像头SLAM
吴建明wujianming_110117
04-29 1242
鱼眼摄像头SLAM 在机器人技术、摄影测量学和计算机视觉等领域,鲁棒相机位姿估计是许多视觉应用的核心。近年来,在复杂、大规模的室内外环境中,人们越来越关注相机位姿估计方法的实时性、通用性和可操作性。其中,相机的视场角起着重要的作用,特别是在具有挑战性的室内场景中,往往是通过鱼眼镜头或相机镜头组合来增加视场角。除了使用鱼眼相机增加视野外,还可以将多个相机进行刚性耦合,形成一个多相机系统,从而有效地利...
Opencv3.0 鱼眼相机标定（fisheye）
01-13
参照opencv及网上资料基于opencv3.0编写，标定结果与matlab2015一致，欢迎交流！
鱼眼摄像头标定与畸变校正（双OPENCV版本）
04-03
最近在整理自己以前做过的一些东西，这是基于opencv的鱼眼摄像头畸变校正程序的github地址（https://github.com/WordZzzz/fisheye_calibration）（不知道怎么设置免积分下载，所以只能贴上github了）。 其中： normal_calibrate：基于OPENCV2与OPENCV3通用的函数实现，可实现USB摄像头实时畸变校正； fishey_calibrate：基于OPENCV3独有的fishyey结构体实现，可实现USB摄像头实时畸变校正； fishey_calibrate_img：基于OPENCV3独有的fishyey结构体实现，可实现单张图片畸变校正；
立体匹配综合论文集
07-31
立体匹配综合论文集，包含立体匹配领域的各类经典论文合集
计算机视觉基础：相机模型与标定（单目+双目+鱼眼+深度相机）
qq_29462849的博客
12-26 1019
相机标定可以说是计算机视觉方向的基石。我们常见的许多计算机视觉任务，比如图像畸变校正，三维重建和立体视觉，获取相机参数，是这些工作绕不开的第一步。如何准确有效的获取相机参数就变得尤为重要，...
鱼眼相机
Ben_Ben_Niao
04-06 2271
OpenCV3.0 alpha在8月21日发布，其中增加了鱼眼镜头模型，提供了标定、去畸变等一系列api，其实现方法参考了{Camera Calibration Toolbox for Matlab}。本文简单介绍了OpenCV 中实现的鱼眼镜头模型，给出调用demo的关键代码、注释和去畸变的结果。 鱼眼镜头模型 　　鱼眼镜头的内参模型可以表示为，与普通镜头的内参一样，但畸变参数不
鱼眼矫正demo_双目矫正
weixin_32258195的博客
01-15 336
最近在做双目相机的一些工作，如标定、矫正等。本文的目的是为了促进自己坚持按时完成工作，也为从事此项工作的一些小伙伴做一些参考。如有错误，烦请指正。本文主要讨论鱼眼相机标定，极线矫正，深度恢复三个主题。相机标定针孔相机标定鱼眼相机标定极线矫正极线矫正的意义Cloop&zhang方法深度恢复我做了一个简单的demo，它基于opencv和ceres，项目地址：stereo_rectify​git...
双目估计方法_论文简述 | 无需校正和不失真的实时变化的鱼眼双目
weixin_39593340的博客
11-23 106
1摘要广角摄像头拍摄的稠密3D地图有利于导航和自动驾驶等机器人应用.在这项工作中,我们提出了一种实时稠密三维鱼眼相机建图方法,无需显式校正和不失真.我们扩展了传统的变分立体方法,通过使用由摄像机运动引起的轨迹场来约束沿外极曲线的对应搜索.与传统的校正方法相比,我们还提出了一种在不增加处理时间的情况下生成轨迹场的快速方法.通过我们的实现,我们能够使用现代图形处理器实现实时处理.我们的结果显...
重磅！相机模型与标定系统教程（单目+双目+鱼眼+深度相机）
3D视觉工坊
10-28 1132
应用背景介绍相机标定可以说是计算机视觉方向的基石。我们常见的许多计算机视觉任务，比如图像畸变校正，三维重建和立体视觉，获取相机参数，是这些工作绕不开的第一步。如何准确有效的获取相机参数就变...
鱼眼相机标定_鱼眼镜头内参标定
weixin_39667509的博客
12-02 1456
一、简介 本文主要介绍鱼眼镜头成像和内参标定技术，结合实际应用场景，解决不同领域使用鱼眼镜头进行内参标定的应用难题。 什么是鱼眼镜头？鱼眼镜头是一种焦距为16mm或更短的并且视角接近或等于180°的镜头。因其具有超大视场，因而被广泛应用于场景监视、卫星定位、智能零售、视觉导航、辅助驾驶及工程测量等领域。鱼眼图像最重要的一个特点就是中间畸变小，边缘畸变大。鱼眼图像畸变校正后就可以建立三...
鱼眼摄像头标定c++
12-21
鱼眼摄像头标定是一种用于校正鱼眼畸变图像的技术。在C++中，可以使用OpenCV库来实现鱼眼摄像头的标定。下面是一个简单的示例代码： ```cpp #include <opencv2/opencv.hpp> #include <opencv2/calib3d.hpp> int main() { // 读取鱼眼图像 cv::Mat image = cv::imread("fish_eye_image.jpg"); // 设置标定板的尺寸 cv::Size boardSize(9, 6); // 检测标定板角点 std::vector<cv::Point2f> corners; bool found = cv::findChessboardCorners(image, boardSize, corners); if (found) { // 进行鱼眼摄像头标定 cv::Mat cameraMatrix, distCoeffs; std::vector<cv::Mat> rvecs, tvecs; cv::calibrateCamera(std::vector<std::vector<cv::Point3f>>(), std::vector<std::vector<cv::Point2f>>(), image.size(), cameraMatrix, distCoeffs, rvecs, tvecs, cv::CALIB_USE_INTRINSIC_GUESS | cv::CALIB_FIX_K4 | cv::CALIB_FIX_K5); // 打印标定结果 std::cout << "Camera Matrix: " << cameraMatrix << std::endl; std::cout << "Distortion Coefficients: " << distCoeffs << std::endl; } else { std::cout << "Chessboard corners not found!" << std::endl; } return 0; } ``` 这段代码使用了OpenCV的`findChessboardCorners`函数来检测标定板的角点，然后使用`calibrateCamera`函数进行鱼眼摄像头的标定。标定结果包括相机矩阵和畸变系数。 注意：在运行代码之前，需要安装OpenCV库并将图像路径修改为实际的图像路径。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值