Radon function result's repeatability

Question

I want to get a Hough transform of some edged image.

When I compare the same transformation on the same image I got different results.

i = 0; While[i < 10, i++; Print[Radon[imgEdged, Method -> "Hough"] == 
               Radon[imgEdged, Method -> "Hough"]]]
True
True
True
False
True
True
False
False
False
True

Why isn't repeatability provided in result of this function?

Update:

imgEdged =

Answer 1

I think I found more hints on what might explain the fact that Hough gives different results each time it is called. But this is too small to fit in a comment.

This is assuming the implementation by Mathematica is as explained in the Wikipedia article for Hough transform. The Hough implementation uses (from the link)

The Hough transform algorithm uses an array, called an accumulator, to detect the existence of a line $y = mx + b$

Then later on it says:

the number of page swaps required for this will be very demanding because the accumulator array is used in a randomly accessed fashion

Notice the word randomly accessed. This is the key.

It seems to work in a fashion similar to Monte Carlo method for numerical integration in the sense only that it uses randomness to do its work for speed vs. quality.

But since using SeedRandom[1] did not resolve the differences between calls as can be seen here:

With[{imgEdged = Image[CellularAutomaton[30, {{1}, 0}, 40], "Bit"]},
 Reap[Do[
   SeedRandom[1];
   im1 = Radon[imgEdged, Method -> "Hough"];
   SeedRandom[1];
   im2 = Radon[imgEdged, Method -> "Hough"];
   Sow[im1 == im2], {i, 100}]]
 ]

My guess now is that Radon[], or the function that implements the Method->Hough does not use the same random number generator that SeedRandom[] resets (the global one), but its own, in the Kernel, and it forgets to reset its own at random number generator at start of each call? Just a guess, since nothing else seems to make sense ;)

You might also want to look at Randomized Hough transform

Answer 2

That was a bug which got fixed in Mathematica 9.0.1.

Answer 3

Thanks to @Nasser I search about probablistic hough transform. Maybe it used in Mathematica implementation for speeding-up. I found good explanation here: http://www.cvmt.dk/education/teaching/f09/VGIS8/AIP/hough_09gr820.pdf

The Hough transform is not a fast algorithm for finding infinite lines in images of a certain size. Since additional analysis is required to detect finite lines, this is even slower. A way to speed up the Hough Transform and finding finite lines at the same time is the Progressive Probabilistic Hough Transform (PPHT). The idea of this methood is to transform randomly selected pixels in the edge image into the accumulator. When a bin in the accumulator corresponding to a particular infinite line has got a certain number of votes, the edge image is searched along that line to see if one or more finite line(s) are present. Then all pixels on that line are removed from the edge image. In this way the algorithm returns finite lines. If the vote threshold is low the number of pixels to evaluate in the accumulator gets small

And important part:

An issue with this algorithm is, that severel runs may may yield different results. This can be the case if many lines share pixels. If two lines cross, the fist line to be detected removes the common pixel (and a band around it) resulting in a gab in the other line. If many lines cross, then many pixels can miss in the last lines, and the votes in the accumulator may not reach the threshold.

So If you want after hough transform get expected lines, I think it's not very useful use hough transform (ImageLines function use Hough transform method inside (or RANSAC, which is randomized too)).

For example OpenCV hough lines provide choice which algorithm used in lines' search.