【opencv】教程代码 —TrackingMotion 角点检测

角点检测
执行角点检测并在可能的角点周围画一个圆
对图像中的角点位置进行检测和细化
Shi-Tomasi方法检测图像角点

1. cornerDetector_Demo.cpp 角点检测

cpp 复制代码

/**
 * @function cornerDetector_Demo.cpp
 * @brief Demo code for detecting corners using OpenCV built-in functions
 * 使用 OpenCV 内置函数进行角点检测的示例代码
 * @author OpenCV team
 */


#include "opencv2/highgui.hpp" // 包含OpenCV图形界面高级操作的头文件
#include "opencv2/imgproc.hpp" // 包含OpenCV图像处理的头文件
#include <iostream> // 包含标准输入输出流的头文件


using namespace cv; // 使用cv命名空间
using namespace std; // 使用std命名空间


/// 全局变量定义
Mat src, src_gray; // 原图和转换为灰度图的图像
Mat myHarris_dst, myHarris_copy, Mc; // Harris算法结果、副本和M矩阵
Mat myShiTomasi_dst, myShiTomasi_copy; // Shi-Tomasi算法结果和副本


int myShiTomasi_qualityLevel = 50; // Shi-Tomasi算法质量等级
int myHarris_qualityLevel = 50; // Harris算法质量等级
int max_qualityLevel = 100; // 最大质量等级


double myHarris_minVal, myHarris_maxVal; // Harris算法最小和最大值
double myShiTomasi_minVal, myShiTomasi_maxVal; // Shi-Tomasi算法最小和最大值


RNG rng(12345); // 随机数生成器，用于产生颜色


const char* myHarris_window = "My Harris corner detector"; // Harris检测器窗口名称
const char* myShiTomasi_window = "My Shi Tomasi corner detector"; // Shi-Tomasi检测器窗口名称


/// 函数头定义
void myShiTomasi_function( int, void* ); // Shi-Tomasi算法函数
void myHarris_function( int, void* ); // Harris算法函数


/**
 * @function main
 */
int main( int argc, char** argv )
{
    /// 加载源图像并将其转换为灰度图
    CommandLineParser parser( argc, argv, "{@input | building.jpg | input image}" );
    src = imread( samples::findFile( parser.get<String>( "@input" ) ) );
    if ( src.empty() )
    {
        cout << "Could not open or find the image!\n" << endl;
        cout << "Usage: " << argv[0] << " <Input image>" << endl;
        return -1;
    }
    cvtColor( src, src_gray, COLOR_BGR2GRAY );


    /// 设置一些参数
    int blockSize = 3, apertureSize = 3; // 定义Harris矩阵和Shi-Tomasi矩阵的块大小和孔径大小


    /// 使用cornerEigenValsAndVecs计算Harris矩阵
    cornerEigenValsAndVecs( src_gray, myHarris_dst, blockSize, apertureSize );
    
    /* 计算 Harris 响应函数Mc */
    Mc = Mat( src_gray.size(), CV_32FC1 ); // 初始化Mc矩阵，大小与灰度图一致
    for( int i = 0; i < src_gray.rows; i++ ) // 遍历图像的每一行
    {
        for( int j = 0; j < src_gray.cols; j++ ) // 遍历图像的每一列
        {
            float lambda_1 = myHarris_dst.at<Vec6f>(i, j)[0]; // 获取第一个特征值lambda_1
            float lambda_2 = myHarris_dst.at<Vec6f>(i, j)[1]; // 获取第二个特征值lambda_2
            Mc.at<float>(i, j) = lambda_1*lambda_2 - 0.04f * ((lambda_1 + lambda_2) * (lambda_1 + lambda_2)); // 计算Mc中每个像素的Harris响应值
        }
    }
    
    minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal ); // 寻找Mc中的最小值和最大值
    
    /* 创建窗口和滑动条 */
    namedWindow( myHarris_window ); // 创建一个名为"My Harris corner detector"的窗口
    createTrackbar( "Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, myHarris_function ); // 创建一个滑动条以调整Harris检测器的质量等级
    myHarris_function( 0, 0 ); // 调用Harris检测器函数
    
    /// 使用cornerMinEigenVal计算Shi-Tomasi矩阵
    cornerMinEigenVal( src_gray, myShiTomasi_dst, blockSize, apertureSize ); // 直接计算灰度图的Shi-Tomasi响应值
    
    minMaxLoc( myShiTomasi_dst, &myShiTomasi_minVal, &myShiTomasi_maxVal ); // 寻找Shi-Tomasi响应值矩阵中的最小值和最大值
    
    /* 创建窗口和滑动条 */
    namedWindow( myShiTomasi_window ); // 创建一个名为"My Shi Tomasi corner detector"的窗口
    createTrackbar( "Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function ); // 创建一个滑动条以调整Shi-Tomasi检测器的质量等级
    myShiTomasi_function( 0, 0 ); // 调用Shi-Tomasi检测器函数
    
    waitKey();
    return 0;
}


/**
 * @function myShiTomasi_function
 */
void myShiTomasi_function( int, void* )
{
    myShiTomasi_copy = src.clone(); // 克隆原图用于绘制
    myShiTomasi_qualityLevel = MAX(myShiTomasi_qualityLevel, 1); // 确保质量等级至少为1


    // 遍历图像每个像素
    for( int i = 0; i < src_gray.rows; i++ )
    {
        for( int j = 0; j < src_gray.cols; j++ )
        {
            // 依据质量等级，判断并绘制角点
            if( myShiTomasi_dst.at<float>(i,j) > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel )
            {
                circle( myShiTomasi_copy, Point(j,i), 4, Scalar( rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256) ), FILLED );
            }
        }
    }
    imshow( myShiTomasi_window, myShiTomasi_copy ); // 显示结果
}


/**
 * @function myHarris_function
 */
void myHarris_function( int, void* )
{
    myHarris_copy = src.clone(); // 克隆原图用于绘制
    myHarris_qualityLevel = MAX(myHarris_qualityLevel, 1); // 确保质量等级至少为1


    // 遍历图像每个像素
    for( int i = 0; i < src_gray.rows; i++ )
    {
        for( int j = 0; j < src_gray.cols; j++ )
        {
            // 依据质量等级，判断并绘制角点
            if( Mc.at<float>(i,j) > myHarris_minVal + ( myHarris_maxVal - myHarris_minVal )*myHarris_qualityLevel/max_qualityLevel )
            {
                circle( myHarris_copy, Point(j,i), 4, Scalar( rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256) ), FILLED );
            }
        }
    }
    imshow( myHarris_window, myHarris_copy ); // 显示结果
}

这段代码是一个用于检测图像中角点的完整示例程序，使用了OpenCV库。它实现了两种角点检测方法：Harris角点检测和Shi-Tomasi角点检测。代码首先读取图像，然后将其转换为灰度图以进行处理。接下来分别计算两种方法的角点响应函数，并创建滑动条以调整检测角点的质量等级。通过滑动条调整后，程序会根据计算出的响应值和用户设定的质量等级绘制出角点。最后显示处理后带有标记角点的图像。

cornerEigenValsAndVecs(src_gray, myHarris_dst, blockSize, apertureSize);

cornerMinEigenVal(src_gray, myShiTomasi_dst, blockSize, apertureSize);

bash 复制代码

if( myShiTomasi_dst.at<float>(i,j) > myShiTomasi_minVal + ( myShiTomasi_maxVal - myShiTomasi_minVal )*myShiTomasi_qualityLevel/max_qualityLevel )
{
    circle( myShiTomasi_copy, Point(j,i), 4, Scalar( rng.uniform(0,256), rng.uniform(0,256), rng.uniform(0,256) ), FILLED );
}

2. cornerHarris_Demo.cpp执行角点检测并在可能的角点周围画一个圆

该代码是一个使用Harris-Stephens方法进行角点检测的演示程序。主要实现以下功能：

读取一张图片，并将其转换为灰度图像。
创建一个窗口和一个滑动条以调整Harris角点检测的阈值。
使用Harris-Stephens角点检测算法检测图像角点。
检测到角点后，在图像上绘制圆形以标记这些角点。
在两个窗口中分别显示原始图像和检测到角点后的图像。

cpp 复制代码

/**
 * @function cornerHarris_Demo.cpp
 * @brief Demo code for detecting corners using Harris-Stephens method
 * @author OpenCV team
 */


#include "opencv2/highgui.hpp" // 包含OpenCV图形界面头文件
#include "opencv2/imgproc.hpp" // 包含OpenCV图像处理头文件
#include <iostream> // 包含标准输入输出流头文件


using namespace cv; // 使用cv命名空间，省去cv::前缀
using namespace std; // 使用std命名空间，省去std::前缀


/// Global variables
Mat src, src_gray; // 声明全局变量src和src_gray，存储原始图像和灰度图像
int thresh = 200; // 声明全局变量thresh，定义Harris角点检测阈值
int max_thresh = 255; // 定义最大阈值


const char* source_window = "Source image"; // 窗口名称常量，原图窗口
const char* corners_window = "Corners detected"; // 窗口名称常量，角点检测结果窗口


/// Function header
void cornerHarris_demo( int, void* ); // 声明函数cornerHarris_demo


/**
 * @function main
 */
int main( int argc, char** argv )
{
    /// Load source image and convert it to gray
    CommandLineParser parser( argc, argv, "{@input | building.jpg | input image}" ); // 解析命令行参数
    src = imread( samples::findFile( parser.get<String>( "@input" ) ) ); // 读取图像文件
    if ( src.empty() )
    {
        cout << "Could not open or find the image!\n" << endl; // 如果图像为空，输出错误信息
        cout << "Usage: " << argv[0] << " <Input image>" << endl; // 提示使用方法
        return -1; // 返回错误代码，终止程序
    }
    cvtColor( src, src_gray, COLOR_BGR2GRAY ); // 将原图像转换为灰度图像


    /// Create a window and a trackbar
    namedWindow( source_window ); // 创建一个窗口
    createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo ); // 创建一个滑动条
    imshow( source_window, src ); // 在窗口中显示原图像


    cornerHarris_demo( 0, 0 ); // 调用cornerHarris_demo函数，执行角点检测


    waitKey(); // 等待按键事件
    return 0; // 正常结束程序
}


/**
 * @function cornerHarris_demo
 * @brief Executes the corner detection and draw a circle around the possible corners
 */
void cornerHarris_demo( int, void* )
{
    /// Detector parameters
    int blockSize = 2; // 角点检测中块的大小
    int apertureSize = 3; // Sobel算子的孔径大小
    double k = 0.04; // Harris角点检测方程中的自由参数
    
    /// Detecting corners
    Mat dst = Mat::zeros( src.size(), CV_32FC1 ); // 创建一个和原图像同样大小的矩阵，初始值为0
    cornerHarris( src_gray, dst, blockSize, apertureSize, k ); // 执行Harris角点检测


    /// Normalizing
    Mat dst_norm, dst_norm_scaled; // 声明两个Mat类型变量，存储正规化后的图像和转换为8位的图像
    normalize( dst, dst_norm, 0, 255, NORM_MINMAX, CV_32FC1, Mat() ); // 正规化处理
    convertScaleAbs( dst_norm, dst_norm_scaled ); // 将正规化后的图像转换为8位


    /// Drawing a circle around corners
    for( int i = 0; i < dst_norm.rows ; i++ )
    {
        for( int j = 0; j < dst_norm.cols; j++ )
        {
            if( (int) dst_norm.at<float>(i,j) > thresh ) // 判断是否为角点
            {
                circle( dst_norm_scaled, Point(j,i), 5,  Scalar(0), 2, 8, 0 ); // 在检测到的角点位置绘制圆圈
            }
        }
    }


    /// Showing the result
    namedWindow( corners_window ); // 创建一个新窗口以显示结果
    imshow( corners_window, dst_norm_scaled ); // 显示结果图像
}

convertScaleAbs( dst_norm, dst_norm_scaled );

3. cornerSubPix_Demo.cpp对图像中的角点位置进行检测和细化

cpp 复制代码

/**
 * @function cornerSubPix_Demo.cpp
 * @brief Demo code for refining corner locations
 * @author OpenCV team
 */


#include "opencv2/highgui.hpp" // 包含OpenCV图形界面高级操作头文件
#include "opencv2/imgproc.hpp" // 包含OpenCV图像处理头文件
#include <iostream> // 包含标准输入输出流头文件


using namespace cv; // 使用命名空间cv，避免每次调用OpenCV函数时都要加cv::前缀
using namespace std; // 使用命名空间std，避免每次调用标准库函数时都要加std::前缀


/// 全局变量定义区域
Mat src, src_gray; // 定义源图像和灰度图像


int maxCorners = 10; // 最大角点数量初始化为10
int maxTrackbar = 25; // 轨迹条的最大值为25


RNG rng(12345); // 随机数生成器，种子为12345
const char* source_window = "Image"; // 显示窗口的名称


/// 函数头声明
void goodFeaturesToTrack_Demo( int, void* );


/**
 * @function main
 */
int main( int argc, char** argv )
{
    /// 读取源图像并转换成灰度图像
    CommandLineParser parser( argc, argv, "{@input | pic3.png | input image}" ); // 解析命令行参数
    src = imread( samples::findFile( parser.get<String>( "@input" ) ) ); // 读取图片文件
    if( src.empty() ) // 如果读取失败，则输出错误信息并返回-1
    {
        cout << "Could not open or find the image!\n" << endl;
        cout << "Usage: " << argv[0] << " <Input image>" << endl;
        return -1;
    }
    cvtColor( src, src_gray, COLOR_BGR2GRAY ); // 把源图像转换为灰度图像


    /// 创建窗口
    namedWindow( source_window );


    /// 创建轨迹条以设置角点数量
    createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );


    imshow( source_window, src ); // 显示源图像


    goodFeaturesToTrack_Demo( 0, 0 ); // 调用角点检测函数


    waitKey(); // 等待键盘事件
    return 0;
}


/**
 * @function goodFeaturesToTrack_Demo.cpp
 * @brief Apply Shi-Tomasi corner detector
 */
void goodFeaturesToTrack_Demo( int, void* )
{
    /// Shi-Tomasi算法的参数设定
    maxCorners = MAX(maxCorners, 1); // 确保角点的数量至少为1
    vector<Point2f> corners; // 角点集合
    double qualityLevel = 0.01; // 角点检测可接受的最小特征值
    double minDistance = 10; // 角点之间的最小距离
    int blockSize = 3, gradientSize = 3; // 块大小和梯度大小
    bool useHarrisDetector = false; // 是否使用哈里斯角点检测器
    double k = 0.04; // 哈里斯角点检测器的自由参数


    /// 复制源图像
    Mat copy = src.clone();


    /// 应用角点检测
    goodFeaturesToTrack( src_gray,
                         corners,
                         maxCorners,
                         qualityLevel,
                         minDistance,
                         Mat(),
                         blockSize,
                         gradientSize,
                         useHarrisDetector,
                         k );




    /// 绘制检测到的角点
    cout << "** Number of corners detected: " << corners.size() << endl;
    int radius = 4; // 绘制的圆形角点的半径
    for( size_t i = 0; i < corners.size(); i++ ) // 遍历所有检测到的角点
    {
        // 绘制圆形角点，颜色随机
        circle( copy, corners[i], radius, Scalar(rng.uniform(0,255), rng.uniform(0, 256), rng.uniform(0, 256)), FILLED );
    }


    /// 显示结果
    namedWindow( source_window );
    imshow( source_window, copy ); // 显示含有角点的图像


    /// 设置细化角点所需的参数
    Size winSize = Size( 5, 5 ); // 搜索窗口的大小
    Size zeroZone = Size( -1, -1 ); // 死区的大小
    TermCriteria criteria = TermCriteria( TermCriteria::EPS + TermCriteria::COUNT, 40, 0.001 ); // 终止迭代的条件


    /// 计算细化后的角点位置
    cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );


    /// 输出细化后的角点位置
    for( size_t i = 0; i < corners.size(); i++ ) // 遍历细化后的角点集
    {
        // 打印每个细化后的角点坐标
        cout << " -- Refined Corner [" << i << "]  (" << corners[i].x << "," << corners[i].y << ")" << endl;
    }
}

该代码是OpenCV的一个演示程序，用于展示如何对图像中的角点位置进行检测和细化 。代码首先读取图像并转换成灰度图像，然后创建一个窗口并添加一个轨迹条来设置角点的最大数量。通过Shi-Tomasi角点检测函数goodFeaturesToTrack来检测图像中的角点 。之后，利用**cornerSubPix函数对已检测到的角点进行位置细化**。结果显示了检测到的角点的数量以及细化后的角点的位置。

cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );

4. goodFeaturesToTrack_Demo.cpp Shi-Tomasi方法检测图像角点

cpp 复制代码

/**
 * @function goodFeaturesToTrack_Demo.cpp
 * @brief Demo code for detecting corners using Shi-Tomasi method
 * @author OpenCV team
 */


#include "opencv2/imgcodecs.hpp"  // 引入OpenCV图像编解码功能库
#include "opencv2/highgui.hpp"     // 引入OpenCV的高级GUI功能库
#include "opencv2/imgproc.hpp"     // 引入OpenCV图像处理功能库
#include <iostream>                // 引入输入输出流库


using namespace cv;               // 使用OpenCV命名空间
using namespace std;              // 使用标准命名空间


/// Global variables
Mat src, src_gray;  // 定义原图像及其灰度图像的全局变量


int maxCorners = 23;               // 定义检测到的最大角点数量
int maxTrackbar = 100;             // 跟踪条的最大值


RNG rng(12345);                    // 定义随机数生成器，用于画图时颜色的随机
const char* source_window = "Image";  // 定义用于显示图像的窗口名


/// Function header
void goodFeaturesToTrack_Demo( int, void* );  // 声明检测角点的函数原型


/**
 * @function main
 */
int main( int argc, char** argv )
{
    /// Load source image and convert it to gray
    CommandLineParser parser( argc, argv, "{@input | pic3.png | input image}" );  // 解析命令行参数
    src = imread( samples::findFile( parser.get<String>( "@input" ) ) );  // 读取图片文件
    if( src.empty() )
    {
        cout << "Could not open or find the image!\n" << endl;  // 如果图片为空，打印错误信息
        cout << "Usage: " << argv[0] << " <Input image>" << endl;
        return -1;
    }
    cvtColor( src, src_gray, COLOR_BGR2GRAY );  // 将原图像转换为灰度图像


    /// Create Window
    namedWindow( source_window );  // 创建一个窗口


    /// Create Trackbar to set the number of corners
    createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );  // 创建一个跟踪条以调整角点的最大数量


    imshow( source_window, src );  // 显示源图像


    goodFeaturesToTrack_Demo( 0, 0 );  // 调用goodFeaturesToTrack_Demo函数


    waitKey();  // 等待按键事件
    return 0;
}


/**
 * @function goodFeaturesToTrack_Demo.cpp
 * @brief Apply Shi-Tomasi corner detector
 */
void goodFeaturesToTrack_Demo( int, void* )
{
    /// Parameters for Shi-Tomasi algorithm
    maxCorners = MAX(maxCorners, 1);  // 确保角点数至少为1
    vector<Point2f> corners;  // 定义角点集合
    double qualityLevel = 0.01;  // 定义角点检测的质量水平
    double minDistance = 10;     // 角点之间的最小距离
    int blockSize = 3, gradientSize = 3;  // 定义块大小和梯度大小
    bool useHarrisDetector = false;  // 是否使用Harris角点检测器
    double k = 0.04;  // Harris检测器的自由参数


    /// Copy the source image
    Mat copy = src.clone();  // 复制源图像


    /// Apply corner detection
    goodFeaturesToTrack( src_gray,  // 输入图像
                         corners,  // 输出角点集合
                         maxCorners,  // 角点的最大数量
                         qualityLevel,  // 角点检测的质量水平
                         minDistance,  // 角点之间的最小距离
                         Mat(),  // 蒙版，为空代表不使用
                         blockSize,  // 块大小
                         gradientSize,  // 梯度大小
                         useHarrisDetector,  // 是否使用Harris检测器
                         k );  // Harris检测器的参数


    /// Draw corners detected
    cout << "** Number of corners detected: " << corners.size() << endl;  // 打印检测到的角点数量
    int radius = 4;  // 角点绘制的圆半径
    for( size_t i = 0; i < corners.size(); i++ )
    {
        circle( copy, corners[i], radius, Scalar(rng.uniform(0,255), rng.uniform(0, 256), rng.uniform(0, 256)), FILLED );  // 在图像上绘制检测到的角点
    }


    /// Show what you got
    namedWindow( source_window );  // 创建窗口
    imshow( source_window, copy );  // 显示含有角点的图像
}

此代码是使用C++语言和OpenCV库编写的角点检测示例程序。它可以加载一个图像文件，将其转换为灰度图，然后使用Shi-Tomasi角点检测方法检测图像中的角点。程序通过一个可调的跟踪条允许用户设置最大角点数，并在图像中显示检测到的角点数量。检测到的角点会以彩色圆圈标出并展示在一个新窗口中。这个示例程序适用于那些想要学习如何使用OpenCV进行基本角点检测的开发者。