【机器视觉笔录】OpenCV特征提取与检测

1
2
3
4
5
6
7
8
  void cv::cornerHarris(
      InputArray src,
      OutputArray dst, 
      int blockSize,
      int ksize,
      double k,
      int borderType = BORDER_DEFAULT
      )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
void Harris_Demo(int, void*)
{
	Mat norm_dst, normScaleDst;
	dst = Mat::zeros(gray_src.size(), CV_32FC1);

	int blockSize = 2;
	int ksize = 3;
	double k = 0.04;
	cornerHarris(gray_src, dst, blockSize, ksize, k, BORDER_DEFAULT);
	normalize(dst, norm_dst, 0, 255, NORM_MINMAX, CV_32FC1, Mat());
	convertScaleAbs(norm_dst, normScaleDst);

	Mat resultImg = src.clone();
	for (int row = 0; row < resultImg.rows; row++)
	{
		uchar* currentRow = normScaleDst.ptr(row);
		for (int col = 0; col < resultImg.cols; col++)
		{
			int value = (int)* currentRow;
			if (value > thresh)
			{
				circle(resultImg, Point(col, row), 2, Scalar(0, 0, 255), 2, 8, 0);
			}
			currentRow++;
		}
	}
	imshow(output_title, resultImg);
}

1
2
3
4
5
6
7
8
9
10
void cv::goodFeatureToTrack(
          InputArray image,
          OutputArray corners,
          int maxCorners,
          double qualityLevel,
          InputArray mask = noArray(),
          int blockSize,
          bool useHarrisDectector = false,
          double k = 0.04
          )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void ShiTomasi_Demo(int, void*)
{
	if (num_corners < 5)
	{
		num_corners = 5;
	}
	vector<Point2f>corners;
	double qualityLevel = 0.01;
	double minDistance = 10;
	int blockSize = 3;
	bool useHarris = false;
	double k = 0.04;
	Mat resultImg = src.clone();
	goodFeaturesToTrack(gray_src, corners, num_corners, qualityLevel, minDistance, Mat(), blockSize, useHarris, k);
	printf("Number of Detected Corners: %d\n", corners.size());

	for (size_t t = 0; t < corners.size(); t++)
	{
		circle(resultImg, corners[t], 2, Scalar(rng.uniform(0, 255), rng.uniform(0, 255), rng.uniform(0, 255)), 2, 8, 0);
	}
	imshow(output_title, resultImg);

}

1
2
3
4
5
6
7
  void cv::cornerEigenValsAndVecs(
      InputArray src,
      OutputArray dst,
      int blockSize,
      int ksize,
      int boderType=BODER_DEFAULT
      )

1
2
3
4
5
6
7
  void cv::cornerMinEigenVal(
      InputArray src,
      OutputArray dst,
      int blockSize,
      int ksize = 3,
      int boderType=BODER_DEFAULT
      )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
	//自定义Harris角点检测
	cvtColor(src1, gray_src, COLOR_BGR2GRAY);
	//计算特征值
	int blockSize = 3;
	double k = 0.04;
	int ksize = 3;
	harris_dst = Mat::zeros(src1.size(), CV_32FC(6));
	harrisRspImg = Mat::zeros(src1.size(), CV_32FC1);
	cornerEigenValsAndVecs(gray_src, harris_dst, blockSize, ksize, 4);

	//计算响应
	for (int row = 0; row < harris_dst.rows; row++)
	{
		for (int col = 0; col < harris_dst.cols; col++)
		{
			double lambda1 = harris_dst.at<Vec6f>(row, col)[0];
			double lambda2 = harris_dst.at<Vec6f>(row, col)[1];
			harrisRspImg.at<float>(row, col) = lambda1 * lambda2 - k * pow((lambda1 + lambda2), 2);
		}
	}

	minMaxLoc(harrisRspImg, &harris_min_rsp, &harris_max_rsp, 0, 0, Mat());
	cout << harris_min_rsp << endl;
	cout << harris_max_rsp << endl;
	namedWindow(harris_win, CV_WINDOW_AUTOSIZE);
	createTrackbar("Quality Value:", harris_win, &qualityLevel, max_count, CustomHarris_Demo);
	CustomHarris_Demo(0, 0);

void CustomHarris_Demo(int, void*)
{
	if (qualityLevel < 10)
	{
		qualityLevel = 10;
	}
	Mat resultImg = src1.clone();
	float t = harris_min_rsp + (((double)qualityLevel) / max_count)*(harris_max_rsp - harris_min_rsp);
	for (int row = 0; row < src1.rows; row++)
	{
		for (int col = 0; col < src1.cols; col++)
		{
			float v = harrisRspImg.at<float>(row, col);
			if (v > t)
			{
				circle(resultImg, Point(col, row), 2, Scalar(0, 0, 255), 2, 8, 0);
			}
		}
	}
	imshow(harris_win, resultImg);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
	//计算最小特征值
	int blockSize = 3;
	double k = 0.04;
	int ksize = 3;
	cvtColor(src1, gray_src, COLOR_BGR2GRAY);
	shiTomasiRsp = Mat::zeros(src1.size(), CV_32FC1);
	cornerMinEigenVal(gray_src, shiTomasiRsp, blockSize, ksize, 4);
	minMaxLoc(shiTomasiRsp, &shitomasi_min_rsp, &shitomasi_max_rsp, 0, 0, Mat());
	namedWindow(shiTomasi_win, CV_WINDOW_AUTOSIZE);
	createTrackbar("Quality:", shiTomasi_win, &sm_qualityLevel, max_count, CustomShiTomasi_Demo);
	CustomShiTomasi_Demo(0, 0);

void CustomShiTomasi_Demo(int, void*)
{
	if (sm_qualityLevel < 20)
	{
		sm_qualityLevel = 20;
	}
	Mat resultImg = src1.clone();
	float t = shitomasi_min_rsp + (((double)sm_qualityLevel) / max_count)*(shitomasi_max_rsp - shitomasi_min_rsp);
	for (int row = 0; row < src1.rows; row++)
	{
		for (int col = 0; col < src1.cols; col++)
		{
			float v = shiTomasiRsp.at<float>(row, col);
			if (v > t)
			{
				circle(resultImg, Point(col, row), 2, Scalar(0, 0, 255), 2, 8, 0);
			}
		}
	}
	imshow(shiTomasi_win, resultImg);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void SubPixel_Demo(int, void*)
{
	if (max_corners < 5)
	{
		max_corners = 5;
	}
	vector<Point2f> corners;
	double qualityLevel = 0.01;
	double minDistance = 10;
	int blockSize = 3;
	double k = 0.04;
	cvtColor(src, gray_src, CV_BGR2GRAY);
	goodFeaturesToTrack(gray_src, corners, max_corners, qualityLevel, minDistance, Mat(), blockSize, false, k);
	cout << "number of corners: " << corners.size() << endl;
	Mat resultImg = src.clone();
	for (size_t t = 0; t < corners.size(); t++)
	{
		circle(resultImg, corners[t], 2, Scalar(0, 0, 255), 2, 8, 0);
	}

	imshow(output_title, resultImg);
	Size winSize = Size(5, 5);
	Size zerozone = Size(-1, -1);
	TermCriteria tc = TermCriteria(TermCriteria::EPS + TermCriteria::MAX_ITER, 40, 0.001);
	cornerSubPix(gray_src, corners, winSize, zerozone, tc);

	for (size_t t = 0; t < corners.size(); t++)
	{
		cout << (t + 1) << "point[x, y]: " << corners[t].x << "," << corners[t].y << endl;
	}
}

1
2
3
4
5
6
7
    cv::xfeatures2d::SURF::create(
      double hessian Threshold = 100,
      int nOctaves = 4,
      int cOctaveLayers = 3,
      bool extended = false,
      bool upright = false
      )

1
2
3
4
5
6
7
8
9
10
11
	//SURF特征检测
	int minHessian = 100;
	Ptr<SURF> detector = SURF::create(minHessian);
	vector<KeyPoint> keypoints;
	detector->detect(src, keypoints, Mat());

	//绘制关键点
	Mat keypoint_img;
	drawKeypoints(src, keypoints, keypoint_img, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
	imshow(output_title, keypoint_img);

1
2
3
4
5
cv::xfeature2d::SIFT::create(
      int nfeatures = 0,
      int nOctaveLayers = 3,
      double contrastThreshold = 0.04,
      double 

1
2
3
4
5
6
7
8
9
10
11
12
13
        
	//SIFT特征检测
	int numFeatures = 100;
	Ptr<SIFT> detector = SIFT::create(numFeatures);
	vector<KeyPoint> keypoints;
	detector->detect(src, keypoints, Mat());
	printf("Total KeyPoints: %d", keypoints.size());

	//绘制特征点
	Mat keypoint_img;
	drawKeypoints(src, keypoints, keypoint_img, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
	namedWindow(output_title, CV_WINDOW_AUTOSIZE);
	imshow(output_title, keypoint_img);

1
2
3
4
5
6
7
8
9
cv::HOGDescriptor::HOGDescriptor(
      Size winSize,
      Size blockSize,
      Size blockStride,
      Size cellSize,
      int nbins,
      ...//不常用的参数
      )
      

1
2
3
4
5
6
7
8
9
	Mat dst, dst_gray;
	resize(src, dst, Size(64, 128));
	cvtColor(dst, dst_gray, COLOR_BGR2GRAY);
	HOGDescriptor detector(Size(64, 128), Size(16, 16), Size(8, 8), Size(8, 8), 9);

	vector<float> descriptors;
	vector<Point> locations;
	detector.compute(dst_gray, descriptors, Size(0, 0), Size(0, 0), locations);
	printf("numbers of HOG descriptors: %d", descriptors.size());

1
2
3
4
5
6
7
8
9
10
11
12
	HOGDescriptor hog = HOGDescriptor();
	hog.setSVMDetector(hog.getDefaultPeopleDetector());

	vector<Rect> foundLocations;
	hog.detectMultiScale(src, foundLocations, 0, Size(8, 8), Size(32, 32), 1.05, 2);
	Mat result = src.clone();
	for (size_t t = 0; t < foundLocations.size(); t++)
	{
		rectangle(result, foundLocations[t], Scalar(0, 0, 255), 2, 8, 0);
	}
	namedWindow(output_title, CV_WINDOW_AUTOSIZE);
	imshow(output_title, result);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
	cvtColor(src, gray_src, COLOR_BGR2GRAY);
	int width = gray_src.cols;
	int height = gray_src.rows;

	Mat lbpImage = Mat::zeros(gray_src.rows - 2, gray_src.cols - 2, CV_8UC1);
	for (int row = 1; row < height - 1; row++)
	{
		for (int col = 1; col < width - 1; col++)
		{
			uchar c = gray_src.at<uchar>(row, col);
			uchar code = 0;
			code |= (gray_src.at<uchar>(row - 1, col - 1) > c) << 7;
			code |= (gray_src.at<uchar>(row - 1, col) > c) << 6;
			code |= (gray_src.at<uchar>(row - 1, col + 1) > c) << 5;
			code |= (gray_src.at<uchar>(row, col + 1) > c) << 4;
			code |= (gray_src.at<uchar>(row + 1, col + 1) > c) << 3;
			code |= (gray_src.at<uchar>(row + 1, col) > c) << 2;
			code |= (gray_src.at<uchar>(row + 1, col - 1) > c) << 1;
			code |= (gray_src.at<uchar>(row, col - 1) > c) << 0;
			lbpImage.at<uchar>(row - 1, col - 1) = code;
		}
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
void ELBP_Demo(int, void*)
{
	int offset = current_radius * 2;
	Mat elbpImage = Mat::zeros(gray_src.rows - offset, gray_src.cols - offset, CV_8UC1);
	int width = gray_src.cols;
	int height = gray_src.rows;

	int numNeighbors = 8;
	for (int n = 0; n < numNeighbors; n++)
	{
		float x = static_cast<float>(current_radius) * cos(2.0 * CV_PI * n / static_cast<float>(numNeighbors));
		float y = static_cast<float>(current_radius) * -sin(2.0 * CV_PI * n / static_cast<float>(numNeighbors));

		int fx = static_cast<int>(floor(x));
		int fy = static_cast<int>(floor(y));
		int cx = static_cast<int>(ceil(x));
		int cy = static_cast<int>(ceil(y));

		float ty = y - fy;
		float tx = x - fx;

		float w1 = (1 - tx) * (1 - ty);
		float w2 = tx * (1 - ty);
		float w3 = (1 - tx) * ty;
		float w4 = tx * ty;

		for (int row = current_radius; row < (height - current_radius); row++)
		{
			for (int col = current_radius; col < (width - current_radius); col++)
			{
				float t = w1 * gray_src.at<uchar>(row + fy, col + fx) + w2 * gray_src.at<uchar>(row + fy, col + cx) + 
					w3 * gray_src.at<uchar>(row + cy, col + fx) + w2 * gray_src.at<uchar>(row + cy, col + cx);
				elbpImage.at<uchar>(row - current_radius, col - current_radius) +=
					((t > gray_src.at<uchar>(row, col)) &&
                     ((abs(t - gray_src.at<uchar>(row, col))) > std::numeric_limits<float>::epsilon())) << n;
			}
		}

	}
	imshow("ELBP Result", elbpImage);
}

1
2
3
4
5
6
7
8
void cv::integral(
      InputArray src,
      OutputArray sum,
      OutputArray sqsum,
      OutputArray tilted,
      int sdepth = -1,
      int sqdepth = -1
      )

1
2
3
4
5
6
7
	Mat sumii = Mat::zeros(src.rows + 1, src.cols + 1, CV_32FC1);
	Mat sqsumii = Mat::zeros(src.rows + 1, src.cols + 1, CV_64FC1);
	integral(src, sumii, sqsumii);

	Mat iiResult;
	normalize(sumii, iiResult, 0, 255, NORM_MINMAX, CV_8UC1, Mat());
	imshow("Integral Image", iiResult);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
	int minHessian = 400;
	Ptr<SURF> detector = SURF::create(minHessian);
	vector<KeyPoint> keypoint_1;
	vector<KeyPoint> keypoint_2;

	Mat descriptor_1, descriptor_2;
	detector->detectAndCompute(src1, Mat(), keypoint_1, descriptor_1);
	detector->detectAndCompute(src2, Mat(), keypoint_2, descriptor_2);

	BFMatcher matcher;
	vector<DMatch> matches;
	matcher.match(descriptor_1, descriptor_2, matches);

	Mat matchesImg;
	drawMatches(src1, keypoint_1, src2, keypoint_2, matches, matchesImg);
	imshow("Descriptor Demo", matchesImg);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
	//FLAAN快速匹配
	int minHessian = 400;
	Ptr<SURF> detector = SURF::create(minHessian);
	vector<KeyPoint> keypoint_obj;
	vector<KeyPoint> keypoint_scene;

	Mat descriptor_obj, descriptor_scene;
	detector->detectAndCompute(src1, Mat(), keypoint_obj, descriptor_obj);
	detector->detectAndCompute(src2, Mat(), keypoint_scene, descriptor_scene);

	FlannBasedMatcher matcher;
	vector<DMatch> matches;
	matcher.match(descriptor_obj, descriptor_scene, matches);

	double minDist = 1000;
	double maxDist = 0;
	for (int i = 0; i < descriptor_obj.rows; i++)
	{
		double dist = matches[i].distance;
		if (dist > maxDist)
		{
			maxDist = dist;
		}
		if (dist < minDist)
		{
			minDist = dist;
		}
	}
	printf("max distance : %f\n", maxDist);
	printf("min distance : %f\n", minDist);

	vector<DMatch> goodMatches;
	for (int i = 0; i < descriptor_obj.rows; i++)
	{
		double dist = matches[i].distance;
		if (dist < max(50 * minDist, 0.02))
		{
			goodMatches.push_back(matches[i]);
		}

	}

	Mat matchesImg;
	drawMatches(src1, keypoint_obj, src2, keypoint_scene, goodMatches, matchesImg, Scalar::all(-1), 
		Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
	imshow("Flann Matching Result", matchesImg);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
	//透视变换
	vector<Point2f> obj;
	vector<Point2f> objInScene;
	for (size_t t = 0; t < goodMatches.size(); t++)
	{
		obj.push_back(keypoint_obj[goodMatches[t].queryIdx].pt);
		objInScene.push_back(keypoint_scene[goodMatches[t].trainIdx].pt);
	}
	Mat H = findHomography(obj, objInScene, RANSAC);

	vector<Point2f> obj_corners(4);
	vector<Point2f> scene_corners(4);
	obj_corners[0] = Point(0, 0);
	obj_corners[1] = Point(src1.cols, 0);
	obj_corners[2] = Point(src1.cols, src1.rows);
	obj_corners[3] = Point(0, src1.rows);

	perspectiveTransform(obj_corners, scene_corners, H);

	line(matchesImg, scene_corners[0] + Point2f(src1.cols, 0), 
		scene_corners[1] + Point2f(src1.cols, 0), Scalar(0, 0, 255), 2, 8, 0);
	line(matchesImg, scene_corners[1] + Point2f(src1.cols, 0),
		scene_corners[2] + Point2f(src1.cols, 0), Scalar(0, 0, 255), 2, 8, 0);
	line(matchesImg, scene_corners[2] + Point2f(src1.cols, 0), 
		scene_corners[3] + Point2f(src1.cols, 0), Scalar(0, 0, 255), 2, 8, 0);
	line(matchesImg, scene_corners[3] + Point2f(src1.cols, 0),
		scene_corners[0] + Point2f(src1.cols, 0), Scalar(0, 0, 255), 2, 8, 0);

	line(src2, scene_corners[0], scene_corners[1], Scalar(0, 0, 255), 2, 8, 0);
	line(src2, scene_corners[1], scene_corners[2], Scalar(0, 0, 255), 2, 8, 0);
	line(src2, scene_corners[2], scene_corners[3], Scalar(0, 0, 255), 2, 8, 0);
	line(src2, scene_corners[3], scene_corners[0], Scalar(0, 0, 255), 2, 8, 0);

	imshow("Find Known Object Demo", matchesImg);
	imshow("Draw Object", src2);

1
2
3
4
5
6
7
8
9
10
11
12
	//AKAZE Detection
	Ptr<AKAZE> detector = AKAZE::create();
	vector<KeyPoint> keypoints;
	double t1 = getTickCount();
	detector->detect(src, keypoints, Mat());
	double t2 = getTickCount();
	double tkaze = 1000 * (t2 - t1) / getTickFrequency();
	printf("KAZE Time Consume(ms): %f", tkaze);

	Mat keypointImg;
	drawKeypoints(src, keypoints, keypointImg, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
	imshow("kaze key points", keypointImg);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
	//AKAZE Detection
	Ptr<AKAZE> detector = AKAZE::create();
	vector<KeyPoint> keypoint_obj;
	vector<KeyPoint> keypoint_scene;
	Mat descriptor_obj, descriptor_scene;
	double t1 = getTickCount();
	detector->detectAndCompute(src1, Mat(), keypoint_obj, descriptor_obj);
	detector->detectAndCompute(src2, Mat(), keypoint_scene, descriptor_scene);
	double t2 = getTickCount();
	double tkaze = 1000 * (t2 - t1) / getTickFrequency();
	printf("KAZE Time Consume(ms): %f", tkaze);

	//Matching
	//BFMatcher matcher(NORM_L2);
	FlannBasedMatcher matcher(new flann::LshIndexParams(20, 10, 2));
	vector<DMatch> matches;
	matcher.match(descriptor_obj, descriptor_scene, matches);

	//Draw KeyPoints
	Mat akazeMatchesImg;
	drawKeypoints(src1, keypoint_obj, src1, Scalar::all(-1), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
	drawMatches(src1, keypoint_obj, src2, keypoint_scene, matches, akazeMatchesImg,
		Scalar::all(-1), Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
	imshow("src1", src1);
	imshow("Akaze Match Results", akazeMatchesImg);

1
FlannBasedMatcher matcher(new flann::LshIndexParams(20, 10, 2));

1
2
3
4
5
6
7
8
9
10
11
12
	//BRISKDetection
	Ptr<Feature2D> detector = BRISK::create();
	vector<KeyPoint> keypoints;
	double t1 = getTickCount();
	detector->detect(src, keypoints, Mat());
	double t2 = getTickCount();
	double tkaze = 1000 * (t2 - t1) / getTickFrequency();
	printf("KAZE Time Consume(ms): %f", tkaze);

	Mat keypointImg;
	drawKeypoints(src, keypoints, keypointImg, Scalar::all(-1), DrawMatchesFlags::DEFAULT);
	imshow("kaze key points", keypointImg);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
	//BRISK Detection
	Ptr<Feature2D> detector = BRISK::create();
	vector<KeyPoint> keypoint_obj;
	vector<KeyPoint> keypoint_scene;
	Mat descriptor_obj, descriptor_scene;
	double t1 = getTickCount();
	detector->detectAndCompute(src1, Mat(), keypoint_obj, descriptor_obj);
	detector->detectAndCompute(src2, Mat(), keypoint_scene, descriptor_scene);
	double t2 = getTickCount();
	double tkaze = 1000 * (t2 - t1) / getTickFrequency();
	printf("KAZE Time Consume(ms): %f", tkaze);

	//Matching
	//BFMatcher matcher(NORM_L2);
	//FlannBasedMatcher matcher(new flann::LshIndexParams(20, 10, 2));
	FlannBasedMatcher matcher;
	vector<DMatch> matches;
	matcher.match(descriptor_obj, descriptor_scene, matches);

	//Draw KeyPoints
	Mat briskMatchesImg;
	drawKeypoints(src1, keypoint_obj, src1, Scalar::all(-1), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
	drawMatches(src1, keypoint_obj, src2, keypoint_scene, matches, briskMatchesImg,
		Scalar::all(-1), Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS);
	imshow("src1", src1);
	imshow("BRISK Match Results", briskMatchesImg);