目标

在使用 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;
 
        //这里也会由于调用运算符*(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 类似，但仅限于二维，并且其函数不返回引用（不能将 GPU 引用与 CPU 引用混合使用）。要将 Mat 对象上传到 GPU，你需要在创建该类实例后调用上传函数。要下载，你可以使用简单的赋值操作将其赋给 Mat 对象，或者使用下载函数。

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。有了这些知识，你就可以编写可行的 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

结果和结论

在一台配备低端 NVIDIA GT220M 显卡的 Intel P8700 笔记本电脑上，性能数据如下

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 上查看一个运行实例。