Your post is quite perfect…

Thank you!

exellent

Nice.

this strange duality you described is far bigger than it seems, it goes beyond the R2 plane and into the Rn space..
the best thing about it is that the professor responsible for most of the developments in this field called “Parallel coordinates”
is teaching in TAU , his name is Alfred Inselberg and this is his page http://www.math.tau.ac.il/~aiisreal/
there you can find for example of a sphere in 5d …

enjoy.

Thank you for your comments.

I have a little problem with the way you analysed the complexity of the algorithm: there are actually several parameters that influence the complexity: w – the number of white pixels, n – the number of lines, m – the number of pixels in the original image, and k – the number of pixels in the hough transformed image. There is a certain correlation between the values of w and n (see below).

Note that finding the intercection of the lines is much easier than what you propose, as when I draw the lines I do not color the buffer with the lines’ color, but rather increase the color value already in the transform image. Finding intersections of more than T lines is then as simple as running through the buffer and checking whether a given pixel has a value of more than T (this is the reason the hough images are not monochromatic).

The first step – drawing the lines, takes O(w*k’) where k’ is the about sqrt(k) (as drawing a line in an image with k pixels takes about sqrt(k) pixel operations). Then finding the lines takes O(k).

So the total complexity comes to O(w*k’)+O(k). An approximation to the relation between n and w is:
w = n*sqrt(m)
So finally we get that the total complexity is:
O(n*sqrt(m)*sqrt(k) + k)
Assuming that k is small compared to the other numbers, we get:
O(n*sqrt(m))

The naive algorithm you proposed, in these notations, takes O(w*w*w) (since going through all the pairs of points takes w*w and for each pair you have to iterate through all other points). This equals:
O(n*n*n*m*sqrt(m))
Which is much worse than the naive complexity (the ratio is like N to N*N*N).

The improvement you suggested in comment 3 is indeed very similar to the hough transform, although you still need to iterate over all PAIRS of points (and the complexity stays higher).

1) The suggested algorithm’s compleixty is O(n^2), since you will get in the dual plane n lines and you’ll have to check their intersection

2) The naive algorithm for the original problem takes O(n^3) – you can find the line equation of each pair of points, and then go over all the other points and check if they fall on this line

3) You can easily modify the naive algorithm to be O(n^2) – for example, create a hash that maps line equations to a counter. For every pair of points, create the line equation, search for it in the hash, and increment the counter.

4) In general, the problem of finding intersection points of the lines is exactly the same. It’s naive algorithm would also take O(n^3) because for every pair of lines you’d have to check how many other lines intersect with the same point. You’d have to modify this naive algorithm a bit to find those points in O(n^2). This is a nice algorithm, since it makes a reduction from a problem involving points to a problem involving lines (there are many other examples for this phenomena in Computational Geometry and some of them are much more suprising) In general, since these reductions are very simple, you can always eventually just trivially map the algorithm that works in the dual plane into an equivalent algorithm for solving the primal (original) problem. (and give up the “duality” step of the algorithm)