OpenCV——Harris、Shi Tomas、自定义、亚像素角点检测

 #include <opencv2/opencv.hpp>
 #include <iostream>

 using namespace cv;
 using namespace std;

 int main(int argc, char** argv)
 {
     Mat src;
     src = imread("数字.jpg",);
     if (src.empty()){
         printf("Can not load Image...");
         return -;
     }
     imshow("input Image", src);

     //进行Harris角点检测
     Mat cornerStrength;
     cornerHarris(src, cornerStrength,,,0.01);//返回局部最大值作为像素，角点坐标存储在cornerStrength中
     imshow("角点检测的图", cornerStrength);//值太小，未转成二值图像显示不明显

     Mat harrisCorner;
     threshold(cornerStrength, harrisCorner,0.00001,,THRESH_BINARY);
     imshow("角点检测的二值图", harrisCorner);

     waitKey();
     return ;
 }

 #include <opencv2/opencv.hpp>
 #include <iostream>

 using namespace cv;
 using namespace std;

 Mat src,src_gray;

 int thresh = ;
 int max_count = ;

 const char* output_title = "Harris_CornerDetection Result";

 void Harris_demo(int,void*);

 int main(int argc, char** argv)
 {
     src = imread("数字.jpg");
     if (src.empty()) {
         printf("Can not load Image...");
         return -;
     }
     imshow("input Image",src);

     cvtColor(src, src_gray, COLOR_BGR2GRAY);

     namedWindow(output_title,CV_WINDOW_AUTOSIZE);
     createTrackbar("Threshold", output_title,&thresh, max_count, Harris_demo);
     Harris_demo(, );

     waitKey();
     return ;
 }

 void Harris_demo(int, void*) {

     Mat cornerStrength;
     int blockSize = ;
     int ksize = ;
     double k = 0.04;
     cornerHarris(src_gray, cornerStrength, blockSize, ksize,k,BORDER_DEFAULT);//返回局部最大值作为像素，角点坐标存储在cornerStrength中
     normalize(cornerStrength, cornerStrength, , , NORM_MINMAX);//归一化
     convertScaleAbs(cornerStrength, cornerStrength);//变成8位无符号整型

     //循环遍历每个像素，将大于阈值的点画出来
     Mat resultImage = src.clone();
     for (int row = ; row < resultImage.rows; row++) {
         uchar* currentRow = cornerStrength.ptr(row);
         for (int col = ; col < resultImage.cols; col++) {
             int value = (int)*currentRow;
             if (value > thresh) {
                 circle(resultImage,Point(col,row),,Scalar(,,),,,);
             }
             currentRow++;
         }
     }

     imshow(output_title, resultImage);

 }

 因为公式更简单，所以Shi-Tomasi角点检测比Harris要快得多

 #include <opencv2/opencv.hpp>
 #include <iostream>

 using namespace cv;
 using namespace std;

 Mat src,src_gray;

 int num_corners = ;
 int max_corners = ;
 const char* output_title = "Shi_Tomasi Detector";

 void Shi_Tomasi_demo(int,void*);

 RNG rng();

 int main(int argc, char** argv) {
     src = imread("数字.jpg");
     if (src.empty()) {
         printf("could not load image...\n");
         return -;
     }
     namedWindow("input image", CV_WINDOW_AUTOSIZE);
     imshow("input image", src);

     cvtColor(src,src_gray,COLOR_BGR2GRAY);

     namedWindow(output_title, CV_WINDOW_AUTOSIZE);
     createTrackbar("角点数:", output_title, &num_corners, max_corners, Shi_Tomasi_demo);
     Shi_Tomasi_demo(,);

     waitKey();
     return ;
 }

 void Shi_Tomasi_demo(int, void*) {
     if (num_corners < ) num_corners = ;

     vector<Point2f> corners;//保存检测到的角点
     //参数设置
     double qualityLevel = 0.01;
     double minDistance = ;
     int blockSize = ;
     bool useHarris = false;//是否使用Harris角点检测
     double k = 0.04;//如果前面使用了角点检测，则需要用到这一项，没有则没有用

     goodFeaturesToTrack(src_gray,corners,num_corners,qualityLevel,minDistance,Mat(),blockSize,useHarris,k);
     printf("Number of detected corner: %d\n",(int)corners.size());

     //画出角点
     Mat resultImage = src.clone();
     for (size_t t=; t < corners.size(); t++)
     {
         circle(resultImage, corners[t], , Scalar(rng.uniform(, ), rng.uniform(, ), rng.uniform(, )), , , );
     }
     imshow(output_title, resultImage);

 }

自定义角点检测器简介:

• 基于Harris与Shi-Tomasi角点检测

• 首先通过计算矩阵M得到lamda1和lamda2两个特征值根据他们得到角点响应值

• 然后自己设置阈值实现计算出阈值得到有效响应值的角点设置

相关API

C++: void cornerEigenValsAndVecs(
       InputArray src,       --单通道输入8位或浮点图像
       OutputArray dst,    --输出图像，同源图像或CV_32FC()
       int blockSize,         --邻域大小值
       int apertureSize,    --Sobel算子的参数
       int borderType=BORDER_DEFAULT --像素外插方法
)//对应于Harris

C++: void cornerMinEigenVal(
       InputArray src,     --单通道输入8位或浮点图像
       OutputArray dst,  --图像存储的最小特征值。类型为CV_32FC1
       int blockSize,       --邻域大小值
       int apertureSize=,   --Sobel算子的参数
       int borderType=BORDER_DEFAULT  --像素外插方法
}//对应Shi-Tomasi

 #include <opencv2/opencv.hpp>
 #include <iostream>

 using namespace cv;
 using namespace std;

 Mat src,src_gray;
 Mat HarrisRsImage;

 double harris_min_rsp,harris_max_rsp;
 int qualityLevel = ;
 int max_count = ;

 const char* harris_window = "Harris";

 void CustomHarris_demo(int, void*);

 int main(int argc, char** argv)
 {
     src = imread("数字.jpg");
     if (src.empty()) {
         printf("Can not load Image...");
         return -;
     }
     imshow("input Image",src);

     cvtColor(src, src_gray, COLOR_BGR2GRAY);

     //计算特征值lambda1和lambda2
     int blockSize = ;
     int ksize = ;
     Mat Harris_dst=Mat::zeros(src.size(),CV_32FC());//CV_32FC(6),有6个值要存储
     cornerEigenValsAndVecs(src_gray, Harris_dst, blockSize, ksize,);

     //计算响应
     HarrisRsImage = Mat::zeros(src.size(), CV_32FC1);
     double k = 0.04;
     for (int row = ; row < Harris_dst.rows; row++) {
         for (int col = ; col < Harris_dst.cols; col++) {
             double lambda1=Harris_dst.at<Vec6f>(row, col)[];
             double lambda2= Harris_dst.at<Vec6f>(row, col)[];
             HarrisRsImage.at<float>(row, col) = lambda1 * lambda2 - k * pow((lambda1 + lambda2), );
         }
     }

     minMaxLoc(HarrisRsImage,&harris_min_rsp,&harris_max_rsp,,,Mat());
     namedWindow(harris_window,CV_WINDOW_AUTOSIZE);
     createTrackbar("Quality", harris_window,&qualityLevel, max_count,CustomHarris_demo);
     CustomHarris_demo(,);

     waitKey();
     return ;
 }

 void CustomHarris_demo(int, void*)
 {
     if (qualityLevel < ) qualityLevel = ;
     Mat resultImage = src.clone();

     float thresh = harris_min_rsp + (((double)qualityLevel) / max_count)*(harris_max_rsp - harris_min_rsp);//阈值
     for (int row = ; row < src.rows; row++) {
         for (int col = ; col < src.cols; col++) {
             float value = HarrisRsImage.at<float>(row, col);
             if (value > thresh) {
                 circle(resultImage, Point(col, row), , Scalar(, , ), , , );
             }

         }
     }

     imshow(harris_window, resultImage);
 }

 //Shi-Tomasi和Harris自定义角点检测

 #include <opencv2/opencv.hpp>
 #include <iostream>

 #include <math.h>
 using namespace cv;
 using namespace std;
 const char* harris_win = "Custom Harris Corners Detector";
 const char* shitomasi_win = "Custom Shi-Tomasi Corners Detector";
 Mat src, gray_src;
 // harris corner response
 Mat harris_dst, harrisRspImg;
 double harris_min_rsp;
 double harris_max_rsp;
 // shi-tomasi corner response
 Mat shiTomasiRsp;
 double shitomasi_max_rsp;
 double shitomasi_min_rsp;
 int sm_qualitylevel = ;
 // quality level
 int qualityLevel = ;
 int max_count = ;
 void CustomHarris_Demo(int, void*);
 void CustomShiTomasi_Demo(int, void*);
 int main(int argc, char** argv) {
     src = imread("D:/vcprojects/images/home.jpg");
     if (src.empty()) {
         printf("could not load image...\n");
         return -;
     }
     namedWindow("input image", CV_WINDOW_AUTOSIZE);
     imshow("input image", src);
     cvtColor(src, gray_src, COLOR_BGR2GRAY);
     // 计算特征值
     int blockSize = ;
     int ksize = ;
     double k = 0.04;
     harris_dst = Mat::zeros(src.size(), CV_32FC());
     harrisRspImg = Mat::zeros(src.size(), CV_32FC1);
     cornerEigenValsAndVecs(gray_src, harris_dst, blockSize, ksize, );
     // 计算响应
     for (int row = ; row < harris_dst.rows; row++) {
         for (int col = ; col < harris_dst.cols; col++) {
             double lambda1 =harris_dst.at<Vec6f>(row, col)[];
             double lambda2 = harris_dst.at<Vec6f>(row, col)[];
             harrisRspImg.at<float>(row, col) = lambda1*lambda2 - k*pow((lambda1 + lambda2), );
         }
     }
     minMaxLoc(harrisRspImg, &harris_min_rsp, &harris_max_rsp, , , Mat());
     namedWindow(harris_win, CV_WINDOW_AUTOSIZE);
     createTrackbar("Quality Value:", harris_win, &qualityLevel, max_count, CustomHarris_Demo);
     CustomHarris_Demo(, );

     // 计算最小特征值
     shiTomasiRsp = Mat::zeros(src.size(), CV_32FC1);
     cornerMinEigenVal(gray_src, shiTomasiRsp, blockSize, ksize, );
     minMaxLoc(shiTomasiRsp, &shitomasi_min_rsp, &shitomasi_max_rsp, , , Mat());
     namedWindow(shitomasi_win, CV_WINDOW_AUTOSIZE);
     createTrackbar("Quality:", shitomasi_win, &sm_qualitylevel, max_count, CustomShiTomasi_Demo);
     CustomShiTomasi_Demo(, );

     waitKey();
     return ;
 }

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

     imshow(harris_win, resultImg);
 }

 void CustomShiTomasi_Demo(int, void*) {
     if (sm_qualitylevel < ) {
         sm_qualitylevel = ;
     }

     Mat resultImg = src.clone();
     float t = shitomasi_min_rsp + (((double)sm_qualitylevel) / max_count)*(shitomasi_max_rsp - shitomasi_min_rsp);
     for (int row = ; row < src.rows; row++) {
         for (int col = ; col < src.cols; col++) {
             float v = shiTomasiRsp.at<float>(row, col);
             if (v > t) {
                 circle(resultImg, Point(col, row), , Scalar(, , ), , , );
             }
         }
     }
     imshow(shitomasi_win, resultImg);
 }

 #include <opencv2/opencv.hpp>
 #include <iostream>

 using namespace cv;
 using namespace std;

 Mat src,src_gray;

 int max_corners = ;
 int max_count = ;

 const char* output_title = "SubPix Result";

 void SubPixel_demo(int,void*);

 int main(int argc, char** argv)
 {
     src = imread("数字.jpg");
     if (src.empty()) {
         printf("Can not load Image...");
         return -;
     }
     imshow("input Image",src);

     cvtColor(src, src_gray, COLOR_BGR2GRAY);

     namedWindow(output_title,CV_WINDOW_AUTOSIZE);
     createTrackbar("Corners:", output_title,&max_corners, max_count, SubPixel_demo);
     SubPixel_demo(,);

     waitKey();
     return ;
 }

 void SubPixel_demo(int, void*)
 {
     if (max_corners < ) max_corners = ;

     //先进行Shi-Tomasi角点检测
     vector<Point2f> corners;
     double qualityLevel = 0.01;
     double minDistance = ;
     int blockSize = ;
     goodFeaturesToTrack(src_gray, corners,max_corners,qualityLevel,minDistance,Mat());
     cout << "number of corners:" << corners.size() << endl;

     //画出角点
     Mat resultImage = src.clone();
     for (size_t t = ; t < corners.size(); t++)
     {
         circle(resultImage, corners[t],,Scalar(,,),,,);
     }

     imshow(output_title, resultImage);

     Size winSize = Size(,);
     Size zerozone = Size(-, -);
     TermCriteria tc = TermCriteria(TermCriteria::EPS+ TermCriteria::MAX_ITER,,0.001);//最大值迭代次数40，精度半径0.001
     cornerSubPix(src_gray, corners, winSize, zerozone, tc);//corners需要输入初始坐标，然后输出精确坐标（因此前面才会先做Shi—Tomasi）
     for (size_t t = ; t < corners.size(); t++)
     {
         cout << (t + ) << "Point(x,y):" << corners[t].x << "," << corners[t].y << endl;
     }
 }