【练习7.6】漫水填充获取掩码并以此计算肤色直方图、用以查找肤色区域即颜色识别

题目要求

程序代码

结果图片

要言妙道

借鉴参考

  

题目要求：

 建立感兴趣的肤色区域检测器

a、在“室内条件下”，利用手来建立肤色直方图（原题是建立RGB直方图，我使用的是HSV直方图）

b、加载另一幅包含手的图像，利用函数cvClacBackProject找到肤色区域 

程序代码：

// OpenCVExerciseTesting.cpp : 定义控制台应用程序的入口点。
//
//D:\Work\Work_Programming\Source\Image\lena.jpg

#include "stdafx.h"
#include <cv.h>
#include <highgui.h>
#include <iostream>

#include <opencv2/legacy/legacy.hpp>
//#pragma comment(lib, "opencv_legacy2411.lib")

using namespace cv;
using namespace std;

//全局变量-->--->-->--->-->--->-->--->/：

const char * soutceFile_InDoor = "D:\Work\Work_Programming\Source\Image\OpenCVExerciseImage\第7章\hand_sample3.jpg";
IplImage *image_Source = cvLoadImage(soutceFile_InDoor, CV_LOAD_IMAGE_UNCHANGED);
const char * soutceFile_Dst = "D:\Work\Work_Programming\Source\Image\OpenCVExerciseImage\第7章\hand_sample2.jpg";
IplImage *image_Dst = cvLoadImage(soutceFile_Dst, CV_LOAD_IMAGE_UNCHANGED);

IplImage * image_mask = cvCreateImage(cvSize(image_Source->width+2,image_Source->height+2), IPL_DEPTH_8U, 1);//②注意mask图像的大小
const char * mask_windowName = "掩码图像窗口";

//<--<--<--<--<--<--<--<--<--全局变量/。


//函数声明-->--->-->--->-->--->-->--->//

void DrawHistogram(IplImage ** image_hist, const CvHistogram * histogram, int scaleValue);

void onTrackbarSlide_low(int pos);
void onTrackbarSlide_up(int pos);
void GetMaskImage(int pos, bool isUpValue);
CvHistogram * CalcHSHistogramByMask(const IplImage* image_RGB, IplImage *mask);
void CalcHSBackProject(const IplImage* image_RGB, const CvHistogram *HSHist);

//<--<--<--<--<--<--<--<--<--函数声明//

int _tmain(int argc, _TCHAR* argv[])
{
    const char * src_windowName = "原始图像窗口";
    cvNamedWindow(src_windowName, CV_WINDOW_AUTOSIZE);

    int slider_position_low = 5;
    int slider_position_up = 30;
    cvCreateTrackbar("loDiff", src_windowName, &slider_position_low, 255, onTrackbarSlide_low);
    cvCreateTrackbar("upDiff", src_windowName, &slider_position_up, 255, onTrackbarSlide_up);

    cvShowImage(src_windowName, image_Source);
    //接下来在TrackBar的回调函数中完成后续的一系列操作

    cvWaitKey();
    cvReleaseImage(&image_Source);
    cvReleaseImage(&image_Dst);
    cvReleaseImage(&image_mask);

    cvDestroyAllWindows();

    return 0;
}


//目前只实现绘制二维直方图
void DrawHistogram(/*IplImage ** image_hist,*/ const CvHistogram * histogram, int scaleValue)
{
    const char * draw_histWindow = "DrawHist";
    cvNamedWindow(draw_histWindow, CV_WINDOW_AUTOSIZE);
    //直方图：横坐标表示各个bin，纵坐标表示各个bin归一化后的值
    int hist_dims = histogram->mat.dims;

    int bin_size1, bin_size2/*, bin_size3*/;

    if (hist_dims == 2)
    {
        bin_size1 = histogram->mat.dim[0].size;
        bin_size2 = histogram->mat.dim[1].size;
        //bin_size3 = histogram->mat.dim[2].size;
    }
    else
    {
        return;
    }

    int bin_count = bin_size1*bin_size2/**bin_size3*/;
    float max_temp;
    cvGetMinMaxHistValue(histogram, NULL, &max_temp);
    int max_value = (int)(max_temp*scaleValue) + 1;
    CvSize hist_imageSize = cvSize(bin_count, max_value);
    IplImage*image_hist = cvCreateImage(hist_imageSize, IPL_DEPTH_8U, 1);
    (image_hist)->origin = 1;
    cvZero(image_hist);

    int x;
    int value;

    for (int r = 0; r < bin_size1; ++r)
    {
        for (int g = 0; g < bin_size2; ++g)
        {
            //for (int b = 0; b < bin_size3; ++b)
            {
                //x = r*(bin_size1*bin_size2) + g*bin_size2 + b;
                x = r* bin_size1 + g;
                value = (int)(cvQueryHistValue_2D(histogram, r, g)*scaleValue);

                //value = (int)(cvQueryHistValue_3D(histogram, r, g, b)*scaleValue);
                /*        if (value == 0)
                {
                value = 10;
                }*/
                cvRectangle(image_hist, cvPoint(x, 0), cvPoint(x, value), cvScalar(255));
            }
        }
    }
    cvShowImage(draw_histWindow, image_hist);
}

void onTrackbarSlide_low(int pos)
{
    GetMaskImage(pos, false);
}

void onTrackbarSlide_up(int pos)
{
    GetMaskImage(pos, true);
}

void GetMaskImage(int pos ,bool isUpValue)
{
    static int lowValue = 0;
    static int upValue = 0;
    CvPoint seedPoint = cvPoint(image_Source->width / 3 * 2, image_Source->height / 3 * 2);

    if (isUpValue == true)
    {
        upValue = pos;
    }
    else
    {
        lowValue = pos;
    }

    if (lowValue > upValue)
    {
        lowValue ^= upValue ^= lowValue ^= upValue;//交换两个变量的值
    }

    int flags = 8
        | CV_FLOODFILL_MASK_ONLY
        | CV_FLOODFILL_FIXED_RANGE
        | (255 << 8);

    cvZero(image_mask);//①重要
    cvNamedWindow(mask_windowName, CV_WINDOW_AUTOSIZE);

    //漫水填充找掩码
    cvFloodFill(image_Source, seedPoint, cvScalar(255, 255, 255), cvScalar(lowValue, lowValue, lowValue), cvScalar(upValue, upValue, upValue), NULL, flags, image_mask);

    //使用掩码计算直方图
    CvRect rect_ROI = cvRect(1, 1, image_mask->width - 2, image_mask->height - 2);
    cvSetImageROI(image_mask, rect_ROI); //③
    cvShowImage(mask_windowName, image_mask);
    CvHistogram * hist_ImageSource = CalcHSHistogramByMask(image_Source, image_mask);
    cvResetImageROI(image_mask);

    //反向投影
    CalcHSBackProject(image_Dst, hist_ImageSource);

    cvNormalizeHist(hist_ImageSource, 1.0);//重要：注意归一化直方图与反向投影的顺序

    DrawHistogram(hist_ImageSource, 3000);

    cvReleaseHist(&hist_ImageSource);
}

CvHistogram * CalcHSHistogramByMask(const IplImage* image_RGB,IplImage *mask)
{
    IplImage* image_HSV = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 3);
    cvCvtColor(image_RGB, image_HSV, CV_BGR2HSV);

    IplImage* h_plane = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 1);
    IplImage* s_plane = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 1);
    IplImage* v_plane = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 1);
    IplImage* planes[] = { h_plane, s_plane };
    cvCvtPixToPlane(image_HSV, h_plane, s_plane, v_plane, 0);

    int dims = 2;
    int h_bins = 30, s_bins = 32;
    CvHistogram* hist;
    int hist_size[] = { h_bins, s_bins };
    float h_ranges[] = { 0, 180 }; // hue is [0,180]
    float s_ranges[] = { 0, 255 };
    float* ranges[] = { h_ranges, s_ranges };

    hist = cvCreateHist(
        dims,
        hist_size,
        CV_HIST_ARRAY,
        ranges,
        1
        );
    cvCalcHist(planes, hist, 0, mask);

    cvReleaseImage(&h_plane);
    cvReleaseImage(&s_plane);
    cvReleaseImage(&v_plane);
    cvReleaseImage(&image_HSV);

    return hist;
}

void CalcHSBackProject(const IplImage* image_RGB, const CvHistogram *HSHist)
{
    IplImage* image_HSV = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 3);
    cvCvtColor(image_RGB, image_HSV, CV_BGR2HSV);

    IplImage* h_plane = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 1);
    IplImage* s_plane = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 1);
    IplImage* v_plane = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 1);
    IplImage* planes[] = { h_plane, s_plane };
    cvCvtPixToPlane(image_HSV, h_plane, s_plane, v_plane, 0);
    IplImage *  image_backProject = cvCreateImage(cvGetSize(image_RGB), IPL_DEPTH_8U, 1);
    cvZero(image_backProject);

    cvCalcBackProject(planes, image_backProject, HSHist);
    cvNamedWindow("反向投影", CV_WINDOW_AUTOSIZE);
    cvShowImage("反向投影", image_backProject);

    cvReleaseImage(&h_plane);
    cvReleaseImage(&s_plane);
    cvReleaseImage(&v_plane);
    cvReleaseImage(&image_HSV);
}

结果图片：

要言妙道：

  

①可以通过掩码操作来抓取手掌所在区域的直方图，也可以使用类似Cognex拖拽矩形的方式选取兴趣区域，获得目标颜色直方图，利用本章内容，实现颜色识别

②注意：cvFloodFill不会覆盖mask的非零像素点，因此，如果不希望mask阻碍填充操作时，将其中元素设为0，即代码中的 cvZero(image_mask);//①重要 ，如果没有这行，会发现掩码图像是一张黑白相间的竖线组成的图片

③注意：cvFloodFill填充时，mask图像必须是一个单通道、8位、像素宽度和高度均比源图像大两个像素的图像。

④但对于cvCalcHist的掩码，又要求掩码图像必须与用于计算的各plane图像相同大小，所以，要对cvFloodFill得到的掩码图像设置兴趣区域，当然，如果mask是矩阵，可以利用OpenCV的Range函数直接得到

⑤注意169行和171行计算方向投影和归一化直方图的先后顺序，如果先归一化直方图，反向投影得不到理想图像，尽管不算错，《学习OpenCV》针对此有如下描述：如果直方图是归一化的吗，此值便与一个条件概率值相关（即图像中像素点为直方图hist所表征的某种成员的概率） 

前几道题“肤色直方图”的计算不准确，应该用本题这种方式 ，在前面各篇中著注明

借鉴参考：

 反向投影_OpenCV中文论坛教程

 cvInRangeS参考