第七章 学习OpenCV——直方图与匹配
第七章 学习OpenCV——直方图与匹配
目录
- 第七章 学习OpenCV直方图与匹配
- 目录
- 例7-1 直方图的计算与显示
- 例7-2 从EMD直方图创建signature用EMD度量相似性
- 例7-3 基于像素点的反向投影cvCalcBackProject
- 例7-4 基于块的反向投影cvCalcArrBackProjectPatch
- 例7-5 模板匹配
- 例7-6 创建一个包含直方图1000个随机值
- 例7-7 bin的个数对直方图匹配产生的影响
- 例7-8 光照对直方图EMD匹配产生的影响
- 例7-9 图像拍摄的光照条件判定
- 例7-10 肤色场景检测器
- 例7-11 RGB肤色区域检测器
- 例7-12 手势梯度方向直方图
- 例7-13 识别手势
- 例7-14 识别手势EMD
- 例7-15 模板匹配寻找手掌区域
- 目录
例7-1 直方图的计算与显示
根据输入的图像计算出一个色相饱和度（hue-saturation）直方图，然后利用网格的方式将该直方图以网格形式显示出来，具体代码如下：
#include
#include
#include
#include
#include
using namespace std;
CvPoint Current_Point; //值为255点当前点 全局变量才可通过普通成员引用变更其值
bool find_point(IplImage *img, char val);
int main(int argc, char* argv[])
{
int threshold_type = CV_THRESH_BINARY; //阈值类型
int Last_Area = 0; //上一个区域面积
int Current_Area = 0; //当前区域面积
double threshold = 65; //阈值
CvPoint Last_Point; //值为255点的上一点
CvConnectedComp comp; //被填充区域统计属性
IplImage *src1, *hsv, *Igray, *Ithreshold, *Itemp, *Iopen, *Imask; //源图像 HSV格式图像
Last_Point = cvPoint(0, 0); //初始化上一点
Current_Point = cvPoint(0, 0); //初始化当前点
if (!(src1 = cvLoadImage("D:\\Template\\OpenCV\\Template46_hue-saturation_Hist\\Debug\\handdd.jpg")))
return -1;
//此处调入图像掩码应为单通道
//if (!(Imask = cvLoadImage("D:\\Template\\OpenCV\\Template46_hue-saturation_Hist\\Debug\\cup2.jpg", CV_LOAD_IMAGE_GRAYSCALE)))
// return -2;
hsv=cvCreateImage(cvGetSize(src1), src1->depth, src1->nChannels);
Igray = cvCreateImage(cvGetSize(src1), src1->depth, 1);
Ithreshold = cvCreateImage(cvGetSize(src1), src1->depth, 1);
Itemp = cvCreateImage(cvGetSize(src1), src1->depth, 1);
Iopen = cvCreateImage(cvGetSize(src1), src1->depth, 1);
Imask = cvCreateImage(cvGetSize(src1), src1->depth, 1); //生成手掌掩码图像用
cvCvtColor(src1, hsv, CV_BGR2HSV); //源图像->HSV格式图像
cvCvtColor(src1, Igray, CV_BGR2GRAY); //源图像->灰度图像
cvThreshold(Igray, Ithreshold, threshold, 255, threshold_type); //二值阈值化
//开运算，去除小亮区域，其他联结 NULL:3*3参考点为中心的核
cvMorphologyEx(Ithreshold, Iopen, Itemp, NULL, CV_MOP_OPEN, 1);
cvNamedWindow("src1", 1);
cvNamedWindow("GRAY_Image", 1);
cvNamedWindow("THRESHHOLD_Image", 1);
cvNamedWindow("OPEN_Image", 1);
cvNamedWindow("FLOOD_FILL", 1);
cvShowImage("src1", src1);
cvShowImage("GRAY_Image", Igray);
cvShowImage("THRESHHOLD_Image", Ithreshold);
cvShowImage("OPEN_Image", Iopen);
cvShowImage("FLOOD_FILL", Imask);
//漫水填充 获得手掌掩码
cvNamedWindow("FLOOD_FILL", 1);
cvCopy(Iopen, Imask); //复制生成手掌掩码
do
{
if (find_point(Imask, 255)) //找像素值为255的像素点
{
cout << " X: " << Current_Point.x << " Y: " << Current_Point.y << endl;
cvFloodFill(Imask, Current_Point, cvScalar(100), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //对值为255的点进行漫水填充，值100
Current_Area = comp.area; //当前区域面积
if (Last_Area//当前区域大于上一区域，上一区域清0
{
if (Last_Area>0)
cvFloodFill(Imask, Last_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //上一区域赋值0
cvShowImage("FLOOD_FILL", Imask);
cvWaitKey(500);
Last_Area = Current_Area; //当前区域赋值给上一区域
Last_Point = Current_Point; //当前点赋值给上一点
//memcpy(&Last_Point, &Current_Point, sizeof(CvPoint)); //错误，此方法复制无法正常使用掩码
}
else //当前区域小于等于上一区域，当前区域清0
{
if (Current_Area>0)
cvFloodFill(Imask, Current_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //当前区域赋值0
cvShowImage("FLOOD_FILL", Imask);
cvWaitKey(500);
}
}
else //最后剩余的最大区域赋值255
{
cvFloodFill(Imask, Last_Point, cvScalar(255), cvScalar(0), cvScalar(0), &comp, 8 | CV_FLOODFILL_FIXED_RANGE);
cvShowImage("FLOOD_FILL", Imask);
cvWaitKey(500);
//上一区域赋值0
break;
}
} while (true);
cvSaveImage("Imask.jpg", Imask);
//色调(hue) 饱和度(saturation) 明度(value)
IplImage *h_plane = cvCreateImage(cvSize(hsv->width, hsv->height), IPL_DEPTH_8U, 1);
IplImage *s_plane = cvCreateImage(cvSize(hsv->width, hsv->height), IPL_DEPTH_8U, 1);
IplImage *v_plane = cvCreateImage(cvSize(hsv->width, hsv->height), IPL_DEPTH_8U, 1);
IplImage *planes[] = {h_plane,s_plane}; //色相饱和度数组
cvCvtPixToPlane(hsv, h_plane, s_plane, v_plane, NULL); //图像分割
//cvSplit(hsv, h_plane, s_plane, v_plane, NULL);
int h_bins = 30, s_bins = 32;
//建立直方图
CvHistogram *hist;
int hist_size[] = { h_bins, s_bins }; //对应维数包含bins个数的数组
float h_ranges[] = { 0, 180 }; //H通道划分范围 饱和度0-180
float s_ranges[] = { 0, 255 }; //S通道划分范围
float* ranges[] = { h_ranges, s_ranges }; //划分范围数对, ****均匀bin，range只要最大最小边界
//创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
hist = cvCreateHist(2, hist_size, CV_HIST_ARRAY, ranges, 1);
cvCalcHist(planes, hist, 0, Imask); //计算直方图（图像，直方图结构，不累加，掩码）
cvNormalizeHist(hist, 1.0); //直方图归一化
//绘制可视化直方图
int scale = 10;
IplImage* hist_img = cvCreateImage(cvSize(h_bins*scale, s_bins*scale), 8, 3); //300*320
cvZero(hist_img);
//以小灰度块填充图像
float max_value = 0;
cvGetMinMaxHistValue(hist, NULL, &max_value, NULL, NULL); //获取直方图最大值
for (int h = 0; h < h_bins; h++)
{
for (int s = 0; s < s_bins; s++)
{
float bin_val = cvQueryHistValue_2D(hist, h, s); //获取直方图相应bin中的浮点数
int intensity = cvRound(bin_val * 255 / max_value); //映射到255空间，归一后太小，难辨
cvRectangle(hist_img, cvPoint(h*scale, s*scale),
cvPoint((h + 1)*scale - 1, (s + 1)*scale - 1),
CV_RGB(intensity, intensity, intensity), CV_FILLED);
}
}
cvNamedWindow("HIST_Image", 1);
cvShowImage("HIST_Image", hist_img);
cvWaitKey();
cvReleaseHist(&hist);
cvReleaseImage(&src1);
cvReleaseImage(&hsv);
cvReleaseImage(&Igray);
cvReleaseImage(&Ithreshold);
cvReleaseImage(&Itemp);
cvReleaseImage(&Iopen);
cvReleaseImage(&Imask);
cvReleaseImage(&h_plane);
cvReleaseImage(&s_plane);
cvReleaseImage(&v_plane);
cvReleaseImage(&hist_img);
cvDestroyWindow("src1");
cvDestroyWindow("HIST_Image");
cvDestroyWindow("GRAY_Image");
cvDestroyWindow("THRESHHOLD_Image");
cvDestroyWindow("OPEN_Image");
cvDestroyWindow("FLOOD_FILL");
cvDestroyWindow("HIST_Image");
}
/******************遍历图像，指针算法********************/
bool find_point(IplImage *img, char val)
{
char* ptr = NULL;
if (img->nChannels == 1)
{
ptr = img->imageData;
if (ptr != NULL)
{
for (int i = 0; i < img->height; i++) //矩阵指针行寻址
{
ptr = (img->imageData + i*(img->widthStep)); //i 行 j 列
for (int j = 0; j < img->width; j++) //矩阵指针列寻址
{
if (ptr[j] == val) //判断某点像素是否为255
{
Current_Point.x = j; /********局部变量此方式 无法实现赋值********/
Current_Point.y = i;
return true;
}
}
}
}
}
return false;
} 运行结果如下图：
例7-2 从EMD直方图创建signature，用EMD度量相似性
根据输入的图像计算色相饱和度（hue-saturation）直方图，然后利用该直方图创建EMD接口参数signature，最后利用EMD来度量两个分布之间的相似性，程序中src1与src2已经过处理，有40的亮度值偏移，具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-3 基于像素点的反向投影（cvCalcBackProject）
根据输入的图像计算色相饱和度（hue-saturation）直方图，以网格形式显示，利用肤色模板直方图进行基于像素点的反向投影，在测试图像中找出该肤色模板直方图对应的区域，对应具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-4 基于块的反向投影（cvCalcArrBackProjectPatch）
根据输入的图像计算色相饱和度（hue-saturation）直方图，以网格形式显示，利用颜色模板直方图进行基于块的反向投影，在测试图像中找出该颜色模板直方图对应的区域，程序中，对于手的检测cvCalcArrBackProjectPatch()做区域检测器，对于杯子的检测cvCalcArrBackProjectPatch()做目标检测器，对应具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-5 模板匹配
读入一个模板和要匹配的图像，然后分别利用6种方法进行匹配，规范化后将匹配结果显示出来，具体代码如下：
#include
#include
#include
#include 运行结果如下图：
注意：本程序中，打印了两次i的值，分别对应for循环中的“++i”“i++”,打印结果相同，并不代表“++i”“i++”没有区别，而是因为for循环中表达式是作为一个语句来执行，因此此处i均是其最终的值。
例7-6 创建一个包含直方图1000个随机值
在0~1之间生成1000个随机值ri，定义一个bin的大小，并且建立一个直方图1/ri,，具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-7 bin的个数对直方图匹配产生的影响
给定三幅在书中讨论的不同光照条件下的手图像，利用cvCalcHist()来获得室内拍照的手的肤色直方图。
1. 依次尝试用少量的bin（如每维有2个），中等数目的bin（每维有16个）和很多bin（每维256个），然后对各种光线下的图像运行匹配程序（使用所有的直方图匹配方法）；
2. 现在加上每维为8个和32个bin，在各种光线条件下进行匹配；
程序中三幅图像已经过处理，依次比前一幅亮度增加40，具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-8 光照对直方图EMD匹配产生的影响
与上例一样，收集手的肤色直方图。以其中的一个室内直方图样本作为模型，并计算其与另一个室内直方图、一个室外阴影直方图、一个室外光照直方图的EMD距离，利用这些测量值设置一个距离阈值，再次比较EMD距离，程序中三幅图像已经过处理，依次比前一幅亮度增加25，具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-9 图像拍摄的光照条件判定
利用手机的手的图像，设计一个直方图，可以判断给定的图像是在哪种光线条件下被捕捉到的。然后，建立亮度值采样特征程序中三幅图像已经过处理，依次比前一幅亮度增加25，具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-10 肤色“场景检测器”
在三种条件下建立两类肤色模板直方图。
1. 从室内、室外阴影和室外阳光下得到的第一类直方图作为模型，用其中每一个分别跟第二类图进行B距离测试，检验肤色匹配效果；
2. 利用（1）中设计的“场景检测器”确定要使用何种直方图模型：室内、室外阴影还是室外阳光；进行其他匹配方式，检验效果；
程序中三幅图像已经过处理，依次比前一幅亮度增加25，具体代码如下：
#include
#include
#include
#include 运行结果如下图：
例7-11 RGB肤色区域检测器
本例进行的工作如下：
1. 在室内条件下，利用一些手和脸来建立RGB直方图；
2. 利用函数cvCalcBackProject()找到肤色区域；
3. 利用本书第五章图像处理相关函数来清除噪声，并利用函数cvFloodFill()找到图像中肤色最大区域。
具体代码如下：
#include
#include
#include
#include
#include
using namespace std;
CvPoint Current_Point; //值为255点当前点 全局变量才可通过普通成员引用变更其值
bool find_point(IplImage *img, char val);
int main(int argc, char* argv[])
{
IplImage* src1, *src2, *Imask, *rgb1, *rgb2, *Ithreshold, *Itemp, *Iclose, *Idst; //源图像 HSV
int threshold_type = CV_THRESH_BINARY; //阈值类型
CvPoint Last_Point; //值为255点的上一点
// CvPoint Current_Point; //值为255点当前点 为局部变量时，只能通过指针引用变更其值
int Last_Area = 0; //上一个区域面积
int Current_Area = 0; //当前区域面积
CvConnectedComp comp; //被填充区域统计属性
Last_Point = cvPoint(0, 0); //初始化上一点
Current_Point = cvPoint(0, 0); //初始化当前点
if (!(src1 = cvLoadImage("D:\\Template\\OpenCV\\Template56_RGB_BackProjection\\Debug\\handdd.jpg")))
return -1;
if (!(src2 = cvLoadImage("D:\\Template\\OpenCV\\Template56_RGB_BackProjection\\Debug\\handd.jpg")))
return -2;
//此处调入图像掩码应为单通道
if (!(Imask = cvLoadImage("D:\\Template\\OpenCV\\Template56_RGB_BackProjection\\Debug\\Imask.jpg", CV_LOAD_IMAGE_GRAYSCALE)))
return -3;
//cvXorS(Imask, cvScalar(255), Imask); //掩码图像按位异或，求反生成新的掩码处理背景色
//cvSet(src1, cvScalarAll(0), Imask); //背景变黑只提取肤色
rgb1 = cvCreateImage(cvGetSize(src1), src1->depth, src1->nChannels);
rgb2 = cvCreateImage(cvGetSize(src2), src2->depth, src2->nChannels);
cvCvtColor(src1, rgb1, CV_BGR2RGB); //源图像->HSV格式图像
cvCvtColor(src2, rgb2, CV_BGR2RGB); //源图像->HSV格式图像
//反向投影图像
IplImage *back_projection = cvCreateImage(cvGetSize(src2), IPL_DEPTH_8U, 1);
//阈值化 开运算图像
Ithreshold=cvCreateImage(cvGetSize(src2), IPL_DEPTH_8U, 1);
Itemp = cvCreateImage(cvGetSize(src2), IPL_DEPTH_8U, 1);
Iclose = cvCreateImage(cvGetSize(src2), IPL_DEPTH_8U, 1);
//最终目标区域图像
Idst = cvCreateImage(cvGetSize(src2), IPL_DEPTH_8U, 1);
//RGB
IplImage *r_plane_1 = cvCreateImage(cvSize(rgb1->width, rgb1->height), IPL_DEPTH_8U, 1);
IplImage *g_plane_1 = cvCreateImage(cvSize(rgb1->width, rgb1->height), IPL_DEPTH_8U, 1);
IplImage *b_plane_1 = cvCreateImage(cvSize(rgb1->width, rgb1->height), IPL_DEPTH_8U, 1);
IplImage *r_plane_2 = cvCreateImage(cvSize(rgb2->width, rgb2->height), IPL_DEPTH_8U, 1);
IplImage *g_plane_2 = cvCreateImage(cvSize(rgb2->width, rgb2->height), IPL_DEPTH_8U, 1);
IplImage *b_plane_2 = cvCreateImage(cvSize(rgb2->width, rgb2->height), IPL_DEPTH_8U, 1);
IplImage *planes1[] = { r_plane_1, g_plane_1, b_plane_1 }; //色相饱和度数组
IplImage *planes2[] = { r_plane_2, g_plane_2, b_plane_2 }; //色相饱和度数组
cvCvtPixToPlane(rgb1, r_plane_1, g_plane_1, b_plane_1, NULL); //图像分割
cvCvtPixToPlane(rgb2, r_plane_2, g_plane_2, b_plane_2, NULL); //图像分割
//cvSplit(hsv, h_plane, s_plane, v_plane, NULL);
int r_bins = 32, g_bins = 32, b_bins = 32;
//建立直方图
CvHistogram *hist_model,*hist_test;
int hist_size[] = { r_bins, g_bins, b_bins }; //对应维数包含bins个数的数组
float r_ranges[] = { 0, 255 }; //R通道划分范围
float g_ranges[] = { 0, 255 }; //G通道划分范围
float b_ranges[] = { 0, 255 }; //R通道划分范围
float* ranges[] = { r_ranges, g_ranges, b_ranges }; //划分范围数对,均匀bin，range只要最大最小边界
hist_model = cvCreateHist(3, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_test = cvCreateHist(3, hist_size, CV_HIST_ARRAY, ranges, 1);
//创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
cvCalcHist(planes1, hist_model, 0, Imask); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes2, hist_test, 0, 0); //计算直方图（图像，直方图结构，不累加，掩码）
//cvNormalizeHist(hist_model, 1.0); //直方图归一化
//cvNormalizeHist(hist_test, 1.0); //直方图归一化
cvCalcBackProject(planes2, back_projection, hist_model); //像素点的反射投影
//cvErode(back_projection, back_projection, NULL); //腐蚀
cvDilate(back_projection, back_projection, NULL); //膨胀
cvThreshold(back_projection, Ithreshold, 100, 255, threshold_type); //二值阈值化
//闭运算，去除小暗区域，亮区域联结 NULL:3*3参考点为中心的核
cvMorphologyEx(Ithreshold, Iclose, Itemp, NULL, CV_MOP_CLOSE, 1);
cvNamedWindow("Mask", 1);
cvNamedWindow("Model", 1);
cvNamedWindow("Test", 1);
cvNamedWindow("BACK_Projection", 1);
cvNamedWindow("Threshhold", 1);
cvNamedWindow("Iclose", 1);
cvShowImage("Mask", Imask);
cvShowImage("Model", src1);
cvShowImage("Test", src2);
cvShowImage("BACK_Projection", back_projection);
cvShowImage("Threshhold", Ithreshold);
cvShowImage("Iclose", Iclose);
//漫水填充 获得手掌目标区域 效果不明显 图中没有太多噪声 闭运算后已达到要求
cvNamedWindow("Destination", 1);
cvCopy(Iclose, Idst); //复制生成手掌目标图像
do
{
if (find_point(Idst, 255)) //找像素值为255的像素点
{
cout << " X: " << Current_Point.x << " Y: " << Current_Point.y << endl;
cvFloodFill(Idst, Current_Point, cvScalar(100), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //对值为255的点进行漫水填充，值100
Current_Area = comp.area; //当前区域面积
if (Last_Area//当前区域大于上一区域，上一区域清0
{
if (Last_Area>0)
cvFloodFill(Idst, Last_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //上一区域赋值0
cvShowImage("Destination", Idst);
cvWaitKey(500);
Last_Area = Current_Area; //当前区域赋值给上一区域
Last_Point = Current_Point; //当前点赋值给上一点
//memcpy(&Last_Point, &Current_Point, sizeof(CvPoint)); //错误，此方法复制无法正常使用掩码
}
else //当前区域小于等于上一区域，当前区域清0
{
if (Current_Area>0)
cvFloodFill(Idst, Current_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //当前区域赋值0
cvShowImage("Destination", Idst);
cvWaitKey(500);
}
}
else //最后剩余的最大区域赋值255
{
cvFloodFill(Idst, Last_Point, cvScalar(255), cvScalar(0), cvScalar(0), &comp, 8 | CV_FLOODFILL_FIXED_RANGE);
cvShowImage("Destination", Idst);
cvWaitKey(500);
//上一区域赋值0
break;
}
} while (true);
cvWaitKey(0);
//system("pause");
cvReleaseHist(&hist_model);
cvReleaseHist(&hist_test);
cvReleaseImage(&Imask);
cvReleaseImage(&src1);
cvReleaseImage(&src2);
cvReleaseImage(&rgb1);
cvReleaseImage(&rgb2);
cvReleaseImage(&Ithreshold);
cvReleaseImage(&Itemp);
cvReleaseImage(&Iclose);
cvReleaseImage(&Idst);
cvReleaseImage(&r_plane_1);
cvReleaseImage(&g_plane_1);
cvReleaseImage(&b_plane_1);
cvReleaseImage(&r_plane_2);
cvReleaseImage(&g_plane_2);
cvReleaseImage(&b_plane_2);
cvReleaseImage(&back_projection);
cvDestroyAllWindows();
}
/******************遍历图像，指针算法********************/
//bool find_point(IplImage *img, char val,CvPoint* P_point)
bool find_point(IplImage *img, char val)
{
char* ptr = NULL;
//uchar* ptr = NULL;
/********** 错，CvMat中为uchar* IplImage中为char* ********/
if (img->nChannels == 1)
{
ptr = img->imageData;
//ptr = (uchar*)img->imageData;
/********** 错，CvMat中为uchar* IplImage中为char* ********/
if (ptr != NULL)
{
for (int i = 0; i < img->height; i++) //矩阵指针行寻址
{
ptr = (img->imageData + i*(img->widthStep)); //i 行 j 列
//ptr = (uchar*)img->imageData + i*img->widthStep; //index1 行 index2 列
/********** 错，mat中为uchar* IplImage中为char* ********/
for (int j = 0; j < img->width; j++) //矩阵指针列寻址
{
//if (ptr[j] == 255) /********错误 ptr对应的值为char型********/
if (ptr[j] == val) //判断某点像素是否为255
{
//P_point->x = j; //列 ****Notice x为列坐标，若为行坐标会出现问题
//P_point->y = i; //行
Current_Point.x = j; /********局部变量此方式 无法实现赋值********/
Current_Point.y = i;
//cout << " j: " << j << " i: " << i << endl;
//cout << " X: " << P_point->x << " Y: " << P_point->y << endl;
//cout << " j: " <
//cout << " X: " << Current_Point.x << " Y: " << Current_Point.y << endl;
return true;
}
}
}
}
}
return false;
} 运行结果如下图：
例7-12 手势梯度方向直方图
根据输入的手势图像，在每一个区域求取其梯度方向，计算出梯度方向直方图，并可视化。具体代码如下：
#include
#include
#include
#include double val = cvGetReal1D(hist->bins, i)*hist_img->height / 255;
CvPoint p0 = cvPoint(30 + i*bin_width, hist_img->height);
CvPoint p1 = cvPoint(30 + (i + 1)*bin_width, hist_img->height - val);
cvRectangle(hist_img, p0, p1, cvScalar(0, 255), 1, 8, 0);
}
cvReleaseHist(&hist); //释放直方图
cvReleaseImage(&sobel_x);
cvReleaseImage(&sobel_y);
}
void Compare_Gesture_Hist(IplImage *sobel1, IplImage *sobel2, IplImage *test, IplImage** canny)
{
//建立直方图
CvHistogram *hist_model1, *hist_model2, *hist_test;
int bins = 20;
int hist_size[] = { bins }; //对应维数包含bins个数的数组
float range[] = { -CV_PI / 2, CV_PI / 2 };
float* ranges[] = { range }; //划分范围数对, ****均匀bin，range只要最大最小边界
//创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
hist_model1 = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_model2 = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_test = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
IplImage *planes1[] = { sobel1 };
IplImage *planes2[] = { sobel2 };
IplImage *planes3[] = { test };
cvCalcHist(planes1, hist_model1, 0, canny[0]); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes2, hist_model2, 0, canny[1]); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes3, hist_test, 0, canny[2]); //计算直方图（图像，直方图结构，不累加，掩码）
cvNormalizeHist(hist_model1, 1.0); //直方图归一化
cvNormalizeHist(hist_model2, 1.0); //直方图归一化
cvNormalizeHist(hist_test, 1.0); //直方图归一化
//比较直方图
for (int j = 0; j < 4; j++)
{
double value1 = cvCompareHist(hist_test, hist_model1, j); //相关方式比较
double value2 = cvCompareHist(hist_test, hist_model2, j); //相关方式比较
if (j == 0)
{
std::printf(" Hist_test & Hist_model1 ,CV_COMP_CORREL: %lf;\n", value1);
std::printf(" Hist_test & Hist_model2 ,CV_COMP_CORREL: %lf;\n", value2);
}
if (j == 1)
{
std::printf(" Hist_test & Hist_model1 ,CV_COMP_CHISQR: %lf;\n", value1);
std::printf(" Hist_test & Hist_model2 ,CV_COMP_CHISQR: %lf;\n", value2);
}
if (j == 2)
{
std::printf(" Hist_test & Hist_model1 ,CV_COMP_INTERSECT: %lf;\n", value1);
std::printf(" Hist_test & Hist_model2 ,CV_COMP_INTERSECT: %lf;\n", value2);
}
if (j == 3)
{
std::printf(" Hist_test & Hist_model1 ,CV_CCOMP_BHATTACHARYYA: %lf;\n", value1);
std::printf(" Hist_test & Hist_model2 ,CV_CCOMP_BHATTACHARYYA: %lf;\n", value2);
}
std::printf("\n");
}
cvReleaseHist(&hist_model1);
cvReleaseHist(&hist_model2);
cvReleaseHist(&hist_test);
}
运行结果如下图：
例7-13 识别手势
尝试识别手势。从摄像机中获取一个2英尺的手的图像，建立一些手势（不能动）：手掌竖直和手掌水平。
1. 利用例11得到的结果，在手周围的肤色区域求取梯度方向并对两种手势建立直方图模型；
2. 利用网络摄像机做识别：利用感兴趣的区域找到“潜在的手”，利用例12的方法，在每一个区域求取其梯度方向，通过设定相应的阈值来检测手势；
3. 本例中，竖直手势识别成功，在测试手势直方图中绘制100x100的蓝色矩形；水平手势识别成功，在测试手势直方图中绘制100x100的红色矩形；
4. 本例中，经过测试进行卡方匹配时差异最大，便于区分识别故采用卡方方式进行直方图匹配；
5. 本例中，有寻找手掌轮廓的程序，因为调用后程序实时性明显降低，故未调用；
6. 本例中，白天黑夜识别准确度略有差异，可观察控制台输出的卡方距离变化值，灵活设置正确识别的阈值；
具体代码如下：
#include
#include
#include
#include //删除宽高比例小于设定值的轮廓
cvSeqRemove(contour, 0);
continue;
}
//CvScalar color = CV_RGB( rand()&255, rand()&255, rand()&255 );//创建一个色彩值
//CvScalar color = CV_RGB(0, 255, 255);
//max_level 绘制轮廓的最大等级。如果等级为0，绘制单独的轮廓。如果为1，绘制轮廓及在其后的相同的级别下轮廓。
//如果值为2，所有的轮廓。如果等级为2，绘制所有同级轮廓及所有低一级轮廓，诸此种种。
//如果值为负数，函数不绘制同级轮廓，但会升序绘制直到级别为abs(max_level)-1的子轮廓。
//cvDrawContours(dst, contour, color, color, -1, 1, 8);//绘制外部和内部的轮廓
}
contour = _contour; /*int k=0;*/
//统计剩余轮廓，并画出最大面积的轮廓
int count = 0;
for (; contour != 0; contour = contour->h_next)
{
count++;
double tmparea = fabs(cvContourArea(contour));
if (tmparea == maxarea /*k==n*/)
{
CvScalar color = CV_RGB(255, 0, 0);
cvDrawContours(dst, contour, color, color, -1, 1, 8);
}
/*k++;*/
}
printf("The total number of contours is:%d", count);
cvNamedWindow("Components", CV_WINDOW_NORMAL);
cvShowImage("Components", dst);
cvSaveImage("dst.jpg", dst);
//roateProcess(dst);
cvWaitKey(0);
//销毁窗口和图像存储
cvDestroyWindow("Source");
cvReleaseImage(&src);
cvDestroyWindow("Components");
cvReleaseImage(&dst);
}
/******************遍历图像-指针算法********************/
bool find_point(IplImage *img, char val)
{
char* ptr = NULL;
if (img->nChannels == 1)
{
ptr = img->imageData;
if (ptr != NULL)
{
for (int i = 0; i < img->height; i++) //矩阵指针行寻址
{
ptr = (img->imageData + i*(img->widthStep)); //i 行 j 列
for (int j = 0; j < img->width; j++) //矩阵指针列寻址
{
if (ptr[j] == val) //判断某点像素是否为255
{
Current_Point.x = j;
Current_Point.y = i;
return true;
}
}
}
}
}
return false;
}
void Create_Imask(IplImage *src, IplImage *dst)
{
int Last_Area = 0; //上一个区域面积
int Current_Area = 0; //当前区域面积
int threshold_type = CV_THRESH_BINARY; //阈值类型
CvPoint Last_Point; //值为255点的上一点
CvConnectedComp comp; //被填充区域统计属性
IplImage *gray, *threshold, *temp,*open; //灰度图像
Last_Point = cvPoint(0, 0); //初始化上一点
Current_Point = cvPoint(0, 0); //初始化当前点
gray = cvCreateImage(cvGetSize(src), src->depth, 1);
threshold = cvCreateImage(cvGetSize(src), src->depth, 1);
temp = cvCreateImage(cvGetSize(src), src->depth, 1);
open = cvCreateImage(cvGetSize(src), src->depth, 1);
cvCvtColor(src, gray, CV_BGR2GRAY); //源图像->灰度图像
//二值阈值化
cvThreshold(gray, threshold, 100, 255, threshold_type);
//开运算，去除小亮区域，其他联结 NULL:3*3参考点为中心的核
cvMorphologyEx(threshold, open, temp, NULL, CV_MOP_OPEN, 1);
cvNamedWindow("肤色模板", 1);
cvNamedWindow("肤色掩码", 1);
cvShowImage("肤色模板", src);
cvShowImage("肤色掩码", dst);
//漫水填充 获得手掌掩码
cvCopy(open, dst); //复制生成手掌掩码
do
{
if (find_point(dst, 255)) //找像素值为255的像素点
{
cout << " X: " << Current_Point.x << " Y: " << Current_Point.y << endl;
cvFloodFill(dst, Current_Point, cvScalar(100), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //对值为255的点进行漫水填充，值100
Current_Area = comp.area; //当前区域面积
if (Last_Area//当前区域大于上一区域，上一区域清0
{
if (Last_Area>0)
cvFloodFill(dst, Last_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //上一区域赋值0
cvShowImage("肤色掩码", dst);
cvWaitKey(500);
Last_Area = Current_Area; //当前区域赋值给上一区域
Last_Point = Current_Point; //当前点赋值给上一点
}
else //当前区域小于等于上一区域，当前区域清0
{
if (Current_Area>0)
cvFloodFill(dst, Current_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //当前区域赋值0
cvShowImage("肤色掩码", dst);
cvWaitKey(500);
}
}
else //最后剩余的最大区域赋值255
{
cvFloodFill(dst, Last_Point, cvScalar(255), cvScalar(0), cvScalar(0), &comp, 8 | CV_FLOODFILL_FIXED_RANGE);
cvShowImage("肤色掩码", dst);
cvWaitKey(500);
//上一区域赋值0
break;
}
} while (true);
//cvSaveImage("Imask.jpg", dst);
cvReleaseImage(&gray);
cvReleaseImage(&threshold);
cvReleaseImage(&temp);
cvReleaseImage(&open);
}
void Find_Hand_Region(IplImage *model, IplImage *test, IplImage *mask, IplImage *dst)
{
int threshold_type = CV_THRESH_BINARY; //阈值类型
//临时图像 反向投影图像
IplImage *temp = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *back_projection = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
//RGB
IplImage *r_plane_1 = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *g_plane_1 = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *b_plane_1 = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *r_plane_2 = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
IplImage *g_plane_2 = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
IplImage *b_plane_2 = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
IplImage *planes1[] = { r_plane_1, g_plane_1, b_plane_1 }; //色相饱和度数组
IplImage *planes2[] = { r_plane_2, g_plane_2, b_plane_2 }; //色相饱和度数组
cvCvtPixToPlane(model, b_plane_1, g_plane_1, r_plane_1, NULL); //图像分割
cvCvtPixToPlane(test, b_plane_2, g_plane_2, r_plane_2, NULL); //图像分割
int r_bins = 32, g_bins = 32, b_bins = 32;
//建立直方图
CvHistogram *hist_model, *hist_test;
int hist_size[] = { r_bins, g_bins, b_bins }; //对应维数包含bins个数的数组
float r_ranges[] = { 0, 255 }; //R通道划分范围
float g_ranges[] = { 0, 255 }; //G通道划分范围
float b_ranges[] = { 0, 255 }; //R通道划分范围
float* ranges[] = { r_ranges, g_ranges, b_ranges }; //划分范围数对, ****均匀bin，range只要最大最小边界
//创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
hist_model = cvCreateHist(3, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_test = cvCreateHist(3, hist_size, CV_HIST_ARRAY, ranges, 1);
cvCalcHist(planes1, hist_model, 0, mask); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes2, hist_test, 0, 0); //计算直方图（图像，直方图结构，不累加，掩码）
//cvNormalizeHist(hist_model, 1.0); //直方图归一化
//cvNormalizeHist(hist_test, 1.0); //直方图归一化
//像素点的反射投影 创建测试hist的图像数组 结果图像 模板hist
cvCalcBackProject(planes2, back_projection, hist_model);
cvSmooth(back_projection, dst, CV_MEDIAN, 11); //中值滤波 去除椒盐噪声
//开运算，去除小亮区域，其他联结 NULL:3*3参考点为中心的核
cvMorphologyEx(dst, dst, temp, NULL, CV_MOP_OPEN, 1);
cvThreshold(dst, dst, 0, 255, threshold_type); //二值阈值化
//边缘检测 src dst 边缘连接 边缘初始分割 核
//cvCanny(dst, dst,90,180,3);
//得到手掌轮廓 绘制轮廓线
//getContoursByC(dst, dst);
cvShowImage("BACK_Projection", back_projection);
cvShowImage("Destination", dst);
//cvSaveImage("DST.jpg", dst);
cvReleaseHist(&hist_model);
cvReleaseHist(&hist_test);
cvReleaseImage(&back_projection);
cvReleaseImage(&temp);
cvReleaseImage(&r_plane_1);
cvReleaseImage(&g_plane_1);
cvReleaseImage(&b_plane_1);
cvReleaseImage(&r_plane_2);
cvReleaseImage(&g_plane_2);
cvReleaseImage(&b_plane_2);
}
void Create_Hist_1D(IplImage* src, IplImage* canny, IplImage* gradient_dir, IplImage* hist_img)
{
IplImage *sobel_x, *sobel_y;
sobel_x = cvCreateImage(cvSize(src->width, src->height), 32, 1);
sobel_y = cvCreateImage(cvSize(src->width, src->height), 32, 1);
//边缘检测, src dst 边缘连接 边缘初始分割 核
cvCanny(src, canny, 60, 180, 3);
//方向导数
cvSobel(src, sobel_x, 1, 0, 3); //横向偏导dx
cvSobel(src, sobel_y, 0, 1, 3); //纵向偏导dy
//梯度方向 dy/dx
cvDiv(sobel_y, sobel_x, gradient_dir);
char* ptr = NULL;
float theta = 0.0; //梯度方向角
ptr = gradient_dir->imageData;
if (ptr != NULL)
{
for (int i = 0; i < gradient_dir->height; i++) //矩阵指针行寻址
{
ptr = (gradient_dir->imageData + i*(gradient_dir->widthStep)); //i 行 j 列
for (int j = 0; j < gradient_dir->width; j++) //矩阵指针列寻址
{
if (cvGetReal2D(canny, i, j) && cvGetReal2D(sobel_x, i, j)) //dx!=0
{
theta = cvGetReal2D(gradient_dir, i, j);
theta = atan(theta);
cvSetReal2D(gradient_dir, i, j, theta);
}
else //dx=0
{
cvSetReal2D(gradient_dir, i, j, 0);
}
}
}
}
float max = 0.0;
int bins = 20;
int hist_size[] = { bins }; //对应维数包含bins个数的数组
float range[] = { -CV_PI / 2, CV_PI / 2 };
float* ranges[] = { range };
CvHistogram* hist = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
cvZero(hist_img);
IplImage *planes[] = { gradient_dir }; //梯度图像数组
cvCalcHist(planes, hist, 0, canny); //只计算边界直方图
cvGetMinMaxHistValue(hist, 0, &max, 0, 0);
//src dst scale shift 缩放bin到[0，255] （条件表达式 ? 真值 : 假值）
cvConvertScale(hist->bins, hist->bins, max ? 255. / max : 0., 0);
//绘制直方图
double bin_width = (double)hist_img->width / bins * 3 / 4;
for (int i = 0; idouble val = cvGetReal1D(hist->bins, i)*hist_img->height / 255;
CvPoint p0 = cvPoint(30 + i*bin_width, hist_img->height);
CvPoint p1 = cvPoint(30 + (i + 1)*bin_width, hist_img->height - val);
cvRectangle(hist_img, p0, p1, cvScalar(0, 255), 1, 8, 0);
}
cvReleaseHist(&hist); //释放直方图
cvReleaseImage(&sobel_x);
cvReleaseImage(&sobel_y);
}
void Compare_Gesture_Hist(IplImage *sobel1, IplImage *sobel2, IplImage *test, IplImage** canny, IplImage* hist_img)
{
//建立直方图
CvHistogram *hist_model1, *hist_model2, *hist_test;
int bins = 20;
int hist_size[] = { bins }; //对应维数包含bins个数的数组
float range[] = { -CV_PI / 2, CV_PI / 2 };
float* ranges[] = { range }; //划分范围数对, ****均匀bin，range只要最大最小边界
//创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
hist_model1 = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_model2 = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_test = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
IplImage *planes1[] = { sobel1 };
IplImage *planes2[] = { sobel2 };
IplImage *planes3[] = { test };
cvCalcHist(planes1, hist_model1, 0, canny[0]); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes2, hist_model2, 0, canny[1]); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes3, hist_test, 0, canny[2]); //计算直方图（图像，直方图结构，不累加，掩码）
cvNormalizeHist(hist_model1, 1.0); //直方图归一化
cvNormalizeHist(hist_model2, 1.0); //直方图归一化
cvNormalizeHist(hist_test, 1.0); //直方图归一化
//比较直方图
for (int j = 0; j < 4; j++)
{
double value1 = cvCompareHist(hist_test, hist_model1, j); //相关方式比较
double value2 = cvCompareHist(hist_test, hist_model2, j); //相关方式比较
//if (j == 0)
//{
// std::printf(" Hist_test & Hist_model1 ,CV_COMP_CORREL: %lf;\n", value1);
// std::printf(" Hist_test & Hist_model2 ,CV_COMP_CORREL: %lf;\n", value2);
//}
if (j == 1)
{
std::printf(" Hist_test & Hist_model1 ,CV_COMP_CHISQR: %lf;\n", value1);
std::printf(" Hist_test & Hist_model2 ,CV_COMP_CHISQR: %lf;\n", value2);
if ((value1 <= 0.25) && (value2 >= 0.55))
{
cvDrawRect(hist_img, cvPoint(100, 100), cvPoint(200, 200), cvScalar(255, 0, 0), CV_FILLED, 8);
}
if ((value1 >= 0.45) && (value2 <= 0.4))
{
cvDrawRect(hist_img, cvPoint(100, 100), cvPoint(200, 200), cvScalar(0, 0, 255), CV_FILLED, 8);
}
}
//if (j == 2)
//{
// std::printf(" Hist_test & Hist_model1 ,CV_COMP_INTERSECT: %lf;\n", value1);
// std::printf(" Hist_test & Hist_model2 ,CV_COMP_INTERSECT: %lf;\n", value2);
//}
//if (j == 3)
//{
// std::printf(" Hist_test & Hist_model1 ,CV_CCOMP_BHATTACHARYYA: %lf;\n", value1);
// std::printf(" Hist_test & Hist_model2 ,CV_CCOMP_BHATTACHARYYA: %lf;\n", value2);
//}
std::printf("\n");
}
cvReleaseHist(&hist_model1);
cvReleaseHist(&hist_model2);
cvReleaseHist(&hist_test);
} 运行结果如下图：
例7-14 识别手势（EMD）
尝试识别手势。实现例13功能，但是利用EMD匹配策略，本例仅对Compare_Gesture_Hist()函数做了适当修改，具体代码如下：
void Compare_Gesture_Hist(IplImage *sobel1, IplImage *sobel2, IplImage *test, IplImage** canny, IplImage* hist_img)
{
//建立直方图
CvHistogram *hist_model1, *hist_model2, *hist_test;
int bins = 20;
int hist_size[] = { bins }; //对应维数包含bins个数的数组
float range[] = { -CV_PI / 2, CV_PI / 2 };
float* ranges[] = { range }; //划分范围数对, ****均匀bin，range只要最大最小边界
//创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
hist_model1 = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_model2 = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_test = cvCreateHist(1, hist_size, CV_HIST_ARRAY, ranges, 1);
IplImage *planes1[] = { sobel1 };
IplImage *planes2[] = { sobel2 };
IplImage *planes3[] = { test };
cvCalcHist(planes1, hist_model1, 0, canny[0]); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes2, hist_model2, 0, canny[1]); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes3, hist_test, 0, canny[2]); //计算直方图（图像，直方图结构，不累加，掩码）
cvNormalizeHist(hist_model1, 1.0); //直方图归一化
cvNormalizeHist(hist_model2, 1.0); //直方图归一化
cvNormalizeHist(hist_test, 1.0); //直方图归一化
//EMD
CvMat *sig1, *sig2, *sig_test;
int numrows = bins;
sig1 = cvCreateMat(numrows, 2, CV_32FC1); //numrows行 2列 矩阵
sig2 = cvCreateMat(numrows, 2, CV_32FC1);
sig_test = cvCreateMat(numrows, 2, CV_32FC1);
for (int h = 0; h < bins; h++)
{
float bin_val = 0.0;
bin_val = cvQueryHistValue_1D(hist_model1, h);
//h:行数 s_bins：总列数（行长度）s:列数 h*s_bins+s 当前bin对应的sig行数
cvSet2D(sig1, h, 0, cvScalar(bin_val));
cvSet2D(sig1, h, 1, cvScalar(h));
bin_val = cvQueryHistValue_1D(hist_model2, h);
//h:行数 s_bins：总列数（行长度）s:列数 h*s_bins+s 当前bin对应的sig行数
cvSet2D(sig2, h, 0, cvScalar(bin_val));
cvSet2D(sig2, h, 1, cvScalar(h));
bin_val = cvQueryHistValue_1D(hist_test, h);
//h:行数 s_bins：总列数（行长度）s:列数 h*s_bins+s 当前bin对应的sig行数
cvSet2D(sig_test, h, 0, cvScalar(bin_val));
cvSet2D(sig_test, h, 1, cvScalar(h));
}
float emd1 = cvCalcEMD2(sig1, sig_test, CV_DIST_L2);
float emd2 = cvCalcEMD2(sig2, sig_test, CV_DIST_L2);
printf("EMD距离1：%f; \n", emd1);
printf("EMD距离2：%f; \n", emd2);
if ((emd1 <= 1) && (emd2 >= 4))
{
cvDrawRect(hist_img, cvPoint(100, 100), cvPoint(200, 200), cvScalar(255, 0, 0), CV_FILLED, 8);
}
if ((emd1 >= 1.7) && (emd2 <= 3.4))
{
cvDrawRect(hist_img, cvPoint(100, 100), cvPoint(200, 200), cvScalar(0, 0, 255), CV_FILLED, 8);
}
printf("\n");
cout << endl;
////比较直方图
//for (int j = 0; j < 4; j++)
//{
// double value1 = cvCompareHist(hist_test, hist_model1, j); //相关方式比较
// double value2 = cvCompareHist(hist_test, hist_model2, j); //相关方式比较
// //if (j == 0)
// //{
// // std::printf(" Hist_test & Hist_model1 ,CV_COMP_CORREL: %lf;\n", value1);
// // std::printf(" Hist_test & Hist_model2 ,CV_COMP_CORREL: %lf;\n", value2);
// //}
// if (j == 1)
// {
// std::printf(" Hist_test & Hist_model1 ,CV_COMP_CHISQR: %lf;\n", value1);
// std::printf(" Hist_test & Hist_model2 ,CV_COMP_CHISQR: %lf;\n", value2);
// if ((value1 <= 0.25) && (value2 >= 0.55))
// {
// cvDrawRect(hist_img, cvPoint(100, 100), cvPoint(200, 200), cvScalar(255, 0, 0), CV_FILLED, 8);
// }
// if ((value1 >= 0.45) && (value2 <= 0.4))
// {
// cvDrawRect(hist_img, cvPoint(100, 100), cvPoint(200, 200), cvScalar(0, 0, 255), CV_FILLED, 8);
// }
// }
// //if (j == 2)
// //{
// // std::printf(" Hist_test & Hist_model1 ,CV_COMP_INTERSECT: %lf;\n", value1);
// // std::printf(" Hist_test & Hist_model2 ,CV_COMP_INTERSECT: %lf;\n", value2);
// //}
// //if (j == 3)
// //{
// // std::printf(" Hist_test & Hist_model1 ,CV_CCOMP_BHATTACHARYYA: %lf;\n", value1);
// // std::printf(" Hist_test & Hist_model2 ,CV_CCOMP_BHATTACHARYYA: %lf;\n", value2);
// //}
// std::printf("\n");
//}运行结果如下图：
例7-15 模板匹配寻找手掌区域
寻找手掌区域，利用模板匹配策略，通过cvMatchTemplate()函数找出手掌区域，本例中，结果一在main()函数中调用了Find_Hand_Region()函数去除了不相关区域，结果二未调用，具体代码如下：
#include
#include
#include
#include //当前区域大于上一区域，上一区域清0
{
if (Last_Area>0)
cvFloodFill(dst, Last_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //上一区域赋值0
cvShowImage("肤色掩码", dst);
cvWaitKey(500);
Last_Area = Current_Area; //当前区域赋值给上一区域
Last_Point = Current_Point; //当前点赋值给上一点
}
else //当前区域小于等于上一区域，当前区域清0
{
if (Current_Area>0)
cvFloodFill(dst, Current_Point, cvScalar(0), cvScalar(0), cvScalar(0),
&comp, 8 | CV_FLOODFILL_FIXED_RANGE); //当前区域赋值0
cvShowImage("肤色掩码", dst);
cvWaitKey(500);
}
}
else //最后剩余的最大区域赋值255
{
cvFloodFill(dst, Last_Point, cvScalar(255), cvScalar(0), cvScalar(0), &comp, 8 | CV_FLOODFILL_FIXED_RANGE);
cvShowImage("肤色掩码", dst);
cvWaitKey(500);
//上一区域赋值0
break;
}
} while (true);
//cvSaveImage("Imask.jpg", dst);
cvReleaseImage(&gray);
cvReleaseImage(&threshold);
cvReleaseImage(&temp);
cvReleaseImage(&open);
}
void Find_Hand_Region(IplImage *model, IplImage *test, IplImage *mask, IplImage *dst)
{
int threshold_type = CV_THRESH_BINARY; //阈值类型
//临时图像 反向投影图像
IplImage *temp = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *back_projection = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
//RGB
IplImage *r_plane_1 = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *g_plane_1 = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *b_plane_1 = cvCreateImage(cvSize(model->width, model->height), IPL_DEPTH_8U, 1);
IplImage *r_plane_2 = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
IplImage *g_plane_2 = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
IplImage *b_plane_2 = cvCreateImage(cvSize(test->width, test->height), IPL_DEPTH_8U, 1);
IplImage *planes1[] = { r_plane_1, g_plane_1, b_plane_1 }; //色相饱和度数组
IplImage *planes2[] = { r_plane_2, g_plane_2, b_plane_2 }; //色相饱和度数组
cvCvtPixToPlane(model, b_plane_1, g_plane_1, r_plane_1, NULL); //图像分割
cvCvtPixToPlane(test, b_plane_2, g_plane_2, r_plane_2, NULL); //图像分割
int r_bins = 32, g_bins = 32, b_bins = 32;
//建立直方图
CvHistogram *hist_model, *hist_test;
int hist_size[] = { r_bins, g_bins, b_bins }; //对应维数包含bins个数的数组
float r_ranges[] = { 0, 255 }; //R通道划分范围
float g_ranges[] = { 0, 255 }; //G通道划分范围
float b_ranges[] = { 0, 255 }; //R通道划分范围
float* ranges[] = { r_ranges, g_ranges, b_ranges }; //划分范围数对, ****均匀bin，range只要最大最小边界
//创建直方图 （维数，对应维数bins个数，密集矩阵方式存储，划分范围数对，均匀直方图）
hist_model = cvCreateHist(3, hist_size, CV_HIST_ARRAY, ranges, 1);
hist_test = cvCreateHist(3, hist_size, CV_HIST_ARRAY, ranges, 1);
cvCalcHist(planes1, hist_model, 0, mask); //计算直方图（图像，直方图结构，不累加，掩码）
cvCalcHist(planes2, hist_test, 0, 0); //计算直方图（图像，直方图结构，不累加，掩码）
//cvNormalizeHist(hist_model, 1.0); //直方图归一化
//cvNormalizeHist(hist_test, 1.0); //直方图归一化
//像素点的反射投影 创建测试hist的图像数组 结果图像 模板hist
cvCalcBackProject(planes2, back_projection, hist_model);
cvSmooth(back_projection, dst, CV_MEDIAN, 11); //中值滤波 去除椒盐噪声
//开运算，去除小亮区域，其他联结 NULL:3*3参考点为中心的核
cvMorphologyEx(dst, dst, temp, NULL, CV_MOP_OPEN, 1);
cvThreshold(dst, dst, 0, 255, threshold_type); //二值阈值化
//边缘检测 src dst 边缘连接 边缘初始分割 核
//cvCanny(dst, dst,90,180,3);
//得到手掌轮廓 绘制轮廓线
//getContoursByC(dst, dst);
cvShowImage("BACK_Projection", back_projection);
cvShowImage("Destination", dst);
cvXorS(dst, cvScalar(255), dst); //掩码图像按位异或，求反生成新的掩码处理模板
cvSet(test, cvScalarAll(0), dst);
cvShowImage("Hand", test);
//cvSaveImage("DST.jpg", dst);
cvReleaseHist(&hist_model);
cvReleaseHist(&hist_test);
cvReleaseImage(&back_projection);
cvReleaseImage(&temp);
cvReleaseImage(&r_plane_1);
cvReleaseImage(&g_plane_1);
cvReleaseImage(&b_plane_1);
cvReleaseImage(&r_plane_2);
cvReleaseImage(&g_plane_2);
cvReleaseImage(&b_plane_2);
} 运行结果如下图：
