Which feature detector algorithm is simplest for learning?

Question

I am wrapping my head around feature detector algorithms. I've studied the options that I have: SIFT, SURF, BRISK, FREAK etc. All of them seem fairly complex in terms of underlying mathematics. On the contrary, I want to take one step at a time therefore I am looking for a simple method which doesn't need to be as good as SURF for example. Which algorithm would you recommend to learn and implement?

Answer 1

The first thing too keep in mind is the difference between a detector and a descriptor. A detector is an algorithm for detecting interest points in an image, which are typically either corners or centers of blob-like structures. Then, if you need to match these points across images, you compute descriptors, which are some kind of vectors of values that represent the patches around the interest points.

This should help clear up some confusion. For example, "good features to track", aka the min-eigen corner detector, is an interest point detector. FREAK is a feature descriptor. SIFT, SURF, and BRISK include both a detector and a descriptor. In general, however, you can mix and match detectors and descriptors.

So for starters, you should look at the corner detectors like GFTT and Harris, and also the Laplacian blob detector. Most of the more recent interest point detectors are faster ways of detecting corners or blobs.

For descriptors, start with SIFT. It may seem a bit scary, but this was the first descriptor that has worked, and it is the inspiration and the benchmark for all the others.

Answer 2

If you are trying to start simple, then perhaps the simplest feature descriptor is to take a NxN square around the detected feature and concat all the pixel values. This doesn't work well in practice because it is very sensitive to small changes in lighting, rotation, scale, etc -- but you can test your implementation with two translated versions of an image.

The simplest feature descriptor that "actually works" seems to be the BRIEF descriptor (http://cvlabwww.epfl.ch/~lepetit/papers/calonder_eccv10.pdf), which randomly compares pairs of nearby pixel values to build up a binary descriptor. Note that it isn't scale- or rotation-invariant however: for that you need one of the many extensions such as AKAZE, BRISK, FREAK, or ORB.

Answer 3

I think you can try GFTT : Good features to tracj based on shi-tomasi definitions and equations. Its very old and I think easy to read too.

Answer 4

In my opinion, SIFT. See vlfeat.org for the code they developed which is free to use, and they have several tutorials for an easy implementation.