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

目录

• 目标
• 源代码
• 如何读取视频流（在线摄像头或离线文件）？
  • 图像相似性 - PSNR 和 SSIM

上一个教程： 使用 GDAL 读取地理空间栅格文件
下一个教程： 使用 OpenCV 创建视频

原作者	Bernát Gábor
兼容性	OpenCV >= 3.0

目标

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

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

源代码

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

C++

#include <iostream> // 用于标准 I/O
#include <string> // 用于字符串
#include <iomanip> // 用于控制浮点数打印精度
#include <sstream> // 字符串到数字转换
 
#include <opencv2/core.hpp> // 基本 OpenCV 结构 (cv::Mat, Scalar)
#include <opencv2/imgproc.hpp> // 高斯模糊
#include <opencv2/videoio.hpp>
#include <opencv2/highgui.hpp> // OpenCV 窗口 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
<< "此程序演示如何使用 OpenCV 读取视频文件。此外，它"
<< "首先使用 PSNR 测试两个输入视频的相似性，对于"
<< "低于 PSNR 触发值的帧，也使用 MSSIM。" << endl
<< "用法：" << 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 << "参数不足" << endl;
        return -1;
    }
 
stringstream conv;
 
    const string sourceReference = argv[1], sourceCompareWith = argv[2];
    int psnrTriggerValue, delay;
conv << argv[3] << endl << argv[4]; // 放入字符串
conv >> psnrTriggerValue >> delay; // 取出数字
 
    int frameNum = -1; // 帧计数器
 
    VideoCapture captRefrnc(sourceReference), captUndTst(sourceCompareWith);
 
    if (!captRefrnc.isOpened())
    {
cout << "无法打开参考 " << sourceReference << endl;
        return -1;
    }
 
    if (!captUndTst.isOpened())
    {
cout << "无法打开测试用例 " << 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 << "输入视频尺寸不同！正在关闭。" << endl;
        return -1;
    }
 
    const char* WIN_UT = "测试中";
    const char* WIN_RF = "参考";
 
    // 窗口
    namedWindow(WIN_RF, WINDOW_AUTOSIZE);
    namedWindow(WIN_UT, WINDOW_AUTOSIZE);
    moveWindow(WIN_RF, 400 , 0); //750, 2 (伯纳特 =0)
    moveWindow(WIN_UT, refS.width, 0); //1500, 2
 
cout << "参考帧分辨率：宽度=" << refS.width << " 高度=" << refS.height
<< " 帧数#: " << captRefrnc.get(CAP_PROP_FRAME_COUNT) << endl;
 
cout << "PSNR 触发值 " << setiosflags(ios::fixed) << setprecision(3)
<< psnrTriggerValue << endl;
 
    Mat frameReference, frameUnderTest;
    double psnrV;
    Scalar mssimV;
 
    for(;;) //在窗口中显示捕获的图像并重复
    {
captRefrnc >> frameReference;
captUndTst >> frameUnderTest;
 
        if (frameReference.empty() || frameUnderTest.empty())
        {
cout << " < < < 游戏结束！ > > > ";
            break;
        }
 
++frameNum;
cout << "帧: " << 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); // 不能在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) // 对于非常小的值，返回 360 来限制 PSNR（理论值为无穷大）
        return 360.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;
/***************************** 初始化 **********************************/
    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;
}
// ![get-mssim]

Python

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
# Python 2/3 兼容性
from __future__ import print_function
 
import numpy as np
import cv2 as cv
import argparse
import sys
 
# [get-psnr]
def getPSNR(I1, I2)
s1 = cv.absdiff(I1, I2) #|I1 - I2|
s1 = np.float32(s1) # 不能在 8 位上进行平方计算
s1 = s1 * s1 # |I1 - I2|^2
sse = s1.sum() # 按通道求和
    if sse <= 1e-10: # 通道求和
        return 360 # 对于非常小的 SSE，返回 360 来限制 PSNR（理论值为无穷大）
    else:
shape = I1.shape
mse = 1.0 * sse / (shape[0] * shape[1] * shape[2])
psnr = 10.0 * np.log10((255 * 255) / mse)
        return psnr
# [get-psnr]
 
# [get-mssim]
def getMSSISM(i1, i2)
C1 = 6.5025
C2 = 58.5225
    # 初始化
 
I1 = np.float32(i1) # 不能在一个字节的大值上进行计算
I2 = np.float32(i2)
 
I2_2 = I2 * I2 # I2^2
I1_2 = I1 * I1 # I1^2
I1_I2 = I1 * I2 # I1 * I2
    # 结束初始化
 
    # 初步计算
mu1 = cv.GaussianBlur(I1, (11, 11), 1.5)
mu2 = cv.GaussianBlur(I2, (11, 11), 1.5)
 
mu1_2 = mu1 * mu1
mu2_2 = mu2 * mu2
mu1_mu2 = mu1 * mu2
 
sigma1_2 = cv.GaussianBlur(I1_2, (11, 11), 1.5)
sigma1_2 -= mu1_2
 
sigma2_2 = cv.GaussianBlur(I2_2, (11, 11), 1.5)
sigma2_2 -= mu2_2
 
sigma12 = cv.GaussianBlur(I1_I2, (11, 11), 1.5)
sigma12 -= mu1_mu2
 
t1 = 2 * mu1_mu2 + C1
t2 = 2 * sigma12 + C2
t3 = t1 * t2 # t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
 
t1 = mu1_2 + mu2_2 + C1
t2 = sigma1_2 + sigma2_2 + C2
t1 = t1 * t2 # t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
 
ssim_map = cv.divide(t3, t1) # ssim_map = t3./t1;
 
mssim = cv.mean(ssim_map) # mssim = ssim 映射的平均值
    return mssim
# [get-mssim]
 
 
def main()
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--delay", type=int, default=30, help=" 时间延迟")
parser.add_argument("-v", "--psnrtriggervalue", type=int, default=30, help="PSNR 触发值")
parser.add_argument("-r", "--ref", type=str, default="Megamind.avi", help="参考视频路径")
parser.add_argument("-t", "--undertest", type=str, default="Megamind_bugy.avi",
help="待测试视频路径")
args = parser.parse_args()
 
sourceReference = args.ref
sourceCompareWith = args.undertest
delay = args.delay
psnrTriggerValue = args.psnrtriggervalue
 
framenum = -1 # 帧计数器
 
captRefrnc = cv.VideoCapture(cv.samples.findFileOrKeep(sourceReference))
captUndTst = cv.VideoCapture(cv.samples.findFileOrKeep(sourceCompareWith))
 
    if not captRefrnc.isOpened()
print("无法打开参考 " + sourceReference)
sys.exit(-1)
    if not captUndTst.isOpened()
print("无法打开测试用例 " + sourceCompareWith)
sys.exit(-1)
 
refS = (int(captRefrnc.get(cv.CAP_PROP_FRAME_WIDTH)), int(captRefrnc.get(cv.CAP_PROP_FRAME_HEIGHT)))
uTSi = (int(captUndTst.get(cv.CAP_PROP_FRAME_WIDTH)), int(captUndTst.get(cv.CAP_PROP_FRAME_HEIGHT)))
 
    if refS != uTSi
print("输入视频尺寸不同！！！正在关闭。")
sys.exit(-1)
 
WIN_UT = "测试中"
WIN_RF = "参考"
 
    cv.namedWindow(WIN_RF, cv.WINDOW_AUTOSIZE)
    cv.namedWindow(WIN_UT, cv.WINDOW_AUTOSIZE)
    cv.moveWindow(WIN_RF, 400, 0) #750, 2 (bernat =0)
    cv.moveWindow(WIN_UT, refS[0], 0) #1500, 2
 
print("参考帧分辨率：宽度={} 高度={} 帧数#: {}".format(refS[0], refS[1],
captRefrnc.get(cv.CAP_PROP_FRAME_COUNT)))
print("PSNR 触发值 {}".format(psnrTriggerValue))
 
    while True: # 在窗口中显示捕获的图像并重复
_, frameReference = captRefrnc.read()
_, frameUnderTest = captUndTst.read()
 
        if frameReference is None or frameUnderTest is None
print(" < < < 游戏结束！ > > > ")
            break
 
framenum += 1
psnrv = getPSNR(frameReference, frameUnderTest)
print("帧: {}# {}dB".format(framenum, round(psnrv, 3)), end=" ")
 
        if (psnrv < psnrTriggerValue and psnrv)
mssimv = getMSSISM(frameReference, frameUnderTest)
print("MSSISM: R {}% G {}% B {}%".format(round(mssimv[2] * 100, 2), round(mssimv[1] * 100, 2),
round(mssimv[0] * 100, 2)), end=" ")
 
print()
 
        cv.imshow(WIN_RF, frameReference)
        cv.imshow(WIN_UT, frameUnderTest)
 
k = cv.waitKey(delay)
        if k == 27
            break
 
sys.exit(0)
 
 
if __name__ == "__main__"
    main()

如何读取视频流（在线摄像头或离线文件）？

本质上，所有视频操作所需的功能都集成在 cv::VideoCapture C++ 类中。它本身基于 FFmpeg 开源库。这是 OpenCV 的一个基本依赖项，所以您不需要担心这个问题。视频由一系列图像组成，我们在文献中称之为帧。在视频文件的情况下，有一个帧率指定了两帧之间的时间长度。而对于摄像机，通常它们每秒可以数字化的帧数是有限制的，这个属性不那么重要，因为摄像机随时都能看到世界的当前快照。

您需要做的第一件事是为 cv::VideoCapture 类分配其源。您可以通过 cv::VideoCapture::VideoCapture 或其 cv::VideoCapture::open 函数来完成此操作。如果此参数是整数，则您将该类绑定到摄像机（一个设备）。此处传递的数字是操作系统分配的设备 ID。如果您的系统连接了一个摄像头，其 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);
// 或
VideoCapture captUndTst;
captUndTst.open(sourceCompareWith);

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

if ( !captRefrnc.isOpened())
  {
cout << "无法打开参考 " << 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())
{
 // 退出程序
}

读取方法由帧抓取和对其应用的解码组成。您可以通过使用 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 << "参考帧分辨率：宽度=" << refS.width << " 高度=" << refS.height
<< " 帧数#: " << captRefrnc.get(CAP_PROP_FRAME_COUNT) << endl;

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

captRefrnc.set(CAP_PROP_POS_MSEC, 1.2); // 跳转到视频的 1.2 秒处
captRefrnc.set(CAP_PROP_POS_FRAMES, 10); // 跳转到视频的第 10 帧
// 现在读取操作将读取设置位置的帧

有关您可以读取和更改的属性，请参阅 cv::VideoCapture::get 和 cv::VideoCapture::set 函数的文档。

图像相似性 - PSNR 和 SSIM

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

\[MSE = \frac{1}{c*i*j} \sum{(I_1-I_2)^2}\]

然后 PSNR 表示为

\[PSNR = 10 \cdot \log_{10} \left( \frac{MAX_I^2}{MSE} \right)\]

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

C++

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) // 对于非常小的值，返回 360 来限制 PSNR（理论值为无穷大）
        return 360.0;
    else
    {
        double mse = sse / (double)(I1.channels() * I1.total());
        double psnr = 10.0 * log10((255 * 255) / mse);
        return psnr;
    }
}

Python

def getPSNR(I1, I2)
s1 = cv.absdiff(I1, I2) #|I1 - I2|
s1 = np.float32(s1) # 不能在 8 位上进行平方计算
s1 = s1 * s1 # |I1 - I2|^2
sse = s1.sum() # 按通道求和
    if sse <= 1e-10: # 通道求和
        return 360 # 对于非常小的 SSE，返回 360 来限制 PSNR（理论值为无穷大）
    else:
shape = I1.shape
mse = 1.0 * sse / (shape[0] * shape[1] * shape[2])
psnr = 10.0 * np.log10((255 * 255) / mse)
        return psnr

通常，视频压缩的结果值在 30 到 50 之间，越高越好。如果图像显着不同，您将获得更低的值，例如 15 等。这种相似性检查易于计算且速度快，但实际上可能与人眼感知不一致。结构相似性算法旨在纠正这一点。

描述这些方法远远超出了本教程的目的。为此，我邀请您阅读介绍它的文章。尽管如此，您可以通过查看下面的 OpenCV 实现来很好地了解它。

注意

SSIM 在以下文章中有更深入的描述：“Z. Wang, A. C. Bovik, H. R. Sheikh 和 E. P. Simoncelli，《图像质量评估：从误差可见性到结构相似性》，IEEE Transactions on Image Processing，第 13 卷，第 4 期，第 600-612 页，2004 年 4 月。”

C++

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

Python

def getMSSISM(i1, i2)
C1 = 6.5025
C2 = 58.5225
    # 初始化
 
I1 = np.float32(i1) # 不能在一个字节的大值上进行计算
I2 = np.float32(i2)
 
I2_2 = I2 * I2 # I2^2
I1_2 = I1 * I1 # I1^2
I1_I2 = I1 * I2 # I1 * I2
    # 结束初始化
 
    # 初步计算
mu1 = cv.GaussianBlur(I1, (11, 11), 1.5)
mu2 = cv.GaussianBlur(I2, (11, 11), 1.5)
 
mu1_2 = mu1 * mu1
mu2_2 = mu2 * mu2
mu1_mu2 = mu1 * mu2
 
sigma1_2 = cv.GaussianBlur(I1_2, (11, 11), 1.5)
sigma1_2 -= mu1_2
 
sigma2_2 = cv.GaussianBlur(I2_2, (11, 11), 1.5)
sigma2_2 -= mu2_2
 
sigma12 = cv.GaussianBlur(I1_I2, (11, 11), 1.5)
sigma12 -= mu1_mu2
 
t1 = 2 * mu1_mu2 + C1
t2 = 2 * sigma12 + C2
t3 = t1 * t2 # t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
 
t1 = mu1_2 + mu2_2 + C1
t2 = sigma1_2 + sigma2_2 + C2
t1 = t1 * t2 # t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
 
ssim_map = cv.divide(t3, t1) # ssim_map = t3./t1;
 
mssim = cv.mean(ssim_map) # mssim = ssim 映射的平均值
    return mssim

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

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

您可以在此处观看其运行时实例。