使用 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
<< "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]; // 放入字符串
conv >> psnrTriggerValue >> delay; // 取出数字
 
    int frameNum = -1; // 帧计数器
 
    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";
 
    // 窗口
    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(;;) // 在窗口中显示捕获的图像并重复
    {
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) // 对于小值返回零
        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); // 不能在一个字节大小的值上计算
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; // 预计算
    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 0 # 对于小值返回零
    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 可能是零，后续的则会递增。如果传递给这些函数的参数是字符串，它将引用一个视频文件，字符串指向文件的位置和名称。例如，对于上面的源代码，一个有效的命令行是

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 << "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())
{
 // 退出程序
}

一个读取方法由帧抓取和对其应用的解码组成。您可以通过使用 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 函数。它的第一个参数仍然是您要更改的属性名称，第二个参数是双精度类型，包含要设置的值。如果成功则返回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) // 对于小值返回零
        return 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 0 # 对于小值返回零
    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 and E. P. Simoncelli, "Image quality assessment: From error visibility to structural similarity," IEEE Transactions on Image Processing, vol. 13, no. 4, pp. 600-612, Apr. 2004.”一文。

C++

 
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); // 不能在一个字节大小的值上计算
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; // 预计算
    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 帧）工作，但要达到相似的性能结果，SSIM 需要显著更多的时间。

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

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