使用 OpenCV 进行视频输入和相似度测量

于 2025-01-14 13:04:16 发布
阅读量101 收藏
点赞数
文章标签： webpack 前端 node.js
原文链接：https://docs.opencv.org/4.x/d5/dc4/tutorial_video_input_psnr_ssim.html
版权
原作者贝尔纳特·加博
兼容性OpenCV >= 3.0

目标

如今，拥有数字视频录制系统已是常有的事。因此，您最终会遇到这样的情况：您不再处理一批图像，而是处理视频流。这些视频流可能有两种：实时图像馈送（在网络摄像头的情况下）或预先录制并存储在硬盘驱动器上的文件。幸运的是，OpenCV 以相同的方式处理这两者，使用相同的 C++ 类。因此，您将在本教程中学习以下内容：

  • 如何打开和阅读视频流
  • 检查图像相似性的两种方法：PSNR 和 SSIM

源代码C++

为了使用 OpenCV 展示这些内容，我创建了一个小程序，用于读取两个视频文件并执行相似性检查。您可以使用它来检查新视频压缩算法的效果。假设有一个参考（原始）视频，例如这个小型 Megamind 剪辑和它的压缩版本samples/data。您还可以在OpenCV 源库文件夹中找到源代码和这些视频文件。

#include <iostream> // for standard I/O
#include <string>   // for strings
#include <iomanip>  // for controlling float print precision
#include <sstream>  // string to number conversion

#include <opencv2/core.hpp>     // Basic OpenCV structures (cv::Mat, Scalar)
#include <opencv2/imgproc.hpp>  // Gaussian Blur
#include <opencv2/videoio.hpp>
#include <opencv2/highgui.hpp>  // OpenCV window I/O

using namespace std;
using namespace cv;

double getPSNR ( const Mat& I1, const Mat& I2);
Scalar getMSSIM( const Mat& I1, const Mat& I2);

static void help()
{
    cout
        << "------------------------------------------------------------------------------" << endl
        << "This program shows how to read a video file with OpenCV. In addition, it "
        << "tests the similarity of two input videos first with PSNR, and for the frames "
        << "below a PSNR trigger value, also with MSSIM."                                   << endl
        << "Usage:"                                                                         << endl
        << "./video-input-psnr-ssim <referenceVideo> <useCaseTestVideo> <PSNR_Trigger_Value> <Wait_Between_Frames> " << endl
        << "--------------------------------------------------------------------------"     << endl
        << endl;
}

int main(int argc, char *argv[])
{
    help();

    if (argc != 5)
    {
        cout << "Not enough parameters" << endl;
        return -1;
    }

    stringstream conv;

    const string sourceReference = argv[1], sourceCompareWith = argv[2];
    int psnrTriggerValue, delay;
    conv << argv[3] << endl << argv[4];       // put in the strings
    conv >> psnrTriggerValue >> delay;        // take out the numbers

    int frameNum = -1;          // Frame counter

    VideoCapture captRefrnc(sourceReference), captUndTst(sourceCompareWith);

    if (!captRefrnc.isOpened())
    {
        cout  << "Could not open reference " << sourceReference << endl;
        return -1;
    }

    if (!captUndTst.isOpened())
    {
        cout  << "Could not open case test " << sourceCompareWith << endl;
        return -1;
    }

    Size refS = Size((int) captRefrnc.get(CAP_PROP_FRAME_WIDTH),
                     (int) captRefrnc.get(CAP_PROP_FRAME_HEIGHT)),
         uTSi = Size((int) captUndTst.get(CAP_PROP_FRAME_WIDTH),
                     (int) captUndTst.get(CAP_PROP_FRAME_HEIGHT));

    if (refS != uTSi)
    {
        cout << "Inputs have different size!!! Closing." << endl;
        return -1;
    }

    const char* WIN_UT = "Under Test";
    const char* WIN_RF = "Reference";

    // Windows
    namedWindow(WIN_RF, WINDOW_AUTOSIZE);
    namedWindow(WIN_UT, WINDOW_AUTOSIZE);
    moveWindow(WIN_RF, 400       , 0);         //750,  2 (bernat =0)
    moveWindow(WIN_UT, refS.width, 0);         //1500, 2

    cout << "Reference frame resolution: Width=" << refS.width << "  Height=" << refS.height
         << " of nr#: " << captRefrnc.get(CAP_PROP_FRAME_COUNT) << endl;

    cout << "PSNR trigger value " << setiosflags(ios::fixed) << setprecision(3)
         << psnrTriggerValue << endl;

    Mat frameReference, frameUnderTest;
    double psnrV;
    Scalar mssimV;

    for(;;) //Show the image captured in the window and repeat
    {
        captRefrnc >> frameReference;
        captUndTst >> frameUnderTest;

        if (frameReference.empty() || frameUnderTest.empty())
        {
            cout << " < < <  Game over!  > > > ";
            break;
        }

        ++frameNum;
        cout << "Frame: " << frameNum << "# ";

        psnrV = getPSNR(frameReference,frameUnderTest);
        cout << setiosflags(ios::fixed) << setprecision(3) << psnrV << "dB";

        if (psnrV < psnrTriggerValue && psnrV)
        {
            mssimV = getMSSIM(frameReference, frameUnderTest);

            cout << " MSSIM: "
                << " R " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[2] * 100 << "%"
                << " G " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[1] * 100 << "%"
                << " B " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[0] * 100 << "%";
        }

        cout << endl;

        imshow(WIN_RF, frameReference);
        imshow(WIN_UT, frameUnderTest);

        char c = (char)waitKey(delay);
        if (c == 27) break;
    }

    return 0;
}

// ![get-psnr]
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;
    }
}
// ![get-psnr]

// ![get-mssim]

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;
}
// ![get-mssim]

 

如何读取视频流（在线相机或离线文件）？

本质上，视频处理所需的所有功能都集成在cv::VideoCapture C++ 类中。它本身基于 FFmpeg 开源库。这是 OpenCV 的基本依赖项，因此您不必担心这一点。视频由一系列图像组成，我们在文献中将它们称为帧。对于视频文件，有一个帧速率，指定两帧之间的时间长度。虽然对于摄像机来说，它们每秒可以数字化的帧数通常有一个限制，但这个属性并不那么重要，因为在任何时候，摄像机都会看到当前的世界快照。

您需要做的第一件事是为cv::VideoCapture类分配其源。您可以通过cv::VideoCapture::VideoCapture或其cv::VideoCapture::open函数执行此操作。如果此参数是整数，那么您将把该类绑定到相机（设备）。此处传递的数字是操作系统分配的设备 ID。如果您的系统上连接了一台相机，其 ID 可能为零，然后从零开始逐渐增加。如果传递给这些的参数是字符串，它将引用视频文件，字符串指向文件的位置和名称。例如，对于上层源代码，有效的命令行是：

video/Megamind.avi video/Megamind_bug.avi  35 10

我们进行相似性检查。这需要参考和测试用例视频文件。前两个参数指的是这个。这里我们使用相对地址。这意味着应用程序将查看其当前工作目录并打开视频文件夹，并尝试在其中找到Megamind.avi和Megamind_bug.avi。

const string sourceReference = argv[1],sourceCompareWith = argv[2];

VideoCapture captRefrnc(sourceReference);
// or
VideoCapture captUndTst;
captUndTst.open(sourceCompareWith);

要检查类与视频源的绑定是否成功，请使用cv::VideoCapture::isOpened函数：

if ( !captRefrnc.isOpened())
  {
  cout  << "Could not open reference " << sourceReference << endl;
  return -1;
  }

当对象析构函数被调用时，视频会自动关闭。但是，如果你想在此之前关闭它，你需要调用它的cv::VideoCapture::release函数。视频的帧只是简单的图像。因此，我们只需要从cv::VideoCapture对象中提取它们并将它们放在Mat对象中。视频流是连续的。你可以通过cv::VideoCapture::read或重载的 >> 运算符一个接一个地获取帧：

Mat frameReference, frameUnderTest;
captRefrnc >> frameReference;
captUndTst.read(frameUnderTest);

如果无法获取任何帧（无论是由于视频流已关闭还是您已到达视频文件的末尾），则上层读取操作将使Mat对象为空。我们可以使用一个简单的 if 来检查这一点：

if( frameReference.empty()  || frameUnderTest.empty())
{
 // exit the program
}

读取方法由帧抓取和对帧进行解码组成。您可以使用cv::VideoCapture::grab和cv::VideoCapture::retrieve函数显式调用这两个函数。

除了帧的内容之外，视频还附加了许多信息。这些信息通常是数字，但在某些情况下可能是短字符序列（4 个字节或更少）。因此，为了获取这些信息，有一个名为cv::VideoCapture::get的通用函数，它返回包含这些属性的双精度值。使用按位运算从双精度类型解码字符，并进行转换，其中有效值仅为整数。它的唯一参数是查询属性的 ID。例如，在这里我们得到参考和测试用例视频文件中帧的大小；加上参考内的帧数。

Size refS = Size((int) captRefrnc.get(CAP_PROP_FRAME_WIDTH),
                 (int) captRefrnc.get(CAP_PROP_FRAME_HEIGHT)),

cout << "Reference frame resolution: Width=" << refS.width << "  Height=" << refS.height
     << " of nr#: " << captRefrnc.get(CAP_PROP_FRAME_COUNT) << endl;

处理视频时，您可能经常想要自己控制这些值。为此，有一个cv::VideoCapture::set函数。它的第一个参数仍然是要更改的属性的名称，第二个参数为 double 类型，包含要设置的值。如果成功，它将返回 true，否则返回 false。一个很好的例子是在视频文件中搜索给定的时间或帧：

captRefrnc.set(CAP_PROP_POS_MSEC, 1.2);  // go to the 1.2 second in the video
captRefrnc.set(CAP_PROP_POS_FRAMES, 10); // go to the 10th frame of the video
// now a read operation would read the frame at the set position

对于您可以阅读和更改的属性，请查看cv::VideoCapture::get和cv::VideoCapture::set函数的文档。

图像相似度——PSNR 和 SSIM

C++Python

我们想要检查视频转换操作的细微程度，因此我们需要一个系统来逐帧检查相似性或差异性。最常用的算法是 PSNR（又称峰值信噪比）。其最简单的定义是从均方误差开始。假设有两幅图像：I1 和 I2；二维尺寸为 i 和 j，由 c 个通道组成。

则PSNR表示为：

这里米一个十我是像素的最大有效值。对于每个像素每个通道的简单单字节图像，该值为 255。当两个图像相同时，MSE 将为零，导致 PSNR 公式中的除以零操作无效。在这种情况下，PSNR 未定义，我们需要单独处理这种情况。转换为对数刻度是因为像素值具有非常宽的动态范围。所有这些转换为 OpenCV，函数如下所示：

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

对于视频压缩，结果值通常介于 30 和 50 之间，值越高越好。如果图像明显不同，结果值会低得多，例如 15 等。这种相似性检查计算起来简单快捷，但在实践中，它可能与人眼感知有些不一致。结构相似性算法旨在纠正这个问题。

描述这些方法远远超出了本教程的目的。为此，我邀请您阅读介绍它的文章。不过，您可以通过查看下面的 OpenCV 实现来获得它的良好印象。

笔记

SSIM 在以下文章中有更深入的描述：“Z. Wang、AC Bovik、HR Sheikh 和 EP Simoncelli，《图像质量评估：从错误可见性到结构相似性》，《IEEE 图像处理学报》，第 13 卷，第 4 期，第 600-612 页，2004 年 4 月。”


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

这将返回图像每个通道的相似性指数。该值介于 0 和 1 之间，其中 1 表示完美匹配。不幸的是，许多高斯模糊的成本相当高，因此虽然 PSNR 可以在实时环境中（每秒 24 帧）工作，但要实现类似的性能结果，这将花费更多时间。

因此，本教程开头提供的源代码将对每一帧执行 PSNR 测量，并仅对 PSNR 低于输入值的帧执行 SSIM 测量。为了实现可视化，我们在 OpenCV 窗口中显示两个图像，并将 PSNR 和 MSSIM 值打印到控制台。预计会看到类似以下内容：

您可以在此处的 YouTube上观看此运行时实例。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值