Detecting truck wheels

Question

I am currently working on a project which we have a set of photos of trucks going by a camera. I need to detect what type of truck it is (how many wheels it has). So I am using EMGU to try to detect this.

Problem I have is I cannot seem to be able to detect the wheels using EMGU's HoughCircle detection, it doesn't detect all the wheels and will also detect random circles in the foliage.

So I don't know what I should try next, I tried implementing SURF algo to match wheels between them but this does not seem to work either since they aren't exactly the same, is there a way I could implement a "loose" SURF algo?

This is what I start with.

This is what I get after the Hough Circle detection. Many erroneous detections, has some are not even close to having a circle and the back wheels are detected as a single one for some reason.

Would it be possible to either confirm that the detected circle are actually wheels using SURF and matching them between themselves? I am a bit lost on what I should do next, any help would be greatly appreciated.

(sorry for the bad English)

UPDATE

Here is what i did. I used blob tracking to be able to find the blob in my set of photos. With this I effectively can locate the moving truck. Then i split the rectangle of the blob in two and take the lower half from there i know i get the zone that should contain the wheels which greatly increases the detection. I will then run a light intensity loose check on the wheels i get. Since they are in general more black i should get a decently low value for those and can discard anything that is too white, 180/255 and up. I also know that my circles radius cannot be greater than half the detection zone divided by half.

Answer 1

I strongly suggest using: http://cvlabwww.epfl.ch/~lepetit/papers/hinterstoisser_pami11.pdf

and the C# implementation: https://github.com/dajuric/accord-net-extensions

(take a look at samples)

This algorithm can achieve real-time performance by using more than 2000 templates (20-30 fps) - so you can cover ellipse (projection) and circle shape cases. You can modify hand tracking sample (FastTemplateMatchingDemo)

by putting your own binary templates (make them in Paint :-))

P.S: To suppress false-positives some kind of tracking is also incorporated. The link to the library that I have posted also contains some tracking algortihms like: Discrete Kalman Filter and Particle Filter all with samples!

This library is still under development so there is possibility that something will not work. Please do not hesitate sending me a message.

Answer 2

First, the wheels projections are ellipses and not circles. Second, some background gradient can easily produce circle-like object so there should be no surprise here. The problem with ellipses of course is that they have 5 DOF and not 3DOF as circles. Note thatfive dimensional Hough space becomes impractical. Some generalized Hough transforms can probably solve ellipse problem at the expense of a lot of additional false alarm (FA) circles. To counter FA you have to verify that they really are wheels that belong to a truck and nothing else.

You probably need to start with specifying your problem in terms of objects and backgrounds rather than wheel detection. This is important since objects would create a visual context to detect wheels and background analysis will show how easy would it be to segment a truck (object) on the first place. If camera is static one can use motion to detect background. If background is relatively uniform a gaussian mixture models of its colors may help to eliminate much of it.

Answer 3

In this answer I describe an approach that was tested successfully with the following images:

The image processing pipeline begins by either downsampling the input image, or performing a color reduction operation to decrease the amount data (colors) in the image. This creates smaller groups of pixels to work with. I chose to downsample:

The 2nd stage of the pipeline performs a gaussian blur in order to smooth/blur the images:

Next, the images are ready to be thresholded, i.e binarized:

The 4th stage requires executing Hough Circles on the binarized image to locate the wheels:

The final stage of the pipeline would be to draw the circles that were found over the original image:

This approach is not a robust solution. It's meant only to inspire you to continue your search for answers.

I don't do C#, sorry. Good luck!