目标

在使用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 map 的平均值
    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 使用 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
定义 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 上观看运行实例。