OpenCv:椭圆上点的计算方程

最新推荐文章于 2024-08-31 19:06:47 发布
最新推荐文章于 2024-08-31 19:06:47 发布
阅读量5k 收藏 5
点赞数
分类专栏： STL/算法 GazeTracker OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wishchin/article/details/51736546
版权
OpenCV 同时被 3 个专栏收录
62 篇文章 8 订阅
订阅专栏
STL/算法
41 篇文章 1 订阅
订阅专栏
GazeTracker
4 篇文章 0 订阅
订阅专栏

椭圆

        椭圆（Ellipse）是平面内到定点F1、F2的距离之和等于常数（大于|F1F2|）的动点P的轨迹，F1、F2称为椭圆的两个焦点。其数学表达式为：                                                                                                                 |PF1|+|PF2|=2a（2a>|F1F2|）。[1] 
        椭圆是圆锥曲线的一种，即圆锥与平面的截线。[2] 椭圆在开普勒行星运行三定律中扮演了重要角色，即恒星是椭圆两焦点中的一个，是数学科重点研究的一个项目。[3] 

标准方程：

      

        椭圆的标准方程共分两种情况：
               当焦点在x轴时，椭圆的标准方程是：x^2/a^2+y^2/b^2=1，(a>b>0)；
              当焦点在y轴时，椭圆的标准方程是：y^2/a^2+x^2/b^2=1，(a>b>0)；
                                                  其中a^2-c^2=b^2

参数方程：

       椭圆上点的参数方程为：

             y = a *sin(  alp ) 

             x=  a *cos( alp )  (a>b>0)；

 此时的角度alp不是中心点到椭圆上点的角度，而是椭圆的仿射圆上的点到圆心的角度，计算角度应考虑到压缩。


压缩方向：

         Height方向拉伸；

         计算变化后的beta；

         计算坐标：

             y = a *sin(  beta ) 

             x=  a *cos( beta )  (a>b>0)；

         Height方向压缩；

               y = a *sin(  beta ) *（b/a）
               x=  a *cos( beta )                   (a>b>0)；

       计算距离。


椭圆上点的计算方程：

        对于 (a>b>0)；

               对应的圆的方程： R = a;

               圆上的点的坐标： x2 = R * sin(Beta)    y2 = R * cos(beta);

               不变性：  alp = beta                 

             

       对应椭圆点的坐标：

               角度：  alp = beta

               角度：  alp = beta

              

计算椭圆上点的代码：

     代码是错误的，不能把点压缩到椭圆上

		//调整椭圆边缘到标准椭圆；在角度方向上进行拉伸
		//angleOfDip 为椭圆的偏斜角，弧度值！
		//增加边界检查
		template <class T1,class T2>
		float AdjustEllipseEdge(
			std::vector<std::pair< T1, T2 > >  &closeEdgeIn,
			std::vector<std::pair< T1, T2 > >  &closeEdgeOut,
			const cv::RotatedRect &ecf,
			const cv::Point2f &rfCentroidS,
			const double angleOfDipSrc,
			const int ww,
			const int hh)
		{
			assert(closeEdgeIn.size() == closeEdgeOut.size() );
			int w = ww -1;
			int h = hh -1;

			const cv::Point2f rfCentroid = ecf.center;
			//cv::Point2f rfCentroid(0,0);
			std::vector< double > angleListS;//为点椭圆角度，用于求取 椭圆点到中心的距离
			angleListS.resize( closeEdgeIn.size() );

			int vOrH = 0;//水平或者竖直？
			vOrH = ecf.size.width > ecf.size.height? 0:1;//若0，则为V;或者为1，水平

			double angleOfDip = 0;
			if (0 == vOrH )
			{//若为水平//width 的倾角
				angleOfDip  = angleOfDipSrc; 
			} 
			else
			{
				angleOfDip  = angleOfDipSrc - PI_1_2; 
			}

			double a = max(ecf.size.height/2.0,ecf.size.width /2.0);//长轴//固定后使用方程
			double b = min(ecf.size.height/2.0,ecf.size.width /2.0);

#ifdef SHOW_TEMP
			cv::Mat canvasSrc = cv::Mat::zeros(200,200,CV_8UC3);
			cv::bitwise_not(canvasSrc,canvasSrc);
			cv::ellipse(canvasSrc,ecf,cv::Scalar(0,0,255),1,8);
#endif

			//在此测试，cos计算的代码
#ifdef SHOW_TEMP

			cv::RotatedRect ecT = RotatedRect(Point2f(100,100), Size2f(50,100), 30);
			std::vector<std::pair< cv::Point2f, double > >  PointCosTest(0);
			cvWish::polygon::GetElipseEdge(ecT, PointCosTest, (ecT.size.height + ecT.size.height)/5.0 );
			cv::ellipse(canvasSrc, ecT, cv::Scalar(0,0,255), 1, 8);
			
			for ( int i=0; i< PointCosTest.size(); ++i)
			{
				cv::circle( canvasSrc, PointCosTest[i].first, 1, cv::Scalar(255,0,0), 1, 8, 0 );
				double af = cvWish::cosCv(ecT.center,PointCosTest[i].first);//cosCv出现计算问题
				std::cout<< "Cos:" << af<< std::endl;
				std::cout<< "Angle:" << PointCosTest[i].second << std::endl;
				cv::imshow("PointCosTest",canvasSrc);
				cv::waitKey(1);
			}

#endif

			for ( int i=0; i<closeEdgeIn.size(); ++i )
			{
				closeEdgeIn[i].second  = cvWish::cosCv( rfCentroid, closeEdgeIn[i].first );

				angleListS[i]  = closeEdgeIn[i].second;
				angleListS[i] -= angleOfDip;//旋转
				angleListS[i]  = angleListS[i]> PI_4_2 ? angleListS[i] - PI_4_2:angleListS[i];

				//探测距离
				double disPC    = cvWish::disCv(rfCentroid,closeEdgeIn[i].first);

				double alp =  angleListS[i];
				//alp =  alp *180/M_PI;
				double disShould = 
					sqrt( b*sin(alp ) *b*sin(alp ) + a*cos(alp) *a*cos(alp) );//公式无误，角度出现问题？
				     //sqrt( b*cos(alp ) *b*cos(alp ) + a*sin(alp) *a*sin(alp) );//公式无误，角度出现问题？
				//可能问题，方向角度出现往长轴极点的方向进行压缩，导致生成距离变大。
				
				//double disShould = sqrt( 
				//	ecf.size.width*cos(angleListS[i]) *ecf.size.width*cos(angleListS[i]) /4
				//	+ ecf.size.height*sin(angleListS[i]) *ecf.size.height*sin(angleListS[i])/4 );
				std::cout<< alp << std::endl;
				std::cout<< cos(alp)  << std::endl;
				std::cout<<"disPc:" <<disPC << std::endl;
				std::cout<< "disShould:" << disShould << std::endl;

#ifdef SHOW_TEMP
				//cv::Mat canvasSrc(100,100,CV_8UC3);
				cv::circle(canvasSrc,closeEdgeIn[i].first,1,cv::Scalar(255,0,0),1,8,0);
				cv::imshow("edgeEvolution",canvasSrc);
				cv::waitKey(1);
#endif
				//调整点到椭圆上
				//adjustPoint2Elipse();

				//根据距离 往角度方向上拉伸点//角度其实产生了偏离//偏角使用图片偏角
				cvWish::PullPoint2Out( closeEdgeIn[i].first, closeEdgeIn[i].second, ( disPC - disShould ) );	

				closeEdgeOut[i].first  = closeEdgeIn[i].first;
				已确认大于0，此时确认不超边界
				closeEdgeOut[i].first.x = min(closeEdgeOut[i].first.x,w);
				closeEdgeOut[i].first.y = min(closeEdgeOut[i].first.y,h);

				closeEdgeOut[i].second = closeEdgeIn[i].second;
#ifdef SHOW_TEMP
				cv::circle(canvasSrc,closeEdgeOut[i].first,1,cv::Scalar(0,255,0),1,8,0);
				cv::imshow("edgeEvolution",canvasSrc);
				cv::waitKey(1);
#endif
			}

			return 1.0;
		}


代码修改：

     使用一个仿射变换

		//调整椭圆边缘到标准椭圆；在角度方向上进行拉伸
		//angleOfDip 为椭圆的偏斜角，弧度值！
		//增加边界检查
		template <class T1,class T2>
		float AdjustEllipseEdge(
			std::vector<std::pair< T1, T2 > >  &closeEdgeIn,
			std::vector<std::pair< T1, T2 > >  &closeEdgeOut,
			const cv::RotatedRect &ecf,
			const cv::Point2f &rfCentroidS,
			const double angleOfDipSrc,
			const int ww,
			const int hh)
		{
			assert(closeEdgeIn.size() == closeEdgeOut.size() );
            int w = ww -1;
            int h = hh -1;

            const cv::Point2f rfCentroid = ecf.center;
            //cv::Point2f rfCentroid(0,0);
            std::vector< double > angleListS;//为点椭圆角度，用于求取 椭圆点到中心的距离
            angleListS.resize( closeEdgeIn.size() );

            int vOrH = 0;//水平或者竖直？
            vOrH = ecf.size.width > ecf.size.height? 0:1;//若0，则为V;或者为1，水平

            double angleOfDip = 0;
            if (0 == vOrH )
            {//若为水平//width 的倾角
                angleOfDip  = angleOfDipSrc; 
            } 
            else
            {
                angleOfDip  = angleOfDipSrc - PI_1_2; 
            }

            //double a = max(ecf.size.height/2.0,ecf.size.width /2.0);//长轴//固定后使用方程
            //double b = min(ecf.size.height/2.0,ecf.size.width /2.0);
            double b = ecf.size.height/2.0//长轴//固定后使用方程
            double a = ecf.size.width /2.0;
            double compressFactor = b /a ;//压缩或者缩放因子

#ifdef SHOW_TEMP
            cv::Mat canvasSrc = cv::Mat::zeros(200,200,CV_8UC3);
            cv::bitwise_not(canvasSrc,canvasSrc);
            cv::ellipse(canvasSrc,ecf,cv::Scalar(0,0,255),1,8);
#endif

            //在此测试，cos计算的代码
#ifdef SHOW_TEMP

            cv::RotatedRect ecT = RotatedRect(Point2f(100,100), Size2f(50,100), 30);
            std::vector<std::pair< cv::Point2f, double > >  PointCosTest(0);
            cvWish::polygon::GetElipseEdge(ecT, PointCosTest, (ecT.size.height + ecT.size.height)/5.0 );
            cv::ellipse(canvasSrc, ecT, cv::Scalar(0,0,255), 1, 8);
            
            for ( int i=0; i< PointCosTest.size(); ++i)
            {
                cv::circle( canvasSrc, PointCosTest[i].first, 1, cv::Scalar(255,0,0), 1, 8, 0 );
                double af = cvWish::cosCv(ecT.center,PointCosTest[i].first);//cosCv出现计算问题
                std::cout<< "Cos:" << af<< std::endl;
                std::cout<< "Angle:" << PointCosTest[i].second << std::endl;
                cv::imshow("PointCosTest",canvasSrc);
                cv::waitKey(1);
            }

#endif

            for ( int i=0; i<closeEdgeIn.size(); ++i )
            {
                closeEdgeIn[i].second  = cvWish::cosCv( rfCentroid, closeEdgeIn[i].first );

                //压缩方向
                angleListS[i]  = closeEdgeIn[i].second;
                angleListS[i] -= angleOfDip;//旋转
                angleListS[i]  = angleListS[i]> PI_4_2 ? angleListS[i] - PI_4_2:angleListS[i];

                //探测距离
                double disPC    = cvWish::disCv(rfCentroid,closeEdgeIn[i].first);

                //double alp =  angleListS[i];
                //alp =  alp *180/M_PI;
                //double disShould = sqrt( b*sin(alp ) *b*sin(alp ) + a*cos(alp) *a*cos(alp) );//公式无误，角度出现问题？
                //可能问题，方向角度出现往长轴极点的方向进行压缩，导致生成距离变大。

                //计算对应仿射圆的角度
                double xDeta =  closeEdgeIn[i].first.x - rfCentroid.x;
                double yDeta =  closeEdgeIn[i].first.y - rfCentroid.y;
                yDeta /= compressFactor;

                //计算角度
                double beta = cvWish::cosCv( rfCentroid, cv::Point2f( rfCentroid.x + xDeta, rfCentroid.y+ yDeta ) );
                double r = a;                                                                
                xDeta  =  r* cos(beta);
                yDeta  =  r* sin(beta);
                yDeta *= compressFactor;

                //直接计算距离
                double disShould = sqrt( xDeta*xDeta + yDeta*yDeta );//公式无误，角度出现问题？

                std::cout<<"disPc:" <<disPC << std::endl;
                std::cout<< "disShould:" << disShould << std::endl;

#ifdef SHOW_TEMP
                //cv::Mat canvasSrc(100,100,CV_8UC3);
                cv::circle(canvasSrc,closeEdgeIn[i].first,1,cv::Scalar(255,0,0),1,8,0);
                cv::imshow("edgeEvolution",canvasSrc);
                cv::waitKey(1);
#endif
                //调整点到椭圆上
                //adjustPoint2Elipse();

                //根据距离 往角度方向上拉伸点//角度其实产生了偏离//偏角使用图片偏角
                cvWish::PullPoint2Out( closeEdgeIn[i].first, closeEdgeIn[i].second, ( disPC - disShould ) );    

                closeEdgeOut[i].first  = closeEdgeIn[i].first;
                已确认大于0，此时确认不超边界
                closeEdgeOut[i].first.x = min(closeEdgeOut[i].first.x,w);
                closeEdgeOut[i].first.y = min(closeEdgeOut[i].first.y,h);

                closeEdgeOut[i].second = closeEdgeIn[i].second;
#ifdef SHOW_TEMP
                cv::circle(canvasSrc,closeEdgeOut[i].first,1,cv::Scalar(0,255,0),1,8,0);
                cv::imshow("edgeEvolution",canvasSrc);
                cv::waitKey(1);
#endif
            }

            return 1.0;
        }

从一个椭圆上面获取特定个数的点的函数：

//参数描述：椭圆；输出的点集；欲获取的点的个数
		int polygon::GetElipseEdge(
			const cv::RotatedRect &ecf,  
			std::vector<std::pair< cv::Point2f, double > >  &ellipseEdge,
			const int numPs,
			cv::Rect &roiRestrict,
			bool openEdgeRestrict )
		{
			if ( numPs == 0 )
			{
				return numPs;
			}
			else
			{
				ellipseEdge.resize( numPs );
			}

			//对椭圆进行划分
			const double angleGap = PI_4_2/numPs;
			const double cx = ecf.center.x;
			const double cy = ecf.center.y;
			const float angleOfDip =  PI_1_2 + ecf.angle*3.1415926 /180.0;//为何偏移了 半个pi
			//const double angleOfDip =0- ecf.angle*3.1415926 /180.0;//

			double w = ecf.size.width /2.0;
			double h = ecf.size.height/2.0;
			for (int i=0 ;i< numPs;++i )
			{
				double as = i*angleGap ;

				double a = as ;
				a += angleOfDip;
				a = a>PI_4_2? a-PI_4_2:a;

				double y = (w) *sin( a );
				double x = (h) *cos( a );

				//旋转
				float xDeta = x*cos( angleOfDip ) - y*sin( angleOfDip );
				float yDeta = x*sin( angleOfDip ) + y*cos( angleOfDip );

				cv::Point2f p( cx+xDeta, cy+yDeta);
				//ellipseEdge[i] = (std::pair< T1, T2 >)(std::make_pair( p,as ) );
				//ellipseEdge[i] = (std::pair< cv::Point2f, double >)(std::make_pair( p,as ) );//此处代码只为运行于GCC修改，有问题，模板库不能使用！！！wishchin!!!
				ellipseEdge[i].first.x = p.x;
				ellipseEdge[i].first.y = p.y;
				ellipseEdge[i].second  =  as;
			}

			
			if (openEdgeRestrict)
			{
				float x,y;
				float xS(roiRestrict.x), yS(roiRestrict.y), xE(roiRestrict.x+roiRestrict.width), yE(roiRestrict.y+roiRestrict.height );
				
				for (int i=0 ;i< numPs;++i )
				{
					x = ellipseEdge[i].first.x;
					y = ellipseEdge[i].first.y;

					x = (std::min)( (std::max)(x,xS),xE );
					y = (std::min)( (std::max)(y,yS),yE );

					//ellipseEdge[i].first = cv::Point2f(x,y);
					ellipseEdge[i].first.x = x;
					ellipseEdge[i].first.y = y;
				}
			} 
			else
			{
			}

			return 1;
		}




 结果显示：

       原始结果：                                                                                    修改后结果：

                                                         

         

wishchin
关注
专栏目录
python opencv 判断一点是否在旋转椭圆内
TU商的博客
02-08 829
2a为长轴，2b为短轴。对于这个椭圆，如果代入一个点（px,py），使得C>1，那么P在椭圆外，如果C
Opencv中，椭圆拟合后，得到该椭圆方程系数。
qq_42027706的博客
12-03 1636
opencv中fitEllipse函数椭圆拟合后，如何求解椭圆方程系数问题。
opencv学习笔记9-opencv绘制椭圆并使用窗口显示
最新发布
The_xz的博客
08-31 327
【代码】opencv学习笔记9-opencv绘制椭圆并使用窗口显示。
js 计算椭圆上的点
yyXieDaiMa的博客
04-02 2145
1.计算椭圆上的点（轨迹） // a 长半径， b 短半径， p 节点的间隔 ， cx, cy 圆心, getCPoint ({ a, b, p = 1, cx = 0, cy = 0, }) { const data = [] for (let index = 0; index < 360; index = index + p) { let x = a * Math.cos(Math.PI * 2 * index / 360) let y
详解OpenCV的椭圆曲线点坐标近似计算函数ellipse2Poly()
昊虹AI笔记
12-21 2058
详解OpenCV的椭圆曲线点坐标近似计算函数ellipse2Poly()
OpenCv获取图像中椭圆长短轴的点的位置
邮箱：feboreigns001@163.com
11-27 3321
目的是得到长短轴上的灰度变换曲线 1 首先使用Opencv的 FindContour fitEllipse 可以得到旋转矩形 2 然后获取矩形长轴和短轴的位置，然后根据位置得到灰度值，最后得到曲线 关键在于如何获取长短轴的位置 1 .先得到两个点的方程，并获取线段方程上的点的位置 void GetLocation(cv::Point p0,cv::Point p1,std::vector<cv::Point> &points){ int a...
OpenCV：10特征检测
m0_59466249的博客
08-04 1014
特征检测是和中的一个概念。它是指使用计算机，决定每个图像的点是否属于一个图像特征。，这些子集往往属于孤立的点、连续的曲线或者连续的区域以拼图游戏为例来说明特征检测的应用流程因此：A、B（蓝色框）不是特征 ——> 不是唯一的C、D（黑色框）不是特指 ——> 不是唯一的E、F（红色框）是特征 ——> 唯一、可追踪、能比较图像特征就是值有意义的区域，具有独特性、易于识别性。...
opencv建立椭圆边缘检测路径（一）—— 建立一条直线并获得直线上各点坐标
smalbig的博客
02-28 1013
1.首先介绍为何要用椭圆检测路径 对于某些圆形物体，当其边缘存在开放缺口的时候，可以通过建立一条椭圆检测路径（实际上是若干条直线路径拼成的椭圆路径，这也是这节的主题），来检测缺口的边缘，从而从检测到的边缘点获知缺口的存在。典型应用如图所示： 蓝色线为由直线路径组成的椭圆路径，橙色十字点为检测到的缺口边缘点。 2.在指定直线路径上进行边缘检测的原理 这节简单介绍下原理，之后再讲实现。实际上就是在一...
基于Hough椭圆检测opencv
01-10
Hough变换的基本原理是将图像空间中的点映射到参数空间的线，对于椭圆检测，则是将像素点映射到参数空间的椭圆方程。在参数空间中，如果某一点获得足够多的投票（对应于图像中的边缘点），那么就可能存在一个椭圆。 ...
opencv椭圆方程
10-02
OpenCV中的椭圆方程可以表示为：((x-cx)/a)^2 + ((y-cy)/b)^2 = 1，其中(cx, cy)是椭圆的中心坐标，a是椭圆的长半轴，b是椭圆的短半轴。 相关问题: 1. 如何使用OpenCV在图像上绘制椭圆？ 2. 如何使用OpenCV拟合椭圆...
椭圆中点算法
言午日月
12-29 1506
椭圆的扫描转换与圆的扫描转换有相似之处，但也有不同，主要区别是椭圆弧上存在改变主位移方向的临界点。瞬时针绘制四分椭圆弧的中点算法，根据对称性可以绘制完整的椭圆。方向上减 1 或 减 0， 取决于中点误差项的值，在区域。而在下一个中点处，不等号改变方向，则说明椭圆弧从区域。显然，在临界点处，法矢量分量的大小发生了变化。的方向递增一个单位，第一个参与判断的中点是。从曲线上的斜率角度来看，在临界点处，斜率为。内，椭圆弧的起点扫描转换后的像素点为。方向为主位移方向，在临界点处，有。内，主位移方向发生变化，由。
椭圆曲线上点的运算
aaron67的博客
10-11 7572
对定义在有限域上的椭圆曲线 E=(p,a,b,G,n,h)E = (p, a, b, G, n, h)E=(p,a,b,G,n,h) y2≡x3+ax+b(modp) y^2 \equiv x^3 + ax + b \pmod{p} y2≡x3+ax+b(modp) 本文将通过代码计算下面两个问题： 已知曲线上的点 P=(xP,yP)P = (x_P, y_P)P=(xP​,yP​) 和 Q=(xQ,yQ)Q = (x_Q, y_Q)Q=(xQ​,yQ​)，求点 R=P+QR = P + QR=P+Q 已
C# 计算椭圆上任意一点坐标
chen1231985111的博客
07-02 568
计算椭圆上任意一点到坐标
已知长短轴求椭圆上任意一点的坐标_椭圆的定义及其方程推导
weixin_39880479的博客
12-04 2971
椭圆与圆的关系圆是一个很简单很对称的图形，它是平面中到圆心的距离为定值的所有点组成的图形。椭圆是对圆定义的一个扩展，它是平面中到两个点的距离之和为定值的所有点组成的图形，这两个点被称为焦点、两个点之间的距离称为焦距。当两个焦点重合时，椭圆也就变成了圆。假设有一条绳子，它的两个端点是固定的，绳子长度超过两个固定点的距离，拿一枝笔将绳子拉直，用这支笔绕一周画出来的图形轨迹就是椭圆，两个固定端点就是椭圆...
根据角度求椭圆上坐标
LaineGates的专栏
04-25 1万+
计算椭圆上坐标 分两步，求离心角和根据离心角求椭圆上坐标。 椭圆方程 椭圆方程是 x2a2+y2b2=(xa)2+(yb)2=(cos(t))2+(sin(t))2=1 \frac{x^2}{a^2} + \frac{y^2}{b^2} = \left(\frac{x}{a}\right)^2+\left(\frac{y}{b}\right)^2=\left(cos\left(t\right)\r...
求圆和椭圆上任意角度的点的坐标
热门推荐
生如蚁，美如神
01-04 3万+
圆上任意角度的点的坐标 如上图，给定圆心（Cx,Cy）,半径为R， 求θ\thetaθ对应的点的坐标？ 此处θ\thetaθ是相对于水平轴的角度。 显然我们可以使用极坐标转换来求： {px=Cx+Rcos(θ)py=Cy+Rsin(θ) \left\{\begin{matrix} px= Cx+Rcos(\theta) \\ py= Cy+Rsin(\theta) \end{matrix}\...
基于DBSCAN算法的椭圆或者圆中心点的检测，opencv+sklearn
Alonewaiting
09-23 2910
DBSCAN+椭圆拟合 首先，这篇文章使用的方法，已经有论文出版，如果需要使用，请注意版权的保护，论文名为Binocular Vision System Integrated with Transcranial Magnetic Stimulation Automatic Therapeutic Apparatus。 优点： 1.计算精度高 2.算法原理简单， 缺点： 1.计算复杂度较高，实时性不...
opencv建立椭圆边缘检测路径（四）——剔除距离过近的边缘点
smalbig的博客
03-03 957
接上节，线性边缘检测后，会得到若干边缘点，有些边缘点强度非常相似，但是对于这一部分边缘点又想删去一部分，留下一部分，比如剔除距离过近的边缘点。 这个方法的应用在于：对于线性排列的重复物体，对其定位时，只希望检测到某个物体的一个最外层边缘，而不希望看到物体里面的边缘也被检测到，这时可以剔除距离过近的边缘点。 （下班，未完待续） ...
Python与OpenCV：掌握计算机视觉基础操作
本资源是一本关于计算机视觉与Python编程结合的实用教程，名为《OpenCV计算机视觉 with Python》。作者Joseph Howse以其在社区的经验，通过Distilled的形式，引导读者学习如何使用OpenCV库来实现视频捕获、图像处理...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值