HOUGH TRANSFORM
HOUGH TRANSFORM
• Introduced in 1962 by Paul Hough
• pronounced like “tough” according to
http://www.citidel.org/bitstream/10117/1289/1/HoughTransf
orm.html
• Detects lines.
• Has been generalized to other shapes as well.
• Handles noise.
• Handles partial occlusion.
PROBLEM: WE PROCESS A GRAY IMAGE AND
CREATE A BINARY VERSION. NEXT, WE WISH TO FIT
LINES TO THE BINARY IMAGE.
• from http://www.cs.uregina.ca/Links/class-info/425nova/Lab4/
MORE EXAMPLES
• from
http://www.cc.utah.edu/~asc10/improc/project4/R
EADME.html
PROBLEM: WE PROCESS A GRAY IMAGE AND
CREATE A BINARY VERSION. NEXT, WE WISH TO FIT
LINES TO THE BINARY IMAGE.
• Slope-intercept equation of line:
y  ax  b
• where a is the slope (y/  x), and b is the y-intercept
PROBLEM: WE PROCESS A GRAY IMAGE AND
CREATE A BINARY VERSION. NEXT, WE WISH TO FIT
LINES TO THE BINARY IMAGE.
• Slope-intercept:
y=ax+b
• We typically think of (x,y) as variables and
(a,b) as constants.
• Instead, let’s think of (a,b) as variables and
(x,y) as constants. Rewritten:
b=-xa+y
• Note that this is also the equation of a line
but in (a,b) space.
• We can pass (infinitely) many lines at
different angles through (x,y). As we do this,
we’ll form a line in (a,b) space.
• Passing many lines through an (x,y) point.
• Figure by Anne Solberg
• Figure by Anne Solberg.
• Two points in (x,y)-space define a line.
• However (if we pass infinitely many lines through
each of these points), we obtain two different lines
in (a,b)-space for each of these points.
• Figure by Anne Solberg.
• Two points in (x,y)-space define a line.
• However (if we pass infinitely many lines through
each of these points), we obtain two different lines
in (a,b)-space for each of these points.
• Then line between them in (x,y)-space gives rise to
a point of intersection in (a,b)-space.
PROBLEM
• (a,b)-space can’t be used in practice because
vertical lines have infinite slope!
PROBLEM
• (a,b)-space can’t be used in practice because
vertical lines have infinite slope!
• Solution:
• Use polar coordinates. Lines are then represented by their
angle  (from the x-axis) and perpendicular distance from
the origin, r.
• All points on the same line will have the same (r,).
r  x cos  y sin 
•
(figure from http://en.wikipedia.org/wiki/Hough_transform)
NOTE
• Each point in (x,y)-space gives rise to a sinusoid in
(r,)-space.
• But that’s OK. Lines in (x,y)-space will still give rise to
intersections in (r,)-space.
DATA STRUCTURE
• Use an accumulator matrix (2D histogram; call it A)
of counts for (r,).
• Voting algorithm.
• We’ll get one vote for each point along the sinusoid.
• Two votes at points of intersection of sinusoids (which denote
lines in (x,y)-space.
• More than two votes for multiple co-linear points (in (x,y)-space).
• Then the points in (r,)-space with the most votes denote strong
lines in (x,y)-space.
DATA STRUCTURE
• Use an accumulator matrix (2D histogram; call it A)
of counts for (r,).
• Voting algorithm.
• So we need to quantize the allowable values for r and .
• For r, we can use all the integer values from 0 to the largest
image diagonal distance. (We could use more as well. For
example, we could multiply this value by 10 and get up to a
resolution of 10ths.)
• For , we can quantize to one degree increments, or we
can use the same number as used for r.
ALGORITHM
• Let Q be the number of angles into which  was
quantized.
• For each point, pi in P:
• For each qi in Q
• Assume that a line at angle =qi passes through pi.
• Calculate r for this line
• Increment A[r, ].
• The values in A that exceed some threshold (or the
K greatest values in A) are the strongest lines.
• What is the complexity of this algorithm?
ALGORITHM
• Let Q be the number of angles into which  was
quantized.
• For each point, pi in P:
• For each qi in Q
• Assume that a line at angle =qi passes through pi.
• Calculate r for this line
• Increment A[r, ].
• The values in A that exceed some threshold (or the
K greatest values in A) are the strongest lines.
• What is the complexity of this algorithm? |P|*|Q|
• But since Q is a constant that we determine, we can think of it as |P|.
GENERALIZATION TO OTHER SHAPES
• y = ax + b can be written as ax + b - y = 0.
• In general, f(x,a)=0, where x and a are vectors.
1. Consider the equation of a circle, (x-a)2 + (y-b) 2 = r2.
• So our vector x above will be <x,y> and a will be <a,b,r> (3D).
1. Consider the equation of an ellipse, (x-h) 2/a2 + (y-k) 2/b2 = 1.
• In this case, our vector x will again be <x,y> and a will be <h,k,a,b>
(4D).
• However, this only characterizes ellipses that are aligned with the
axes. So in general, for ellipses we need 5D space, <h,k,a,b,>.
MORE ABOUT THE
ACCUMULATOR MATRIX …
• Ex. two points:
• (r==10 && c==10)
• (r==100 && c==10)
• Ex. four points:
•
•
•
•
(r==75 && c==75)
(r==200 && c==200)
(r==300 && c==300)
(r==500 && c==500)
• Let’s take a look at one with gimp.
• This test has just two point, (200,200) and (500,500).
• We see nothing (at 18% magnification)!
• At 100% we can begin to see the sinusoids.
• But we are only changing theta by 0.1 so between
0..2 Pi there are only 62 samples.
• So the intersections “miss.”
• So let’s try more samples.
• Let’s try sampling in one degree increments
(resulting in 360 samples).
• Now we see intersections!
• Let’s try sampling in one degree increments
(resulting in 360 samples).
• Now we see intersections!
• And a look at the PGM file confirms that the max
value is 2.
• Let’s try sampling in one degree increments
(resulting in 360 samples).
• Now we see intersections!
• But there appears to be two! Why?
• Let’s try sampling in one degree increments
(resulting in 360 samples).
• Now we see intersections!
• But there appears to be two! Why?
• Because we are rotating around 360 when we only need
180.
• Better!
• But now I’m afraid that I might miss intersections due
to undersampling. So let’s sample tenths or
hundredths of a degree (instead of one degree
increments).
• But where are the most votes?
• Not at the points of intersection!
• Why?
• Because many points along the real curve are mapping
(repeatedly) so a single point in our array.
SOLUTION(S)?
1. (Oversample.) As you trace along a sinusoid,
keep track of the last point and don’t count
repetitions.
• easier to code
• less reliable
2. (Undersample.) As you trace along a sinusoid,
draw straight lines between pairs of points (and still
disallowing repeats as in #1).
• harder to code
• more reliable
MORAL OF THE STORY: SOMETIMES IT’S
BETTER TO PLAY “CONNECT THE DOTS”
THAN IT IS TO OVERSAMPLE!