Leaning OpenCV:Corner Detection Using cvGoodFeaturesToTrack

转自：http://blog.csdn.net/utimes/archive/2010/07/05/5714224.aspx

Here’s an example opencv application which uses cvGoodFeaturesToTrack to detect corners in a webcam video feed.

// This code displays corners found by the opencv function
// GoodFeaturesToTrack (cvGoodFeaturesToTrack)
//
// Note: I commented out the corner detection using the Harris
// algorithm because my computer isn't fast enough to process
// both the Harris and the eigenvalue corners in real time.
// You can uncomment it and test for yourself.
//
#include <cv.h>
#include <highgui.h>
#include <stdio.h>
#include <time.h>
#define VIDEO_WINDOW "Webcam"
#define CORNER_EIG "Eigenvalue Corner Detection"
// Disable harris processing
//#define CORNER_HARRIS "Corner Detection (Harris)"
#define USEC_PER_SEC 1000000L
CvScalar target_color[4] = { // in BGR order
{{ 0, 0, 255, 0 }}, // red
{{ 0, 255, 0, 0 }}, // green
{{ 255, 0, 0, 0 }}, // blue
{{ 0, 255, 255, 0 }} // yellow
};
// returns the number of usecs of (t2 - t1)
long time_elapsed (struct timeval &t1, struct timeval &t2) {
long sec, usec;
sec = t2.tv_sec - t1.tv_sec;
usec = t2.tv_usec - t1.tv_usec;
if (usec < 0) {
--sec;
usec = usec + USEC_PER_SEC;
}
return sec*USEC_PER_SEC + usec;
}
struct timeval start_time;
struct timeval end_time;
void start_timer() {
struct timezone tz;
gettimeofday (&start_time, &tz);
}
long end_timer() {
struct timezone tz;
gettimeofday (&end_time, &tz);
return time_elapsed(start_time, end_time);
}
// A Simple Camera Capture Framework
int main(int argc, char *argv[]) {
long harris_time;
long eig_time;
CvCapture* capture = 0;
IplImage* curr_frame = 0; // current video frame
IplImage* gray_frame = 0; // grayscale version of current frame
int w, h; // video frame size
IplImage* eig_image = 0;
IplImage* temp_image = 0;
// Disable harris processing
//IplImage* harris_eig_image = 0;
//IplImage* harris_temp_image = 0;

// Pick one of these capture methods:
// You must have compiled opencv with ffmpeg enabled
// to use a web stream!
//capture = cvCaptureFromFile(
//"http://user:pw@192.168.1.101:81/img/video.mjpeg");
//capture = cvCaptureFromAVI(
//"http://user:pw@192.168.1.101:81/img/video.mjpeg");

// Capture from a webcam
capture = cvCaptureFromCAM(CV_CAP_ANY);
//capture = cvCaptureFromCAM(0); // capture from video device #0
if ( !capture) {
fprintf(stderr, "ERROR: capture is NULL... Exiting/n");
//getchar();
return -1;
}

// Create a window in which the captured images will be presented
cvNamedWindow(VIDEO_WINDOW, 0); // allow the window to be resized

cvNamedWindow(CORNER_EIG, 0); // allow the window to be resized
cvMoveWindow(CORNER_EIG, 330, 0);

// Disable harris processing
//cvNamedWindow(CORNER_HARRIS, 0); // allow the window to be resized
//cvMoveWindow(CORNER_HARRIS, 660, 0);

// Show the image captured from the camera in the window and repeat
while (true) {

// Get one frame
curr_frame = cvQueryFrame(capture);
if ( !curr_frame) {
fprintf(stderr, "ERROR: frame is null... Exiting/n");
//getchar();
break;
}
// Do not release the frame!
// Get frame size
w = curr_frame->width;
h = curr_frame->height;
// Convert the frame image to grayscale
if( ! gray_frame ) {
//fprintf(stderr, "Allocate gray_frame/n");
int channels = 1;
gray_frame = cvCreateImage(
cvGetSize(curr_frame),
IPL_DEPTH_8U, channels);
}
cvCvtColor(curr_frame, gray_frame, CV_BGR2GRAY);

// ==== Allocate memory for corner arrays ====
if ( !eig_image) {
//fprintf(stderr, "Allocate eig_image/n");
eig_image = cvCreateImage(cvSize(w, h),
IPL_DEPTH_32F, 1);
}
if ( !temp_image) {
//fprintf(stderr, "Allocate temp_image/n");
temp_image = cvCreateImage(cvSize(w, h),
IPL_DEPTH_32F, 1);
}
// Disable harris processing
//if ( !harris_eig_image) {
fprintf(stderr, "Allocate harris_eig_image/n");
//harris_eig_image = cvCreateImage(cvSize(w, h),
//IPL_DEPTH_32F, 1);
//}
//if ( !harris_temp_image) {
fprintf(stderr, "Allocate harris_temp_image/n");
//harris_temp_image = cvCreateImage(cvSize(w, h),
//IPL_DEPTH_32F, 1);
//}

// ==== Corner Detection: MinEigenVal method ====
start_timer();
const int MAX_CORNERS = 100;
CvPoint2D32f corners[MAX_CORNERS] = {0};
int corner_count = MAX_CORNERS;
double quality_level = 0.1;
double min_distance = 5;
int eig_block_size = 3;
int use_harris = false;

cvGoodFeaturesToTrack(gray_frame,
eig_image, // output
temp_image,
corners,
&corner_count,
quality_level,
min_distance,
NULL,
eig_block_size,
use_harris);
cvScale(eig_image, eig_image, 100, 0.00);
eig_time = end_timer();
cvShowImage(CORNER_EIG, eig_image);

// Disable harris processing
==== Corner Detection: Harris method ====
//start_timer();
const int MAX_CORNERS = 100;
//CvPoint2D32f harris_corners[MAX_CORNERS] = {0};
//int harris_corner_count = MAX_CORNERS;
//double harris_quality_level = 0.1;
//double harris_min_distance = 1;
//int harris_eig_block_size = 3;
//int harris_use_harris = true;
//
//cvGoodFeaturesToTrack(gray_frame,
//harris_eig_image, // output
//harris_temp_image,
//harris_corners,
//&harris_corner_count,
//harris_quality_level,
//harris_min_distance,
//NULL,
//harris_eig_block_size,
//harris_use_harris);
//cvScale(harris_eig_image, harris_eig_image, 200, 0.50);
//harris_time = end_timer();
//cvShowImage(CORNER_HARRIS, harris_eig_image);
//
//fprintf(stderr, "harris time: %i eig time: %i/n", harris_time, eig_time);

// ==== Draw circles around detected corners in original image
//fprintf(stderr, "corner[0] = (%f, %f)/n", corners[0].x, corners[0].y);
for( int i = 0; i < corner_count; i++) {
int radius = h/25;
cvCircle(curr_frame,
cvPoint((int)(corners[i].x + 0.5f),(int)(corners[i].y + 0.5f)),
radius,
target_color[0]);
}
cvShowImage(VIDEO_WINDOW, curr_frame);
// If ESC key pressed, Key=0x10001B under OpenCV 0.9.7(linux version),
// remove higher bits using AND operator
if ( (cvWaitKey(10) & 255) == 27)
break;
}
// Release the capture device housekeeping
cvReleaseCapture( &capture);
cvDestroyWindow(VIDEO_WINDOW);
cvDestroyWindow(CORNER_EIG);
// Disable harris processing
//cvDestroyWindow(CORNER_HARRIS);
return 0;
}