目标

在使用OpenCV进行视频输入和相似性测量教程中，我已经介绍了用于检查两张图像相似性的PSNR和SSIM方法。正如你所看到的，执行过程相当耗时，尤其是在SSIM的情况下。然而，如果OpenCV针对CPU的实现性能不能满足你的需求，并且你的系统恰好拥有NVIDIA CUDA GPU设备，那么一切都还没有失去。你可以尝试将自己的算法移植或编写到显卡上。

本教程将详细介绍如何使用OpenCV的GPU模块进行编码。作为先决条件，你应该已经知道如何处理core、highgui和imgproc模块。所以，我们的主要目标是：

与CPU相比有什么不同？
为PSNR和SSIM创建GPU代码
优化代码以获得最大性能

源代码

你也可以在OpenCV源库的samples/cpp/tutorial_code/gpu/gpu-basics-similarity/gpu-basics-similarity目录中找到源代码和视频文件，或者从此处下载。完整的源代码相当长（由于通过命令行参数控制应用程序和性能测量）。因此，为了避免这些部分过于混乱，这里只提供了函数本身。

PSNR返回一个浮点数，如果两个输入图像相似，该值介于30到50之间（越高越好）。

double getPSNR(const Mat& I1, const Mat& I2)
{
    Mat s1;
    absdiff(I1, I2, s1); // |I1 - I2|
s1.convertTo(s1, CV_32F); // 不能对8位值进行平方运算
s1 = s1.mul(s1); // |I1 - I2|^2
 
    Scalar s = sum(s1); // 每通道求和
 
    double sse = s.val[0] + s.val[1] + s.val[2]; // 各通道求和
 
    if( sse <= 1e-10) // 对于小值返回零
        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) // 对于小值返回零
        return 0;
    else
    {
        double mse =sse /(double)(gI1.channels() * I1.total());
        double psnr = 10.0*log10((255*255)/mse);
        return psnr;
    }
}

struct BufferPSNR // 优化的CUDA版本
{ // 在CUDA上数据分配非常昂贵。使用缓冲区解决：分配一次，以后重复使用。
    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) // 对于小值返回零
        return 0;
    else
    {
        double mse = sse /(double)(I1.channels() * I1.total());
        double psnr = 10.0*log10((255*255)/mse);
        return psnr;
    }
}

SSIM返回图像的MSSIM。这也是一个介于零和一之间的浮点数（越高越好），但是每个通道有一个值。因此，我们返回一个Scalar OpenCV数据结构

Scalar getMSSIM( const Mat& i1, const Mat& i2)
{
    const double C1 = 6.5025, C2 = 58.5225;
/***************************** 初始化 **********************************/
    int d = CV_32F;
 
    Mat I1, I2;
i1.convertTo(I1, d); // 不能在一个字节大的值上计算
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
 
/*************************** 初始化结束 **********************************/
 
    Mat mu1, mu2; // 初步计算
    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 = ssim图的平均值
    return mssim;
}

Scalar getMSSIM_CUDA( const Mat& i1, const Mat& i2)
{
    const float C1 = 6.5025f, C2 = 58.5225f;
/***************************** 初始化 **********************************/
    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
 
/*************************** 初始化结束 **********************************/
        cuda::GpuMat mu1, mu2; // 初步计算
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 // 优化的CUDA版本
{ // 在CUDA上数据分配非常昂贵。使用缓冲区解决：分配一次，以后重复使用。
    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;
/***************************** 初始化 **********************************/
 
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; - 这会导致额外的数据传输操作
 
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;
 
        //这里也会因为调用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

如上所示，每种操作我们都有三种类型的函数。一个用于CPU，两个用于GPU。我为GPU制作了两个版本的原因是为了说明，简单地将CPU代码移植到GPU上实际上可能会使其变慢。如果你想获得一些性能提升，你需要记住一些规则，我将在后面详细介绍。

GPU模块的开发旨在尽可能地与CPU对应版本相似。这使得移植过程更容易。在编写任何代码之前，你需要做的第一件事是将GPU模块链接到你的项目，并包含该模块的头文件。GPU的所有函数和数据结构都位于cv命名空间的gpu子命名空间中。你可以通过use namespace关键字将其添加到默认命名空间，或者通过cv::在所有地方显式标记它以避免混淆。我将采用后者。

#include <opencv2/gpu.hpp> // GPU结构和方法

GPU是“图形处理单元”的缩写。它最初是为了渲染图形场景而构建的。这些场景在某种程度上建立在大量数据之上。然而，这些数据并非以顺序方式相互依赖，并且可以进行并行处理。因此，GPU将包含多个较小的处理单元。这些不是最先进的处理器，在一对一测试中，它们会落后于CPU。然而，其优势在于其数量。近年来，将GPU这些大规模并行能力用于非图形场景（也包括渲染）的趋势日益增长。这催生了图形处理单元上的通用计算（GPGPU）。

GPU有自己的内存。当你使用OpenCV从硬盘读取数据到Mat对象时，这发生在你的系统内存中。CPU通过其缓存直接处理这些数据，但GPU不能。它必须将计算所需的信息从系统内存传输到自己的内存中。这是通过上传过程完成的，并且耗时。最终，结果必须下载回系统内存，供CPU查看和使用。不建议将小型函数移植到GPU，因为上传/下载时间将大于并行执行所获得的收益。

Mat对象仅存储在系统内存（或CPU缓存）中。要将OpenCV矩阵获取到GPU，你需要使用其GPU对应项cv::cuda::GpuMat。它的工作方式与Mat类似，但仅限于2D，并且其函数不返回引用（不能混合GPU引用和CPU引用）。要将Mat对象上传到GPU，你需要创建类的实例后调用upload函数。要下载，你可以直接赋值给Mat对象或使用download函数。

Mat I1; // 主内存项 - 例如，用imread读取图像到此
gpu::GpuMat gI; // GPU矩阵 - 目前为空
gI1.upload(I1); // 将数据从系统内存上传到GPU内存
 
I1 = gI1; // 下载，gI1.download(I1) 也可以

一旦你的数据上传到GPU内存中，你就可以调用OpenCV中支持GPU的函数。大多数函数与CPU上的函数名称相同，区别在于它们只接受GpuMat输入。

另一点需要记住的是，并非所有通道数的图像都能在GPU上高效地实现算法。通常，我发现GPU图像的输入图像需要是单通道或四通道的，并且元素大小为char或float类型。抱歉，GPU不支持double类型。对于某些函数，传入其他类型的对象会导致抛出异常，并在错误输出上显示错误消息。文档在大多数地方详细说明了输入所接受的类型。如果你有三通道图像作为输入，你可以做两件事：要么添加一个新通道（并使用char元素），要么拆分图像并为每个图像调用函数。第一种方法不建议使用，因为它会浪费内存。

对于某些函数，元素的（相邻项的）位置不重要时，快速解决方案是将其重塑为单通道图像。PSNR实现就是这种情况，因为对于absdiff方法，邻居的值不重要。然而，对于GaussianBlur，这不是一个选项，因此SSIM需要使用split方法。有了这些知识，你可以制作可行的GPU代码（就像我的GPU代码一样）并运行它。你会惊讶地发现它可能比你的CPU实现慢。

优化

这是因为你将内存分配和数据传输的成本抛诸脑后。在GPU上，这个成本非常高。另一种优化可能性是借助cv::cuda::Stream引入异步OpenCV GPU调用。

GPU上的内存分配成本相当大。因此，如果可能的话，尽可能少地分配新内存。如果你创建一个打算多次调用的函数，那么一个好主意是在第一次调用时只分配函数的所有局部参数。为此，你可以创建一个包含所有将使用的局部变量的数据结构。例如，在PSNR的情况下，这些变量是：
struct BufferPSNR // 优化的GPU版本

{ // 在GPU上数据分配非常昂贵。使用缓冲区解决：分配一次，以后重复使用。

gpu::GpuMat gI1, gI2, gs, t1,t2;

gpu::GpuMat buf;

};

然后在主程序中创建它的一个实例
BufferPSNR bufferPSNR;

最后，每次调用时都将其传递给函数
double getPSNR_GPU_optimized(const Mat& I1, const Mat& I2, BufferPSNR& b)

现在你可以这样访问这些局部参数：b.gI1、b.buf等等。只有当新矩阵的大小与前一个不同时，GpuMat才会重新分配内存。
避免不必要的功能数据传输。一旦你转向GPU，任何小的数据传输都会变得非常重要。因此，如果可能，请进行所有就地计算（换句话说，不要创建新的内存对象——原因在上一节中已解释）。例如，尽管算术运算可能更容易用一行公式表达，但它会更慢。在SSIM的情况下，我需要计算：
b.t1 = 2 * b.mu1_mu2 + C1;

尽管上面的调用会成功，但请注意，其中存在一个隐藏的数据传输。在进行加法之前，它需要将乘法结果存储在某个地方。因此，它会在后台创建一个局部矩阵，将C1值添加到其中，最后将其赋值给t1。为了避免这种情况，我们使用gpu函数而不是算术运算符：
gpu::multiply(b.mu1_mu2, 2, b.t1); //b.t1 = 2 * b.mu1_mu2 + C1;

gpu::add(b.t1, C1, b.t1);
使用异步调用（cv::cuda::Stream）。默认情况下，每当你调用一个GPU函数时，它都会等待调用完成并返回结果。然而，可以进行异步调用，这意味着它会调用操作执行，为算法进行昂贵的数据分配，然后立即返回。现在你可以调用另一个函数，如果你愿意的话。对于MSSIM，这是一个小的优化点。在我们的默认实现中，我们将图像拆分为通道，并为每个通道调用GPU函数。通过流可以实现小程度的并行化。通过使用流，我们可以在GPU已经在执行给定方法时进行数据分配和上传操作。例如，我们需要上传两张图像。我们将它们一个接一个地排队，然后调用处理它们的函数。函数将等待上传完成，但在此期间，它会为下一个要执行的函数进行输出缓冲区分配。
gpu::Stream stream;

stream.enqueueConvert(b.gI1, b.t1, CV_32F); // 上传

gpu::split(b.t1, b.vI1, stream); // 方法（将流作为最后一个参数传递）。

gpu::multiply(b.vI1[i], b.vI1[i], b.I1_2, stream); // I1^2

CV_32F
#define CV_32F
Definition interface.h:78

结果和结论

在配备低端NVIDIA GT220M的Intel P8700笔记本电脑CPU上，性能数据如下：

PSNR CPU时间（10次运行平均）：41.4122毫秒。结果：19.2506
PSNR GPU时间（10次运行平均）：158.977毫秒。结果：19.2506
GPU优化初始调用：31.3418毫秒。结果：19.2506
PSNR GPU优化时间（/ 10次运行）：24.8171毫秒。结果：19.2506
 
MSSIM CPU时间（10次运行平均）：484.343毫秒。结果为B0.890964 G0.903845 R0.936934
MSSIM GPU时间（10次运行平均）：745.105毫秒。结果为B0.89922 G0.909051 R0.968223
MSSIM GPU初始调用时间：357.746毫秒。结果为B0.890964 G0.903845 R0.936934
MSSIM GPU优化时间（/ 10次运行）：203.091毫秒。结果为B0.890964 G0.903845 R0.936934

在这两种情况下，我们都实现了与CPU实现相比近100%的性能提升。这可能正是你的应用程序工作所需的改进。你可以在YouTube上观看此功能的运行时实例。