最小二乘法拟合圆心公式推导及基于opencv的程序实现

最新推荐文章于 2024-05-01 17:30:00 发布
最新推荐文章于 2024-05-01 17:30:00 发布
阅读量8k 收藏 99
点赞数 13
分类专栏： opencv 文章标签： opencv 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinxin_Tian/article/details/104769814
版权

最小二乘法拟合圆心

文章为个人学习过程中笔记，原理部分参考其他作者内容，侵权必删
最小二乘法(least squares analysis)是一种数学优化技术，它通过最小化误差的平方和找到一组数据的最佳函数匹配。最小二乘法是用最简的方法求得一些绝对不可知的真值，而令误差平方之和为最小来寻找一组数据的最佳匹配函数的计算方法，最小二乘法通常用于曲线拟合 (least squares fitting) 。最小二乘圆拟合方法是一种基于统计的检测方法，即便是图像中圆形目标受光照强度不均等因素的影响而产生边缘缺失，也不会影响圆心的定位和半径的检测，若边缘定位精确轮廓清晰，最小二乘法可实现亚像素级别的精确拟合定位。

1.1公式推导过程

原理部分来自博客：Jacky_Ponder
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.基于opencv数据结构的c++代码实现

下面是一个最小二乘拟合圆心的函数：
参数 输入1.存储2d点坐标的向量 输出2.圆心坐标点 输出double类型的圆的半径

void CircleFitting(
	std::vector<cv::Point> &pts,		// 2d点坐标存储向量
	cv::Point2d& center,				//圆心坐标
	double& radius)						//圆的半径
{
	center = cv::Point2d(0, 0);			//初始化圆心为(0,0)
	radius = 0.0;						//半径为0
//	if (pts.size() < 3) return false;	//判断输入点的个数若小于三个则不能拟合

	//定义计算中间变量
	double sumX1 = 0.0; //代表Xi的和(从1~n) ，X1代表X的1次方
	double sumY1 = 0.0;
	double sumX2 = 0.0;	//代表(Xi)^2的和(i从1~n)，X2代表X的二次方
	double sumY2 = 0.0;
	double sumX3 = 0.0;
	double sumY3 = 0.0;
	double sumX1Y1 = 0.0;
	double sumX1Y2 = 0.0;
	double sumX2Y1 = 0.0;
	const double N = (double)pts.size();//获得输入点的个数
	for (int i = 0; i < pts.size(); ++i)
	{
		double x = pts.at(i).x;			//获得第i个点的x坐标
		double y = pts.at(i).y;			//获得第i个点的y坐标
		double x2 = x * x;				//计算x^2
		double y2 = y * y;				//计算y^2
		double x3 = x2 * x;				//计算x^3
		double y3 = y2 * y;				//计算y^3
		double xy = x * y;				//计算xy
		double x1y2 = x * y2;			//计算x*y^2
		double x2y1 = x2 * y;			//计算x^2*y

		sumX1 += x;						//sumX=sumX+x;计算x坐标的和
		sumY1 += y;						//sumY=sumY+y;计算y坐标的和
		sumX2 += x2;					//计算x^2的和
		sumY2 += y2;					//计算各个点的y^2的和
		sumX3 += x3;					//计算x^3的和
		sumY3 += y3;
		sumX1Y1 += xy;
		sumX1Y2 += x1y2;
		sumX2Y1 += x2y1;
	}
	double C = N * sumX2 - sumX1 * sumX1;
	double D = N * sumX1Y1 - sumX1 * sumY1;
	double E = N * sumX3 + N * sumX1Y2 - (sumX2 + sumY2) * sumX1;
	double G = N * sumY2 - sumY1 * sumY1;
	double H = N * sumX2Y1 + N * sumY3 - (sumX2 + sumY2) * sumY1;

	double denominator = C * G - D * D;
//	if (std::abs(denominator) < DBL_EPSILON) return false;//判断分母的绝对值是否接近于（等于）0，使用此行判断须将函数改为bool类型，才能有返回值
	double a = (H * D - E * G) / (denominator);
	//denominator = D * D - G * C;
	//if (std::abs(denominator) < DBL_EPSILON) return false;
	double b = (H * C - E * D) / (-denominator);
	double c = -(a * sumX1 + b * sumY1 + sumX2 + sumY2) / N;

	center.x = a / (-2);
	center.y = b / (-2);
	radius = std::sqrt(a * a + b * b - 4 * c) / 2;
//	return true;将函数改为bool类型需要加返回值
}

以下为自己修改的程序，主要功能如下：
测试图片在下方
1.输入一张图片进行 高斯滤波和边缘检测检测出圆形led的边缘
2.使用opencv提供的findContours()函数将提取的边缘存储于Circle_Data中
3.调用CircleFitting()函数进行最小二乘圆拟合，计算的结果存放于向量Circle_Center 和向量Circle_R中

#include<iostream>
#include<opencv2/opencv.hpp>

//****函数声明圆心拟合函数
void CircleFitting(
	std::vector<std::vector<cv::Point>>& pts,
	std::vector<cv::Point2d>& center, std::vector<double>& radius);
//****函数声明end

int main(int argc, char**argv) {

	//【0】输入图像并进行高斯滤波和canny边缘检测
	cv::Mat srcImg = cv::imread("Led_Point.jpg", 1);//以原图的形式输入RGB
	if (!srcImg.data) { std::cout << "enter srcImg wrong" << std::endl;	return false; }

	cv::Mat srcImg_1 = srcImg.clone();	//复制到srcImg_1中
	cv::Mat gray, dstImg;		//原图的灰度图，canny检测后输出

	cv::cvtColor(srcImg_1, gray, cv::COLOR_BGR2GRAY);//gray为滤波之前的灰度图
	cv::GssianBlur(gray, gray, cv::Size(3, 3), 0, 0, cv::BORDER_DEFAULT);

	cv::Canny(gray, gray, 3, 9, 3);//边缘检测后的图存放于gray中,单通道
	//std::cout << "gray.channels=" << gray.channels() << std::endl;
	dstImg.create(srcImg.size(), srcImg.type());//创建与原图相同尺寸和类型的dstImg
	dstImg = cv::Scalar::all(0);
	srcImg_1.copyTo(dstImg, gray);
	//测试通道数用
	//std::cout << "dstImg.channels=" << dstImg.channels() << std::endl;//三通道
	cv::cvtColor(dstImg, dstImg, cv::COLOR_BGR2GRAY);//转化为单通道灰度图
	cv::threshold(dstImg, dstImg, 100, 255, cv::THRESH_BINARY);//转化为二值图（单通道）

	//std::cout << "dstImg=" << dstImg.channels() << std::endl;//不使用cvtColor则为三通道

	//[1]使用opencv提供的findContours()函数将检测到的边缘按每个边缘一组存放于Circle_Data中
	std::vector<std::vector<cv::Point>> Circle_Data;//Circle_Data用于存放多个led边缘的坐标
	std::vector<cv::Vec4i> hierarchy;
	//函数findContours参数:dstImg必须为单通道图像
	cv::findContours(dstImg, Circle_Data, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE, cv::Point());

	//测试函数findContours输出是否正确
	//for (int i = 0; i < Circle_Data.size(); i++) {
	//	//Circle_Data[i]代表的是第i个轮廓，Circle_Data[i].size()代表的是第i个轮廓上所有的像素点数  
	//	for (int j = 0; j < Circle_Data[i].size(); j++) {
	//		//每个点坐标为： cv::point(contours[i][j].x, contours[i][j].y);
	//		std::cout << "【" << i << "】" << "(" << Circle_Data[i][j].x << "," << Circle_Data[i][j].y << ")" << std::endl;
	//	}
	//}

	//[3]创建存储每个led轮廓的圆心坐标向量和半径存储向量进行最小二乘曲线拟合拟合圆心坐标和圆的半径
	std::vector<cv::Point2d> Circle_Center;	//声明用于存储圆心坐标的向量
	std::vector<double> Circle_R;			//声明用于存储半径的向量

	//函数可处理多个圆轮廓的圆心和半径的拟合
	CircleFitting(Circle_Data, Circle_Center, Circle_R);


	//测试用：输出圆的坐标和半径
	for (int i = 0; i < Circle_Data.size(); i++) {

		std::cout << "Circle_Center[" << i << "]= (" << Circle_Center[i].x << "," << Circle_Center[i].y << ")" << std::endl;
		std::cout << "Circle_R[" << i << "]=" << Circle_R[i] << std::endl;
	}


	system("PAUSE");//用于保持输出终端
	return 0;
}


//最小二乘拟合圆心原理https://blog.csdn.net/Jacky_Ponder/article/details/70314919
void CircleFitting(
	std::vector<std::vector<cv::Point>> &pts,		// 按组存储2d点坐标
	std::vector<cv::Point2d>& center,				//圆心坐标
	std::vector<double>& radius)						//圆的半径
{
	for (int k = 0; k < pts.size(); k++) {
		//	std::cout << "k=" << pts.size() << std::endl;
		center.push_back(cv::Point2d(0, 0));			//初始化圆心为(0,0)
		radius.push_back(0.0);						//半径为0
	//	if (pts.size() < 3) return false;	//判断输入点的个数若小于三个则不能拟合

		//定义计算中间变量
		double sumX1 = 0.0; //代表Xi的和(从1~n) ，X1代表X的1次方
		double sumY1 = 0.0;
		double sumX2 = 0.0;	//代表(Xi)^2的和(i从1~n)，X2代表X的二次方
		double sumY2 = 0.0;
		double sumX3 = 0.0;
		double sumY3 = 0.0;
		double sumX1Y1 = 0.0;
		double sumX1Y2 = 0.0;
		double sumX2Y1 = 0.0;
		const double N = (double)pts[k].size();//获得第k组输入点的个数
		for (int i = 0; i < pts[k].size(); ++i)//遍历第k组中所有数据
		{
			double x = 0;
			double y = 0;
			x = pts[k][i].x;			//获得第k组中第i个点的x坐标
			y = pts[k][i].y;			//获得第k组中第i个点的y坐标
			double x2 = x * x;				//计算x^2
			double y2 = y * y;				//计算y^2
			double x3 = x2 * x;				//计算x^3
			double y3 = y2 * y;				//计算y^3
			double xy = x * y;				//计算xy
			double x1y2 = x * y2;			//计算x*y^2
			double x2y1 = x2 * y;			//计算x^2*y

			sumX1 += x;						//sumX=sumX+x;计算x坐标的和
			sumY1 += y;						//sumY=sumY+y;计算y坐标的和
			sumX2 += x2;					//计算x^2的和
			sumY2 += y2;					//计算各个点的y^2的和
			sumX3 += x3;					//计算x^3的和
			sumY3 += y3;
			sumX1Y1 += xy;
			sumX1Y2 += x1y2;
			sumX2Y1 += x2y1;
		}
		double C = N * sumX2 - sumX1 * sumX1;
		double D = N * sumX1Y1 - sumX1 * sumY1;
		double E = N * sumX3 + N * sumX1Y2 - (sumX2 + sumY2) * sumX1;
		double G = N * sumY2 - sumY1 * sumY1;
		double H = N * sumX2Y1 + N * sumY3 - (sumX2 + sumY2) * sumY1;

		double denominator = C * G - D * D;
		//	if (std::abs(denominator) < DBL_EPSILON) return false;//判断分母的绝对值是否接近于（等于）0
		double a = (H * D - E * G) / (denominator);
		//denominator = D * D - G * C;
		//if (std::abs(denominator) < DBL_EPSILON) return false;
		double b = (H * C - E * D) / (-denominator);
		double c = -(a * sumX1 + b * sumY1 + sumX2 + sumY2) / N;

		center[k].x = a / (-2);
		center[k].y = b / (-2);
		radius[k] = std::sqrt(a * a + b * b - 4 * c) / 2;
		//	return true;
	}
}

测试程序用图：在这里插入图片描述
程序改进：将以上功能封装进一个函数中

#include<iostream>
#include<opencv2/opencv.hpp>

void LedCircleCenter(cv::Mat &srcImg, std::vector<std::vector<cv::Point>> &Circle_Data,
	std::vector<cv::Vec4i> &hierarchy, std::vector<cv::Point2d> &Circle_Center,
	std::vector<double> &Circle_R);

int main() {

	cv::Mat srcImg = cv::imread("Led_Point.jpg", 1);
	std::vector<std::vector<cv::Point>> CircleData;
	std::vector<cv::Vec4i> hierarchy;
	std::vector<cv::Point2d> CircleCenter;
	std::vector<double> CircleR;

	 LedCircleCenter(srcImg,CircleData,hierarchy,CircleCenter,CircleR);

	 for (int i = 0; i < CircleCenter.size(); i++) {
	 
		 std::cout<<"CircleCenter["<<i<<"]="<<CircleCenter[i]<<
			 "	"<<"CircleR["<<i<<"]="<<CircleR[i]<<std::endl;

	 }

	 system("Pause");
	 return 0;

}

//void LedCircleCenter(cv::Mat &srcImg, std::vector<std::vector<cv::Point>> &Circle_Data,
//	std::vector<cv::Vec4i> &hierarchy, std::vector<cv::Point2d> &Circle_Center,
//	std::vector<double> &Circle_R)
//function:函数用于将输入图片中的led灯的边缘提取后进行最小二乘拟合圆心和半径
//step:1.高斯滤波 2.canny边缘提取 3.存储每个边缘的坐标点 4.采用最小二乘法拟合圆心
//prgm 1: cv::Mat 类型的输入图像srcImg（格式不限）
/*prgm 2: std::vector<std::vector<cv::Point>> 类型的Circle_Data，存储了n组圆的边缘坐标，第一维代表圆的组号i,
第二维代表第i组中的j个坐标点,第三维代表第i个圆中的第j个点的x坐标和y坐标*/
//prgm 3:std::vector<cv::Vec4i> 检测用hierarchy(必须声明)
//prgm 4:std::vector<cv::Point2d> 类型的Circle_Center，用于存放i组圆圆心坐标的向量
//prgm 5:std::vector<double> 类型的Circle_R，用于存放i组圆对应的半径
void LedCircleCenter(cv::Mat &srcImg, std::vector<std::vector<cv::Point>> &Circle_Data,
	std::vector<cv::Vec4i> &hierarchy, std::vector<cv::Point2d> &Circle_Center,
	std::vector<double> &Circle_R) {

	cv::Mat srcImg_1 = srcImg.clone();	//复制到srcImg_1中
	cv::Mat gray, dstImg;		//原图的灰度图，canny检测后输出

	cv::cvtColor(srcImg_1, gray, cv::COLOR_BGR2GRAY);//gray为滤波之前的灰度图

	cv::GaussianBlur(gray, gray, cv::Size(5, 5), 0, 0, cv::BORDER_DEFAULT);//高斯滤波

	cv::Canny(gray, gray, 40, 120, 3);//边缘检测后的图存放于gray中,单通道，数据来源于
	dstImg.create(srcImg.size(), srcImg.type());//创建与原图相同尺寸和类型的dstImg
	dstImg = cv::Scalar::all(0);
	srcImg_1.copyTo(dstImg, gray);

	cv::cvtColor(dstImg, dstImg, cv::COLOR_BGR2GRAY);//转化为单通道灰度图
	cv::threshold(dstImg, dstImg, 100, 255, cv::THRESH_BINARY);//转化为二值图（单通道）

	//函数findContours,将检测到的边缘存放于Circle_Data中 参数:dstImg必须为单通道图像
	cv::findContours(dstImg, Circle_Data, hierarchy, cv::RETR_EXTERNAL, cv::CHAIN_APPROX_NONE, cv::Point());


	for (int k = 0; k < Circle_Data.size(); k++) {
		//	std::cout << "k=" << pts.size() << std::endl;
		Circle_Center.push_back(cv::Point2d(0, 0));			//初始化圆心为(0,0)
		Circle_R.push_back(0.0);						//半径为0
	//	if (pts.size() < 3) return false;	//判断输入点的个数若小于三个则不能拟合

		//定义计算中间变量
		double sumX1 = 0.0; //代表Xi的和(从1~n) ，X1代表X的1次方
		double sumY1 = 0.0;
		double sumX2 = 0.0;	//代表(Xi)^2的和(i从1~n)，X2代表X的二次方
		double sumY2 = 0.0;
		double sumX3 = 0.0;
		double sumY3 = 0.0;
		double sumX1Y1 = 0.0;
		double sumX1Y2 = 0.0;
		double sumX2Y1 = 0.0;
		const double N = (double)Circle_Data[k].size();//获得第k组输入点的个数
		for (int i = 0; i < Circle_Data[k].size(); ++i)//遍历第k组中所有数据
		{
			double x = 0;
			double y = 0;
			x = Circle_Data[k][i].x;			//获得第k组中第i个点的x坐标
			y = Circle_Data[k][i].y;			//获得第k组中第i个点的y坐标
			double x2 = x * x;				//计算x^2
			double y2 = y * y;				//计算y^2
			double x3 = x2 * x;				//计算x^3
			double y3 = y2 * y;				//计算y^3
			double xy = x * y;				//计算xy
			double x1y2 = x * y2;			//计算x*y^2
			double x2y1 = x2 * y;			//计算x^2*y

			sumX1 += x;						//sumX=sumX+x;计算x坐标的和
			sumY1 += y;						//sumY=sumY+y;计算y坐标的和
			sumX2 += x2;					//计算x^2的和
			sumY2 += y2;					//计算各个点的y^2的和
			sumX3 += x3;					//计算x^3的和
			sumY3 += y3;
			sumX1Y1 += xy;
			sumX1Y2 += x1y2;
			sumX2Y1 += x2y1;
		}
		double C = N * sumX2 - sumX1 * sumX1;
		double D = N * sumX1Y1 - sumX1 * sumY1;
		double E = N * sumX3 + N * sumX1Y2 - (sumX2 + sumY2) * sumX1;
		double G = N * sumY2 - sumY1 * sumY1;
		double H = N * sumX2Y1 + N * sumY3 - (sumX2 + sumY2) * sumY1;

		double denominator = C * G - D * D;
		//if (std::abs(denominator) < DBL_EPSILON) return false;//判断分母的绝对值是否接近于（等于）0
		double a = (H * D - E * G) / (denominator);
		//denominator = D * D - G * C;
		//if (std::abs(denominator) < DBL_EPSILON) return false;
		double b = (H * C - E * D) / (-denominator);
		double c = -(a * sumX1 + b * sumY1 + sumX2 + sumY2) / N;

		Circle_Center[k].x = a / (-2);
		Circle_Center[k].y = b / (-2);
		Circle_R[k] = std::sqrt(a * a + b * b - 4 * c) / 2;
	}
}
INANNANER
关注
  • 13
    点赞
  • 踩
  • 99
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最小二乘法拟合圆
09-06
for(int i=0;i<n;i++){ int x=samples[i].x; int y=samples[i].y; X1=X1+x; Y1=Y1+y; X2=X2+x*x; Y2 = Y2 +y*y; X3 = X3 + x*x*x; Y3 = Y3 + y*y*y; X1Y1 = X1Y1 + x*y; X1Y2 = X1Y2 + x*y*y; X2Y1 = X2Y1 + x*x*y;
最小二乘法求圆心和半径
07-09
该方法采用提取图像轮廓，并进行最小二乘法计算拟合出圆。最后得出圆心和半径。
Sobel算法：边缘提取的原理与实践【基于python、C++基于opencv的代码实现！！】
最新发布
xiaoh_7的博客
05-01 1438
Sobel算法作为边缘检测的经典方法，通过计算图像的梯度来准确捕捉边缘信息。本文深入解析了Sobel算法的原理，包括卷积操作、梯度计算与合成以及阈值处理等步骤，并探讨了其在实际应用中的优缺点。并给出了代码实现！
最小二乘法的圆(球)心拟合的思路方法
m0_52785249的博客
01-17 959
在圆弧上每隔1°-2°取一个值,至少取取25-50个点即可 求所有点的均值作为待拟合的初始圆心,所有点到该点的距离为待拟合的初始半径 基于最小二乘法,让所有点到拟合圆(球)心距离最短,即拟合圆(球)公式最小 以球为例,即令下式最小,其中xc,yc,zc为拟合球的中心,r为拟合半径: (x - xc) ** 2 + (y - yc) ** 2 + (z - zc) ** 2 - r ** 2 求出圆(球)心及半径
最小二乘法求解圆方程圆形及半径
m0_59160272的博客
06-17 3155
此文章为最小二乘法拟合圆方程，并求得圆心坐标与半径的算法推导，内附MATLAB代码。简单的来说，最小二乘法为一类线性算法，将需要求解的系数当作未知数，f(x)与x当作已知数，通过多组对应关系求得系数的方法。所以，最小二乘法仅适合系数为一次项方程式例如：，k与b作为系数是可通过最小二乘法求的而：，A作为系数，是不可通过最小二乘法求得的理论过程：当圆心为（0,0），半径为r时，可得圆的方程式为：令圆心为(h,k)时.........
最小二乘法拟合圆心与半径
Jaguar_95的博客
10-24 4767
由于现实世界观测的变量存在噪声，找不到完美、不存在误差的关系，因此我们退而求其次，尽可能减小误差影响。误差有正有负，而我们希望消除正负方向的差异，所以采用了平方的方法，二乘其实是指平方，只比较误差长度。举个例子，我们通过观测得到一组点(x, y)，这些点原则来上说属于一条直线，由于观测噪声的存在，找不到这样一条直线涵盖所有点。但是通过最小二乘法，观测尽可能多的点，可以拟合出较为准确的斜率和截距。最小二乘法的目的，通俗来说，就是拟合变量之间的关系。
OpenCV最小二乘法圆拟合
量子孤岛
01-10 6926
纸上得来终觉浅，绝知此事要躬行！ 时至今日我才发现做项目的意义所在，确实只有实战才能验证自己学的到底怎么样，事实证明，我目前学的狗屁不是，眼高手低，而且没有静下心来好好搞科研，甚是浮躁，没有仔细思考，我今天深刻检讨自己。 项目设计的图像处理，就是从一堆圆环中提取想要的圆心和半径，但是由于零件本身的缺陷以及光照问题导致的噪声让问题处理起来相当棘手，理论学了很多，真正用起来确实需要大量实验和猜想来...
圆拟合算法学习【1】最小二乘法数据拟合
minglan123的博客
04-02 7134
圆拟合算法学习【1】最小二乘法数据拟合 学过统计学的朋友们应该知道最小二乘法至关重要的地位，目前我的研究方面要对数据进行拟合，具体任务是在平面坐标系中拟合出圆心位置和半径来，首当其冲的想到了这一种方法，因此便把所学内容整理出来和大家分享。 1. 什么是最小二乘？ 1805年最小二乘法便被提出，让我们来看看这两百多年前的成果吧。其实该方法用语言表达或者公式表达都很容易理解： yi是我们得到的样本组，对于后者可以说是我们拟合的试验品，那么E便是样本和拟合的误差，机器学习中将此描述为损失函数，最小二乘法的思想便
最小二乘法拟合圆公式推导及其实现
Jacky_Ponder的博客
04-21 4万+
1.1最小二乘拟合圆介绍与推导 最小二乘法(least squares analysis)是一种数学优化技术，它通过最小化误差的平方和找到一组数据的最佳函数匹配。最小二乘法是用最简的方法求得一些绝对不可知的真值，而令误差平方之和为最小来寻找一组数据的最佳匹配函数的计算方法，最小二乘法通常用于曲线拟合 (least squares fitting) 。最小二乘圆拟合方法是一种基于统计的检测方法，即
C++opencv找圆心？看着一篇，一定有你要（边缘轮廓检测，拟合，凸包）找出相应的轮廓或者全部轮廓画外界圆轮廓并且标出轮廓中心
qq_65356682的博客
03-30 3869
本文主要是利用（面积判断，边缘轮廓检测，拟合，凸包）找出相应的轮廓或者全部轮廓画外界圆轮廓并且标出轮廓中心
机器视觉-opencv-最小二乘法拟合圆
03-05
本主题将深入探讨如何使用OpenCV实现最小二乘法来拟合圆，这是解决实际问题，如识别、定位或分析圆形特征时的一个关键技巧。 最小二乘法是一种优化技术，用于找到最佳拟合线、面或曲线，使得所有数据点到这条拟合...
用OpenCV对图像中圆的检测以及拟合
12-24
用OpenCV对图像中圆的检测以及拟合，很有用噢
OpenCV3.3最小二乘法直线拟合
04-20
首先，我们来看OpenCV库如何实现最小二乘法直线拟合。OpenCV提供了`cv::fitLine()`函数，它能对二维或三维数据集进行线性拟合。该函数使用德班多夫斯基-普拉托变换（Durbin-Watson transformation）来计算最佳拟合线...
python最小二乘法三维坐标拟合平面-最小二乘法拟合平面
04-19
本资源主要讲述了使用 Python 实现最小二乘法三维坐标拟合平面的方法。该方法使用 OpenCV 库来实现平面拟合，通过对点云数据的处理和_singular value decomposition（SVD）来估计平面参数。 知识点一：最小二乘法 ...
最小二乘法拟合一个圆.cpp
03-17
使用最小二乘法对一个点集拟合一个圆，返回该拟合圆的圆心和半径。c++的opencv版本。 原理代码：https://blog.csdn.net/qq_42914355/article/details/104927023
C++最小二乘法拟合直线
03-19
C++最小二乘法拟合直线，根据数据直接计算直线的斜率、截距和相似度，即拟合的好坏。
OpenCV曲线拟合与圆拟合
youandme520的专栏
08-10 1万+
OpenCV曲线拟合与圆拟合 使用OpenCV做图像处理与分析的时候，经常会遇到需要进行曲线拟合与圆拟合的场景，很多OpenCV开发者对此却是一筹莫展，其实OpenCV中是有现成的函数来实现圆拟合与直线拟合的，而且还会告诉你拟合的圆的半径是多少，简直是超级方便，另外一个常用到的场景就是曲线拟合，常见的是基于多项式拟合，可以根据设定的多项式幂次生成多项式方程，然后根据方程进行一系列的点生成，形成完整的曲线，这个车道线检测，轮廓曲线拟合等场景下特别有用。下面就通过两个简单的例子来分别学习一下曲线拟合与圆拟合的
基于OpenCV数据结构最小二乘法拟合圆-代码部分
地狱，乃是天堂必经之路！
03-20 4117
对于网上常用的拟合圆代码(经过修改， 因为除数可能为0) /* * 参考: http://blog.csdn.net/liyuanbhu/article/details/50889951 * 通过最小二乘法来拟合圆的信息 * pts: 所有点坐标 * center: 得到的圆心坐标 * radius: 圆的半径 */ static bool CircleInfo2(std::vector&lt;...
最小二乘法的拟合原理
热门推荐
weixin_41797870的博客
12-08 10万+
一. 最小二乘法的拟合原理 根据《数学指南》书中的解释: 图2 《数学指南》中对最小二乘法的解释 上面这段话，枯燥且无趣，大家不用厌恶，数学向来这个样子。 现在，我们来慢慢认识上面这段话的意思，这句话的意思是说，拟合有两个前提： 1. 要有N个不同的点（x1,x2...xN)的测量值（y1,y2,y3..yN) ，说得简单一点，就是要用三坐标在零件上采很多个不同位置的点，如(x1,y...
最小二乘法拟合圆心
05-28
在上一个问题中，我们已经使用Hough Circle Transform函数检测到了圆，现在我们需要使用最小二乘法来拟合圆心。 最小二乘法是一种常用的拟合方法，可以用来拟合数据点到一个函数或者曲线。在这里，我们可以用最小二乘法来拟合圆心。 假设我们已经检测到了n个圆，在检测到的圆中，第i个圆的圆心坐标为(xi, yi)，我们需要求出这些圆心坐标的最优拟合圆（也就是最小二乘法拟合的圆）。 最小二乘法拟合圆心的思路如下： 1. 对于每个圆心(xi, yi)，我们可以将它表示为(x - xi)^2 + (y - yi)^2 = r^2的形式。 2. 将上式展开，得到x^2 + y^2 - 2xi*x - 2yi*y + (xi^2 + yi^2 - r^2) = 0。 3. 对于每个圆心(xi, yi)，我们可以将上式表示为Aix + Biy + Ci = Di^2的形式，其中Ai = -2xi, Bi = -2yi, Ci = xi^2 + yi^2 - r^2, Di = xi^2 + yi^2。 4. 将上述方程组表示成矩阵形式：AX = B，其中X = [a, b, c]T，A为n x 3的矩阵，B为n x 1的矩阵，X为3 x 1的矩阵，T表示矩阵的转置。 5. 使用最小二乘法求解X，即X = (ATA)^-1ATB。 6. 求出a,b,c之后，可以得到最小二乘法拟合的圆心为(x0, y0) = (-a/2, -b/2)，半径为r = sqrt(a^2 + b^2 - 4c)/2。 下面是一个示例代码，演示如何使用最小二乘法拟合图像中检测到的圆心： ```c++ #include <opencv2/opencv.hpp> #include <iostream> #include <vector> using namespace std; using namespace cv; int main() { Mat image = imread("circles.png", IMREAD_GRAYSCALE); if (image.empty()) { cout << "Could not open or find the image" << endl; return -1; } Mat blurred; GaussianBlur(image, blurred, Size(5, 5), 2); vector<Vec3f> circles; HoughCircles(blurred, circles, HOUGH_GRADIENT, 1, 10, 100, 30, 5, 50); Mat A(circles.size(), 3, CV_32F); Mat B(circles.size(), 1, CV_32F); for (size_t i = 0; i < circles.size(); i++) { float xi = circles[i][0]; float yi = circles[i][1]; float ri = circles[i][2]; A.at<float>(i, 0) = -2 * xi; A.at<float>(i, 1) = -2 * yi; A.at<float>(i, 2) = xi * xi + yi * yi - ri * ri; B.at<float>(i, 0) = xi * xi + yi * yi; } Mat ATA, ATB, X; transpose(A, ATA); ATB = ATA * B; X = (ATA * A).inv() * ATB; float a = X.at<float>(0, 0); float b = X.at<float>(1, 0); float c = X.at<float>(2, 0); Point2f center(-a / 2, -b / 2); float radius = sqrt(a * a + b * b - 4 * c) / 2; // 用红色圆画出最小二乘法拟合的圆心 circle(image, center, 3, Scalar(0, 0, 255), -1, 8, 0); // 用蓝色圆画出最小二乘法拟合的圆 circle(image, center, radius, Scalar(255, 0, 0), 3, 8, 0); // 输出最小二乘法拟合的圆心和半径 cout << "Fitted Circle:" << endl; cout << "Center: (" << center.x << ", " << center.y << ")" << endl; cout << "Radius: " << radius << endl; namedWindow("Fitted Circle", WINDOW_NORMAL); imshow("Fitted Circle", image); waitKey(0); return 0; } ``` 在此示例中，我们使用前面的代码检测到了圆，并将每个圆心(xi, yi)表示为Aix + Biy + Ci = Di^2的形式。然后，我们将这些方程表示为矩阵形式，使用最小二乘法求解出拟合圆的参数a, b, c。最后，我们计算出最小二乘法拟合的圆心和半径，并在图像上画出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值