閱讀(9.4k) 書簽贊(0) 我要糾錯(cuò)

GPU上的相似性檢查（PNSR和SSIM）

2018-10-25 10:45 更新

目標(biāo)

在OpenCV和相似度測量教程的視頻輸入中，我已經(jīng)介紹了用于檢查兩個(gè)圖像之間的相似性的PSNR和SSIM方法。正如你所看到的，執(zhí)行過程需要相當(dāng)長的一段時(shí)間，特別是在SSIM的情況下。然而，如果CPU的OpenCV實(shí)現(xiàn)的性能數(shù)字不能滿足您的需求，并且您的系統(tǒng)中恰好有一個(gè)NVidia CUDA GPU設(shè)備，則所有這些都不會丟失。您可以嘗試為視頻卡端口或?qū)懭肽膐wm算法。

本教程將很好地掌握如何使用OpenCV的GPU模塊來處理編碼。作為先決條件，您應(yīng)該已經(jīng)知道如何處理core，highgui和imgproc模塊。所以我們的主要目標(biāo)是：

與CPU相比有什么不同？
為PSNR和SSIM創(chuàng)建GPU代碼
優(yōu)化代碼以獲得最大性能

源代碼

您也可以將源代碼和視頻文件放在samples/cpp/tutorial_code/gpu/gpu-basics-similarity/gpu-basics-similarityOpenCV源庫的目錄中或從這里下載。完整的源代碼相當(dāng)長（由于通過命令行參數(shù)和性能測量來控制應(yīng)用程序）。因此，為了避免這些部分與這些部分混亂，這里只有功能本身。

PSNR返回一個(gè)浮點(diǎn)數(shù)，如果兩個(gè)輸入在30和50之間是相似的（越高越好）。

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_CUDA(const Mat& I1, const Mat& I2)
{
    cuda::GpuMat gI1, gI2, gs, t1,t2;
    gI1.upload(I1);
    gI2.upload(I2);
    gI1.convertTo(t1, CV_32F);
    gI2.convertTo(t2, CV_32F);
    cuda::absdiff(t1.reshape(1), t2.reshape(1), gs);
    cuda::multiply(gs, gs, gs);
    Scalar s = cuda::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;
    }
}

struct BufferPSNR                                     // Optimized CUDA versions
{   // Data allocations are very expensive on CUDA. Use a buffer to solve: allocate once reuse later.
    cuda::GpuMat gI1, gI2, gs, t1,t2;
    cuda::GpuMat buf;
};

double getPSNR_CUDA_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);
    cuda::absdiff(b.t1.reshape(1), b.t2.reshape(1), b.gs);
    cuda::multiply(b.gs, b.gs, b.gs);
    double sse = cuda::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;
    }
}

SSIM返回圖像的MSSIM。這也是零和一之間的浮點(diǎn)數(shù)（更高更好），但是每個(gè)通道都有一個(gè)。因此，我們返回一個(gè)Scalar OpenCV數(shù)據(jù)結(jié)構(gòu)：

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;
    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_CUDA( const Mat& i1, const Mat& i2)
{
    const float C1 = 6.5025f, C2 = 58.5225f;
    /***************************** INITS **********************************/
    cuda::GpuMat gI1, gI2, gs1, tmp1,tmp2;
    gI1.upload(i1);
    gI2.upload(i2);
    gI1.convertTo(tmp1, CV_MAKE_TYPE(CV_32F, gI1.channels()));
    gI2.convertTo(tmp2, CV_MAKE_TYPE(CV_32F, gI2.channels()));
    vector<cuda::GpuMat> vI1, vI2;
    cuda::split(tmp1, vI1);
    cuda::split(tmp2, vI2);
    Scalar mssim;
    Ptr<cuda::Filter> gauss = cuda::createGaussianFilter(vI2[0].type(), -1, Size(11, 11), 1.5);
    for( int i = 0; i < gI1.channels(); ++i )
    {
        cuda::GpuMat I2_2, I1_2, I1_I2;
        cuda::multiply(vI2[i], vI2[i], I2_2);        // I2^2
        cuda::multiply(vI1[i], vI1[i], I1_2);        // I1^2
        cuda::multiply(vI1[i], vI2[i], I1_I2);       // I1 * I2
        /*************************** END INITS **********************************/
        cuda::GpuMat mu1, mu2;   // PRELIMINARY COMPUTING
        gauss->apply(vI1[i], mu1);
        gauss->apply(vI2[i], mu2);
        cuda::GpuMat mu1_2, mu2_2, mu1_mu2;
        cuda::multiply(mu1, mu1, mu1_2);
        cuda::multiply(mu2, mu2, mu2_2);
        cuda::multiply(mu1, mu2, mu1_mu2);
        cuda::GpuMat sigma1_2, sigma2_2, sigma12;
        gauss->apply(I1_2, sigma1_2);
        cuda::subtract(sigma1_2, mu1_2, sigma1_2); // sigma1_2 -= mu1_2;
        gauss->apply(I2_2, sigma2_2);
        cuda::subtract(sigma2_2, mu2_2, sigma2_2); // sigma2_2 -= mu2_2;
        gauss->apply(I1_I2, sigma12);
        cuda::subtract(sigma12, mu1_mu2, sigma12); // sigma12 -= mu1_mu2;
        cuda::GpuMat t1, t2, t3;
        mu1_mu2.convertTo(t1, -1, 2, C1); // t1 = 2 * mu1_mu2 + C1;
        sigma12.convertTo(t2, -1, 2, C2); // t2 = 2 * sigma12 + C2;
        cuda::multiply(t1, t2, t3);        // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
        cuda::addWeighted(mu1_2, 1.0, mu2_2, 1.0, C1, t1);       // t1 = mu1_2 + mu2_2 + C1;
        cuda::addWeighted(sigma1_2, 1.0, sigma2_2, 1.0, C2, t2); // t2 = sigma1_2 + sigma2_2 + C2;
        cuda::multiply(t1, t2, t1);                              // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
        cuda::GpuMat ssim_map;
        cuda::divide(t3, t1, ssim_map);      // ssim_map =  t3./t1;
        Scalar s = cuda::sum(ssim_map);
        mssim.val[i] = s.val[0] / (ssim_map.rows * ssim_map.cols);
    }
    return mssim;
}

struct BufferMSSIM                                     // Optimized CUDA versions
{   // Data allocations are very expensive on CUDA. Use a buffer to solve: allocate once reuse later.
    cuda::GpuMat gI1, gI2, gs, t1,t2;
    cuda::GpuMat I1_2, I2_2, I1_I2;
    vector<cuda::GpuMat> vI1, vI2;
    cuda::GpuMat mu1, mu2;
    cuda::GpuMat mu1_2, mu2_2, mu1_mu2;
    cuda::GpuMat sigma1_2, sigma2_2, sigma12;
    cuda::GpuMat t3;
    cuda::GpuMat ssim_map;
    cuda::GpuMat buf;
};

Scalar getMSSIM_CUDA_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b)
{
    const float C1 = 6.5025f, C2 = 58.5225f;
    /***************************** INITS **********************************/
    b.gI1.upload(i1);
    b.gI2.upload(i2);
    cuda::Stream stream;
    b.gI1.convertTo(b.t1, CV_32F, stream);
    b.gI2.convertTo(b.t2, CV_32F, stream);
    cuda::split(b.t1, b.vI1, stream);
    cuda::split(b.t2, b.vI2, stream);
    Scalar mssim;
    Ptr<cuda::Filter> gauss = cuda::createGaussianFilter(b.vI1[0].type(), -1, Size(11, 11), 1.5);
    for( int i = 0; i < b.gI1.channels(); ++i )
    {
        cuda::multiply(b.vI2[i], b.vI2[i], b.I2_2, 1, -1, stream);        // I2^2
        cuda::multiply(b.vI1[i], b.vI1[i], b.I1_2, 1, -1, stream);        // I1^2
        cuda::multiply(b.vI1[i], b.vI2[i], b.I1_I2, 1, -1, stream);       // I1 * I2
        gauss->apply(b.vI1[i], b.mu1, stream);
        gauss->apply(b.vI2[i], b.mu2, stream);
        cuda::multiply(b.mu1, b.mu1, b.mu1_2, 1, -1, stream);
        cuda::multiply(b.mu2, b.mu2, b.mu2_2, 1, -1, stream);
        cuda::multiply(b.mu1, b.mu2, b.mu1_mu2, 1, -1, stream);
        gauss->apply(b.I1_2, b.sigma1_2, stream);
        cuda::subtract(b.sigma1_2, b.mu1_2, b.sigma1_2, cuda::GpuMat(), -1, stream);
        //b.sigma1_2 -= b.mu1_2;  - This would result in an extra data transfer operation
        gauss->apply(b.I2_2, b.sigma2_2, stream);
        cuda::subtract(b.sigma2_2, b.mu2_2, b.sigma2_2, cuda::GpuMat(), -1, stream);
        //b.sigma2_2 -= b.mu2_2;
        gauss->apply(b.I1_I2, b.sigma12, stream);
        cuda::subtract(b.sigma12, b.mu1_mu2, b.sigma12, cuda::GpuMat(), -1, stream);
        //b.sigma12 -= b.mu1_mu2;
        //here too it would be an extra data transfer due to call of operator*(Scalar, Mat)
        cuda::multiply(b.mu1_mu2, 2, b.t1, 1, -1, stream); //b.t1 = 2 * b.mu1_mu2 + C1;
        cuda::add(b.t1, C1, b.t1, cuda::GpuMat(), -1, stream);
        cuda::multiply(b.sigma12, 2, b.t2, 1, -1, stream); //b.t2 = 2 * b.sigma12 + C2;
        cuda::add(b.t2, C2, b.t2, cuda::GpuMat(), -12, stream);
        cuda::multiply(b.t1, b.t2, b.t3, 1, -1, stream);     // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
        cuda::add(b.mu1_2, b.mu2_2, b.t1, cuda::GpuMat(), -1, stream);
        cuda::add(b.t1, C1, b.t1, cuda::GpuMat(), -1, stream);
        cuda::add(b.sigma1_2, b.sigma2_2, b.t2, cuda::GpuMat(), -1, stream);
        cuda::add(b.t2, C2, b.t2, cuda::GpuMat(), -1, stream);
        cuda::multiply(b.t1, b.t2, b.t1, 1, -1, stream);     // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
        cuda::divide(b.t3, b.t1, b.ssim_map, 1, -1, stream);      // ssim_map =  t3./t1;
        stream.waitForCompletion();
        Scalar s = cuda::sum(b.ssim_map, b.buf);
        mssim.val[i] = s.val[0] / (b.ssim_map.rows * b.ssim_map.cols);
    }
    return mssim;
}

怎么做？ - GPU

如上所述，我們對每個(gè)操作有三種類型的功能。一個(gè)用于CPU，另一個(gè)用于GPU。我為GPU制作兩個(gè)原因也說明了將CPU簡單移植到GPU的時(shí)候，實(shí)際上會慢一些。如果你想要一些表現(xiàn)獲得，你將需要記住一些規(guī)則，稍后將詳細(xì)介紹。

GPU模塊的開發(fā)使其盡可能類似于其CPU對應(yīng)。這使得移植過程更容易。在編寫任何代碼之前，您需要做的第一件事是將GPU模塊鏈接到項(xiàng)目，并包含模塊的頭文件。GPU的所有功能和數(shù)據(jù)結(jié)構(gòu)都位于cv命名空間的gpu子命名空間中。您可以通過use namespace關(guān)鍵字將其添加到默認(rèn)值，或者通過cv ::顯式地標(biāo)記它，以避免混淆。我稍后會做。

#include <opencv2/gpu.hpp>        // GPU structures and methods

GPU代表“圖形處理單元”。它最初是為了渲染圖形場景而構(gòu)建的。這些場景以某種方式建立在很多數(shù)據(jù)上。然而，這些并不都是以順序的方式彼此依賴的，并且它們可以并行處理它們。由于這一點(diǎn)，GPU將包含多個(gè)較小的處理單元。這些不是最先進(jìn)的處理器，而是在一個(gè)一個(gè)測試中與一個(gè)CPU會落后。然而，其實(shí)力在于其數(shù)量。在過去的幾年中，在非圖形場景中收獲GPU的巨大并行力量已經(jīng)呈上升趨勢; 渲染也是如此。這產(chǎn)生了圖形處理單元（GPGPU）的通用計(jì)算。

GPU有自己的內(nèi)存。當(dāng)您使用OpenCV從硬盤驅(qū)動器讀取數(shù)據(jù)到系統(tǒng)內(nèi)存中發(fā)生的Mat對象時(shí)。CPU直接在此（通過其緩存）工作，但是GPU不能。它必須將計(jì)算所需的信息從系統(tǒng)內(nèi)存?zhèn)鬏數(shù)狡渥陨?。這是通過上傳過程完成的，并且耗時(shí)。最后，結(jié)果將不得不下載回您的系統(tǒng)內(nèi)存，讓您的CPU看到并使用它。不推薦將小功能移植到GPU，因?yàn)樯蟼?下載時(shí)間將大于并行執(zhí)行所獲得的數(shù)量。

Mat對象僅存儲在系統(tǒng)內(nèi)存（或CPU緩存）中。要獲得OpenCV矩陣到GPU，您需要使用其GPU對應(yīng)的cv :: cuda :: GpuMat。它的作用類似于僅具有2D限制的Mat，并且沒有參考返回其功能（不能將GPU引用與CPU混合）。要將Mat對象上傳到GPU，您需要在創(chuàng)建類的實(shí)例之后調(diào)用upload功能。要下載，您可以使用Mat對象的簡單分配或使用下載功能。

Mat I1;         // Main memory item - read image into with imread for example
gpu::GpuMat gI; // GPU matrix - for now empty
gI1.upload(I1); // Upload a data from the system memory to the GPU memory
I1 = gI1;       // Download, gI1.download(I1) will work too

一旦你的數(shù)據(jù)在GPU內(nèi)存中，你可以調(diào)用OpenCV的GPU啟用功能。大多數(shù)功能與CPU相同，名稱與GpuMat輸入不同。您可以在文檔中找到這些的完整列表：在這里或源代碼附帶的OpenCV參考手冊。

要記住的另一件事是，不是所有的頻道號碼都可以在GPU上制作高效的算法。一般來說，我發(fā)現(xiàn)GPU圖像的輸入圖像需要是一個(gè)或四個(gè)通道圖像，而一個(gè)char或float類型用于項(xiàng)目大小。對GPU沒有雙重支持，對不起。傳遞某些功能的其他類型的對象將導(dǎo)致異常拋出，并在錯(cuò)誤輸出上顯示錯(cuò)誤消息。大多數(shù)地方的輸入文件接受的類型的文檔詳細(xì)信息。如果您有三個(gè)通道圖像作為輸入，您可以做兩件事情：添加新的通道（并使用char元素）或分割圖像并調(diào)用每個(gè)圖像的功能。第一個(gè)不是真的推薦，因?yàn)檫@浪費(fèi)了浪費(fèi)存儲空間。

對于某些功能，元素（鄰居項(xiàng)目）的位置無關(guān)緊要，快速解決方案是將其重新形成單個(gè)通道圖像。這是PSNR實(shí)現(xiàn)的情況，對于absdiff方法，鄰居的值不重要。然而，對于GaussianBlur，這不是一個(gè)選項(xiàng)，因此需要使用分割方法來進(jìn)行SSIM。有了這個(gè)知識，你可以制作一個(gè)GPU可行的代碼（像我的GPU一個(gè)），并運(yùn)行它。您會驚訝地發(fā)現(xiàn)，它可能會比您的CPU執(zhí)行速度慢。

優(yōu)化

這樣做的原因是您在窗口上扔出內(nèi)存分配和數(shù)據(jù)傳輸?shù)膬r(jià)格。在GPU上，這是很高的。優(yōu)化的另一種可能性是在cv :: cuda :: Stream的幫助下引入異步OpenCV GPU調(diào)用。

GPU上的內(nèi)存分配相當(dāng)可觀。因此，如果可能的話，盡可能多地分配新的內(nèi)存。如果你創(chuàng)建一個(gè)函數(shù)你打算多次調(diào)用，最好在第一次調(diào)用期間為函數(shù)分配一次本地參數(shù)一次。為此，您將創(chuàng)建一個(gè)包含將使用的所有局部變量的數(shù)據(jù)結(jié)構(gòu)。例如在PSNR的情況下，這些是：

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

然后在主程序中創(chuàng)建一個(gè)這樣的實(shí)例：

BufferPSNR bufferPSNR;

最后把它傳給函數(shù)，每次你調(diào)用它：

double getPSNR_GPU_optimized（const Mat＆I1，const Mat＆I2，BufferPSNR＆b）

現(xiàn)在，您可以訪問這些本地參數(shù)：b.gI1，b.buf等。如果新的矩陣大小與上一個(gè)矩陣的大小不同，GpuMat將僅重新分配一個(gè)新的調(diào)用。

避免不必要的功能數(shù)據(jù)傳輸一旦你去GPU，任何小的數(shù)據(jù)傳輸將是重要的。因此，如果可能的話，現(xiàn)在就進(jìn)行所有的計(jì)算（換句話說，不會創(chuàng)建新的內(nèi)存對象 - 由于上一點(diǎn)說明的原因）。例如，雖然表達(dá)算術(shù)操作可能更容易以一行公式表示，但是會更慢。在SSIM的情況下，我需要計(jì)算：

b.t1 = 2 * b.mu1_mu2 + C1;

雖然上層呼叫會成功，但請注意存在隱藏的數(shù)據(jù)傳輸。在它添加之前，它需要在某個(gè)地方存儲乘法。因此，它將在后臺創(chuàng)建一個(gè)局部矩陣，并將其添加到C1值，最后將其分配給t1。為了避免這種情況，我們使用gpu函數(shù)，而不是算術(shù)運(yùn)算符：

gpu :: multiply（b.mu1_mu2，2，b.t1）; //b.t1 = 2 * b.mu1_mu2 + C1;
gpu :: add（b.t1，C1，b.t1）;

使用asynchronous調(diào)用（cv :: cuda :: Stream）。默認(rèn)情況下，只要您調(diào)用GPU功能，它將等待調(diào)用完成，然后返回結(jié)果。然而，可以進(jìn)行asynchronous調(diào)用，這意味著它將調(diào)用操作執(zhí)行，從而為算法提供昂貴的數(shù)據(jù)分配并立即返回?，F(xiàn)在你可以調(diào)用另一個(gè)函數(shù)，如果你愿意的話。對于MSSIM，這是一個(gè)很小的優(yōu)化點(diǎn)。在我們的默認(rèn)實(shí)現(xiàn)中，我們將圖像分解為通道，并為GPU的每個(gè)通道調(diào)用它們。流可以進(jìn)行小程度的并行化。通過使用流，我們可以在GPU已經(jīng)執(zhí)行給定的方法時(shí)進(jìn)行數(shù)據(jù)分配，上傳操作。例如，我們需要上傳兩個(gè)圖像。我們一個(gè)接一個(gè)地排隊(duì)，并調(diào)用處理它的功能。

gpu::Stream stream;
stream.enqueueConvert(b.gI1, b.t1, CV_32F);    // Upload
gpu::split(b.t1, b.vI1, stream);              // Methods (pass the stream as final parameter).
gpu::multiply(b.vI1[i], b.vI1[i], b.I1_2, stream);        // I1^2

結(jié)果和結(jié)論

在配備低端NVidia GT220M的Intel P8700筆記本電腦CPU上，性能數(shù)字如下：

Time of PSNR CPU (averaged for 10 runs): 41.4122 milliseconds. With result of: 19.2506
Time of PSNR GPU (averaged for 10 runs): 158.977 milliseconds. With result of: 19.2506
Initial call GPU optimized:              31.3418 milliseconds. With result of: 19.2506
Time of PSNR GPU OPTIMIZED ( / 10 runs): 24.8171 milliseconds. With result of: 19.2506
Time of MSSIM CPU (averaged for 10 runs): 484.343 milliseconds. With result of B0.890964 G0.903845 R0.936934
Time of MSSIM GPU (averaged for 10 runs): 745.105 milliseconds. With result of B0.89922 G0.909051 R0.968223
Time of MSSIM GPU Initial Call            357.746 milliseconds. With result of B0.890964 G0.903845 R0.936934
Time of MSSIM GPU OPTIMIZED ( / 10 runs): 203.091 milliseconds. With result of B0.890964 G0.903845 R0.936934

在這兩種情況下，與CPU執(zhí)行相比，我們的性能提升了近100％。這可能只是您的應(yīng)用程序工作所需的改進(jìn)

以上內(nèi)容是否對您有幫助：

← 高級拼接API（Stitcher類）

使用cv :: cuda :: GpuMat推力（thrust） →

寫筆記

我要補(bǔ)充

GPU上的相似性檢查（PNSR和SSIM）

目標(biāo)

源代碼

怎么做？ - GPU

優(yōu)化

結(jié)果和結(jié)論

怎么做？ - GPU