SHARP - A parallel algorithm for shape recognition

SHARP
A shape recognition system and its parallel implementation
Leonardo Arcari
leonardo1.arcari@gmail.com
Politecnico di Milano

Agenda
● Theoretical aspects of Hough transformation
● Algorithm description
● Implementation considerations
● Expected results

Theoretical aspects of Hough Transformation

Shape recognition problem
● Fundamental aspect problem of computer vision.
● Defined as the problem of determining whether the test image contains one of the
available reference shapes or not.
● SHARP algorithm takes into account the problem of shape recognition in binary
images.

Shape representation: Hough transformation (1)
● An arbitrary shape can be considered as
composed of small tangent straight line
segments.
● In cartesian coordinates, a line is
commonly represented by the equation
● The Hough transformation represents
lines in polar coordinates.

● The dimension is given by the angle of the normal
of the line.
● The r dimension is the distance of the line from the
origin.
● Value of is restricted to the interval [0, π] and r
is restricted to the interval

● Representing a line back in the cartesian plane, after the considerations made:
● In general, for each point (x0
, y0
), we can define a family of lines that goes
through that point as:
● This means that each pair ( , r) represents each line that passes through (x0
, y0
)

Key point
Two curves intersecting in the Hough space
determine a ( , r) pair , i.e. a straight line,
on which the two points that generated
those curves lie on.

Hough space (1)
● Discretized and represented as a two-dimensional accumulator array.
● In general, Hough transform implementations accumulate in each array cell the
number of pixels lying on the same line in the cartesian plane.
● This does not preserve the information of which pixel belongs to a particular line.
X
X
X
X
Same as

Hough space (2)
● SHARP prefers to adopt a modified version known as Straight-line Hough
Transform (SLHT).
● According to this variant, pixels mapped to the same ( , r) are grouped in lines of
adjacent points.
● This way, we can identify dominant segments based on their length instead of the
number of points that eventually lie on the same line.

Algorithm outline
In order to recognize a shape, three macro-steps are required:
1. Computation of SLHT for the test image.
2. Computation of the STIRS signature of the test image.
3. Matching the test signature with that of the reference shapes.

STIRS Signature
● Distances between pairs of parallel tangential lines to a curve C.
● Basically a feature of a shape.
Has the following properties:
● It is invariant to the translation of the shape.
● Rotation of the shape corresponds to a circular-shift of its signature in the ( , r)
space.
● If the shape is scaled by a factor S, then the signature is also scaled by the same
factor.
Therefore named: scalable translation-invariant rotation-to-shifting (STIRS) signature.

Parallelization scheme (1)
● Assuming a distributed-memory, multiple instruction, multiple data (MIMD)
computational model.
● The SLHT array is divided over the space into p partitions, number of
processors.
● Each processor i computes the SLHT and the (partial) STIRS signature for angles
in range

Parallelization scheme (2)
● Each processor i also applies the matching algorithm to the test image and the
reference image for the angles in range Ai
for all the m orientations of the
reference shape.
● The matching procedure produces a matching score, which is partial for the range
of angles taken into account.
● A merging step is carried out by adding the partial scores, using a binary-tree
reduction procedure

SHARP Algorithm in details (2)
Complexity
O(n2
l * m /p)

Complexity
O(mr
2
* m /p)

Complexity
O(mr
* m 2
/p)

Complexity
O(m * log2
p + tcomm
)

Input data
Generating input shapes (both test and reference)
● Manually drawn
● Perform edge detection on samples (e.g. with Canny algorithm) to build a binary
image. We could exploit OpenCV library.
Communication among threads
● Given the adoption of OpenMP framework, we can exploit locking APIs on a
mutex for each processor, as well as a pointer to the local data structure to merge
for each processor. Like a std::unique_ptr so that we enforce use of efficient move
semantics.

Parameters
The SHARP paper suggests the following parameters, as they are those showed in their
results:
1. Shape size: n = 256
2. 0 ≤ ≤
3. -363 ≤ r ≤ 363
4. = 5° i.e. m = 37
5. r
= 1 i.e. mr
= 727
6. Line length threshold = 2.0

Ideal speedup of SHARP algorithm
Parallel time
Sequential time
Speedup

Experimental results
Run time [ms] with # of
threads:
1 2 4 8
pentagon_35_degrees.jpg 22.90 12.70 12.40 8.20
tr_oval.jpg 42.20 23.30 16.80 14.40
duck_scaled_15_degrees.jpg 18.70 11.70 6.80 13.50
duck_scaled_50_degrees.jpg 18.80 12.60 5.90 13.60
oval_45_degrees.jpg 28.00 15.20 10.90 9.80
oval_90_degrees.jpg 24.20 12.80 10.40 8.20
stewie_135_degrees.jpg 49.60 27.70 27.50 16.20
hexagon_135_degrees.jpg 23.10 13.90 11.60 10.70

SHARP - A parallel algorithm for shape recognition

More Related Content

What's hot (19)

Similar to SHARP - A parallel algorithm for shape recognition (20)

Recently uploaded (20)

SHARP - A parallel algorithm for shape recognition