使用 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 上觀看此程式的執行時例項。