使用OpenCV读取视频和视频的相似性度量
目标
当今，数字摄像设备是随处可见。因此，一定会遇到这样的情况：图像处理已经不能满足要求，而需要进行视频处理。这大致分两种情况：
- 1、实时采集(对于网络摄像头)。
- 2、预先录制的或存在硬盘里的视频文件。
OpenCV使用相同的c++类以相同的方式处理这两种情况。这就是本教程要学习的内容：
- 如何打开并读取视频流
- 两种检查图像相似性的方法：PSNR和SSIM
结合代码说明
下面是一个使用OpenCV读取两个视频文件，并在它们之间执行相似性检查的测试用例，这可以用来测试一个新的视频压缩算法的性能。比如参考(原始)视频"this small Megamind clip"的剪辑和它的压缩版本。您还可以在OpenCV库的samples/data文件夹中找到源代码和这些视频文件。
#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;
}
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;
}
}
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;
}
如何读取视频流(实时相机或离线文件)?
基本上，视频操作所需的所有功能都集成在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);
// or
VideoCapture captUndTst;
captUndTst.open(sourceCompareWith);
检查类与视频源的绑定是否成功,使用cv::VideoCapture:: isopen函数:
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.open(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
我们想要检查我们的视频转换操作到底有多难以察觉，因此我们需要一个系统来逐帧检查相似性或差异性。最常用的算法是PSNR(即峰值信噪比)。最简单的定义是从平均阵容误差开始的。假设有两个图像:I1和I2;具有二维尺寸i和j，由c个通道组成。
则PSNR表示为:
这里的MAXI是像素的最大有效值。对于简单的单字节图像每像素每通道值为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); // 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实现获得更好的效果。
- See also
SSIM is described more in-depth in the: “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.” article.
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
/***********************PRELIMINARY COMPUTING ******************************/
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 = average of ssim map
return mssim;
}
这里将为图像的每个通道返回一个相似性索引。这个值介于0和1之间，其中1对应于完全匹配。不幸的是，高斯模糊计算很费时，因此，虽然PSNR可能在实时环境中工作(每秒24帧)，这比完成类似的性能结果需要多得多的时间。
因此，本教程开始时提供的源代码将为每个帧执行PSNR测量，而SSIM只针对PSNR低于输入值的帧。为了实现可视化，我们在OpenCV窗口中显示了两幅图像，并将PSNR和MSSIM值打印到控制台。预计会看到:
