OpenCVによる動画入力と類似度測定

目次

• 目標
• ソースコード
• How to read a video stream (online-camera or offline-file)?
  • 画像の類似度 - PSNRとSSIM

前のチュートリアル: GDALを用いた地理空間ラスタファイルの読み込み
次のチュートリアル: OpenCVで動画を作成する

原著者	Bernát Gábor
互換性	OpenCV >= 3.0

目標

今日では、デジタル映像記録システムを手元に持つことは一般的だ。そのため、いずれは一連の画像のバッチを処理するのではなく、ビデオストリームを処理する状況に出くわすことになる。これらは2種類ある: リアルタイムの画像入力(ウェブカメラの場合)、あるいは事前に録画されハードディスクドライブに保存されたファイルだ。幸いOpenCVはこれら2つを、同じC++クラスで同じように扱う。そこで、このチュートリアルで学ぶ内容は次のとおり:

• ビデオストリームを開いて読み込む方法
• 画像の類似度を確認する2つの方法: PSNRとSSIM

ソースコード

OpenCVを使ってこれらを披露するテストケースとして、2つのビデオファイルを読み込んで両者の類似度チェックを行う小さなプログラムを作成した。これは、新しいビデオ圧縮アルゴリズムがどれだけうまく動作するかを確認するのに使えるものだ。この小さなMegamindクリップのような参照(オリジナル)動画と、その圧縮版があるとしよう。ソースコードとこれらのビデオファイルは、OpenCVソースライブラリの samples/data フォルダにもある。

C++

#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 very small values, return 360 to cap PSNR (theoretical value is infinity)
 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;
    /***************************** 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]

Python

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
# Python 2/3 compatibility
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)     # cannot make a square on 8 bits
    s1 = s1 * s1            # |I1 - I2|^2
    sse = s1.sum()          # sum elements per channel
 if sse <= 1e-10:        # sum channels
 return 360          # For very small SSE, return 360 to cap PSNR (theoretical value is infinity)
 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
 # INITS
 
    I1 = np.float32(i1) # cannot calculate on one byte large values
    I2 = np.float32(i2)
 
    I2_2 = I2 * I2 # I2^2
    I1_2 = I1 * I1 # I1^2
    I1_I2 = I1 * I2 # I1 * I2
 # END INITS
 
 # PRELIMINARY COMPUTING
    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 = average of ssim map
 return mssim
# [get-mssim]
 
 
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("-d", "--delay", type=int, default=30, help=" Time delay")
    parser.add_argument("-v", "--psnrtriggervalue", type=int, default=30, help="PSNR Trigger Value")
    parser.add_argument("-r", "--ref", type=str, default="Megamind.avi", help="Path to reference video")
    parser.add_argument("-t", "--undertest", type=str, default="Megamind_bugy.avi",
                        help="Path to the video to be tested")
    args = parser.parse_args()
 
    sourceReference = args.ref
    sourceCompareWith = args.undertest
    delay = args.delay
    psnrTriggerValue = args.psnrtriggervalue
 
    framenum = -1 # Frame counter
 
    captRefrnc = cv.VideoCapture(cv.samples.findFileOrKeep(sourceReference))
    captUndTst = cv.VideoCapture(cv.samples.findFileOrKeep(sourceCompareWith))
 
 if not captRefrnc.isOpened():
        print("Could not open the reference " + sourceReference)
        sys.exit(-1)
 if not captUndTst.isOpened():
        print("Could not open case test " + 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("Inputs have different size!!! Closing.")
        sys.exit(-1)
 
    WIN_UT = "Under Test"
    WIN_RF = "Reference"
 
 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("Reference frame resolution: Width={} Height={} of nr#: {}".format(refS[0], refS[1],
                                                                             captRefrnc.get(cv.CAP_PROP_FRAME_COUNT)))
    print("PSNR trigger value {}".format(psnrTriggerValue))
 
 while True: # Show the image captured in the window and repeat
        _, frameReference = captRefrnc.read()
        _, frameUnderTest = captUndTst.read()
 
 if frameReference is None or frameUnderTest is None:
            print(" < < <  Game over!  > > > ")
 break
 
        framenum += 1
        psnrv = getPSNR(frameReference, frameUnderTest)
        print("Frame: {}# {}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の基本的な依存ライブラリなので、気にする必要はないだろう。動画は連続した画像で構成されており、文献ではこれらをフレームと呼ぶ。ビデオファイルの場合、2つのフレームの間隔を指定する フレームレート がある。ビデオカメラの場合は通常、1秒間にデジタル化できるフレーム数に上限があるが、カメラはどの時点でも世界の現在のスナップショットを捉えているため、この特性はそれほど重要ではない。

最初に行うべきタスクは、cv::VideoCapture クラスにそのソースを割り当てることだ。これは cv::VideoCapture::VideoCapture または cv::VideoCapture::open 関数を通じて行える。この引数が整数であれば、クラスをカメラ、つまりデバイスにバインドする。ここで渡す番号は、オペレーティングシステムによって割り当てられたデバイスのIDだ。システムにカメラが1台だけ接続されている場合、そのIDはおそらく0で、それ以降のものは増加していく。これらに渡すパラメータが文字列の場合、それはビデオファイルを指し、その文字列はファイルの場所と名前を指し示す。例えば、上のソースコードに対して有効なコマンドラインは次のとおり:

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

類似度チェックを行う。これには参照用とテスト用のビデオファイルが必要だ。最初の2つの引数がこれらを指す。ここでは相対アドレスを使う。これは、アプリケーションが現在の作業ディレクトリ内を見てvideoフォルダを開き、その中から 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);

上のread操作は、フレームを取得できなかった場合(ビデオストリームが閉じられたか、ビデオファイルの終わりに達したかのいずれか)、Mat オブジェクトを空のままにする。これは簡単なifで確認できる:

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

readメソッドは、フレームのグラブと、それに適用されるデコードから成る。cv::VideoCapture::grab とそれに続く cv::VideoCapture::retrieve 関数を使って、この2つを明示的に呼ぶこともできる。

動画には、フレームの内容以外にも非常に多くの情報が付随している。これらは通常は数値だが、場合によっては短い文字列(4バイト以下)であることもある。このため、これらの情報を取得するには cv::VideoCapture::get という汎用関数があり、これらの特性を含むdouble値を返す。double型から文字をデコードするにはビット演算を、有効な値が整数のみの場合は型変換を使う。その唯一の引数は、問い合わせる特性の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 関数がある。その第1引数は変更したい特性の名前のままで、設定する値を含むdouble型の第2引数がある。成功すれば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

動画変換操作がどれだけ知覚されないかを確認したいので、フレームごとに類似度や差異をチェックする仕組みが必要だ。これに最もよく使われるアルゴリズムはPSNR(別名 ピーク信号対雑音比 (Peak signal-to-noise ratio))だ。最も単純な定義は 平均二乗誤差 (mean squared error) から始まる。2枚の画像 I1 と I2 があるとし、2次元のサイズ 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\) はピクセルが取りうる最大の有効値だ。ピクセルあたりチャンネルあたり1バイトの単純な画像の場合、これは255だ。2枚の画像が同一の場合、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);  // 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 very small values, return 360 to cap PSNR (theoretical value is infinity)
 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)     # cannot make a square on 8 bits
    s1 = s1 * s1            # |I1 - I2|^2
    sse = s1.sum()          # sum elements per channel
 if sse <= 1e-10:        # sum channels
 return 360          # For very small SSE, return 360 to cap PSNR (theoretical value is infinity)
 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程度といったずっと低い値になる。この類似度チェックは計算が簡単で高速だが、実際には人間の目の知覚といくらか一致しないことが判明する場合がある。構造的類似性 (structural similarity) アルゴリズムはこれを補正することを目的としている。

手法の詳細を説明することは、このチュートリアルの目的を大きく超える。それについては、それを紹介した論文を読むことをお勧めする。とはいえ、以下の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);            // 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;
}

Python

def getMSSISM(i1, i2):
    C1 = 6.5025
    C2 = 58.5225
 # INITS
 
    I1 = np.float32(i1) # cannot calculate on one byte large values
    I2 = np.float32(i2)
 
    I2_2 = I2 * I2 # I2^2
    I1_2 = I1 * I1 # I1^2
    I1_I2 = I1 * I2 # I1 * I2
 # END INITS
 
 # PRELIMINARY COMPUTING
    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 = average of ssim map
 return mssim

これは画像の各チャンネルについての類似度指標を返す。この値はゼロから1の間で、1が完全な一致に対応する。残念ながら、多数のガウシアン平滑化はかなりコストが高いため、PSNRがリアルタイムのような環境(毎秒24フレーム)で動作する一方、こちらは同程度の性能を達成するのにかなり多くの時間がかかる。

そのため、このチュートリアルの冒頭で示したソースコードは、各フレームについてPSNR測定を行い、SSIMはPSNRが入力値を下回るフレームについてのみ行う。可視化のために両方の画像をOpenCVウィンドウに表示し、PSNRとMSSIMの値をコンソールに出力する。次のようなものが表示されると思ってよい:

これの実行時の様子はこちらのYouTubeで見られる。