【练习7.3】从直方图创建signature、计算两个直方图的EMD距离

题目要求

程序代码

结果图片

要言妙道

  

题目要求：

 收集三种光照条件下的手的直方图，计算它们之间的EMD距离

程序代码：

// 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;

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

CvHistogram * Create3DHistogram(const int dims, int bins);
void CreateSingleImage(IplImage * image_Src, IplImage **image_r, IplImage **image_g, IplImage **image_b);
void DrawHistogram(IplImage ** image_hist, const CvHistogram * histogram, int scaleValue);
void CreateSignatureFromHistogram(const CvHistogram * histgogram, CvMat ** signature);

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

int _tmain(int argc, _TCHAR* argv[])
{
    const char * soutceFile_InDoor = "D:\Work\Work_Programming\Source\Image\OpenCVExerciseImage\第7章\hand_sample3.jpg";
    const char * soutceFile_OutDoor = "D:\Work\Work_Programming\Source\Image\OpenCVExerciseImage\第7章\hand_sample2.jpg";
    const char * soutceFile_OutDoorSun = "D:\Work\Work_Programming\Source\Image\OpenCVExerciseImage\第7章\hand_sample1.jpg";

    IplImage * image_Source_Indoor = cvLoadImage(soutceFile_InDoor, CV_LOAD_IMAGE_UNCHANGED);
    assert(image_Source_Indoor);
    IplImage * image_Source_Outdoor = cvLoadImage(soutceFile_OutDoor, CV_LOAD_IMAGE_UNCHANGED);
    assert(image_Source_Outdoor);
    IplImage * image_Source_OutdoorSun = cvLoadImage(soutceFile_OutDoorSun, CV_LOAD_IMAGE_UNCHANGED);
    assert(image_Source_OutdoorSun);

    IplImage * image_r;
    IplImage * image_g;
    IplImage * image_b;

    CvHistogram * histgram_3D_InDoor;
    CvHistogram * histgram_3D_OutDoor;
    CvHistogram * histgram_3D_OutDoorSun;
    CvMat * sig_Indoor, *sig_Outdoor, *sig_OutdoorSun;

    double emd_result;

    const int dims = 3;
    int bin_N[] = { 8 }; //本题只计算bin值为8的情况
    size_t length_bin_N = sizeof(bin_N) / sizeof(bin_N[0]);

    for (size_t i = 0; i < length_bin_N; ++i)
    {
        //室内直方图
        CreateSingleImage(image_Source_Indoor, &image_r, &image_g, &image_b);
        cvCvtPixToPlane(image_Source_Indoor, image_r, image_g, image_b, NULL);
        IplImage *allImagePlane[3] = { image_r, image_g, image_b };

        histgram_3D_InDoor = Create3DHistogram(dims, bin_N[i]);
        cvCalcHist(allImagePlane, histgram_3D_InDoor);
        //cvNormalizeHist(histgram_3D_InDoor, 1.0);
        CreateSignatureFromHistogram(histgram_3D_InDoor, &sig_Indoor);

        cvReleaseImage(&image_r);
        cvReleaseImage(&image_g);
        cvReleaseImage(&image_b);

        //室外直方图
        CreateSingleImage(image_Source_Outdoor, &image_r, &image_g, &image_b);
        cvCvtPixToPlane(image_Source_Outdoor, image_r, image_g, image_b, NULL);
        allImagePlane[0] = image_r;
        allImagePlane[1] = image_g;
        allImagePlane[2] = image_b;

        histgram_3D_OutDoor = Create3DHistogram(dims, bin_N[i]);
        cvCalcHist(allImagePlane, histgram_3D_OutDoor);
        //cvNormalizeHist(histgram_3D_OutDoor, 1.0);
        CreateSignatureFromHistogram(histgram_3D_OutDoor, &sig_Outdoor);

        cvReleaseImage(&image_r);
        cvReleaseImage(&image_g);
        cvReleaseImage(&image_b);

        //室外阳光直方图
        CreateSingleImage(image_Source_OutdoorSun, &image_r, &image_g, &image_b);
        cvCvtPixToPlane(image_Source_OutdoorSun, image_r, image_g, image_b, NULL);
        allImagePlane[0] = image_r;
        allImagePlane[1] = image_g;
        allImagePlane[2] = image_b;

        histgram_3D_OutDoorSun = Create3DHistogram(dims, bin_N[i]);
        cvCalcHist(allImagePlane, histgram_3D_OutDoorSun);
        //cvNormalizeHist(histgram_3D_OutDoorSun, 1.0);
        CreateSignatureFromHistogram(histgram_3D_OutDoorSun, &sig_OutdoorSun);

        cvReleaseImage(&image_r);
        cvReleaseImage(&image_g);
        cvReleaseImage(&image_b);
            
        cout << "=============直方图EMD距离:0表示最精确的匹配=============" << endl << endl;
        cout << "-------------Indoor和Outdoor直方图EMD距离-------------" << endl;
        emd_result = cvCalcEMD2(sig_Indoor, sig_Outdoor, CV_DIST_L2);
        cout << emd_result << endl;

        cout << "-------------Indoor和OutdoorSun直方图EMD距离-------------" << endl;
        emd_result = cvCalcEMD2(sig_Indoor, sig_OutdoorSun, CV_DIST_L2);
        cout << emd_result << endl;

        cout << "-------------Outdoor和OutdoorSun直方图EMD距离-------------" << endl;
        emd_result = cvCalcEMD2(sig_OutdoorSun, sig_Outdoor, CV_DIST_L2);
        cout << emd_result << endl;
        emd_result = cvCalcEMD2(sig_Outdoor, sig_OutdoorSun, CV_DIST_L2);
        cout << emd_result<<"  可见cvCalcEMD2参数signature顺序无关，不影响结果" << endl;

        cvReleaseMat(&sig_Indoor);
        cvReleaseMat(&sig_Outdoor);
        cvReleaseMat(&sig_OutdoorSun);

        cvReleaseHist(&histgram_3D_InDoor);
        cvReleaseHist(&histgram_3D_OutDoor);
        cvReleaseHist(&histgram_3D_OutDoorSun);
    }

    system("pause");

    cvWaitKey();
    cvReleaseImage(&image_Source_Indoor);
    cvReleaseImage(&image_Source_Outdoor);
    cvReleaseImage(&image_Source_OutdoorSun);

    cvDestroyAllWindows();

    return 0;
}

CvHistogram * Create3DHistogram(const int dims, int bins)
{
    int hist_sizes[] = { bins, bins, bins };
    int hist_type = CV_HIST_ARRAY;
    float r_range[] = { 0, 255 };
    float g_range[] = { 0, 255 };
    float b_range[] = { 0, 255 };
    float *hist_ranges[] = { r_range, g_range, b_range };

    return cvCreateHist(dims, hist_sizes, hist_type, hist_ranges, 1);
}

void CreateSingleImage(IplImage * image_Src, IplImage **image_r, IplImage **image_g, IplImage **image_b)
{
    IplImage * image_temp = cvCreateImage(cvGetSize(image_Src), IPL_DEPTH_8U, 1);
    //image_r = &image_temp; 
    //如果用上面这行这种方式，编译通过，但运行崩溃，本函数结束后image_r便被释放，
    //因为image_temp只是一个指针变量，占用四个字节的局部变量，对它取地址即&image_temp只是这个局部指针变量的地址，函数结束后自然释放掉
    //但是，将使用下面这行：将image_temp指针变量所保存的地址赋值给“*image_r”，这个地址是从cvCreateImagere中turn出来的，自然不会随函数结束而释放
    *image_r = image_temp;

    *image_g = cvCloneImage(image_temp);
    *image_b = cvCloneImage(image_temp);
    cvZero(*image_r);
    cvZero(*image_g);
    cvZero(*image_b);
}

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

    int bin_size1, bin_size2, bin_size3;

    if (hist_dims == 3)
    {
        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);
    *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;
                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));
            }
        }
    }
}

void CreateSignatureFromHistogram(const CvHistogram * histgogram,CvMat ** signature)
{
    int hist_dims = histgogram->mat.dims;

    int bin_size1, bin_size2, bin_size3;

    //只实现从三维直方图的创建
    if (hist_dims == 3)
    {
        bin_size1 = histgogram->mat.dim[0].size;
        bin_size2 = histgogram->mat.dim[1].size;
        bin_size3 = histgogram->mat.dim[2].size;
    }
    else
    {
        return;
    }

    int numrows = bin_size1*bin_size2*bin_size3;
    *signature = cvCreateMat(numrows, 4, CV_32FC1);

    float bin_value;
    int idx;
    for (int r = 0; r < bin_size1; ++r)
    {
        for (int g = 0; g < bin_size2; ++g)
        {
            for (int b = 0; b < bin_size3; ++b)
            {
                idx = r*(bin_size1*bin_size2) + g*bin_size2 + b;
                bin_value = cvQueryHistValue_3D(histgogram, r, g, b);
                cvSet2D(*signature, idx, 0, cvScalar(bin_value));
                cvSet2D(*signature, idx, 1, cvScalar(r));
                cvSet2D(*signature, idx, 2, cvScalar(g));
                cvSet2D(*signature, idx, 3, cvScalar(b));
            }
        }
    }
}

结果图片：

要言妙道：

 ①EMD用来度量两个分布之间的相似性