vs2012配置OpenCV开发环境

第一步，下载opencv安装包，解压缩。以管理员权限执行cmd命令

setx -m OPENCV_DIR e:\sdk\opencv\build

第二步，打开vs2012工程，配置工程属性。

debug模式下需要配置以下lib链接文件

opencv_core246d.lib
opencv_imgproc246d.lib
opencv_highgui246d.lib
opencv_ml246d.lib
opencv_video246d.lib
opencv_features2d246d.lib
opencv_calib3d246d.lib
opencv_objdetect246d.lib
opencv_contrib246d.lib
opencv_legacy246d.lib
opencv_flann246d.lib

release模式下删除对应的d即可，例如：opencv_core246.lib

配置完成，现在就可以开始编写代码了。。。。

#include <iostream>
#include <string>
#include <iomanip>
#include <sstream>

#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>

using namespace std;
using namespace cv;

double getPSNR(const Mat& I1, const Mat& I2);
Scalar getMSSIM(const Mat& I1, const Mat& I2);


void help()
{
	cout << "\n--------------------------------------------------------------------------" << 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 " << endl
		<< "trigger value, also with MSSIM."<< endl
		<< "Usage:" << endl
		<< "./video-source referenceVideo useCaseTestVideo PSNR"
		<< endl
		<< "--------------------------------------------------------------------------" << endl
		<< endl;
}


int main(int argc, char* argv[])
{
	help();
	if (argc != 5)
	{
		cout << "Not enough parameters" << endl;
		return -1;
	}
	stringstream conv;
	const string sourceRefrence = argv[1], sourceCompareWith = argv[2];
	int psnrTriggerValue, delay;
	conv << argv[3] << argv[4];
	conv >> psnrTriggerValue >> delay;
	char c;
	int frameNum = -1;
	VideoCapture captRefrnc(sourceRefrence), captUndTst(sourceCompareWith);
	if (!captRefrnc.isOpened())
	{
		cout << "Could not open reference " << sourceRefrence << endl;
		return -1;
	}

	if (!captUndTst.isOpened())
	{
		cout << "Could not open case test " << sourceCompareWith << endl;
		return -1;
	}

	Size refS = Size((int)captRefrnc.get(CV_CAP_PROP_FRAME_WIDTH),
		(int)captRefrnc.get(CV_CAP_PROP_FRAME_HEIGHT)),
		uTsi = Size((int)captUndTst.get(CV_CAP_PROP_FRAME_WIDTH),
		(int)captUndTst.get(CV_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, CV_WINDOW_AUTOSIZE);
	namedWindow(WIN_UT, CV_WINDOW_AUTOSIZE);
	cvMoveWindow(WIN_RF, 400, 0);
	cvMoveWindow(WIN_UT, refS.width, 0);

	cout << "Frame resolution: Width=" << refS.width << " Height=" << refS.height
		<< " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
	cout << "PSNR trigger value " << setiosflags(ios::fixed)
		<< setprecision(3) << psnrTriggerValue << endl;

	Mat frameReference, frameUnderTest;
	double psnrV;
	Scalar mssimV;
	while (true)
	{
		captRefrnc >> frameReference;
		captUndTst >> frameUnderTest;
		if (frameReference.empty() || frameUnderTest.empty())
		{
			cout << " < < < Game Over! > > > " << endl;
			break;
		}
		++frameNum;
		cout << "Frame: " << frameNum;
		psnrV = getPSNR(frameReference, frameUnderTest);
		cout << setiosflags(ios::fixed) << setprecision(3) << psnrV << "dB";

		if (psnrV < psnrTriggerValue)
		{
			mssimV = getMSSIM(frameReference, frameUnderTest);
			
			cout << " MSSIM: "
				<< "R" << setiosflags(ios::fixed) << setprecision(3) << mssimV.val[2]*100
				<< "G" << setiosflags(ios::fixed) << setprecision(3) << mssimV.val[1]*100
				<< "B" << setiosflags(ios::fixed) << setprecision(3) << mssimV.val[0]*100;
		}

		cout << endl;

		/// show image ///
		imshow(WIN_RF, frameReference);
		imshow(WIN_UT, frameUnderTest);

		c = (char)cvWaitKey(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);
	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;
	}
}


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);
	Mat I1_I2 = I1.mul(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);

	t1 = mu1_2 + mu2_2 + C1;
	t2 = sigma1_2 + sigma2_2 + C2;
	t1 = t1.mul(t2);

	Mat ssim_map;
	divide(t3, t1, ssim_map);

	Scalar mssim = mean(ssim_map);
	return mssim;
}