OpenCv案例(十三)：基于OpenCVSharp-模板匹之旋转角度匹配

已于 2024-01-17 13:45:12 修改
阅读量2.5k 收藏 32
点赞数 11
分类专栏： OpenCVSharp视觉学习 OpenCv C# 文章标签： opencv 人工智能 计算机视觉
于 2024-01-17 13:43:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37835727/article/details/135646120
版权
OpenCVSharp视觉学习 同时被 3 个专栏收录
14 篇文章 98 订阅
订阅专栏
C#
11 篇文章 5 订阅
订阅专栏
OpenCv
10 篇文章 6 订阅
订阅专栏

原模板匹配方法中，是无法进行任意角度和旋转匹配的，但我们在实际的使用中，模板图像的位置和方向都是不确定的，因此，就需要我们对模板图像进行预处理，处理后在进行模板匹配。

基本处理方法如下：

  • 模板图像读取
  • 进行模糊
  • 绘制轮廓
  • 形态学处理
  • 提取轮廓
  • 获取当前位置角度
  • 图像旋转。
  • 原图读取
  • 从4个角度进行模板匹配（0°，90°，180°，270°）
  • 记录每个角度的匹配值
  • 进行后续操作。

1：原图如下所示:

2：模板图像如下所示：

3：思路：在模板图像中，抠出图像，并且找到当前的旋转角度，将其恢复为正向0°，在进行对其模板匹配，给出匹配结果。处理过程图像如下：

分别是将其调整为正向后，0°，90°，180°，270°的旋转匹配，同时记录匹配度的值。

 

源码图下：

 public List<Point2d> GetResult(Mat tempImage, string srcImgPath, out double robotRotateAngel, out double arcVal)
 {
     List<Point2d> point2Ds = new List<Point2d>();
     robotRotateAngel = 999;
     arcVal = 0;
     try
     {
         double rotAngel;
         Point2f centerPoint;
         Rect rect;
         Mat tempMat = SetTemplateImage1(tempImage, out rotAngel, out rect, out centerPoint);
         bool matchRet = GetMatchRet1(srcImgPath, tempMat, rotAngel, out robotRotateAngel, out arcVal);

         if (!matchRet)
         {
             //图像识别失败
             return null;
         }
     }
     catch (Exception ex)
     {
         
     }
     return point2Ds;
 }

public Mat SetTemplateImage1(Mat image, out double rotAngel, out Rect rect, out Point2f centerPoint)
{
    rotAngel = -1;
    rect = new Rect();
    centerPoint = new Point2f();
    Mat blurImg = GaussBlurImage(image);//ip.MedBlurImage(image);// 
    Mat cannyImg = new Mat();
    Cv2.Canny(blurImg, cannyImg, 30, 90);
    Mat morphImg = MorphImage(cannyImg);
    //Cv2.ImShow("morphImg1", morphImg);
    Mat roiImage = GetRioOutline(morphImg, image, out rotAngel, out rect, out centerPoint);
    //Cv2.ImShow("roiImage", roiImage);
    Mat rotImg = ImageRotate(roiImage, rotAngel, rect);
    //Cv2.ImShow("rotImg", rotImg);
    Mat mat = GetRoi(rotImg, rect);
    Cv2.ImShow("mat", mat);
    return mat;
}

        /// <summary>
        /// 高斯 模糊
        /// </summary>
        /// <param name="img"></param>
        /// <returns></returns>
        public Mat GaussBlurImage(Mat image)
        {
            Mat gaussianimage = new Mat();
            Cv2.GaussianBlur(image, gaussianimage, new OpenCvSharp.Size(3, 3), 3, 3);//尽可能多的去除杂质
            return gaussianimage;
        }

        /// <summary>
        /// 图像形态学操作
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public Mat MorphImage(Mat image)
        {
            Mat morphImage = new Mat();
            Mat kernel = Cv2.GetStructuringElement(MorphShapes.Rect, new OpenCvSharp.Size(3, 3), new Point(-1, -1));
            Cv2.MorphologyEx(image, morphImage, MorphTypes.Gradient, kernel, new Point(-1, -1), 2);
            return morphImage;
        }

        /// <summary>
        /// 提取图像轮廓
        /// </summary>
        /// <param name="morphImage">形态学图片</param>
        /// <param name="srcImage">原图</param>
        /// <param name="rotateAngel">返回旋转角度</param>
        /// <param name="rect">返回获取的矩形边框</param>
        /// <returns></returns>
        public Mat GetRioOutline(Mat morphImage, Mat srcImage, out double rotateAngel, out Rect rect, out Point2f minRectcenterPoint)
        {
            OpenCvSharp.Point[][] contours;
            HierarchyIndex[] hierarchies;
            //Cv2.ImShow(",mmmm", morphImage);
            Cv2.FindContours(morphImage, out contours, out hierarchies, RetrievalModes.External, ContourApproximationModes.ApproxTC89KCOS, new Point());
            Mat connImg = Mat.Zeros(morphImage.Size(), MatType.CV_8UC3);
            rotateAngel = 0;
            //Point2f[] vertices = new Point2f[4];
            minRectcenterPoint = new Point2f();
            rect = new Rect();
            int index = 0;
            int count = -1;
            //寻找最大轮廓
            for (int i = 0; i < contours.Length; i++)
            {
                for (int j = 0; j < contours[i].Length; j++)
                {
                    if (count < contours[i].Length)
                    {
                        count = contours[i].Length;
                        index = i;
                    }
                }
            }
            //获取轮廓点的矩形区域
            rect = Cv2.BoundingRect(contours[index]);
            //minAreaRect():以X轴正方形为起点，顺时针为正，逆时针为负
            //绘制Rio区域最小矩形
            #region 绘制Rio区域最小矩形
            RotatedRect minRect = Cv2.MinAreaRect(contours[index]);
            rotateAngel = minRect.Angle;
            minRectcenterPoint = minRect.Center;
            //vertices = minRect.Points(); 
            #endregion
            //绘制最小矩形
            #region 绘制最小矩形
            //Cv2.Line(srcImage, Convert.ToInt32(vertices[0].X), Convert.ToInt32(vertices[0].Y), Convert.ToInt32(vertices[1].X), Convert.ToInt32(vertices[1].Y), new Scalar(0, 255, 255));
            //Cv2.Line(srcImage, Convert.ToInt32(vertices[0].X), Convert.ToInt32(vertices[0].Y), Convert.ToInt32(vertices[3].X), Convert.ToInt32(vertices[3].Y), new Scalar(0, 255, 255));
            //Cv2.Line(srcImage, Convert.ToInt32(vertices[1].X), Convert.ToInt32(vertices[1].Y), Convert.ToInt32(vertices[2].X), Convert.ToInt32(vertices[2].Y), new Scalar(0, 255, 255));
            //Cv2.Line(srcImage, Convert.ToInt32(vertices[2].X), Convert.ToInt32(vertices[2].Y), Convert.ToInt32(vertices[3].X), Convert.ToInt32(vertices[3].Y), new Scalar(0, 255, 255));
            //Console.WriteLine("AngleRect_angle: {0}", minRect.Angle); 
            #endregion

            //Cv2.ImShow("srcImage", srcImage);

            return srcImage;
        }

        /// <summary>
        /// 图像旋转
        /// </summary>
        /// <param name="image">旋转图像</param>
        /// <param name="rotateAngel">旋转角度</param>
        /// <returns></returns>
        public Mat ImageRotate(Mat image, double rotateAngel, Rect rect)
        {
            if (rotateAngel > -90 && rotateAngel <= -45)
            {
                rotateAngel += 90;
            }
            else if (!(rotateAngel > -45 && rotateAngel < 0))
            {
                //degree = degree;
                rotateAngel = 0;
            }
            //OpenCvSharp.Point center = new OpenCvSharp.Point(image.Cols / 2, image.Rows / 2);
            //以被截取的区域中心位置旋转
            //边缘放大截取
            OpenCvSharp.Point center = new OpenCvSharp.Point(rect.TopLeft.X + (rect.Width / 2), rect.TopLeft.Y + (rect.Height / 2));
            //截取最小矩形
            //OpenCvSharp.Point center = new OpenCvSharp.Point(image.Cols / 2, image.Rows / 2);
            double angle = rotateAngel;
            double scale = 1;
            Mat rotate = new Mat(2, 3, MatType.CV_32FC1);
            rotate = Cv2.GetRotationMatrix2D(center, angle, scale);//getRotationMatrix2D():以X轴正方形为起点，顺时针为负，逆时针为正
            Mat rotImage = new Mat();
            Cv2.WarpAffine(image, rotImage, rotate, image.Size(), InterpolationFlags.Linear, BorderTypes.Wrap);
            int winSize = 0;
            if (image.Cols > image.Rows)
            {
                winSize = image.Cols;
            }
            else
            {
                winSize = image.Rows;
            }
            return rotImage;
        }


        /// <summary>
        /// 获取感兴趣区域
        /// </summary>
        /// <param name="image">图像</param>
        /// <param name="rect">面积</param>
        /// <returns></returns>
        public Mat GetRoi(Mat image, Rect rect)
        {
            //Mat imageRoi = new Mat(image, new Rect(new Point(rect.TopLeft.X - rect.Width / 2, rect.TopLeft.Y), new Size(rect.Height, rect.Height)));
            Mat imageRoi = new Mat(image, new Rect(new Point(rect.TopLeft.X, rect.TopLeft.Y), new Size(rect.Width, rect.Height)));
            return imageRoi;
        }

        Dictionary<int, double> angelDic1;
        /// <summary>
        /// 模板匹配是否成功
        /// </summary>
        /// <param name="srcBmp">原图</param>
        /// <param name="templateMat">模板图像</param>
        /// <param name="rotAngel">初始旋转角度</param>
        /// <param name="robotRotateAngel">机器人需要旋转的角度</param>
        /// <returns></returns>
        public bool GetMatchRet1(string srcImgFilePath, Mat templateMat, double rotAngel, out double robotRotateAngel, out double arcValue)
        {
            double matchVal = 0;
            //最大旋转角度360
            robotRotateAngel = 999;
            arcValue = 0;
            try
            {
                Mat src = Cv2.ImRead(@"E:\SoftwarePackage\CodePackage\ImgPro\Img\T1.bmp");
                //src.ConvertTo(src, MatType.CV_8UC4);
                if (src.Empty())
                {
                    //Console.WriteLine("src could not load image...\n");
                    return false;
                }
                Cv2.ImShow("src", src);
                //Mat templateMat = Cv2.ImRead(@"E:\SoftwarePackage\CodePackage\ImgPro\Img\T21.bmp");
                if (templateMat.Empty())
                {
                    //Console.WriteLine("src could not load image...\n");
                    return false;
                }

                angelDic1 = new Dictionary<int, double>(); ;
                //记录角度
                int rotateAngel = 0;
                //第一张调正之后的图像
                //Cv2.ImShow(0.ToString(), mat);
                Point p;
                Bitmap rotateBmp;
                //旋转图像4个角度
                for (int i = 0; i < 4; i++)
                {
                    if (templateMat.Rows > src.Rows || templateMat.Cols > src.Cols)
                    {
                        continue;
                    }
                    Bitmap bmp = MatchTemplate(templateMat, src, out p, out matchVal);
                    if (matchVal > TemplateMatchThreshold)
                    {
                        angelDic1.Add(rotateAngel, matchVal);
                    }
                    //Mat rotImg1 = ip.ImageRotate(mat, 90);
                    rotateBmp = BitmapConverter.ToBitmap(templateMat);
                    rotateBmp.RotateFlip(RotateFlipType.Rotate90FlipXY);
                    rotateAngel += 90;
                    templateMat = BitmapConverter.ToMat(rotateBmp);
                    if (1 + i > 3)
                    {
                        break;
                    }
                    Cv2.ImShow((i + 1).ToString(), templateMat);
                }
                //若匹配值没有符合条件
                if (angelDic1.Count < 1)
                {
                    return false;
                }

                List<double> matchRet = new List<double>();
                foreach (KeyValuePair<int, double> kvp in angelDic1)
                {
                    matchRet.Add(kvp.Value);
                }
                //判断匹配最大值是否大于设定阈值 否则 匹配失败
                //if (matchRet.Max() < TemplateMatchThreshold)
                //{
                //    return false;
                //}
                //抠出模板图像 与原图进行模板匹配,并且记住最大匹配度的角度
                var ag = angelDic1.Where(q => q.Value == matchRet.Max()).Select(q => q.Key);
                robotRotateAngel = CalcRotateAngel(rotAngel, ag.Max());
                //角度转弧度
                arcValue = robotRotateAngel * arc;
            }
            catch (Exception ex)
            {
                //LogHelper.WriteLog(ex.Message, ex);
            }
            return true;
        }

        private double arc1 = Math.PI / 180;

        /// <summary>
        /// 模板匹配
        /// </summary>
        /// <param name="tempalte">模板图片像</param>
        /// <param name="srcPic">被匹配图像</param>
        /// <returns>标注匹配区域的图像</returns>
        public Bitmap MatchTemplate(Mat tempalte, Mat srcPic, out OpenCvSharp.Point tempPoint, out double matchValue)
        {

            using (Mat result = new Mat()) //匹配结果
            {                             //模板匹配
                Double minVul;
                Double maxVul;
                OpenCvSharp.Point minLoc = new OpenCvSharp.Point(0, 0);
                OpenCvSharp.Point maxLoc = new OpenCvSharp.Point(0, 0);
                OpenCvSharp.Point matchLoc = new OpenCvSharp.Point(0, 0);
                Cv2.MatchTemplate(srcPic, tempalte, result, TemplateMatchModes.CCoeffNormed);//CCoeffNormed  最好匹配为1,值越小匹配越差 xxxNormed的算法无需归一化
                                                                                             //Cv2.Normalize(result, result, 0, 1, NormTypes.MinMax, -1);//归一化
                Cv2.MinMaxLoc(result, out minVul, out maxVul, out minLoc, out maxLoc);//查找极值
                                                                                      //Cv2.MinMaxLoc(result, out minVul, out maxVul, out minLoc, out maxLoc, null);//查找极值
                matchLoc = maxLoc;//最大值坐标
                                  //result.Set(matchLoc.Y, matchLoc.X, 0);//改变最大值为最小值  
                Mat mask = srcPic.Clone();//复制整个矩阵
                                          //Console.WriteLine("最大值：{0}，X:{1}，Y:{2}", maxVul, matchLoc.Y, matchLoc.X);
                matchValue = maxVul;
                tempPoint.X = matchLoc.X;
                tempPoint.Y = matchLoc.Y;
                //画框显示 :对角线画框，起点和终点，都用Point，线宽
                if (matchValue > TemplateMatchThreshold)
                {
                    Cv2.Rectangle(mask, matchLoc, new OpenCvSharp.Point(matchLoc.X + tempalte.Cols, matchLoc.Y + tempalte.Rows), Scalar.Green, 2);//2代表画的线条的宽细程度
                }
                return OpenCvSharp.Extensions.BitmapConverter.ToBitmap(mask);
            }
        }

        /// <summary>
        /// 计算角度
        /// </summary>
        /// <param name="srcAngel"></param>
        /// <param name="rotateAngle"></param>
        /// <returns></returns>
        public double CalcRotateAngel(double srcAngel, int rotateAngle)
        {
            //逆时针旋转为负 顺时针旋转为正
            double tempSrcAngel = Math.Abs(srcAngel);
            double resultAngel = -1;
            if (tempSrcAngel >= 45)
            {
                switch (rotateAngle)
                {
                    case 0:
                        resultAngel = 90 - tempSrcAngel;
                        break;
                    case 90:
                        resultAngel = 180 - tempSrcAngel;
                        break;
                    case 180:
                        //逆时针
                        resultAngel = -(90 + tempSrcAngel);
                        break;
                    case 270:
                        //逆时针
                        resultAngel = -tempSrcAngel;
                        break;
                }
            }
            else if (tempSrcAngel < 45)
            {
                switch (rotateAngle)
                {
                    case 0:
                        //逆时针
                        resultAngel = -tempSrcAngel;
                        break;
                    case 90:
                        resultAngel = 90 - tempSrcAngel;
                        break;
                    case 180:
                        resultAngel = 90 + tempSrcAngel;
                        break;
                    case 270:
                        //逆时针
                        resultAngel = -(90 + tempSrcAngel);
                        break;
                }
            }
            return resultAngel;
        }

完整代码都在上面了，感兴趣的小伙伴可以在优化优化。下个案例见。

码小跳
关注
  • 11
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python+opencv实现NCC模板旋转匹配（图像处理）
m0_53362727的博客
02-17 9598
使用python代码实现NCC匹配 1.旋转使用圆投影 2.使用降采样加速匹配 3.差分简化运算的实现
图像匹配得到精确的旋转角度
热门推荐
Hao_09的专栏
08-14 3万+
当对平面物体进行视觉定位时，往往采用图像模板匹配的方式，然而当目标含有一定角度的旋转时，如何精确估算出旋转角度成了一个难题。下面是博主根据自己的理解所做的一个小的总结，也能算纠结，欢迎高手围观。 1 基于灰度的模板匹配（NCC等）     用灰度模板进行模板匹配，往往耗时，并且要匹配含有旋转的目标，就需要建立多角度的模板。如果目标的角度范围是（-30°，30°），以1°为步幅，则需要60个模板
基于OpenCv的旋转匹配
09-10
基于OpenCv实现了模板图像的旋转匹配，此代码基于matchTemplate函数封装实现可以得知旋转角度的模板匹配
基于OpenCV的的图像旋转匹配算法模板（C++实现）
01-02
1.基于OpenCv的旋转匹配 基于OpenCv实现了模板图像的旋转匹配，此代码基于matchTemplate函数封装实现可以得知旋转角度的模板匹配（vs2013+opencv2.4.9） 2.带旋转的模板匹配的原理及算法实现(c++) 带旋转的模板匹配算法，能够匹配带旋转角度的模板。（VS 2015+OPENCV C++）
opencv--使用opencv实现旋转角度的模板匹配
进击的菜鸟
06-06 431
下面的例子是简单的使用opencv 实现的模板匹配流程，其中时间性能和精确度还需要调整，如果直接使用会出问题，所以这个只是例子，根据代码原理可以实现尺度变化的模板匹配和旋转尺度变化同时，具体根据实现的旋转代码进一步实现，但是就结果而言和halcon的模板匹配差距较大，性能更不行，因此仅供参考。
多目标多角度的快速模板匹配算法（基于边缘梯度)
weixin_39450742的博客
07-09 2384
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/14615375.html 侵删 基于NCC的多目标多角度快速模板匹配算法详见：https://www.cnblogs.com/Imageshop/p/14559685.html 乘着研究NCC的热情，顺便也研究了下基于边缘梯度的匹配。 基于边缘梯度方面的匹配，最为出名的莫过于CodeProject...
基于Csharp+OpenCV图像处理实战
04-22
一、主要内容：OpenCV能够实现强大丰富的图像处理，但是它缺少一个能够支持它运行的界面。Csharp经过多年的发展,得益于它的“所见及所得”能力，非常方便编写界面。这两者如果能够“双剑合璧”，将有效帮助实际工作产出。本课着重推荐GOCW采用“Csharp基于CLR直接调用Opencv编写的算法库”方法，能够将最新的OpenCV技术引入进来，同时保证生成程序的最小化。    为了进一步说明Csharp和OpenCV的结合使用，首先一个较为完整的基于winform实现答题卡识别的例子，相比较之前的实现，本次进一步贴近生产实际、内涵丰富，对算法也进行了进一步提炼。同时我们对WPF下对OpenCV函数的调用、OpenCV.js的调用进行相关教授。       二、课程结构1、 EmguCV、OpenCVSharp和GOCW之间进行比较（方便代码编写、能够融入最新的算法、速度有保障、方便调试找错、拒绝黑箱化）；2、视频采集模块的构建，视频采集和图像处理之间的关系；3、视频采集专用的SDK和“陪练”系统的介绍；4、在视频增强类项目中和图像处理项目中，算法的选择；5、Csharp界面设计、图片的存储和其他构建设计；6、较为完整的答题卡识别例子，兼顾界面设计和算法分析;8、WPF基于GOCW也同样可以基于GOCW实现算法调用；webForm虽然也可以通过类似方法调用，但是OpenCV.JS的方法更现代高效。9、关于软件部署的相关要点和窍门。       三、知识要点：１、基本环境构建和程序框架；２、CLR基本原理和应用方法；３、接入、采集、模拟输入;４、图像处理，通过构建循环采集图片；５、增强和实时处理；６、基于投影等技术的答题卡识别算法；７、存储、转换；８、部署交付。        课程能够帮助你掌握Csharp调用Opencv的基本方法，获得相应框架代码和指导；从而进一步提升实现“基于图像处理”的解决方案能力。  
opencv入门（15）-- 模板匹配
weixin_43212588的博客
09-02 163
模板匹配就是在给定的图像中，通过计算模板与图片对应区域的匹配度，查找与模板最相似的区域。模板匹配的核心其实就是将模板与源图像的每个区域进行比较，逐像素滑动。从本质上讲，是将模板在源图像上进行卷积，创建新的图像或矩阵，其中每个像素值表示模板与源图像中相应区域之间的相似性。分析结果图像，可以通过峰值找到与模板匹配的紧缺位置。
[C#]OpenCvSharp-模板匹配MatchTemplate
FL1768317420的博客
04-04 559
方法通过在输入图像中滑动模板图像并计算每个位置的匹配度来查找模板的位置。匹配度通常使用平方差或等指标来度量，具体取决于所选择的匹配方法。
C# OpenCvSharp 模板匹配.rar
11-09
C# OpenCvSharp 模板匹配.rar 博客地址： https://blog.csdn.net/weixin_46771779/article/details/134305423
opencvsharp-master.zip_OpenCVSharp匹配_OpenCvSharp_图片识别_标记识别
07-14
OpenCVSharp是一个基于.NET框架的OpenCV库的封装，它为C#程序员提供了与OpenCV相同的功能，使得在.NET环境中进行图像处理和计算机视觉任务变得简单。本项目"opencvsharp-master.zip"包含了OpenCVSharp的源代码和示例...
基于QT+Opencv模板匹配支持（缩放、旋转)
02-21
**基于QT+OpenCV的模板匹配技术详解** 在计算机视觉领域，模板匹配是一种常见的图像处理技术，用于在大图像中寻找与给定模板相似的小区域。这个过程在目标检测、图像识别、视频分析等应用场景中非常有用。在本文中...
基于opencv的模板匹配
04-27
**基于OpenCV的模板匹配** 在计算机视觉领域，图像处理是一项关键的技术，它涉及对图像进行分析、识别和操作。OpenCV（开源计算机视觉库）是这个领域内广泛使用的库，提供了大量的函数和方法，用于图像处理和计算机...
c# OpenCvSharp 检测（斑点检测、边缘检测、轮廓检测）（五）
转眼之间 一路有你
12-22 6710
在C#中使用OpenCV进行图像处理时，可以使用不同的算法和函数来实现斑点检测、边缘检测和轮廓检测。
OpenCVSharp 4.5 轮廓边框（旋转矩形和椭圆）
jimtien的专栏
07-01 1532
用OpenCVSharp4.5跑一遍OpenCV官方教程 原官方教程链接：OpenCV: Creating Bounding rotated boxes and ellipses for contours 核心函数：minAreaRect，fitEllipse using System; using OpenCvSharp; namespace ConsoleApp1 { class tutorial26 : ITutorial { static Mat src_.
【Opencv】绘制最小外接矩形、最小外接圆
AI知识搬运工
09-21 6772
Opencv绘制最小外接矩形、最小外接圆 Opencv中求点集的最小外结矩使用方法minAreaRect，求点集的最小外接圆使用方法minEnclosingCircle。 minAreaRect方法原型： RotatedRectminAreaRect(InputArraypoints); 输入参数points是所要求最小外结矩的点集数组或向量； minEnclosin...
基于opencvsharp的模板匹配
F_soar的博客
03-30 1462
1.对一张图中，进行多个匹配，找出所有与模板图相似的值 核心思想: 用 Cv2.MatchTemplate和Cv2.Normalize对图像进行模板匹配和归一化处理，然后选中最匹配的值，得到相应的坐标； 2.代码如下: 如有不对的地方，欢迎指正，谢谢！ ...
基于OpenCvSharp的数字图像处理 - 轮廓
lweiyue的专栏
05-11 4767
我们在前面的章节里讲过边缘检测，本章所说的轮廓是基于边缘检测的。我们之前所做的边缘检测，结果只是基于像素的，而很多时候，我们可能需要对轮廓进行一些几何操作，例如分析区域是否连通，求出轮廓的凸包，判断一个点是不是在轮廓内，等等。我们先来看两种生成轮廓的方法，再看对轮廓的一些应用。 一、从边缘得到轮廓 虽然轮廓似乎就是边缘，但实际上，OpenCV只能从二值图得到轮廓，边缘被看成是非常窄的区域（宽1个像素）。所以，从边缘得到轮廓时，会出现两条轮廓基本相同，它们是边缘的内外。 示例代码如下： Mat sr
使用OpenCV的absdiff函数报错
最新发布
qq_62964142的博客
07-09 204
terminate called after throwing an instance of 'cv::Exception' what(): OpenCV(4.2.0) ../modules/core/src/arithm.cpp:666: error: (-209:Sizes of input arguments do not match) The operation is neither 'array op array' (where arrays have the same size and t
img_matplotlib = img_OpenCV[:, :, ::-1]
03-21
这是一个将 OpenCV 图像转换为 Matplotlib 图像的代码，其中 img_OpenCV 是 OpenCV 中读取的图像，img_matplotlib 是转换后的 Matplotlib 图像。[:, :, ::-1] 表示将图像的 RGB 通道顺序反转，因为 OpenCV 中的通道顺序是 BGR，而 Matplotlib 中的通道顺序是 RGB。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值