OpenCV进行图像相似度对比的几种办法

朴灿烈づ我的快乐病毒、 2022-06-18 10:43 231阅读 0赞

转载请注明出处：[http://blog.csdn.net/wangyaninglm/article/details/43853435][http_blog.csdn.net_wangyaninglm_article_details_43853435]，   
来自：[shiter编写程序的艺术][shiter]

![这里写图片描述][20160529220600738]

对计算图像相似度的方法，本文做了如下总结，主要有三种办法：

--------------------

# 1.PSNR峰值信噪比 #

PSNR（Peak Signal to Noise Ratio），一种全参考的图像质量评价指标。

简介：[https://en.wikipedia.org/wiki/Peak\_signal-to-noise\_ratio][https_en.wikipedia.org_wiki_Peak_signal-to-noise_ratio]

PSNR是最普遍和使用最为广泛的一种图像客观评价指标，然而它是基于对应像素点间的误差，即基于误差敏感的图像质量评价。由于并未考虑到人眼的视觉特性（人眼对空间频率较低的对比差异敏感度较高，人眼对亮度对比差异的敏感度较色度高，人眼对一个区域的感知结果会受到其周围邻近区域的影响等），因而经常出现评价结果与人的主观感觉不一致的情况。

SSIM（structural similarity）结构相似性，也是一种全参考的图像质量评价指标，它分别从亮度、对比度、结构三方面度量图像相似性。

![这里写图片描述][20160529215855875]

SSIM取值范围\[0,1\]，值越大，表示图像失真越小.

在实际应用中，可以利用滑动窗将图像分块，令分块总数为N，考虑到窗口形状对分块的影响，采用高斯加权计算每一窗口的均值、方差以及协方差，然后计算对应块的结构相似度SSIM，最后将平均值作为两图像的结构相似性度量，即平均结构相似性MSSIM：

--------------------

## 参考资料 ##

\[1\] 峰值信噪比-维基百科

\[2\] 王宇庆，刘维亚，王勇. 一种基于局部方差和结构相似度的图像质量评价方法\[J\]. 光电子激光，2008。   
\[3\][http://www.cnblogs.com/vincent2012/archive/2012/10/13/2723152.html][http_www.cnblogs.com_vincent2012_archive_2012_10_13_2723152.html]

官方文档的说明，不过是GPU版本的，我们可以修改不用gpu不然还得重新编译

[http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.html\#videoinputpsnrmssim][http_www.opencv.org.cn_opencvdoc_2.3.2_html_doc_tutorials_highgui_video-input-psnr-ssim_video-input-psnr-ssim.html_videoinputpsnrmssim]   
[http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/gpu/gpu-basics-similarity/gpu-basics-similarity.html?highlight=psnr][http_www.opencv.org.cn_opencvdoc_2.3.2_html_doc_tutorials_gpu_gpu-basics-similarity_gpu-basics-similarity.html_highlight_psnr]

--------------------

// PSNR.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    
    #include <iostream> // Console I/O
    #include <sstream> // String to number conversion
    
    #include <opencv2/core/core.hpp> // Basic OpenCV structures
    #include <opencv2/imgproc/imgproc.hpp>// Image processing methods for the CPU
    #include <opencv2/highgui/highgui.hpp>// Read images
    #include <opencv2/gpu/gpu.hpp> // GPU structures and methods
    
    using namespace std;
    using namespace cv;
    
    double getPSNR(const Mat& I1, const Mat& I2);      // CPU versions
    Scalar getMSSIM( const Mat& I1, const Mat& I2);
    
    double getPSNR_GPU(const Mat& I1, const Mat& I2);  // Basic GPU versions
    Scalar getMSSIM_GPU( const Mat& I1, const Mat& I2);
    
    struct BufferPSNR                                     // Optimized GPU versions
    {   // Data allocations are very expensive on GPU. Use a buffer to solve: allocate once reuse later.
        gpu::GpuMat gI1, gI2, gs, t1,t2;
    
        gpu::GpuMat buf;
    };
    double getPSNR_GPU_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b);
    
    struct BufferMSSIM                                     // Optimized GPU versions
    {   // Data allocations are very expensive on GPU. Use a buffer to solve: allocate once reuse later.
        gpu::GpuMat gI1, gI2, gs, t1,t2;
    
        gpu::GpuMat I1_2, I2_2, I1_I2;
        vector<gpu::GpuMat> vI1, vI2;
    
        gpu::GpuMat mu1, mu2; 
        gpu::GpuMat mu1_2, mu2_2, mu1_mu2; 
    
        gpu::GpuMat sigma1_2, sigma2_2, sigma12; 
        gpu::GpuMat t3; 
    
        gpu::GpuMat ssim_map;
    
        gpu::GpuMat buf;
    };
    Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b);
    
    void help()
    {
        cout
            << "\n--------------------------------------------------------------------------" << endl
            << "This program shows how to port your CPU code to GPU or write that from scratch." << endl
            << "You can see the performance improvement for the similarity check methods (PSNR and SSIM)."  << endl
            << "Usage:"                                                               << endl
            << "./gpu-basics-similarity referenceImage comparedImage numberOfTimesToRunTest(like 10)." << endl
            << "--------------------------------------------------------------------------"   << endl
            << endl;
    }
    
    int main(int argc, char *argv[])
    {
        help(); 
        Mat I1 = imread("swan1.jpg",1);           // Read the two images
        Mat I2 = imread("swan2.jpg",1);
    
        if (!I1.data || !I2.data)           // Check for success
        {
            cout << "Couldn't read the image";
            return 0;
        }
    
        BufferPSNR bufferPSNR;
        BufferMSSIM bufferMSSIM;
    
        int TIMES; 
        stringstream sstr("500"); 
        sstr >> TIMES;
        double time, result;
    
        //------------------------------- PSNR CPU ----------------------------------------------------
        time = (double)getTickCount();    
    
        for (int i = 0; i < TIMES; ++i)
            result = getPSNR(I1,I2);
    
        time = 1000*((double)getTickCount() - time)/getTickFrequency();
        time /= TIMES;
    
        cout << "Time of PSNR CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
            << " With result of: " <<  result << endl; 
    
        ------------------------------- PSNR GPU ----------------------------------------------------
        //time = (double)getTickCount(); 
    
        //for (int i = 0; i < TIMES; ++i)
        // result = getPSNR_GPU(I1,I2);
    
        //time = 1000*((double)getTickCount() - time)/getTickFrequency();
        //time /= TIMES;
    
        //cout << "Time of PSNR GPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
        // << " With result of: " << result << endl; 
    /* //------------------------------- PSNR GPU Optimized-------------------------------------------- time = (double)getTickCount(); // Initial call result = getPSNR_GPU_optimized(I1, I2, bufferPSNR); time = 1000*((double)getTickCount() - time)/getTickFrequency(); cout << "Initial call GPU optimized: " << time <<" milliseconds." << " With result of: " << result << endl; time = (double)getTickCount(); for (int i = 0; i < TIMES; ++i) result = getPSNR_GPU_optimized(I1, I2, bufferPSNR); time = 1000*((double)getTickCount() - time)/getTickFrequency(); time /= TIMES; cout << "Time of PSNR GPU OPTIMIZED ( / " << TIMES << " runs): " << time << " milliseconds." << " With result of: " << result << endl << endl; //------------------------------- SSIM CPU ----------------------------------------------------- Scalar x; time = (double)getTickCount(); for (int i = 0; i < TIMES; ++i) x = getMSSIM(I1,I2); time = 1000*((double)getTickCount() - time)/getTickFrequency(); time /= TIMES; cout << "Time of MSSIM CPU (averaged for " << TIMES << " runs): " << time << " milliseconds." << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; //------------------------------- SSIM GPU ----------------------------------------------------- time = (double)getTickCount(); for (int i = 0; i < TIMES; ++i) x = getMSSIM_GPU(I1,I2); time = 1000*((double)getTickCount() - time)/getTickFrequency(); time /= TIMES; cout << "Time of MSSIM GPU (averaged for " << TIMES << " runs): " << time << " milliseconds." << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; //------------------------------- SSIM GPU Optimized-------------------------------------------- time = (double)getTickCount(); x = getMSSIM_GPU_optimized(I1,I2, bufferMSSIM); time = 1000*((double)getTickCount() - time)/getTickFrequency(); cout << "Time of MSSIM GPU Initial Call " << time << " milliseconds." << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl; time = (double)getTickCount(); for (int i = 0; i < TIMES; ++i) x = getMSSIM_GPU_optimized(I1,I2, bufferMSSIM); time = 1000*((double)getTickCount() - time)/getTickFrequency(); time /= TIMES; cout << "Time of MSSIM GPU OPTIMIZED ( / " << TIMES << " runs): " << time << " milliseconds." << " With result of B" << x.val[0] << " G" << x.val[1] << " R" << x.val[2] << endl << endl; return 0; */
        getchar();
    }
    
    
    double getPSNR(const Mat& I1, const Mat& I2)
    {
        Mat s1; 
        absdiff(I1, I2, s1);       // |I1 - I2|
        s1.convertTo(s1, CV_32F);  // cannot make a square on 8 bits
        s1 = s1.mul(s1);           // |I1 - I2|^2
    
        Scalar s = sum(s1);         // sum elements per channel
    
        double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
    
        if( sse <= 1e-10) // for small values return zero
            return 0;
        else
        {
            double  mse =sse /(double)(I1.channels() * I1.total());
            double psnr = 10.0*log10((255*255)/mse);
            return psnr;
        }
    }
    
    
    
    double getPSNR_GPU_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b)
    {    
        b.gI1.upload(I1);
        b.gI2.upload(I2);
    
        b.gI1.convertTo(b.t1, CV_32F);
        b.gI2.convertTo(b.t2, CV_32F);
    
        gpu::absdiff(b.t1.reshape(1), b.t2.reshape(1), b.gs);
        gpu::multiply(b.gs, b.gs, b.gs);
    
        double sse = gpu::sum(b.gs, b.buf)[0];
    
        if( sse <= 1e-10) // for small values return zero
            return 0;
        else
        {
            double mse = sse /(double)(I1.channels() * I1.total());
            double psnr = 10.0*log10((255*255)/mse);
            return psnr;
        }
    }
    
    double getPSNR_GPU(const Mat& I1, const Mat& I2)
    {
        gpu::GpuMat gI1, gI2, gs, t1,t2; 
    
        gI1.upload(I1);
        gI2.upload(I2);
    
        gI1.convertTo(t1, CV_32F);
        gI2.convertTo(t2, CV_32F);
    
        gpu::absdiff(t1.reshape(1), t2.reshape(1), gs); 
        gpu::multiply(gs, gs, gs);
    
        Scalar s = gpu::sum(gs);
        double sse = s.val[0] + s.val[1] + s.val[2];
    
        if( sse <= 1e-10) // for small values return zero
            return 0;
        else
        {
            double  mse =sse /(double)(gI1.channels() * I1.total());
            double psnr = 10.0*log10((255*255)/mse);
            return psnr;
        }
    }
    
    Scalar getMSSIM( const Mat& i1, const Mat& i2)
    { 
        const double C1 = 6.5025, C2 = 58.5225;
        /***************************** INITS **********************************/
        int d     = CV_32F;
    
        Mat I1, I2; 
        i1.convertTo(I1, d);           // cannot calculate on one byte large values
        i2.convertTo(I2, d); 
    
        Mat I2_2   = I2.mul(I2);        // I2^2
        Mat I1_2   = I1.mul(I1);        // I1^2
        Mat I1_I2  = I1.mul(I2);        // I1 * I2
    
        /*************************** END INITS **********************************/
    
        Mat mu1, mu2;   // PRELIMINARY COMPUTING
        GaussianBlur(I1, mu1, Size(11, 11), 1.5);
        GaussianBlur(I2, mu2, Size(11, 11), 1.5);
    
        Mat mu1_2   =   mu1.mul(mu1);    
        Mat mu2_2   =   mu2.mul(mu2); 
        Mat mu1_mu2 =   mu1.mul(mu2);
    
        Mat sigma1_2, sigma2_2, sigma12; 
    
        GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
        sigma1_2 -= mu1_2;
    
        GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
        sigma2_2 -= mu2_2;
    
        GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
        sigma12 -= mu1_mu2;
    
        / FORMULA 
        Mat t1, t2, t3; 
    
        t1 = 2 * mu1_mu2 + C1; 
        t2 = 2 * sigma12 + C2; 
        t3 = t1.mul(t2);              // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    
        t1 = mu1_2 + mu2_2 + C1; 
        t2 = sigma1_2 + sigma2_2 + C2;     
        t1 = t1.mul(t2);               // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
    
        Mat ssim_map;
        divide(t3, t1, ssim_map);      // ssim_map = t3./t1;
    
        Scalar mssim = mean( ssim_map ); // mssim = average of ssim map
        return mssim; 
    }
    
    Scalar getMSSIM_GPU( const Mat& i1, const Mat& i2)
    { 
        const float C1 = 6.5025f, C2 = 58.5225f;
        /***************************** INITS **********************************/
        gpu::GpuMat gI1, gI2, gs1, t1,t2; 
    
        gI1.upload(i1);
        gI2.upload(i2);
    
        gI1.convertTo(t1, CV_MAKE_TYPE(CV_32F, gI1.channels()));
        gI2.convertTo(t2, CV_MAKE_TYPE(CV_32F, gI2.channels()));
    
        vector<gpu::GpuMat> vI1, vI2; 
        gpu::split(t1, vI1);
        gpu::split(t2, vI2);
        Scalar mssim;
    
        for( int i = 0; i < gI1.channels(); ++i )
        {
            gpu::GpuMat I2_2, I1_2, I1_I2; 
    
            gpu::multiply(vI2[i], vI2[i], I2_2);        // I2^2
            gpu::multiply(vI1[i], vI1[i], I1_2);        // I1^2
            gpu::multiply(vI1[i], vI2[i], I1_I2);       // I1 * I2
    
            /*************************** END INITS **********************************/
            gpu::GpuMat mu1, mu2;   // PRELIMINARY COMPUTING
            gpu::GaussianBlur(vI1[i], mu1, Size(11, 11), 1.5);
            gpu::GaussianBlur(vI2[i], mu2, Size(11, 11), 1.5);
    
            gpu::GpuMat mu1_2, mu2_2, mu1_mu2; 
            gpu::multiply(mu1, mu1, mu1_2);   
            gpu::multiply(mu2, mu2, mu2_2);   
            gpu::multiply(mu1, mu2, mu1_mu2);   
    
            gpu::GpuMat sigma1_2, sigma2_2, sigma12; 
    
            gpu::GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
            //sigma1_2 = sigma1_2 - mu1_2;
            gpu::subtract(sigma1_2,mu1_2,sigma1_2);
    
            gpu::GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
            //sigma2_2 = sigma2_2 - mu2_2;
    
            gpu::GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
            (Mat)sigma12 =(Mat)sigma12 - (Mat)mu1_mu2;
            //sigma12 = sigma12 - mu1_mu2
    
            / FORMULA 
            gpu::GpuMat t1, t2, t3; 
    
    // t1 = 2 * mu1_mu2 + C1; 
    // t2 = 2 * sigma12 + C2; 
    // gpu::multiply(t1, t2, t3); // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    // 
    // t1 = mu1_2 + mu2_2 + C1; 
    // t2 = sigma1_2 + sigma2_2 + C2; 
    // gpu::multiply(t1, t2, t1); // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
    
            gpu::GpuMat ssim_map;
            gpu::divide(t3, t1, ssim_map);      // ssim_map = t3./t1;
    
            Scalar s = gpu::sum(ssim_map);    
            mssim.val[i] = s.val[0] / (ssim_map.rows * ssim_map.cols);
    
        }
        return mssim; 
    }
    
    Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b)
    { 
        int cn = i1.channels();
    
        const float C1 = 6.5025f, C2 = 58.5225f;
        /***************************** INITS **********************************/
    
        b.gI1.upload(i1);
        b.gI2.upload(i2);
    
        gpu::Stream stream;
    
        stream.enqueueConvert(b.gI1, b.t1, CV_32F);
        stream.enqueueConvert(b.gI2, b.t2, CV_32F);      
    
        gpu::split(b.t1, b.vI1, stream);
        gpu::split(b.t2, b.vI2, stream);
        Scalar mssim;
    
        for( int i = 0; i < b.gI1.channels(); ++i )
        {        
            gpu::multiply(b.vI2[i], b.vI2[i], b.I2_2, stream);        // I2^2
            gpu::multiply(b.vI1[i], b.vI1[i], b.I1_2, stream);        // I1^2
            gpu::multiply(b.vI1[i], b.vI2[i], b.I1_I2, stream);       // I1 * I2
    
            //gpu::GaussianBlur(b.vI1[i], b.mu1, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
            //gpu::GaussianBlur(b.vI2[i], b.mu2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
    
            gpu::multiply(b.mu1, b.mu1, b.mu1_2, stream);   
            gpu::multiply(b.mu2, b.mu2, b.mu2_2, stream);   
            gpu::multiply(b.mu1, b.mu2, b.mu1_mu2, stream);   
    
            //gpu::GaussianBlur(b.I1_2, b.sigma1_2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
            //gpu::subtract(b.sigma1_2, b.mu1_2, b.sigma1_2, stream);
            //b.sigma1_2 -= b.mu1_2; - This would result in an extra data transfer operation
    
            //gpu::GaussianBlur(b.I2_2, b.sigma2_2, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
            //gpu::subtract(b.sigma2_2, b.mu2_2, b.sigma2_2, stream);
            //b.sigma2_2 -= b.mu2_2;
    
            //gpu::GaussianBlur(b.I1_I2, b.sigma12, Size(11, 11), 1.5, 0, BORDER_DEFAULT, -1, stream);
            //gpu::subtract(b.sigma12, b.mu1_mu2, b.sigma12, stream);
            //b.sigma12 -= b.mu1_mu2;
    
            //here too it would be an extra data transfer due to call of operator*(Scalar, Mat)
            gpu::multiply(b.mu1_mu2, 2, b.t1, stream); //b.t1 = 2 * b.mu1_mu2 + C1; 
            //gpu::add(b.t1, C1, b.t1, stream);
            gpu::multiply(b.sigma12, 2, b.t2, stream); //b.t2 = 2 * b.sigma12 + C2; 
            //gpu::add(b.t2, C2, b.t2, stream); 
    
            gpu::multiply(b.t1, b.t2, b.t3, stream);     // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    
            //gpu::add(b.mu1_2, b.mu2_2, b.t1, stream);
            //gpu::add(b.t1, C1, b.t1, stream);
    
            //gpu::add(b.sigma1_2, b.sigma2_2, b.t2, stream);
            //gpu::add(b.t2, C2, b.t2, stream);
    
    
            gpu::multiply(b.t1, b.t2, b.t1, stream);     // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2)) 
            gpu::divide(b.t3, b.t1, b.ssim_map, stream);      // ssim_map = t3./t1;
    
            stream.waitForCompletion();
    
            Scalar s = gpu::sum(b.ssim_map, b.buf);    
            mssim.val[i] = s.val[0] / (b.ssim_map.rows * b.ssim_map.cols);
    
        }
        return mssim; 
    }
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100
       101
       102
       103
       104
       105
       106
       107
       108
       109
       110
       111
       112
       113
       114
       115
       116
       117
       118
       119
       120
       121
       122
       123
       124
       125
       126
       127
       128
       129
       130
       131
       132
       133
       134
       135
       136
       137
       138
       139
       140
       141
       142
       143
       144
       145
       146
       147
       148
       149
       150
       151
       152
       153
       154
       155
       156
       157
       158
       159
       160
       161
       162
       163
       164
       165
       166
       167
       168
       169
       170
       171
       172
       173
       174
       175
       176
       177
       178
       179
       180
       181
       182
       183
       184
       185
       186
       187
       188
       189
       190
       191
       192
       193
       194
       195
       196
       197
       198
       199
       200
       201
       202
       203
       204
       205
       206
       207
       208
       209
       210
       211
       212
       213
       214
       215
       216
       217
       218
       219
       220
       221
       222
       223
       224
       225
       226
       227
       228
       229
       230
       231
       232
       233
       234
       235
       236
       237
       238
       239
       240
       241
       242
       243
       244
       245
       246
       247
       248
       249
       250
       251
       252
       253
       254
       255
       256
       257
       258
       259
       260
       261
       262
       263
       264
       265
       266
       267
       268
       269
       270
       271
       272
       273
       274
       275
       276
       277
       278
       279
       280
       281
       282
       283
       284
       285
       286
       287
       288
       289
       290
       291
       292
       293
       294
       295
       296
       297
       298
       299
       300
       301
       302
       303
       304
       305
       306
       307
       308
       309
       310
       311
       312
       313
       314
       315
       316
       317
       318
       319
       320
       321
       322
       323
       324
       325
       326
       327
       328
       329
       330
       331
       332
       333
       334
       335
       336
       337
       338
       339
       340
       341
       342
       343
       344
       345
       346
       347
       348
       349
       350
       351
       352
       353
       354
       355
       356
       357
       358
       359
       360
       361
       362
       363
       364
       365
       366
       367
       368
       369
       370
       371
       372
       373
       374
       375
       376
       377
       378
       379
       380
       381
       382
       383
       384
       385
       386
       387
       388
       389
       390
       391
       392
       393
       394
       395
       396
       397
       398
       399
       400
       401
       402
       403
       404
       405
       406
       407
       408
       409
       410
       411
       412
       413
       414
       415
       416
       417
       418
       419
       420
       421
       422
       423
       424
       425
       426
       427
       428
       429
       430
       431
       432
       433
       434
       435
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100
       101
       102
       103
       104
       105
       106
       107
       108
       109
       110
       111
       112
       113
       114
       115
       116
       117
       118
       119
       120
       121
       122
       123
       124
       125
       126
       127
       128
       129
       130
       131
       132
       133
       134
       135
       136
       137
       138
       139
       140
       141
       142
       143
       144
       145
       146
       147
       148
       149
       150
       151
       152
       153
       154
       155
       156
       157
       158
       159
       160
       161
       162
       163
       164
       165
       166
       167
       168
       169
       170
       171
       172
       173
       174
       175
       176
       177
       178
       179
       180
       181
       182
       183
       184
       185
       186
       187
       188
       189
       190
       191
       192
       193
       194
       195
       196
       197
       198
       199
       200
       201
       202
       203
       204
       205
       206
       207
       208
       209
       210
       211
       212
       213
       214
       215
       216
       217
       218
       219
       220
       221
       222
       223
       224
       225
       226
       227
       228
       229
       230
       231
       232
       233
       234
       235
       236
       237
       238
       239
       240
       241
       242
       243
       244
       245
       246
       247
       248
       249
       250
       251
       252
       253
       254
       255
       256
       257
       258
       259
       260
       261
       262
       263
       264
       265
       266
       267
       268
       269
       270
       271
       272
       273
       274
       275
       276
       277
       278
       279
       280
       281
       282
       283
       284
       285
       286
       287
       288
       289
       290
       291
       292
       293
       294
       295
       296
       297
       298
       299
       300
       301
       302
       303
       304
       305
       306
       307
       308
       309
       310
       311
       312
       313
       314
       315
       316
       317
       318
       319
       320
       321
       322
       323
       324
       325
       326
       327
       328
       329
       330
       331
       332
       333
       334
       335
       336
       337
       338
       339
       340
       341
       342
       343
       344
       345
       346
       347
       348
       349
       350
       351
       352
       353
       354
       355
       356
       357
       358
       359
       360
       361
       362
       363
       364
       365
       366
       367
       368
       369
       370
       371
       372
       373
       374
       375
       376
       377
       378
       379
       380
       381
       382
       383
       384
       385
       386
       387
       388
       389
       390
       391
       392
       393
       394
       395
       396
       397
       398
       399
       400
       401
       402
       403
       404
       405
       406
       407
       408
       409
       410
       411
       412
       413
       414
       415
       416
       417
       418
       419
       420
       421
       422
       423
       424
       425
       426
       427
       428
       429
       430
       431
       432
       433
       434
       435

两幅一样的图片，对比结果：

![这里写图片描述][20160529220407439]   
![这里写图片描述][20150216180004747]

--------------------

# 2.感知哈希算法 #

(perceptual hash algorithm）

[http://blog.csdn.net/fengbingchun/article/details/42153261][http_blog.csdn.net_fengbingchun_article_details_42153261]

感知哈希算法(perceptual hash algorithm)，它的作用是对每张图像生成一个“指纹”(fingerprint)字符串，然后比较不同图像的指纹。结果越接近，就说明图像越相似。

实现步骤：

1.  缩小尺寸：将图像缩小到8\*8的尺寸，总共64个像素。这一步的作用是去除图像的细节，只保留结构/明暗等基本信息，摒弃不同尺寸/比例带来的图像差异；
2.  简化色彩：将缩小后的图像，转为64级灰度，即所有像素点总共只有64种颜色；
3.  计算平均值：计算所有64个像素的灰度平均值；
4.  比较像素的灰度：将每个像素的灰度，与平均值进行比较，大于或等于平均值记为1，小于平均值记为0；
5.  计算哈希值：将上一步的比较结果，组合在一起，就构成了一个64位的整数，这就是这张图像的指纹。组合的次序并不重要，只要保证所有图像都采用同样次序就行了；
6.  得到指纹以后，就可以对比不同的图像，看看64位中有多少位是不一样的。在理论上，这等同于”汉明距离”(Hamming distance,在信息论中，两个等长字符串之间的汉明距离是两个字符串对应位置的不同字符的个数)。如果不相同的数据位数不超过5，就说明两张图像很相似；如果大于10，就说明这是两张不同的图像。   
    以上内容摘自：[http://www.ruanyifeng.com/blog/2011/07/principle\_of\_similar\_image\_search.html][http_www.ruanyifeng.com_blog_2011_07_principle_of_similar_image_search.html]

代码：

// similarity.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    
    #pragma comment(lib,"opencv_core2410d.lib") 
    #pragma comment(lib,"opencv_highgui2410d.lib") 
    #pragma comment(lib,"opencv_imgproc2410d.lib") 
    
    
    using namespace std;
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    
        string strSrcImageName = "swan.jpg";
    
        cv::Mat matSrc, matSrc1, matSrc2;
    
        matSrc = cv::imread(strSrcImageName, CV_LOAD_IMAGE_COLOR);
        CV_Assert(matSrc.channels() == 3);
    
        cv::resize(matSrc, matSrc1, cv::Size(357, 419), 0, 0, cv::INTER_NEAREST);
        //cv::flip(matSrc1, matSrc1, 1);
        cv::resize(matSrc, matSrc2, cv::Size(2177, 3233), 0, 0, cv::INTER_LANCZOS4);
    
        cv::Mat matDst1, matDst2;
    
        cv::resize(matSrc1, matDst1, cv::Size(8, 8), 0, 0, cv::INTER_CUBIC);
        cv::resize(matSrc2, matDst2, cv::Size(8, 8), 0, 0, cv::INTER_CUBIC);
    
        cv::cvtColor(matDst1, matDst1, CV_BGR2GRAY);
        cv::cvtColor(matDst2, matDst2, CV_BGR2GRAY);
    
        int iAvg1 = 0, iAvg2 = 0;
        int arr1[64], arr2[64];
    
        for (int i = 0; i < 8; i++)
        {
            uchar* data1 = matDst1.ptr<uchar>(i);
            uchar* data2 = matDst2.ptr<uchar>(i);
    
            int tmp = i * 8;
    
            for (int j = 0; j < 8; j++) 
            {
                int tmp1 = tmp + j;
    
                arr1[tmp1] = data1[j] / 4 * 4;
                arr2[tmp1] = data2[j] / 4 * 4;
    
                iAvg1 += arr1[tmp1];
                iAvg2 += arr2[tmp1];
            }
        }
    
        iAvg1 /= 64;
        iAvg2 /= 64;
    
        for (int i = 0; i < 64; i++) 
        {
            arr1[i] = (arr1[i] >= iAvg1) ? 1 : 0;
            arr2[i] = (arr2[i] >= iAvg2) ? 1 : 0;
        }
    
        int iDiffNum = 0;
    
        for (int i = 0; i < 64; i++)
            if (arr1[i] != arr2[i])
                ++iDiffNum;
    
        cout<<"iDiffNum = "<<iDiffNum<<endl;
    
        if (iDiffNum <= 5)
            cout<<"two images are very similar!"<<endl;
        else if (iDiffNum > 10)
            cout<<"they are two different images!"<<endl;
        else
            cout<<"two image are somewhat similar!"<<endl;
    
        getchar();
        return 0;
    }
    
    
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90

一幅图片自己对比：

![这里写图片描述][20150216181623696]

结果：

![这里写图片描述][20150216181642185]

--------------------

# 3.计算特征点 #

OpenCV的feature2d module中提供了从局部图像特征（Local image feature）的检测、特征向量（feature vector）的提取，到特征匹配的实现。其中的局部图像特征包括了常用的几种局部图像特征检测与描述算子，如FAST、SURF、SIFT、以及ORB。对于高维特征向量之间的匹配，OpenCV主要有两种方式：

1）BruteForce穷举法；   
2）FLANN近似K近邻算法（包含了多种高维特征向量匹配的算法，例如随机森林等）。

feature2d module： [http://docs.opencv.org/modules/features2d/doc/features2d.html][http_docs.opencv.org_modules_features2d_doc_features2d.html]

OpenCV FLANN: [http://docs.opencv.org/modules/flann/doc/flann.html][http_docs.opencv.org_modules_flann_doc_flann.html]

FLANN: [http://www.cs.ubc.ca/~mariusm/index.php/FLANN/FLANN][http_www.cs.ubc.ca_mariusm_index.php_FLANN_FLANN]

原文：

[http://blog.csdn.net/icvpr/article/details/8491369][http_blog.csdn.net_icvpr_article_details_8491369]

//localfeature.h
    #ifndef _FEATURE_H_ 
    #define _FEATURE_H_
    
    #include <iostream>
    #include <vector>
    #include <string>
    
    #include <opencv2/opencv.hpp>
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/nonfree/nonfree.hpp> 
    #include <opencv2/nonfree/features2d.hpp> 
    using namespace cv;
    using namespace std;
    
    class Feature
    {
    public:
        Feature();
        ~Feature();
    
        Feature(const string& detectType, const string& extractType, const string& matchType);
    
    public:
    
        void detectKeypoints(const Mat& image, vector<KeyPoint>& keypoints);  // 检测特征点
        void extractDescriptors(const Mat& image, vector<KeyPoint>& keypoints, Mat& descriptor);  // 提取特征向量
        void bestMatch(const Mat& queryDescriptor, Mat& trainDescriptor, vector<DMatch>& matches);  // 最近邻匹配
        void knnMatch(const Mat& queryDescriptor, Mat& trainDescriptor, vector<vector<DMatch>>& matches, int k);  // K近邻匹配
    
        void saveKeypoints(const Mat& image, const vector<KeyPoint>& keypoints, const string& saveFileName = "");  // 保存特征点
        void saveMatches(const Mat& queryImage,
            const vector<KeyPoint>& queryKeypoints,
            const Mat& trainImage,
            const vector<KeyPoint>& trainKeypoints,
            const vector<DMatch>& matches,
            const string& saveFileName = "");  // 保存匹配结果到图片中
    
    private:
        Ptr<FeatureDetector> m_detector;
        Ptr<DescriptorExtractor> m_extractor;
        Ptr<DescriptorMatcher> m_matcher;
    
        string m_detectType;
        string m_extractType;
        string m_matchType;
    
    };
    
    
    #endif
    
    //localfeature.cpp
    
    #include "stdafx.h"
    #include "localfeature.h"
    
    
    Feature::Feature()
    {
        m_detectType = "SIFT";
        m_extractType = "SIFT";
        m_matchType = "BruteForce";
    }
    
    Feature::~Feature()
    {
    
    }
    
    
    Feature::Feature(const string& detectType, const string& extractType, const string& matchType)
    {
        assert(!detectType.empty());
        assert(!extractType.empty());
        assert(!matchType.empty());
    
        m_detectType = detectType;
        m_extractType = extractType;
        m_matchType = matchType;
    }
    
    
    void Feature::detectKeypoints(const Mat& image, std::vector<KeyPoint>& keypoints) 
    {
        assert(image.type() == CV_8UC1);
        assert(!m_detectType.empty());
    
        keypoints.clear();
    
        initModule_nonfree();
    
        m_detector = FeatureDetector::create(m_detectType);
        m_detector->detect(image, keypoints);
    
    }
    
    
    
    void Feature::extractDescriptors(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptor)
    {
        assert(image.type() == CV_8UC1);
        assert(!m_extractType.empty());
    
        initModule_nonfree(); 
        m_extractor = DescriptorExtractor::create(m_extractType);
        m_extractor->compute(image, keypoints, descriptor);
    
    }
    
    
    void Feature::bestMatch(const Mat& queryDescriptor, Mat& trainDescriptor, std::vector<DMatch>& matches) 
    {
        assert(!queryDescriptor.empty());
        assert(!trainDescriptor.empty());
        assert(!m_matchType.empty());
    
        matches.clear();
    
        m_matcher = DescriptorMatcher::create(m_matchType);
        m_matcher->add(std::vector<Mat>(1, trainDescriptor));
        m_matcher->train();
        m_matcher->match(queryDescriptor, matches);
    
    }
    
    
    void Feature::knnMatch(const Mat& queryDescriptor, Mat& trainDescriptor, std::vector<std::vector<DMatch>>& matches, int k)
    {
        assert(k > 0);
        assert(!queryDescriptor.empty());
        assert(!trainDescriptor.empty());
        assert(!m_matchType.empty());
    
        matches.clear();
    
        m_matcher = DescriptorMatcher::create(m_matchType);
        m_matcher->add(std::vector<Mat>(1, trainDescriptor));
        m_matcher->train();
        m_matcher->knnMatch(queryDescriptor, matches, k);
    
    }
    
    
    
    void Feature::saveKeypoints(const Mat& image, const vector<KeyPoint>& keypoints, const string& saveFileName)
    {
        assert(!saveFileName.empty());
    
        Mat outImage;
        cv::drawKeypoints(image, keypoints, outImage, Scalar(255,255,0), DrawMatchesFlags::DRAW_RICH_KEYPOINTS );
    
        //
        string saveKeypointsImgName = saveFileName + "_" + m_detectType + ".jpg";
        imwrite(saveKeypointsImgName, outImage);
    
    }
    
    
    
    void Feature::saveMatches(const Mat& queryImage,
        const vector<KeyPoint>& queryKeypoints,
        const Mat& trainImage,
        const vector<KeyPoint>& trainKeypoints,
        const vector<DMatch>& matches,
        const string& saveFileName)
    {
        assert(!saveFileName.empty());
    
        Mat outImage;
        cv::drawMatches(queryImage, queryKeypoints, trainImage, trainKeypoints, matches, outImage, 
            Scalar(255, 0, 0), Scalar(0, 255, 255), vector<char>(),  DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
    
        //
        string saveMatchImgName = saveFileName + "_" + m_detectType + "_" + m_extractType + "_" + m_matchType + ".jpg";
        imwrite(saveMatchImgName, outImage);
    }
    
    
    
    // main.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp>
    #include <opencv2/imgproc/imgproc.hpp>
    #include <opencv2/nonfree/nonfree.hpp> 
    #include <opencv2/nonfree/features2d.hpp> 
    
    #include "localfeature.h"
    
    #pragma comment(lib,"opencv_core2410d.lib") 
    #pragma comment(lib,"opencv_highgui2410d.lib") 
    #pragma comment(lib,"opencv_imgproc2410d.lib") 
    #pragma comment(lib,"opencv_nonfree2410d.lib") 
    #pragma comment(lib,"opencv_features2d2410d.lib") 
    
    
    using namespace std;
    
    
    
    
    
    int main(int argc, char** argv)
    {
        /*if (argc != 6) { cout << "wrong usage!" << endl; cout << "usage: .exe FAST SIFT BruteForce queryImage trainImage" << endl; return -1; }*/
    
        string detectorType = "SIFT";
        string extractorType = "SIFT";
        string matchType = "BruteForce";
        string queryImagePath = "swan.jpg";
        string trainImagePath = "swan.jpg";
    
    
        Mat queryImage = imread(queryImagePath, CV_LOAD_IMAGE_GRAYSCALE);
        if (queryImage.empty())
        {
            cout<<"read failed"<< endl;
            return -1;
        }
    
        Mat trainImage = imread(trainImagePath, CV_LOAD_IMAGE_GRAYSCALE);
        if (trainImage.empty())
        {
            cout<<"read failed"<< endl;
            return -1;
        }
    
    
        Feature feature(detectorType, extractorType, matchType);
    
        vector<KeyPoint> queryKeypoints, trainKeypoints; 
        feature.detectKeypoints(queryImage, queryKeypoints);
        feature.detectKeypoints(trainImage, trainKeypoints);
    
    
        Mat queryDescriptor, trainDescriptor;
    
    
        feature.extractDescriptors(queryImage, queryKeypoints, queryDescriptor);
        feature.extractDescriptors(trainImage, trainKeypoints, trainDescriptor);
    
    
        vector<DMatch> matches;
        feature.bestMatch(queryDescriptor, trainDescriptor, matches);
    
        vector<vector<DMatch>> knnmatches;
        feature.knnMatch(queryDescriptor, trainDescriptor, knnmatches, 2);
    
        Mat outImage;
        feature.saveMatches(queryImage, queryKeypoints, trainImage, trainKeypoints, matches, "../");
    
    
        return 0;
    }
    
    
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100
       101
       102
       103
       104
       105
       106
       107
       108
       109
       110
       111
       112
       113
       114
       115
       116
       117
       118
       119
       120
       121
       122
       123
       124
       125
       126
       127
       128
       129
       130
       131
       132
       133
       134
       135
       136
       137
       138
       139
       140
       141
       142
       143
       144
       145
       146
       147
       148
       149
       150
       151
       152
       153
       154
       155
       156
       157
       158
       159
       160
       161
       162
       163
       164
       165
       166
       167
       168
       169
       170
       171
       172
       173
       174
       175
       176
       177
       178
       179
       180
       181
       182
       183
       184
       185
       186
       187
       188
       189
       190
       191
       192
       193
       194
       195
       196
       197
       198
       199
       200
       201
       202
       203
       204
       205
       206
       207
       208
       209
       210
       211
       212
       213
       214
       215
       216
       217
       218
       219
       220
       221
       222
       223
       224
       225
       226
       227
       228
       229
       230
       231
       232
       233
       234
       235
       236
       237
       238
       239
       240
       241
       242
       243
       244
       245
       246
       247
       248
       249
       250
       251
       252
       253
       254
       255
       256
       257
       258
       259
       260
       261
       262
       263
       264
       265
       266
       267
      
     
      
       1
       2
       3
       4
       5
       6
       7
       8
       9
       10
       11
       12
       13
       14
       15
       16
       17
       18
       19
       20
       21
       22
       23
       24
       25
       26
       27
       28
       29
       30
       31
       32
       33
       34
       35
       36
       37
       38
       39
       40
       41
       42
       43
       44
       45
       46
       47
       48
       49
       50
       51
       52
       53
       54
       55
       56
       57
       58
       59
       60
       61
       62
       63
       64
       65
       66
       67
       68
       69
       70
       71
       72
       73
       74
       75
       76
       77
       78
       79
       80
       81
       82
       83
       84
       85
       86
       87
       88
       89
       90
       91
       92
       93
       94
       95
       96
       97
       98
       99
       100
       101
       102
       103
       104
       105
       106
       107
       108
       109
       110
       111
       112
       113
       114
       115
       116
       117
       118
       119
       120
       121
       122
       123
       124
       125
       126
       127
       128
       129
       130
       131
       132
       133
       134
       135
       136
       137
       138
       139
       140
       141
       142
       143
       144
       145
       146
       147
       148
       149
       150
       151
       152
       153
       154
       155
       156
       157
       158
       159
       160
       161
       162
       163
       164
       165
       166
       167
       168
       169
       170
       171
       172
       173
       174
       175
       176
       177
       178
       179
       180
       181
       182
       183
       184
       185
       186
       187
       188
       189
       190
       191
       192
       193
       194
       195
       196
       197
       198
       199
       200
       201
       202
       203
       204
       205
       206
       207
       208
       209
       210
       211
       212
       213
       214
       215
       216
       217
       218
       219
       220
       221
       222
       223
       224
       225
       226
       227
       228
       229
       230
       231
       232
       233
       234
       235
       236
       237
       238
       239
       240
       241
       242
       243
       244
       245
       246
       247
       248
       249
       250
       251
       252
       253
       254
       255
       256
       257
       258
       259
       260
       261
       262
       263
       264
       265
       266
       267

两幅同样图片结果：

![这里写图片描述][20150216183848936]

几年前上学时候写了这个文章，没想到现在居然是博客访问最高的一篇文章，现在我又收集了一些论文文档资料，当然衡量图像相似度的方法有很多不止上述的三种方法，具体我们再看看论文和外围资料，下载链接：

[http://download.csdn.net/detail/wangyaninglm/9764301][http_download.csdn.net_detail_wangyaninglm_9764301]

转载请注明出处：[http://blog.csdn.net/wangyaninglm/article/details/51533549][http_blog.csdn.net_wangyaninglm_article_details_51533549]，   
来自：

[shiter编写程序的艺术][shiter]

[http_blog.csdn.net_wangyaninglm_article_details_43853435]: http://blog.csdn.net/wangyaninglm/article/details/43853435
[shiter]: http://blog.csdn.net/wangyaninglm
[20160529220600738]: /images/20220618/f1ab5861d9fa4f5a89e67de875dc7fe0.png
[https_en.wikipedia.org_wiki_Peak_signal-to-noise_ratio]: https://en.wikipedia.org/wiki/Peak_signal-to-noise_ratio
[20160529215855875]: /images/20220618/ccca4f6ce74040ab93b7dd735d5929ef.png
[http_www.cnblogs.com_vincent2012_archive_2012_10_13_2723152.html]: http://www.cnblogs.com/vincent2012/archive/2012/10/13/2723152.html
[http_www.opencv.org.cn_opencvdoc_2.3.2_html_doc_tutorials_highgui_video-input-psnr-ssim_video-input-psnr-ssim.html_videoinputpsnrmssim]: http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.html#videoinputpsnrmssim
[http_www.opencv.org.cn_opencvdoc_2.3.2_html_doc_tutorials_gpu_gpu-basics-similarity_gpu-basics-similarity.html_highlight_psnr]: http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/gpu/gpu-basics-similarity/gpu-basics-similarity.html?highlight=psnr
[20160529220407439]: /images/20220618/fe50e2be33d9443ea9e26bb0575713e5.png
[20150216180004747]: /images/20220618/5b20b8ee45c7499f9d629b8f38c8e207.png
[http_blog.csdn.net_fengbingchun_article_details_42153261]: http://blog.csdn.net/fengbingchun/article/details/42153261
[http_www.ruanyifeng.com_blog_2011_07_principle_of_similar_image_search.html]: http://www.ruanyifeng.com/blog/2011/07/principle_of_similar_image_search.html
[20150216181623696]: /images/20220618/b7a4ce16517747fca6666213f95caf09.png
[20150216181642185]: /images/20220618/02f3e21d01a54d1aa8e76b12f9cc5af6.png
[http_docs.opencv.org_modules_features2d_doc_features2d.html]: http://docs.opencv.org/modules/features2d/doc/features2d.html
[http_docs.opencv.org_modules_flann_doc_flann.html]: http://docs.opencv.org/modules/flann/doc/flann.html
[http_www.cs.ubc.ca_mariusm_index.php_FLANN_FLANN]: http://www.cs.ubc.ca/~mariusm/index.php/FLANN/FLANN
[http_blog.csdn.net_icvpr_article_details_8491369]: http://blog.csdn.net/icvpr/article/details/8491369
[20150216183848936]: /images/20220618/6c0be43fcc4a4905b0de1ee3d48f6745.png
[http_download.csdn.net_detail_wangyaninglm_9764301]: http://download.csdn.net/detail/wangyaninglm/9764301
[http_blog.csdn.net_wangyaninglm_article_details_51533549]: http://blog.csdn.net/wangyaninglm/article/details/51533549