opencv使用convexityDefects计算轮廓凸缺陷

引自：http://www.xuebuyuan.com/1684976.html

http://blog.csdn.net/lichengyu/article/details/38392473

http://www.cnblogs.com/yemeishu/archive/2013/01/19/2867286.html谈谈NITE 2与OpenCV结合提取指尖坐标

一 概念：

Convexity hull, Convexity defects

如上图所示，黑色的轮廓线为convexity hull, 而convexity hull与手掌之间的部分为convexity defects. 每个convexity defect区域有四个特征量：起始点（startPoint），结束点(endPoint)，距离convexity hull最远点(farPoint)，最远点到convexity hull的距离(depth)。

二．OpenCV中的相关函数

void convexityDefects(InputArray contour, InputArray convexhull, OutputArrayconvexityDefects)

参数：

coutour: 输入参数，检测到的轮廓，可以调用findContours函数得到；

convexhull: 输入参数，检测到的凸包，可以调用convexHull函数得到。注意，convexHull函数可以得到vector<vector<Point>>和vector<vector<int>>两种类型结果，这里的convexhull应该为vector<vector<int>>类型，否则通不过ASSERT检查；

convexityDefects：输出参数，检测到的最终结果，应为vector<vector<Vec4i>>类型，Vec4i存储了起始点（startPoint），结束点(endPoint)，距离convexity hull最远点(farPoint)以及最远点到convexity hull的距离(depth)

三．代码

//http://docs.opencv.org/doc/tutorials/imgproc/shapedescriptors/hull/hull.html
//http://www.codeproject.com/Articles/782602/Beginners-guide-to-understand-Fingertips-counting

#include "opencv2/highgui/highgui.hpp"
 #include "opencv2/imgproc/imgproc.hpp"
 #include <iostream>
 #include <stdio.h>
 #include <stdlib.h>

 using namespace cv;
 using namespace std;

 Mat src; Mat src_gray;
 int thresh = 100;
 int max_thresh = 255;
 RNG rng(12345);

 /// Function header
 void thresh_callback(int, void* );

/** @function main */
int main( int argc, char** argv )
 {
   /// Load source image and convert it to gray
   src = imread( argv[1], 1 );

   /// Convert image to gray and blur it
   cvtColor( src, src_gray, CV_BGR2GRAY );
   blur( src_gray, src_gray, Size(3,3) );

   /// Create Window
   char* source_window = "Source";
   namedWindow( source_window, CV_WINDOW_AUTOSIZE );
   imshow( source_window, src );

   createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
   thresh_callback( 0, 0 );

   waitKey(0);
   return(0);
 }

 /** @function thresh_callback */
 void thresh_callback(int, void* )
 {
   Mat src_copy = src.clone();
   Mat threshold_output;
   vector<vector<Point> > contours;
   vector<Vec4i> hierarchy;

   /// Detect edges using Threshold
   threshold( src_gray, threshold_output, thresh, 255, THRESH_BINARY );

   /// Find contours
   findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );

   /// Find the convex hull object for each contour
   vector<vector<Point> >hull( contours.size() );
   // Int type hull
   vector<vector<int>> hullsI( contours.size() );
   // Convexity defects
   vector<vector<Vec4i>> defects( contours.size() );

   for( size_t i = 0; i < contours.size(); i++ )
   {
	   convexHull( Mat(contours[i]), hull[i], false );
	   // find int type hull
	   convexHull( Mat(contours[i]), hullsI[i], false );
	   // get convexity defects
	   convexityDefects(Mat(contours[i]),hullsI[i], defects[i]);

   }

   /// Draw contours + hull results
   Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
   for( size_t i = 0; i< contours.size(); i++ )
      {
        Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
        drawContours( drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() );
        drawContours( drawing, hull, i, color, 1, 8, vector<Vec4i>(), 0, Point() );

		// draw defects
		size_t count = contours[i].size();
        std::cout<<"Count : "<<count<<std::endl;
        if( count < 300 )
            continue;

        vector<Vec4i>::iterator d =defects[i].begin();

        while( d!=defects[i].end() ) {
            Vec4i& v=(*d);
            //if(IndexOfBiggestContour == i)
			{

                int startidx=v[0];
                Point ptStart( contours[i][startidx] ); // point of the contour where the defect begins
                int endidx=v[1];
                Point ptEnd( contours[i][endidx] ); // point of the contour where the defect ends
                int faridx=v[2];
                Point ptFar( contours[i][faridx] );// the farthest from the convex hull point within the defect
                int depth = v[3] / 256; // distance between the farthest point and the convex hull

                if(depth > 20 && depth < 80)
                {
                line( drawing, ptStart, ptFar, CV_RGB(0,255,0), 2 );
                line( drawing, ptEnd, ptFar, CV_RGB(0,255,0), 2 );
				circle( drawing, ptStart,   4, Scalar(255,0,100), 2 );
				circle( drawing, ptEnd,   4, Scalar(255,0,100), 2 );
                circle( drawing, ptFar,   4, Scalar(100,0,255), 2 );
                }

				/*printf("start(%d,%d) end(%d,%d), far(%d,%d)\n",
					ptStart.x, ptStart.y, ptEnd.x, ptEnd.y, ptFar.x, ptFar.y);*/
            }
            d++;
        }

      }

   /// Show in a window
   namedWindow( "Hull demo", CV_WINDOW_AUTOSIZE );
   imshow( "Hull demo", drawing );
   //imwrite("convexity_defects.jpg", drawing);
 }

　　另一个版本的说法

首先介绍今天主角：void convexityDefects(InputArray contour, InputArray、convexhull, OutputArray convexityDefects)

使用时注意，最后一个参数 convexityDefects 是存储 Vec4i 的向量(vector<varname>)，函数计算成功后向量的大小是轮廓凸缺陷的数量，向量每个元素Vec4i存储了4个整型数据，因为Vec4i对[]实现了重载，所以可以使用 _vectername[i][0] 来访问向量 _vactername的第i个元素的第一个分量。再说 Vec4i 中存储的四个整形数据，

Opencv 使用这四个元素表示凸缺陷，

第一个名字叫做  
start_index,表示缺陷在轮廓上的开始处，他的值是开始点在函数第一个参数 contour 中的下标索引；

Vec4i 第二个元素的名字叫
end_index， 顾名思义其对应的值就是缺陷结束处在 contour 中的下标索引；

Vec4i 第三个元素 
farthest_pt_index 是缺陷上距离 轮廓凸包(convexhull)最远的点；

Vec4i最后的元素叫
fixpt_depth，fixpt_depth/256  表示了
轮廓上以 farthest_pt_index 为下标的点到 轮廓凸包的(convexhull)的距离,以像素为单位。

All is so easy!下面就是简单的代码示例（首先计算两个轮廓的凸包，然后计算两个轮廓的凸缺陷）:

// 计算凸缺陷 convexityDefect
//

#include "stdafx.h"
#include <opencv.hpp>
#include <iostream>

using namespace std;
using namespace cv;

int _tmain(int argc, _TCHAR* argv[])
{
	Mat *img_01 = new Mat(400, 400, CV_8UC3);
	Mat *img_02 = new Mat(400, 400, CV_8UC3);
	*img_01 = Scalar::all(0);
	*img_02 = Scalar::all(0);
	// 轮廓点组成的数组
	vector<Point> points_01,points_02;

	// 给轮廓组赋值
	points_01.push_back(Point(10, 10));points_01.push_back(Point(10,390));
	points_01.push_back(Point(390, 390));points_01.push_back(Point(150, 250));
	points_02.push_back(Point(10, 10));points_02.push_back(Point(10,390));
	points_02.push_back(Point(390, 390));points_02.push_back(Point(250, 150));

	vector<int> hull_01,hull_02;
	// 计算凸包
	convexHull(points_01, hull_01, true);
	convexHull(points_02, hull_02, true);

	// 绘制轮廓
	for(int i=0;i < 4;++i)
	{
		circle(*img_01, points_01[i], 3, Scalar(0,255,255), CV_FILLED, CV_AA);
		circle(*img_02, points_02[i], 3, Scalar(0,255,255), CV_FILLED, CV_AA);
	}
	// 绘制凸包轮廓
	CvPoint poi_01 = points_01[hull_01[hull_01.size()-1]];
	for(int i=0;i < hull_01.size();++i)
	{
		line(*img_01, poi_01, points_01[i], Scalar(255,255,0), 1, CV_AA);
		poi_01 = points_01[i];
	}
	CvPoint poi_02 = points_02[hull_02[hull_02.size()-1]];
	for(int i=0;i < hull_02.size();++i)
	{
		line(*img_02, poi_02, points_02[i], Scalar(255,255,0), 1, CV_AA);
		poi_02 = points_02[i];
	}

	vector<Vec4i> defects;
	// 如果有凸缺陷就把它画出来
	if( isContourConvex(points_01) )
	{
		cout<<"img_01的轮廓是凸包"<<endl;
	}else{
		cout<<"img_01的轮廓不是凸包"<<endl;
		convexityDefects(
			points_01,
			Mat(hull_01),
			defects
			);
		// 绘制缺陷
		cout<<"共"<<defects.size()<<"处缺陷"<<endl;
		for(int i=0;i < defects.size();++i)
		{
			circle(*img_01, points_01[defects[i][0]], 6, Scalar(255,0,0), 2, CV_AA);
			circle(*img_01, points_01[defects[i][1]], 6, Scalar(255,0,0), 2, CV_AA);
			circle(*img_01, points_01[defects[i][2]], 6, Scalar(255,0,0), 2, CV_AA);
			line(*img_01, points_01[defects[i][0]], points_01[defects[i][1]], Scalar(255,0,0), 1, CV_AA);
			line(*img_01, points_01[defects[i][1]], points_01[defects[i][2]], Scalar(255,0,0), 1, CV_AA);
			line(*img_01, points_01[defects[i][2]], points_01[defects[i][0]], Scalar(255,0,0), 1, CV_AA);
			cout<<"第"<<i<<"缺陷<"<<points_01[defects[i][0]].x<<","<<points_01[defects[i][0]].y
				<<">,<"<<points_01[defects[i][1]].x<<","<<points_01[defects[i][1]].y
				<<">,<"<<points_01[defects[i][2]].x<<","<<points_01[defects[i][2]].y<<">到轮廓的距离为："<<defects[i][3]/256<<"px"<<endl;
		}
		defects.clear();
	}
	if( isContourConvex( points_02 ) )
	{
		cout<<"img_02的轮廓是凸包"<<endl;
	}else{
		cout<<"img_02的轮廓不是凸包"<<endl;
		vector<Vec4i> defects;
		convexityDefects(
			points_01,
			Mat(hull_01),
			defects
			);
		// 绘制出缺陷的轮廓
		for(int i=0;i < defects.size();++i)
		{
			circle(*img_02, points_01[defects[i][0]], 6, Scalar(255,0,0), 2, CV_AA);
			circle(*img_02, points_01[defects[i][1]], 6, Scalar(255,0,0), 2, CV_AA);
			circle(*img_02, points_01[defects[i][2]], 6, Scalar(255,0,0), 2, CV_AA);
			line(*img_02, points_01[defects[i][0]], points_01[defects[i][1]], Scalar(255,0,0), 1, CV_AA);
			line(*img_02, points_01[defects[i][1]], points_01[defects[i][2]], Scalar(255,0,0), 1, CV_AA);
			line(*img_02, points_01[defects[i][2]], points_01[defects[i][0]], Scalar(255,0,0), 1, CV_AA);
			// 因为 img_02 没有缺陷所以就懒的写那些输出代码了
		}
		defects.clear();
	}

	imshow("img_01 的轮廓和凸包：", *img_01);
	imshow("img_02 的轮廓和凸包：", *img_02);
	cvWaitKey();

	return 0;
}

　　

时间： 2024-10-09 06:51:13

opencv使用convexityDefects计算轮廓凸缺陷的相关文章

OpenCV 学习（计算图像的直方图）

OpenCV 计算图像的直方图 计算图像的直方图是图像处理领域一个非常常见的基本操作. OpenCV 中提供了 calcHist 函数来计算图像直方图.不过这个函数说实话挺难用的,研究了好久才掌握了些基本的用法. calcHist 函数 C++ 的函数原型如下: void calcHist(const Mat* images, int nimages, const int* channels, InputArray mask, SparseMat& hist, int dims, const i

opencv实现移动速度计算

简介 本篇使用opencv函数phaseCorrelate来计算video录像时候移动速度和方向或者说是摄像头当前移动速度和方向. phaseCorrelate Point2d phaseCorrelate(InputArray src1, InputArray src2, InputArray window=noArray()) src1:前一帧video图像; src2:当前video图像; window:浮点阵列的窗口系数,用来减少边缘效应(可选). 返回的Point2d:返回的二维坐标,

OpenCV学习代码记录——轮廓(contour)检测

很久之前学习过一段时间的OpenCV,当时没有做什么笔记,但是代码都还在,这里把它贴出来做个记录. 代码放在码云上,地址在这里https://gitee.com/solym/OpenCVTest/tree/master/OpenCVTest #include <opencv2/core/core.hpp> #include <opencv2/highgui/highgui.hpp> #include <opencv2/imgproc/imgproc.hpp> // cv

OpenCV——积分图计算

1 #include <opencv2/opencv.hpp> 2 #include <iostream> 3 #include "math.h" 4 5 using namespace cv; 6 using namespace std; 7 8 int main(int argc, char** argv) { 9 Mat src = imread("test.jpg",0); 10 if (src.empty()) { 11 print

[Opencv]几种对轮廓的处理方式

boundingRect() 作用:计算点集的右上边框. 形式:boundingRect(InputArray points): 参数:points:输入二维点集,并用std::vector or Mat存储: points:输入信息,可以为包含点的容器(vector)或是Mat.返回包覆输入信息的最小正矩形.如下图: RotateRect minAreaRect(InputArray points)作用:生成最小外接矩形 points,输入信息,可以为包含点的容器(vector)或者是Mat

【OpenCV学习】计算两幅图像的重叠区域

问题描述:已知两幅图像Image1和Image2,计算出两幅图像的重叠区域,并在Image1和Image2标识出重叠区域. 算法思想: 若两幅图像存在重叠区域,则进行图像匹配后,会得到一张完整的全景图,因而可以转换成图像匹配问题. 图像匹配问题,可以融合两幅图像,得到全景图,但无法标识出在原图像的重叠区域. 将两幅图像都理解为多边形,则其重叠区域的计算,相当于求多边形的交集. 通过多边形求交,获取重叠区域的点集,然后利用单应矩阵还原在原始图像的点集信息,从而标识出重叠区域. 算法步骤: 1.图像

（原+转）使用opencv的DFT计算卷积

转载请注明出处: http://www.cnblogs.com/darkknightzh/p/5462665.html 参考网址: http://blog.csdn.net/lichengyu/article/details/18848281 貌似还有其他的,记不清了 convolveDFT函数是从官方文档中抄录并做了修改,因为原来的程序有问题.一是输出Mat C应声明为引用:二是其中的mulSpectrums函数的第四个参数flag值没有指定,应指定为DFT_COMPLEX_OUTPUT或是D

OpenCV——查找、绘制轮廓（实际是把连通域填上某种颜色）

原文地址:https://www.cnblogs.com/long5683/p/9692417.html

OpenCV——使用多边形包围轮廓

原文地址:https://www.cnblogs.com/long5683/p/9692807.html