在 ”光流跟踪“ 中，使用了 Harris 角点作为 LK 光流跟踪输入点。角点定义为在两个方向上均有较大梯度变化的小区域，使用自相关函数描述。
自相关函数为为图像平移前后某一个区域的相似度度量。图像可以看作二维平面上的连续函数，使用泰勒级数可以将自相关函数转换为自相关矩阵。
通过分析自相关矩阵的特征值，可以判断在该区域内各个方向上梯度变化情况，从而决定是否为角点。
在 opencv 中，cv::goodFeatrueToTrack 函数可以提取 Harris 角点，其中参数 useHarrisDetector 决定使用 Harris 判定依据还是 Shi-Tomasi 判定依据。
使用 cv::GFTTDetector 可以实现与 cv::goodFeatrueToTrack 基本一致的功能。然而，cv::GFTTDetector 继承自 cv::Feature2D，将角点视为通用关键点，可以对角点做更多后续处理（如特征点描述）。
以下是 cv::GFTTDetector 的构造函数，其参数与 cv::goodFeatrueToTrack 基本一致，如下：
static Ptr<GFTTDetector> create( int maxCorners=1000, double qualityLevel=0.01, double minDistance=1,
int blockSize=3, bool useHarrisDetector=false, double k=0.04 );
其中，maxCorners 决定提取关键点最大个数；
qualityLevel 表示关键点强度阈值，只保留大于该阈值的关键点（阈值 = 最强关键点强度 * qualityLevel）；
minDistance 决定关键点间的最小距离；
blockSize 决定自相关函数累加区域，也决定了 Sobel 梯度时窗口尺寸；
useHarrisDetector 决定使用 Harris 判定依据还是 Shi-Tomasi 判定依据；
k 仅在使用 Harris 判定依据时有效；
以下代码使用 cv::GFTTDetector 检测角点并绘制角点：
1 // 检测 keypoints 2 std::vector<cv::KeyPoint> key_points; 3 cv::Ptr<cv::GFTTDetector> gftt = cv::GFTTDetector::create(1000, .3, 5., 3, false); 4 gftt->detect(img, key_points); 5 6 // 使用 opencv 内置函数绘制 keypoints 7 cv::Mat key_points_img; 8 cv::drawKeypoints(img, key_points, key_points_img, 9 cv::Scalar(255, 0, 0), cv::DrawMatchesFlags::DEFAULT); 10 11 // 读取 cv::KeyPoint 绘制 keypoints 12 cv::Mat key_points_img2; 13 cv::cvtColor(img, key_points_img2, CV_GRAY2BGR); 14 for (int i = 0; i < key_points.size(); ++i) 15 { 16 cv::Point c(key_points[i].pt.x, key_points[i].pt.y); 17 float r = key_points[i].size / 2.; 18 int draw_r = r * 2.; 19 cv::circle(key_points_img2, c, draw_r, cv::Scalar(255, 0, 0)); 20 }
cv::GFTTDetector 内部如何实现角点检测呢，opencv 提供了以下几个基本函数：
1）void cornerEigenValsAndVecs( InputArray src, OutputArray dst,
int blockSize, int ksize,
int borderType = BORDER_DEFAULT );
2）void cornerHarris( InputArray src, OutputArray dst, int blockSize,
int ksize, double k,
int borderType = BORDER_DEFAULT );
3） void cornerMinEigenVal( InputArray src, OutputArray dst,
int blockSize, int ksize = 3,
int borderType = BORDER_DEFAULT );
其中，函数1 仅仅级数图像上每个点上自相关函数的特征值与特征向量，函数2 在 函数1 基础上应用 Harris 判定依据检测角点，函数3 在 函数1 基础上应用 Shi-Tomasi 判定依据检测角点。
以上函数参数含义与 cv::GFTTDetector create 函数基本一致，其中 blockSize 表示自相关函数计算窗口，ksize 表示 Sobel 函数计算窗口。
通过以上函数，可以自己构造一个角点检测算法：
1 void harrisKeyPoints(cv::Mat& img, 2 std::vector<cv::Point>& key_points, std::vector<cv::Point2f>& eigen_vals) 3 { 4 cv::Mat smt_img; 5 cv::GaussianBlur(img, smt_img, cv::Size(3, 3), 0); 6 7 // 使用 cornerEigenValsAndVecs 提取特征值与特征向量 8 cv::Mat eigen_img = cv::Mat::zeros(img.size(), CV_32FC(6)); 9 cv::cornerEigenValsAndVecs(smt_img, eigen_img, 3, 3); 10 11 // 计算每个点上最小特征值 12 cv::Mat min_eigen_img = cv::Mat::zeros(eigen_img.size(), CV_32FC1); 13 cv::Mat max_eigen_img = cv::Mat::zeros(eigen_img.size(), CV_32FC1); 14 for (int y = 0; y < eigen_img.rows; ++y) 15 { 16 float *eigen_data = eigen_img.ptr<float>(y); 17 float *min_eigen_data = min_eigen_img.ptr<float>(y); 18 float *max_eigen_data = max_eigen_img.ptr<float>(y); 19 for (int x = 0; x < eigen_img.cols; ++x) 20 { 21 float eigen_val1 = eigen_data[x * 6]; 22 float eigen_val2 = eigen_data[x * 6 + 1]; 23 if (eigen_val1 > eigen_val2) 24 std::swap(eigen_val1, eigen_val2); 25 26 min_eigen_data[x] = eigen_val1; 27 max_eigen_data[x] = eigen_val2; 28 } 29 } 30 31 // 计算特征值阈值 32 double min_eigen = 0.; 33 double max_eigen = 0.; 34 minMaxIdx(min_eigen_img, &min_eigen, &max_eigen); 35 float eigen_threshold = max_eigen * .15; // 保留 15% 最大强度特征点 36 37 // 保留满足条件的特征点 38 const int min_dist_permitted = 10 * 10; // 特征点间最小距离 39 const int max_size_permitted = 50; // 特征点最大数量 40 41 key_points.clear(); 42 eigen_vals.clear(); 43 int key_points_size = 0; 44 45 float max_eigen_val = 0.; 46 float min_eigen_val = 10000.; 47 int min_eigen_val_idx = -1; 48 49 for (int y = 0; y < min_eigen_img.rows; ++y) 50 { 51 float *data = min_eigen_img.ptr<float>(y); 52 for (int x = 0; x < min_eigen_img.cols; ++x) 53 { 54 if (data[x] > eigen_threshold) 55 { 56 if (key_points_size < max_size_permitted) 57 { 58 bool already_exists = false; 59 for (int i = 0; i < key_points_size; ++i) 60 { 61 int dist = (x - key_points[i].x) * (x - key_points[i].x) + 62 (y - key_points[i].y) * (y - key_points[i].y); 63 if (dist < min_dist_permitted) 64 { 65 already_exists = true; 66 if (eigen_vals[i].x < data[x]) 67 { 68 // 列表中存在邻近点且特征值较小，使用新值替代 69 key_points[i].x = x; 70 key_points[i].y = y; 71 eigen_vals[i].x = data[x]; 72 eigen_vals[i].y = max_eigen_img.ptr<float>(y)[x]; 73 74 if (max_eigen_val < data[x]) 75 max_eigen_val = data[x]; 76 if (min_eigen_val > data[x]) 77 { 78 min_eigen_val = data[x]; 79 min_eigen_val_idx = i; 80 } 81 } 82 } 83 } 84 85 if (!already_exists) 86 { 87 // 列表中不存在邻近点，添加新值到列表中 88 key_points.push_back(cv::Point(x, y)); 89 eigen_vals.push_back(cv::Point2f(data[x], max_eigen_img.ptr<float>(y)[x])); 90 ++key_points_size; 91 92 if (max_eigen_val < data[x]) 93 max_eigen_val = data[x]; 94 if (min_eigen_val > data[x]) 95 { 96 min_eigen_val = data[x]; 97 min_eigen_val_idx = key_points_size - 1; 98 } 99 } 100 } 101 else 102 { 103 // 特征值小于列表中最小值，不更新 104 if (data[x] <= min_eigen_val) 105 continue; 106 107 // 是否存在距离较近元素 108 bool already_exists = false; 109 for (int i = 0; i < key_points_size; ++i) 110 { 111 int dist = (x - key_points[i].x) * (x - key_points[i].x) + 112 (y - key_points[i].y) * (y - key_points[i].y); 113 if (dist < min_dist_permitted) 114 { 115 already_exists = true; 116 if (eigen_vals[i].x < data[x]) 117 { 118 key_points[i].x = x; 119 key_points[i].y = y; 120 eigen_vals[i].x = data[x]; 121 eigen_vals[i].y = max_eigen_img.ptr<float>(y)[x]; 122 123 if (max_eigen_val < data[x]) 124 max_eigen_val = data[x]; 125 } 126 } 127 } 128 129 // 当不存在较近元素时替换最小元素 130 if (!already_exists) 131 { 132 key_points[min_eigen_val_idx].x = x; 133 key_points[min_eigen_val_idx].y = y; 134 eigen_vals[min_eigen_val_idx].x = data[x]; 135 eigen_vals[min_eigen_val_idx].y = max_eigen_img.ptr<float>(y)[x]; 136 137 // 重新搜索最大最小元素 138 max_eigen_val = 0.; 139 min_eigen_val = 10000.; 140 min_eigen_val_idx = -1; 141 142 for (int i = 0; i < key_points_size; ++i) 143 { 144 float val = eigen_vals[i].x; 145 if (max_eigen_val < val) 146 max_eigen_val = val; 147 if (min_eigen_val > val) 148 { 149 min_eigen_val = val; 150 min_eigen_val_idx = i; 151 } 152 } 153 } 154 } 155 } 156 } 157 } 158 159 // 绘制特征点 160 cv::Mat color_img; 161 cv::cvtColor(img, color_img, CV_GRAY2BGR); 162 for (int i = 0; i < key_points.size(); ++i) 163 cv::circle(color_img, key_points[i], 5, cv::Scalar(255, 0, 0), 1, cv::LINE_AA); 164 165 }
由于每一个关键点对应一对特征值，这里使用特征值作为关键点的简单描述符，尝试关键点匹配（效果较差），代码如下：
1 void matchKeypoints(std::vector<cv::Point>& prev_key_points, std::vector<cv::Point2f>& prev_eigen_vals, 2 std::vector<cv::Point>& next_key_points, std::vector<cv::Point2f>& next_eigen_vals, std::vector<cv::Point>& match) 3 { 4 5 std::vector<int> prev_used; 6 std::vector<int> next_used; 7 for (int i = 0; i < prev_eigen_vals.size(); ++i) 8 prev_used.push_back(0); 9 for (int i = 0; i < next_eigen_vals.size(); ++i) 10 next_used.push_back(0); 11 12 match.clear(); 13 for (int i = 0; i < prev_eigen_vals.size(); ++i) 14 { 15 if (prev_used[i] > 0) 16 continue; 17 18 float min_dist = .0001 * .0001; 19 int min_dist_idx = -1; 20 for (int j = 0; j < next_eigen_vals.size(); ++j) 21 { 22 if (next_used[j] > 0) 23 continue; 24 25 float dist = (prev_eigen_vals[i].x - next_eigen_vals[j].x) * 26 (prev_eigen_vals[i].x - next_eigen_vals[j].x) + 27 (prev_eigen_vals[i].y - next_eigen_vals[j].y) * 28 (prev_eigen_vals[i].y - next_eigen_vals[j].y); 29 if (dist < min_dist) 30 { 31 min_dist = dist; 32 min_dist_idx = j; 33 } 34 } 35 36 if (min_dist_idx < 0) 37 continue; 38 39 float min_dist2 = .0001 * .0001; 40 int min_dist_idx2 = -1; 41 for (int k = 0; k < prev_eigen_vals.size(); ++k) 42 { 43 if (prev_used[k] > 0) 44 continue; 45 46 float dist = (prev_eigen_vals[k].x - next_eigen_vals[min_dist_idx].x) * 47 (prev_eigen_vals[k].x - next_eigen_vals[min_dist_idx].x) + 48 (prev_eigen_vals[k].y - next_eigen_vals[min_dist_idx].y) * 49 (prev_eigen_vals[k].y - next_eigen_vals[min_dist_idx].y); 50 if (dist < min_dist2) 51 { 52 min_dist2 = dist; 53 min_dist_idx2 = k; 54 } 55 } 56 57 if (min_dist < min_dist2) 58 { 59 if (min_dist_idx >= 0) 60 { 61 match.push_back(cv::Point(i, min_dist_idx)); 62 prev_used[i] = 1; 63 next_used[min_dist_idx] = 1; 64 } 65 } 66 else 67 { 68 if (min_dist_idx2 >= 0) 69 { 70 match.push_back(cv::Point(min_dist_idx2, min_dist_idx)); 71 prev_used[min_dist_idx2] = 1; 72 next_used[min_dist_idx] = 1; 73 } 74 } 75 } 76 }
1 // 分别求两幅图像关键点，将对应特征值向量作为关键点描述符 2 std::vector<cv::Point> key_points; 3 std::vector<cv::Point2f> eigen_vals; 4 harrisKeyPoints(img, key_points, eigen_vals, 1); 5 6 std::vector<cv::Point> key_points2; 7 std::vector<cv::Point2f> eigen_vals2; 8 harrisKeyPoints(img2, key_points2, eigen_vals2, 0); 9 10 // 简单匹配 11 std::vector<cv::Point> match; 12 matchKeypoints(key_points, eigen_vals, key_points2, eigen_vals2, match); 13 14 // 输出匹配结果 15 cv::Mat match_img = cv::Mat::zeros(img.rows, img.cols * 2 + 4, CV_8UC1); 16 for (int y = 0; y < match_img.rows; ++y) 17 { 18 uchar *dst_data1 = match_img.ptr<uchar>(y); 19 uchar *dst_data2 = dst_data1 + img.cols + 4; 20 uchar *src_data1 = img.ptr<uchar>(y); 21 uchar *src_data2 = img2.ptr<uchar>(y); 22 23 memcpy(dst_data1, src_data1, img.cols); 24 memcpy(dst_data2, src_data2, img2.cols); 25 } 26 27 for (int i = 0; i < match.size(); ++i) 28 { 29 cv::Point pt1(key_points[match[i].x]); 30 cv::Point pt2(key_points2[match[i].y]); 31 pt2.x += img.cols + 4; 32 cv::line(match_img, pt1, pt2, cv::Scalar(255), 2); 33 } 34
参考资料 Learning OpenCV 3 Adrian Kaehler & Gary Bradski