好久没更新博客了，最近都在忙找工作，目前来看形势还不错。感觉我基本已经跟computer vision没什么关系了，面了很多公司，只有一个是视觉的，其它都是纯码农活儿了。

这学期上了个计算机架构的水课，最后的大作业我就benchmark了一下OpenCV在x86和ARM下面的性能，我的笔记本的CPU是Intel Core i7 620M，iOS测试我用的是iPod Touch，和iPhone 4是一样的CPU, Apple A4。最新的iPhone 4s和iPad2上的Apple A5没机会测，因为这俩都不能完全越狱。x86比ARM快那是肯定的，不过这个benchmark可以看出来到底差多少。

编译：在x86上我用的是64位编译的，因为Apple A4分别支持ARM v6和v7两个版本，我就分别都编译了不同的静态库。

测试：我使用了不同的数据类型，8/16/32位整形，32/64位浮点；不同的输入矩阵大小，4*4/8*8/…/256*256/512*512；不同的操作，加、乘、转置、求逆、SVD，还有一组图像处理的比较。

下面是一些比较结果：

这门课一直有个旁听的哥们儿，present完了下课后他跑过来跟我聊天，原来他是苹果高级硬件工程师，Accelerate Framework组，就是专门搞这些底层优化的，我提到的很多细节他能接着说好多，他说ARM如果优化的好的话，不会像我benchmark的结果那么不济的，可能会比x86差个一两倍的样子。关公面前耍了次大刀。

下面是原始输出数据：

/*****************************************************/
/* (Time: μs)                                        */
/* Platform:		x86					ARM v6				ARM v7     */
/*****************************************************/
Run bench on type CV_8UC1

Size 512:
	cvAdd: 				417.0				11977.0				5991.5
	cvMul:				417.5				9798.0				6805.5
	cvTranspose: 	214.0				3578.0		 		3322.0
Size 256:
	cvAdd: 				85.25				1431.0				619.5
	cvMul:				119.5				1432.75				786.0
	cvTranspose: 	61.25				528.5					412.25
Size 128:
	cvAdd: 				19.625			346.125				145.375
	cvMul:				33.125			403.375				200.125
	cvTranspose: 	10.125			95.875				65.25
Size 64:
	cvAdd: 				4.9375			89.4375				39.8125
	cvMul:				9.6875			94.125				53.8125
	cvTranspose: 	2.6875			28.5					20.25
Size 32:
	cvAdd: 				2.3125			28.125				15.90625
	cvMul:				2.625				29.90625			18.90625
	cvTranspose: 	1.0		 			10.71875		 	8.40625
Size 16:
	cvAdd: 				0.812500		12.984375			10.25
	cvMul:				0.859375		12.90625			10.125
	cvTranspose: 	0.390625		6.46875		 		5.8125
Size 8:
	cvAdd: 				0.390625		9.03125				8.601562
	cvMul:				0.421875		8.898438			10.5625
	cvTranspose: 	0.203125		5.234375		 	4.9375
Size 4:
	cvAdd: 				0.324219		8.109375			12.742188
	cvMul:				0.300781		11.875				7.351562
	cvTranspose: 	0.167969		7.757812		 	4.917969

Run bench on type CV_16UC1

Size 512:
	cvAdd: 				411.0				5764.0		 		4730.0
	cvMul:				317.5				7719.5				6369.5
	cvTranspose: 	265.0				9700.5		 		9623.5
Size 256:
	cvAdd: 				65.0			 	1084.75				2062.0
	cvMul:				81.75				1634.5				2225.5
	cvTranspose: 	41.75				821.75		 		590.0
Size 128:
	cvAdd: 				29.25				246.5					184.625
	cvMul:				29.0				406.875				260.125
	cvTranspose: 	18.75				138.0					77.5
Size 64:
	cvAdd: 				7.4375			61.375		 		44.75
	cvMul:				7.5					95.375				68.0
	cvTranspose: 	4.8125			36.5		 			21.6875
Size 32:
	cvAdd: 				2.125			 	30.375		 		17.0625
	cvMul:				2.125				34.34375			22.3125
	cvTranspose: 	1.34375			18.125		 		9.15625
Size 16:
	cvAdd: 				0.765625		11.5625		 		15.5
	cvMul:				0.75				20.90625			11.0625
	cvTranspose: 	0.468750		8.125		 			5.9375
Size 8:
	cvAdd: 				0.429688		14.375		 		8.734375
	cvMul:				0.406250		10.734375			8.312500
	cvTranspose: 	0.257812		8.109375		 	5.164062
Size 4:
	cvAdd: 				0.328125		10.320312			8.316406
	cvMul:				0.316406		11.355469			7.527344
	cvTranspose: 	0.191406		7.027344		 	4.835938

Run bench on type CV_32SC1

Size 512:
	cvAdd: 				967.0			 	6999.0 				6702.0
	cvMul:				356.5				8320.0				6334.5
	cvTranspose: 	362.0				10754.0		 		10374.0
Size 256:
	cvAdd: 				120.25			1857.0		 		1805.5
	cvMul:				63.5				1899.75				2062.25
	cvTranspose: 	69.25			 	946.0		 			928.5
Size 128:
	cvAdd: 				33.0			 	217.125				179.25
	cvMul:				15.875			264.75				194.625
	cvTranspose: 	12.5			 	144.0		 			121.375
Size 64:
	cvAdd: 				8.1875			44.5		 			42.8125
	cvMul:				4.25				68.5					50.125
	cvTranspose: 	3.5625			28.625		 		22.0625
Size 32:
	cvAdd: 				2.5625			14.75		 			14.593750
	cvMul:				1.3125			22.375				17.0
	cvTranspose: 	0.90625			10.8125		 		9.125
Size 16:
	cvAdd: 				0.96875			9.5		 				9.703125
	cvMul:				0.4375			11.078125			10.046875
	cvTranspose: 	0.25		 		6.5625		 		5.765625
Size 8:
	cvAdd: 				0.445312		15.570312		 	8.734375
	cvMul:				0.265625		11.132812			7.828125
	cvTranspose: 	0.148438		5.359375		 	5.179688
Size 4:
	cvAdd: 				0.273438		7.882812		 	9.667969
	cvMul:				0.257812		7.757812			7.523438
	cvTranspose: 	0.125000		4.941406		 	7.773438

Run bench on type CV_32FC1

Size 512:
	cvAdd: 				593.5				21375.5				6131.0
	cvMul:				350.5				19938.5				5418.0
	cvTranspose: 	332.0		 		10824.0				10323.0
	cvInvert:		 	273243.5		25071806.0		9195260.0
	cvSVD: 				423692.0		174561882.0		34340097.5
Size 256:
	cvAdd: 				116.5				5301.75		 		1176.0
	cvMul:				53.75				5172.25				851.75
	cvTranspose: 	53.25		 		1020.25		 		841.5
	cvInvert:			29972.75		2256949.75		813636.0
	cvSVD: 				55176.75		20055794.5		3947355.5
Size 128:
	cvAdd: 				44.0				1046.625			219.5
	cvMul:				18.75				1065.375			167.375
	cvTranspose: 	18.375			216.375		 		121.0
	cvInvert: 		5215.25			259487.25			96067.25
	cvSVD: 				9909.75			2546950.25		494365.125
Size 64:
	cvAdd: 				8.75				261.0625			56.0625
	cvMul:				4.5					248.6875			48.875
	cvTranspose: 	2.9375			28.75		 			22.3125
	cvInvert: 		502.3125		31718.375			12318.125
	cvSVD: 				1814.1875		311974.5			65447.9375
Size 32:
	cvAdd: 				3.0625			69.312500			19.34375
	cvMul:				1.375				151.718750		17.15625
	cvTranspose: 	1.03125			17.031250		 	9.21875
	cvInvert: 		76.3125			8175.531250		1585.75
	cvSVD: 				605.75			45699.031250	8469.8125
Size 16:
	cvAdd: 				5.953125		22.875		 		10.781250
	cvMul:				0.578125		22.796875			9.828125
	cvTranspose: 	4.203125		6.453125			5.796875
	cvInvert: 		14.453125		530.921875		222.046875
	cvSVD: 				57.265625		4529.875			1129.640625
Size 8:
	cvAdd: 				0.414062		11.765625		 	8.992188
	cvMul:				0.351562		11.375				7.859375
	cvTranspose: 	0.250000		5.359375		 	5.046875
	cvInvert: 		1.609375		78.390625			39.562500
	cvSVD: 				11.835938		729.984375		224.789062
Size 4:
	cvAdd: 				0.285156		13.300781			8.308594
	cvMul:				0.199219		10.527344			8.335938
	cvTranspose: 	0.183594		5.429688		 	7.472656
	cvInvert:		 	0.460938		21.921875			13.855469
	cvSVD: 				2.289062		111.308594		52.316406

Run bench on type CV_64FC1

Size 512:
	cvAdd: 				1389.5			30775.0				9891.0
	cvMul:				991.5				29783.5				8469.0
	cvTranspose: 	1137.5			16028.0				15558.5
	cvInvert: 		290684.0		38524160.0		13876679.5
	cvSVD: 				1058105.5		349269399.5		139599952.0
Size 256:
	cvAdd: 				84.0				7091.75				2188.0
	cvMul:				81.25				7265.25				1922.25
	cvTranspose: 	120.75			3243.25				3414.0
	cvInvert: 		34608.25		3467022.5			1393893.75
	cvSVD: 				122659.5		38763803.75		15673162.25
Size 128:
	cvAdd: 				18.875			1391.0				405.875
	cvMul:				19.125			1318.0				505.25
	cvTranspose: 	19.5				319.625				281.125
	cvInvert: 		3644.875		369943.25			157781.625
	cvSVD: 				15826.75		4468381.25		1725834.125
Size 64:
	cvAdd: 				5.125000		337.4375			102.875
	cvMul:				3.937500		333.3125			109.375
	cvTranspose: 	7.062500		58.8125				51.1875
	cvInvert: 		358.4375		44394.625			19697.0625
	cvSVD: 				2203.3125		530734.875		206134.5
Size 32:
	cvAdd: 				1.562500		86.062500			30.125
	cvMul:				1.500000		87.187500			32.34375
	cvTranspose: 	1.781250		18.093750			15.28125
	cvInvert: 		82.6875			5553.281250		2522.625
	cvSVD: 				350.5				64459.53125		25085.78125
Size 16:
	cvAdd: 				0.343750		26.921875			13.546875
	cvMul:				0.328125		27.468750			13.468750
	cvTranspose: 	0.390625		8.234375			7.625
	cvInvert: 		9.781250		716.296875		344.0
	cvSVD: 				72.328125		7913.484375		3133.546875
Size 8:
	cvAdd: 				0.335938		12.734375			9.484375
	cvMul:				0.328125		12.632812			8.687500
	cvTranspose: 	0.335938		5.773438			5.484375
	cvInvert: 		2.375000		102.585938	 	50.281250
	cvSVD: 				14.054688		973.703125		400.695312
Size 4:
	cvAdd: 				0.207031		9.218750			9.550781
	cvMul:				0.160156		8.968750			10.441406
	cvTranspose: 	0.109375 		5.082031			5.308594
	cvInvert: 		0.382812		21.628906	 		15.808594
	cvSVD: 				2.500000		137.589844		68.695312

Run bench on lena

Size 512:
	cvSmooth: 		423.5				34196.5		 		11714.0
	cvSobel: 			649.0		 		67786.5		 		13859.0
	cvDCT: 				5845.0		 	599860.5 			105444.5
	cvDFT: 				3565.5			458634.5			87149.5
Size 256:
	cvSmooth: 		171.0				6350.0		 		2987.0
	cvSobel: 			129.75			16870.0		 		2867.0
	cvDCT: 				1201.75			131520.5			18459.5
	cvDFT: 				765.0		 		98563.75			14267.0
Size 128:
	cvSmooth: 		35.25		 		1783.25				1066.0
	cvSobel: 			27.875		 	4449.375	 		826.875
	cvDCT: 				244.75		 	28718.375			3922.125
	cvDFT: 				171.5		 		21448.125			2890.0
Size 64:
	cvSmooth: 		14.4375		 	587.75		 		383.875
	cvSobel: 			12.5				1662.1875			373.25
	cvDCT: 				58.1875		 	6595.625			905.375
	cvDFT: 				38.5		 		4662.75				643.5
Size 32:
	cvSmooth: 		8.1875		 	267.25		 		211.9375
	cvSobel: 			8.125		 		450.65625			189.875
	cvDCT: 				14.71875		1478.0			 	218.5625
	cvDFT: 				10.3125		 	1032.531250		203.0
Size 16:
	cvSmooth:		 	5.953125		162.6875			145.453125
	cvSobel: 			6.125		 		222.25				144.468750
	cvDCT: 				4.46875			358.625		 		76.734375
	cvDFT: 				3.078125		242.875				61.078125
Size 8:
	cvSmooth: 		5.203125		135.0625			116.539062
	cvSobel: 			4.898438		150.015625		123.187500
	cvDCT: 				1.46875			85.531250			28.054688
	cvDFT: 				1.25				60.304688			29.742188
Size 4:
	cvSmooth: 		4.660156		123.445312		103.402344
	cvSobel: 			4.4375		 	129.628906		110.570312

benchmark的测试代码：

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <cxcore.h>
#include <highgui.h>
#include <cv.h>

float time_diff(struct timeval start, struct timeval end, int rounds);
void run_bench_math_type(int, int);
void run_bench_image(int);

int main(){

	srandom(0);// This gurantees the number sequence is the same

	printf("Time is in micro-seconds.\n");

	int round_base = 2;

	printf("\n\nRun bench on lena\n");

	run_bench_image(round_base);

	printf("\n\nRun bench on type CV_8UC1\n");
	run_bench_math_type(CV_8UC1, round_base);

	printf("\n\nRun bench on type CV_16UC1\n");
	run_bench_math_type(CV_16UC1, round_base);

	printf("\n\nRun bench on type CV_32SC1\n");
	run_bench_math_type(CV_32SC1, round_base);

	printf("\n\nRun bench on type CV_32FC1\n");
	run_bench_math_type(CV_32FC1, round_base);

	printf("\n\nRun bench on type CV_64FC1\n");
	run_bench_math_type(CV_64FC1, round_base);

	return 0;
}

void run_bench_math_type(int elem_type, int roundbase){

	const int min_size = 4;
	const int max_size = 512;
	int nrounds = roundbase;

	CvMat *matA, *matB, *matC;
	struct timeval t0, t1;

	for(int n = max_size; n >= min_size; nrounds*=2, n /= 2){
		printf("Size %d with %d rounds average:\n", n, nrounds);
		matA = cvCreateMat(n, n, elem_type);
		matB = cvCreateMat(n, n, elem_type);
		matC = cvCreateMat(n, n, elem_type);

		// Init for each round
		for (int i = 0; i < n; i++ ){
			for (int j = 0; j < n; j++ ){
				cvSet2D( matA, i, j, cvScalar(1.0 + random()%254, 0, 0, 0));
				cvSet2D( matB, i, j, cvScalar(1.0 + random()%254, 0, 0, 0));
			}
		}

		gettimeofday(&t0, NULL);
		for (int k = 0; k < nrounds; k++){
			cvAdd(matA, matB, matC, NULL);
		}
		gettimeofday(&t1, NULL);
		printf("\tcvAdd: \t\t%f\n", time_diff(t0, t1, nrounds));

		gettimeofday(&t0, NULL);
		for (int k = 0; k < nrounds; k++){
			cvMul(matA, matB, matC, 1);
		}
		gettimeofday(&t1, NULL);
		printf("\tcvMul:\t\t%f\n", time_diff(t0, t1, nrounds));

		gettimeofday(&t0, NULL);
		for (int k = 0; k < nrounds; k++){
			cvTranspose(matA, matC);
		}
		gettimeofday(&t1, NULL);
		printf("\tcvTranspose: \t%f\n", time_diff(t0, t1, nrounds));

		if ( elem_type == CV_32FC1 || elem_type == CV_64FC1 ){
			gettimeofday(&t0, NULL);
			for (int k = 0; k < nrounds; k++){
				cvInvert(matA, matC, CV_LU);
			}
			gettimeofday(&t1, NULL);
			printf("\tcvInvert: \t%f\n", time_diff(t0, t1, nrounds));
		}

		if ( elem_type == CV_32FC1 || elem_type == CV_64FC1 ){
			gettimeofday(&t0, NULL);
			for (int k = 0; k < nrounds; k++){
				cvSVD(matA, matC, NULL, NULL, 1);
			}
			gettimeofday(&t1, NULL);
			printf("\tcvSVD: \t\t%f\n", time_diff(t0, t1, nrounds));
		}
		cvReleaseMat(&matA);
		cvReleaseMat(&matB);
		cvReleaseMat(&matC);
	}
}

void run_bench_image(int roundbase){

	int nrounds = roundbase;
	const int min_size = 4;
	const int max_size = 512;
	struct timeval t0, t1;

	IplImage *source_imgi = cvLoadImage("lena.bmp", CV_LOAD_IMAGE_GRAYSCALE);
	IplImage *source_imgf = cvCreateImage(cvSize(source_imgi->width, source_imgi->height), IPL_DEPTH_32F, source_imgi->nChannels);
	cvConvert(source_imgi, source_imgf);

	assert( source_imgi->width==512 && source_imgi->height == 512);
	IplImage *imgAi, *imgBi;
	IplImage *imgAf, *imgBf;

	// cvSaveImage("lena.jpg", imgB, 0);

	for(int n = max_size; n >= min_size; nrounds*=2, n /= 2){
		printf("Size %d with %d rounds average:\n", n, nrounds);

		imgAi = cvCreateImage(cvSize(n, n), source_imgi->depth, source_imgi->nChannels);
		imgAf = cvCreateImage(cvSize(n, n), IPL_DEPTH_32F, source_imgi->nChannels);
		imgBi = cvCreateImage(cvSize(n, n), source_imgi->depth, source_imgi->nChannels);
		imgBf = cvCreateImage(cvSize(n, n), IPL_DEPTH_32F, source_imgi->nChannels);

		cvResize(source_imgi, imgAi, CV_INTER_LINEAR);
		cvResize(source_imgf, imgAf, CV_INTER_LINEAR);

		gettimeofday(&t0, NULL);
		for (int k = 0; k < nrounds; k++){
			cvSmooth(imgAi, imgBi, CV_GAUSSIAN, 3, 0 ,0, 0);
		}
		gettimeofday(&t1, NULL);
		printf("\tcvSmooth: \t%f\n", time_diff(t0, t1, nrounds));

		gettimeofday(&t0, NULL);
		for (int k = 0; k < nrounds; k++){
			cvSobel(imgAf, imgBf, 0, 1, 3);
		}
		gettimeofday(&t1, NULL);
		printf("\tcvSobel: \t%f\n", time_diff(t0, t1, nrounds));

		gettimeofday(&t0, NULL);
		for (int k = 0; k < nrounds; k++){
			cvDCT(imgAf, imgBf, CV_DXT_FORWARD);
		}
		gettimeofday(&t1, NULL);
		printf("\tcvDCT: \t\t%f\n", time_diff(t0, t1, nrounds));

		gettimeofday(&t0, NULL);
		for (int k = 0; k < nrounds; k++){
			cvDFT(imgAf, imgBf, CV_DXT_FORWARD, 0);
		}
		gettimeofday(&t1, NULL);
		printf("\tcvDFT: \t\t%f\n", time_diff(t0, t1, nrounds));

		cvReleaseImage(&imgAi);
		cvReleaseImage(&imgAf);
		cvReleaseImage(&imgBi);
		cvReleaseImage(&imgBf);
	}
}

float time_diff(struct timeval start, struct timeval end, int rounds){

	return ((end.tv_sec - start.tv_sec) * 1000000.0 +
			end.tv_usec - start.tv_usec) / (float)rounds;

}

From 老杨

(一句话总结，综合考虑速度和性能，ORB是最好的。）

Introduction

For this test i have written special test framework, which allows me to easily add the new kind of descriptors and test cases and generate report data in CSV-like format. Than i upload it in Google docs and create this awesome charts. Five quality and one performance test was done for each kind of descriptor.

Test cases

• Rotation test -  this test shows how the feature descriptor depends on feature orientation.
• Scaling test -  this test shows how the feature descriptor depends on feature size.
• Blur test -  this test shows how the feature descriptor is robust against blur.
• Lighting test -  this test shows how the feature descriptor is robust against lighting.
• Pattern detection test – this test performs detection of planar object (image) on the real video. In contrast to the synthetic tests, this test gives a real picture of the overall stability of the particular descriptor.
• Performance test is a measurement of description extraction time.

All quality tests works in similar way. Using a given source image we generate a synthetic test data: transformed images corresponding feature points. The transformation algorithm depends on the particular test. For the rotation test case, it’s the rotation of the source image around it’s center for 360 degrees, for scaling – it’s resizing of image from 0.25X to 2x size of original. Blur test uses gaussian blur with several steps and the lighting test changes the overall picture brightness.

The pattern detection test deserves a special attention. This test is done on very complex and noisy video sequence. So it’s challenging task for any feature descriptor algorithm to demonstrate a good results in this test.

The metric for all quality tests is the percent of correct matches between the source image and the transformed one. Since we use planar object, we can easily select the inliers from all matches using the homography estimation. I use OpenCV’s function cvFindHomography for this. This metric gives very good and stable results. I do no outlier detection of matches before homography estimation because this will affect the results in unexpected way. The matching of descriptors is done via brute-force matching from the OpenCV.

Rotation test

In this test i obtain pretty expectable results, because all descriptors are rotation invariant expect the BRIEF. Slight changes in stability can be explained by the feature orientation calculation algorithm and descriptor nature. A detailed study of why the descriptor behaves exactly as it is, takes time and effort. It’s a topic for another article. Maybe later on….

Scaling test

SURF and SIFT descriptors demonstrate us very good stability in this test because they do expensive keypoint size calculation. Other descriptors uses fixed-size descriptor and you can see what it leads to. Currently for LAZY descriptor i do not have separate LAZY feature detector (i use ORB detector for tests) but I’m thinking on lightweight feature detector with feature size calculation, because it’s a must-have feature. Actually, scale invariance is much more important rather than precise orientation calculation.

Blur test

In this test i tried to simulate the motion blur which can occurs if camera moves suddenly. All descriptors demonstrate good results in this test. By “good” I mean that the more blur size is applied the less percent of correct matches is obtained. Which is expected behavior.

Lighting test

In lighting test the transformed images differs only in overall image brightness. All kinds of descriptors works well in this case. The major reason is that all descriptors extracted normalized, e.g the norm_2 of the descriptor vector equals 1. This normalization makes descriptor invariant to brightness changes.

Pattern detection on real video

Detection of the object on real video is the most complex task since ground truth contains rotation, scaling and motion blur. Also other objects are also present. And finally, it’s not HD quality. These conditions are dictated by the actual conditions of application of computer vision.

As you can see on diagram, the SIFT and SURF descriptors gives the best results, nevertheless they are far away from ideal, it’s quite enough for such challenging video. Unfortunately, scale-covariant descriptors show very bad results in this test because pattern image appears in 1:1 scale only at the beginning of the video (The “spike” near frame 20). On the rest of the video sequence target object moves from the camera back and scale-covariant descriptors can’t handle this situation.

Performance summary

This chart shows the extraction time for N features. I made Y-axis as logarithm scale to make it more readable. For all descriptor extraction algorithm the extraction time depends on number of features linearly. Local spikes is probably caused by some vector resizing or L2 cache misses. This performance test was done on Mac Book Pro 2.2 with Core 2 Duo 2.13 Ghz.

Further works

Add new quality test cases. One additional test i know for sure – affine transformations. Your ideas for other tests are welcome!

• Add new kind of descriptors. Definitely will add an A-SIFT implementation.
• Create an LAZY detector with feature size and orientation estimation.
• Improve the LAZY descriptor extraction procedure. Expect at least 20% performance gain.
• Generate matching video for each test to demonstrate the behavior of each descriptor algorithm.

玩了一下OpenCV2.3的python接口。有如下几个注意事项：

1：OpenCV2.3RC使用VS2005编译会提示确实DirectShow，所以最好还是升级到OpenCV2.3

2: 使用VisualStudio2008/2010的可以直接下载OpenCV2.3 Superpack，免去编译之累。

3：编译好python库之后将cv.pyd, cv2.pyd拷贝至python2.x的Lib/Sitepackage目录下。

4：cv2中的函数使用的numpy.ndarray来表示图像，所以要使用cv2.imread函数来装载图像，而不要使用cv模块中的loadImage或者loadImageM

以上事项都搞定的话，写个简单的小程序就木有问题了。下面用新的cv2模块将以前贴过的提取surf特征的代码重写一遍：

[python toolbar="true"]

from numpy import *

import cv

import cv2

img = cv2.imread(‘C:\OpenCV-2.3.0\samples\c\cat.jpg’)

gray = cv2.cvtColor(img, cv.CV_BGR2GRAY)

surf_detector = cv2.SURF(200,

print type(img)

(keys, descs) = surf_detector.detect(gray, None, False)

print type(keys)

print type(descs)

for key, desc in zip(keys, descs):

r = key.size

cv.Circle(img, key.pt, r, cv.RGB(255,255,0), 1, cv.CV_AA)

angle = key.angle

sx = key.pt[0]

sy = key.pt[1]

ex = sx + r * cos(angle/180. * pi)

ey = sy + r * sin(angle/180. * pi)

cv.Line(img, (sx,sy), (ex, ey), cv.RGB(0, 255, 0), 1., cv.CV_AA)

cv.ShowImage(‘cat’, img)

cv.WaitKey(0)

[/python]

OpenCV2.3自带了了一些sample，在OpenCV-2.3.0\samples\python2目录下面，比如这个Coherence-Enhancing Shock Filters的小程序：（这个滤波器功能是实现保留flow结构的边缘增强效果。）

注意代码有些小错误，cv2.sobel应该改为cv2.Sobel。（S要大写）。

大家都知道苹果系统是一个很奇怪的系统。有最精美的UI，确实基于最古老的系统。有最好的编程软件，确有自己的编程语言。这里提供一个专门为iOS准备的opencv的sh。链接

不过大家也都知道跨平台是一件巨痛苦的事情，所以貌似要读以下的一个国外网站的教程（其实那个sh也是那个网站提供的）

• http://computer-vision-talks.com/2010/12/building-opencv-for-ios/
• http://computer-vision-talks.com/2011/01/using-opencv-in-objective-c-code/
• http://computer-vision-talks.com/2011/02/building-opencv-for-iphone-in-one-click/
• http://computer-vision-talks.com/2011/03/opencv-build-script-with-xcode-4-support-is-here/

大家到这里看看what’s new：新增加了一个stitching拼接模块，Android支持更加方便了，使用Google test框架，其他变化主要是内部性能改进。

Update 关于手持设备方面的:

首先，OpenCV 2.3的Android build终于变成了官方支持的NDK-Build的方式了。以前的方法相当让人头疼，使用的非Android官方的方法去写JNI接口，tutorial跟着走一遍也不知道所以然。

其次，What’s new里面说道，新的Android支持是NVidia在开发，让然浮想连篇啊！本来OpenCV就是支持CUDA显卡加速的，那请细读下面的报道：http://computervisioncentral.com/content/nvidia-releases-opencv-android-tegra-301677 Tegra 3 support，会不会有硬件加速？OpenCV在Apple A4 这个级别的ARM处理器的性能要比桌面x86处理器慢~20倍，GPU加速让人期待。

最后小八卦，文中提到的Kari Pulli原来在Nokia，他和Stanford合作的FCam API是基于跑在Nokia N900/800 Maemo Linux上的Computational Photograph的API。现在转投NVidia门下把FCam带入到Tegra？有意思，看来NVidia很看中未来手持设备的Visual computing的能力，到处发力找突破。

–幻肢老杨

如有特别推荐的代码，请在本页留言，或者email我：cvchina AT gmail.com

通用库/General Library

• OpenCV

无需多言。

• RAVL

Recognition And Vision Library. 线程安全。强大的IO机制。包含AAM。

• CImg

很酷的一个图像处理包。整个库只有一个头文件。包含一个基于PDE的光流算法。

图像，视频IO/Image, Video IO

• FreeImage
• DevIL
• ImageMagick
• FFMPEG
• VideoInput
• portVideo

AR相关/Augmented Reality

• ARToolKit

基于Marker的AR库

• ARToolKitPlus

ARToolKit的增强版。实现了更好的姿态估计算法。

• PTAM

实时的跟踪、SLAM、AR库。无需Marker，模板，内置传感器等。

• BazAR

基于特征点检测和识别的AR库。

局部不变特征/Local Invariant Feature

• VLFeat

目前最好的Sift开源实现。同时包含了KD-tree，KD-Forest，BoW实现。

• Ferns

基于Naive Bayesian Bundle的特征点识别。高速，但占用内存高。

• SIFT By Rob Hess

基于OpenCV的Sift实现。

目标检测/Object Detection

• AdaBoost By JianXin.Wu

又一个AdaBoost实现。训练速度快。

• 行人检测 By JianXin.Wu

基于Centrist和Linear SVM的快速行人检测。

（近似）最近邻/ANN

• FLANN

目前最完整的（近似）最近邻开源库。不但实现了一系列查找算法，还包含了一种自动选取最快算法的机制。

• ANN

另外一个近似最近邻库。

SLAM & SFM

• SceneLib [LGPL]

monoSLAM库。由Androw Davison开发。

图像分割/Segmentation

• SLIC Super Pixel

使用Simple Linear Iterative Clustering产生指定数目，近似均匀分布的Super Pixel。

目标跟踪/Tracking

• TLD

基于Online Random Forest的目标跟踪算法。

• KLT

Kanade-Lucas-Tracker

• Online boosting trackers

Online Boosting Trackers

直线检测/Line Detection

• DSCC

基于联通域连接的直线检测算法。

• LSD [GPL]

基于梯度的，局部直线段检测算子。

指纹/Finger Print

• pHash [GPL]

基于感知的多媒体文件Hash算法。（提取，对比图像、视频、音频的指纹）

图像检索/Image Retrieval

• libpmk

Pyramid Matching Algorithm实现。

• vocsearch

一个简单的的Vocabulary Tree实现。

视觉显著性/Visual Salience

• Global Contrast Based Salient Region Detection

Ming-Ming Cheng的视觉显著性算法。

FFT/DWT

• FFTW [GPL]

最快，最好的开源FFT。

• FFTReal [WTFPL]

轻量级的FFT实现。许可证是亮点。

音频处理/Audio processing

• STK [Free]

音频处理，音频合成。

• libsndfile [LGPL]

音频文件IO。

• libsamplerate [GPL ]

音频重采样。

以下为CtrlCV。。。

Google Summer of Code 2011今天出结果了，有1100多人获得由Google的赞助参与到各种开源项目的开发中去。大体上是这样的：开源项目方给出感兴趣的课题，参与者获得锻炼机会并且有一定的经济补助，Google大款散点小钱落得个支持开源社区的好名声，这是个三赢局面。当然也不是随便什么项目就可以打着GSOC的名号来骗苦力的，Google批准了175个项目。我觉得这些项目必然有值得支持的理由，于是从头到尾扫了一遍，其中很多有名的开源项目，像GCC, GNU, FreeBSD, GNOME, KDE, Mozilla。下图是所有项目的关键词的用wordle在线服务生成的标签云，可以快速预览一下众开源项目的口味。

我挑几个我个人感兴趣的说说：

1. OpenCV 这个排第一没办法，平时都会用到的。计算机视觉的算法库，自打有了这个库，酱油学生们的日子舒服多了，几行人脸检测函数糊弄一下毕业设计就过关了；软件公司也可以二度创作，搞出像绿坝那样的造福下一代的软件。OpenCV东家Willow Garage的另一个开源库Cloud Point Library也入围了，这个应该是视觉里的一个子领域，专门处理点云和三维空间数据。
2. CMU Sphinx 这是个开源语音识别库，Sphinx在典故里是个让人猜谜语的狮子，喻指语音识别，出自CMU因此得名。训练识别全套都有，这个项目从九十年代开始已经培养出一堆一堆的PhD了，看了几个Demo，感觉很蛮准的。Sphinx已经被port到iOS移动平台上，叫做OpenEar。语音识别已经是相对比较成熟的应用了，个人感觉这个库应该还蛮靠谱的。不过到目前为之我所见到的最牛的还是Google在Android手机里提供的服务，我试过不管是中英文（需要预先设定识别语言），包括各种脏话，都可以准确的识别。需要指出的是，识别是在云端，手机上只是提取特征，传输有延时，并且没网络不行。
3. Apertium 一个machine translation库，自动文本翻译，说白了就是让金山快译什么的回家歇歇的免费库。我看了一下首页的翻译demo里没有中文选项，鉴于我也只会中英两种就没再试了。系统构架应该是可扩展的平台，如果提供中文训练数据应该也可以work。不过这方面Google应该还是老大，试试Google translate就知道了。
4. Hugin 唯一的panorama全景拼接开源工具，折腾过panorama全景拼接的人应该都知道，提供GUI和命令行方式。这里可以观看Hugin的展示作品
5. Shogun 在日文里是将军的意思。这是个machine learning库，强调large scale，估计对大吞吐的数据比较有用。原生C/C++实现在实际应用中的灵活性自由度更大，并且提供其他主流语言包括Java, Python, Matlab等的wrapper。项目主页上给出了和其他同类项目的详细比较。等有机会可以试玩试玩。。。
6. Processing 这个数据可视化的工具，需要使用类似Java的脚本语言去生成各种玄酷的图。很多Infographics的图表都是由它生成的。我打算在遥远的将来学学这东西。
7. Gephi 同样是数据可视化工具，不过这个是所见即所得的，并且主要用于可视化网、图和社会关系。我在这里介绍过。
8. Liquid Galaxy Project 一个虚拟现实的项目，似乎是多块屏幕组成可以观测星空的玩意儿。
9. Orange 又一个machine learning data mining的库，不过看截图好像有点弱，只是直观感觉，没有细究。
10. MetaBrainz 这是个音乐数据库项目，我一直想找到一个很好的自动填补修复音乐ID3 tag的软件，希望这个项目可以好好发展。他们家的MusicBrainz Picard我试过，还有很大提高空间。。。

大概就这么多。从前到后说的越来越少，那是因为我是在太困了。。。发完睡觉去。。。

疯子007童鞋翻译了opencv 2.2的官方网站，在还没有得到允许的情况下我就转载了过来，让我们掌声感谢疯子007童鞋

总体修改和改进：

• 重新组织库结构，用较详细，更小的模块来取代cxcore, cv, cvaux, highgui 和 ml库
  • opencv_core – core函数库（基本的结构，架构和线性代数，DFT，xml 和yam i/o接口函数等）
  • opencv_imgproc -图像处理函数库（滤波，高斯模糊，形态学膨胀/腐蚀，线性缩放图像大小，图像几何变化，颜色结构变化，计算直方图等）
  • opencv_highgui – GUI，图像和视频接口函数库
  • opencv_ml -统计机器学习模型函数库（SVM，决策树，级联等）
  • opencv_features2d -二维特征检测器和描述子函数库（SURF,FAST 等，包括一种新的特征描述子匹配结构）
  • opencv_video -动态分析和物体追踪函数库（光流法，移动模板，背景消除）
  • opencv_objdetect -图像目标检测函数库（haar小波 & LBP人脸检测和识别，HOG人检测等）
  • opencv_calib3d -摄像头标定，视觉匹配和三维数据处理函数库
  • opencv_flann -近似最近领域搜索库和OpenCV分装器
  • opencv_contrib - 最新贡献但不是很成熟的函数库
  • opencv_legacy -过时代码，为了后续代码兼容性而存在
  • opencv_gpu -用CUDA来加速一些openCV函数的类库（相对不太稳定，但对openCV开发非常有帮助）

如果你用Cmake 或者pkg-config来进行配置openCV，如果没有任何改动，你的源码编译会正常。否则，你需要修改连接参数（修改库名）和更新头文件路径。

仍然支持使用#include <cv.h>等，但是备注修改为 #include “opencv2/imgproc/imgproc.hpp”等等。

请查看新的c和c++例子文件，你会发现，这样样例的头文件都采用了新的引用格式。如：https://code.ros.org/svn/opencv/trunk/opencv/samples/c/blobtrack_sample.cpp（这是我自己加的，原文没有，便于大家查看）

• 新格式的分装器覆盖了更多的opencv2.x API，文档和例子将在后面加上。为了采用额外的函数库，你需要numpy

SWIG-不在包含Python分装器

• OpenCV现在支持Android开发（GSoC 2010 工程），一些样例可以在http://opencv.willowgarage.com/wiki/Android 找到
• 完整全新的opencv_gpu加速器模块由NVidida开发支持，详细请看下面。

新的函数，特征集

• core:
• • cv::Matx<T, m, n> 可以增加给定类型，给定大小矩阵

Vec<T, n> 由 Matx<T, n, 1>派生，此类可被用于cv::Mat开销过大时的小矩阵。此操作子可实现Matx 和 Mat相互转换。

• • cv::Mat ，cv::MatND 是同一类型: typedef cv::Mat cv::MatND. 考虑到很多函数没有检查矩阵维数，在用openCV处理3维，4维等高维矩阵时要小心。
  • 实验支持支持2.x/3.x特征 (在Cmake参数选择WITH_EIGEN2). 同时，可以实现Eigen2 matrices和cv::Mat相互转换。详情查看modules/core/include/opencv2/core/eigen.hpp.
  • cv::Mat 支持”<<”操作。详情查看  opencv/samples/cpp/cout_mat.cpp.
  • cv::exp ，cv::log由于SSE2的优化，速度更快
• imgproc:
• • 颜色转换函数被重写；
  • • RGB->Lab & RGB->Luv 得到明显改善。函数假设sRGB输入颜色空间（比如，gamma=2.2）,如果你想要原始线性RGB->L**转换 ，采用CV_LBGR2LAB
    • VNG 算法增加了Bayer->RGB。虽然比简单迭代算法慢了很多，但是更详细的图像信息
    • 对8位图增加了RGB->HSV/HLS 转换函数 ，这里H通道采用完整的 0..255 区域，而不是原来的0..179区域。转换代码为CV_RGB2HSV_FULL等。
    • initUndistortRectifyMap为多角度摄像头增添了专用变量： initWideAngleProjMap()
• features2d:
• • 引入关键点检测，计算描述子和匹配的统一架构。先前的一些可用和新的监测子和描述子，比如SURF，Fast， StarDetector 等，被分装在这个架构中。这个架构的关键的特点（除了为不同检测子和描述子统一的API）是他为图像匹配和基于纹理的物体检查提供了高层工具，详情请看http://opencv.willowgarage.com/documentation/cpp/features2d_common_interfaces_of_feature_detectors.html

C++样例:

• • • descriptor_extractor_matcher.cpp –采用关键点和描述子 从场景中查找物体
    • generic_descriptor_matcher.cpp – 在物体上采用变动，可以使描述子计算不必太精确。
    • bagofwords_classification.cpp –一个用这种架构处理VOC下载的数据的例子，VOC数据集:http://pascallin.ecs.soton.ac.uk/challenges/VOC/
    • Ethan Rublee集成了由Michael Calonder提出的最新更快的关键点描述子BRIEF。例子请查看opencv/samples/cpp/video_homography.cpp
    • SURF 关键点检测子采用TBB （此模块由 imahon 和yvo2m开发)进行并行计算
• objdetect:
• • LatentSVM 物体检查子，应用于P. Felzenszwalb的算法，由Nizhniy Novgorod State University (NNSU) team开发.详情请查看opencv/samples/c/latentsvmdetect.cpp
• calib3d:
• • 一种新的合理的标定模型：

x’ = x*(1 + k₁*r² + k₂*r⁴ + k₃*r⁶)/(1 + k₄*r² + k₅*r⁴ + k₆*r⁶) + <tangential_distortion for x>,

y’ = y*(1 + k₁*r² + k₂*r⁴ + k₃*r⁶)/(1 + k₄*r² + k₅*r⁴ + k₆*r⁶) + <tangential_distortion for y>

被引入。对广角镜头的摄像头标定很有用，因为增加的参数可以优化你所提供数据和增加估计这些数据的鲁棒性。 或者可以简单的初始化畸变向量为0，并且CV_CALIB_RATIONAL_MODEL +CV_CALIB_FIX_K3 + CV_CALIB_FIX_K4 + CV_CALIB_FIX_K5 或者其他连接去选择去增强或者取消一些系数

• • 增加校正三目摄像头（三目在同一水平线上），详情请查看 samples/cpp/3calibration.cpp
• ml:
• • 引入由NNSU工作组开发的梯度级联树模型
• highgui:
• • 增加支持 Qt 后台开发，源于由Yannick Verdie完成的GSoC 2010工程。后台开发有一些新特征没有体现，如采用TTF字体的文字翻译 ，独立的控制面板，包括滚动条，按钮，单选按钮，复选按钮，大小变化，图像显示区，highgui 窗体, “保存”等等。详情请看Yannick在youtube视频演示新特征：http://www.youtube.com/user/MrFrenchCookie#p/u
  • 新的API被引入： http://opencv.willowgarage.com/documentation/cpp/highgui_qt_new_functions.html，如果你机器上有 Qt SDK (或者 libqt4 开发包)，可以采用新的API，并且采用QT编译OpenCV (pass-DWITH_QT=ON to CMake; 注意结果，确认Qt为GUI后台编译)
  • 支持16位和LZW-压缩TIFFs
  • 支持Linux环境下IEEE1394 模式的摄像头
• contrib:
• • 增加Marius Muja，Antonella Cascitelli， Marco Di Stefano ,Stefano Fabri开发的斜面匹配算法. 详情查看 samples/cpp/chamfer.cpp
• gpu:
• • 这一部分是OpenCV的全新部分，由NVidia开发并支持。注意，此开发包处于测试阶段，所以在开发时请注意和关注OpenCV SVN 的更新。

在采用gpu，需要安装最新的 NVidia CUDA SDK ，并且采用CUDA 编译OpenCV (-DWITH_CUDA=ON CMake flag).所有函数采用cv::gpu namespace命名空间。完整的函数和类在opencv/modules/gpu/include/opencv2/gpu/gpu.hpp,下面是 API中一些主要组成部分：

• • 图像计算，滤波操作，形态学，几何变换，直方图计算
  • 立体视觉匹配算法：块匹配， Belief Propagation 和Constant-Space Belief Propagation.
  • 基于HOG物体检查子。It runs more than order of magnitude faster than the CPU version!
  • • See opencv/samples/gpu
• python bindings:
• • 大量 OpenCV 2.x 函数被转换为Python 语言。

这些新的分装需要安装numpy (请查看http://opencv.willowgarage.com/wiki/InstallGuide).

同理，C++ API，在python环境下，不需要定位输出数组，他们会自动由相互函数创建，下面是一个小例子：

§       import cv

§

§       a=cv.imread(“lena.jpg”,0)

§       b=cv.canny(a, 50, 100, apertureSize=3)

§       cv.imshow(“test”,b)

§       cv.waitKey(0)

在例子中， a和 b 是普通 numpy 数组，所以OpenCV 函数完全支持numpy 和 scipy

PS.在你用opencv2.2的时候，记得库已经不是原来的库的，记得换库

Nvidia作为我们长期使用用来看电视、看电影、看很多奇怪东西的解码芯片的集合板。

他们居然要合体融合了，NVIDIA的CUDA给我们的印象一直是飞一般的感觉，据称就要被原生的OpenCV支持了。

据GTC 2010 GPU上面称，2011年春OpenCV就要出一个CUDA支持版本，这个会让很多计算机视觉的算法速度有非常大的速度提升。

ps：用原ATI，现AMD显卡的用户泪奔飘过，希望童鞋们努力

最近发现了两个第三方的对opencv的扩展。

第一个是周同学介绍的，HARPIA，目的是提供类似simulink的opencv图形化接口。额。还嫌opencv不够方便么？下面是截图一枚。

估计也没啥用，还是下面一个扩展比较给力，来自Nvidia，提供对opencv，基于CUDA的GPU加速。不过据说要在2011年才能放出初始版本。貌似在willow的svn服务器上可以看到这个玩意的踪迹。有兴趣有装备的可以研究一下。

OpenCV is a free open source library of computer vision algorithms. Recently a new module consisting of functions implemented on GPU was introduced in OpenCV. It consists of several methods for calculating stereo correspondence between two images that is used to reconstruct a 3D scene. A simple block-matching algorithm works up to 10x faster compared to a CPU implementation in OpenCV providing real-time processing of HD stereo pairs on Tesla cards. Belief propagation-based algorithms show 20-50x speedup compared to a CPU implementation.

来源