Fingerprint Minutiae Extraction Based On
FPGA and MatLab
Víctor López Lorenzo, Pablo Huerta Pellitero, José Ignacio Martínez Torre, Javier Castillo Villar
{victor.lopez, pablo.huerta, joseignacio.martinez, javier.castillo}@urjc.es
Grupo de Diseño HwSw
Universidad Rey Juan Carlos
Abstract
Robust fingerprint minutiae extraction systems
impose computational requirements that are difficult
to fulfill for a processing system. Many hardware
solutions have been proposed to date that sacrifice
robustness in favor of speed; but these systems are
not able to handle partial, dirty or damaged
fingerprints or, at least, can not extract enough
minutiae to allow the matching algorithm to
recognize the fingerprint as a valid one. The
approach proposed in this paper is that of software
minutiae extraction aided by a coprocessing PCI
card, equipped with a Xilinx FPGA.
Keywords: Fingerprint, Biometrics, FPGA,
Minutiae, Handel-C, MatLab, PCI.
1. Introduction
The process involves a series of image
enhancement and minutiae extraction steps that can
be classified in the following phases:
- Fingerprint norma1ization
- Local Ridge Orientation extraction
- Fingerprint filtering
- Image Thresholding
- Image Thinning
- Minutiae Extraction
- False Minutiae Removal
For each of the steps, research was conducted on
the state of the art of biometric algorithms, looking
for the best quality/complexity ratios for each of
them. The main goal being a robust implementation
of minutiae extraction which could find minutiae in
many kinds of suboptimal fingerprints; and at the
same time not being overcomplex for small amounts
of improvement over simpler algorithms.
The fingerprint normalization algorithm chosen
was the one proposed by Hong, Wan and Jain [1].
The Local Ridge Orientation map extraction
method implemented was at first the one proposed
This work has been supported by the Spanish
PROFIT and Medea+ programme under FIT-
0700000-2003-930 contract
by B.G. Sherlock [2]. Later, the algorithm suggested
by Hong, Wan and Jain [1] was found to be more
suitable and precise, being a least mean square
estimation algorithm, and less error prone than the
previous one.
The filtering process selected is based on a
frequency domain directional Fourier bank of filters.
This approach was proposed by B.G. Sherlock [2]
and by Chikkerur and Govindaraju [3].
The algorithm employed for thresholding, again
the recommended in [2] and [3], is an adaptive
threshold with a window of 32x32 pixels.
The final step of image processing before
minutiae extraction is thinning, performed by means
of a modified Zhang and Suen [4] thinning
algorithm. The minutiae extraction procedure takes
as input the thinned image from the previous step
and processes matrices of 3x3 pixels in the way
defined by Arcelli and Baja [5] looking for ridge
endings and ridge bifurcations.
After this simple extraction step, it was decided
to implement a final very efficient and complete
false minutiae elimination algorithm on the basis of
the work done by Kim, Lee and Kim [6].
This sequential chain of algorithms has been
programmed in MatLab in a modular way so as to
allow substitution of several of them from the
software implementation to the hardware one
through a small software stub.
The PCI card used was an AlphaData ADM-
XRC-II equipped with a Xilinx Virtex 2,
XC2V6000-4 with 24 MB of onboard SRAM. This
board is supplied along with a MatLab toolbox to
access the PCI bus and send/receive data in 32 bit
blocks.
The computer used for the tests was a Pentium 4
workstation running at 3 GHz with 2 GB of RAM. A
usual fingerprint image in the test databases has
388x374 grayscale pixels with a resolution of 500
dpi. This means that an uncompressed image takes
up to 145,112 bytes.
2. Fingerprint Enhancement
The first step before filtering is the
normalization of the input image in case the image it
was overexposed (too bright) or underexposed (too
dark). It shall be remembered that the input image is coordinates to polar coordinates and enter them in
grayscale and its pixels will have a different mean the previous formulas. The resulting filters have the
and variance (M and VAR) depending on the following appearance (the one depicted is for 0º):
lightning conditions. In order to change its
appearance several calculations are performed to
approximate it to a desired mean and variance (M0
and VAR0). The process modifies the value of every
pixel in accordance to the following equation [1]:

⎧ VAR0 ( X (i, j ) − M )
2
⎪M 0 + , X (i, j ) > M
⎪ VAR
Y (i, j ) = ⎨
VAR0 ( X (i, j ) − M )
2
⎪
⎪⎩ M 0 − VAR
, otherwise

The recommended desired values are used, Filter frequency domain representation
with a mean and a variance of one hundred.
As Fourier filtering is going to be used, The resulting filters are saved and applied to
aliasing may be found in the edges. This is in part the Fourier transformed fingerprint image by
avoided by applying a taper function to the image, multiplying the two of them together pixel by pixel.
enlarging its size by 10% with a split-cosine The sixteen resulting filtered images look this way:
window. By definition the taper must be applied to a
zero mean series; so that the mean shall be
subtracted from each pixel value and then apply a
simple split-cosine window.
The next step performs a directional Fourier
filtering using polar coordinates. In order for it to
function well, the frequency origin of the frequency
domain transformed image (by FFT) shall be shifted
to the middle of the image. This is done thanks to a
little trick in the time-domain space, just by
changing the sign of the odd pixels of the image. Test fingerprint image
The result is a shifted frequency origin located at the
middle of the image.

Now the process goes on to the filtering

section in which it was decided to divide the filtering
in sixteen polar filters, going from 0, π/16, 2· π/16,
up to π - π/16. Then, each of the filters is created, as
described in [2] and [3], with the following
formulas:

H (r , φ ) = H r (r ) ⋅ H φ (φ )

(r ⋅ rBW )2n
H r (r ) =
(r ⋅ rBW )2 n + (r 2 − rc 2 )
2n

⎧ 2 π ⋅ (φ − φ c )
⎪cos , if φ − φ c ≤ φ BW Resulting filtered images in all 16 directions
H φ (φ ) = ⎨ 2 ⋅ φ BW
⎪⎩ 0 , otherwise
The radial center frequency selected after
rBW : radial − bandwidth
testing was 30 pixels, while the bandwidth used was
φ BW : angular − bandwidth 60 pixels. Anyway, it was found that the results were
φ c : mean − orientation not very sensitive to these parameters. In the case of
rc : mean − frequency angles, the bandwidth is obviously the previously
The method used to generate the filter images mentioned π/16 and the center frequencies are in the
H(r,Φ) is to create a matrix the same size as the center of these bandwidths, that is π/32, 3·π/32, and
fingerprint image, then translate the row-column so on.

Image (left) and filters’ combined (right) Fourier
Power Spectra
Once the filtering process has finished the
local ridge orientation map of the image must be
computed, dividing the fingerprint in sectors of
12x12 pixels of a discrete orientation (in steps of
π/16). The method employed for map finding is the
one described by Hong in [1] of least mean squares.
The process requires the calculation of the row and
column gradients ( ∂ x (u , v ) ⋅ ∂ y (u , v ) , the Sobel
operator was used) at each pixel. Then the
orientation at each block are computed applying
these formulas:
select among the sixteen previous filtered images
which one shall be used to compose the final filtered
image.
A difficulty that arises is for blocks in which
the orientation is not clearly defined. For instance,
where singularities exist, like loops or whorls, there
are many angles contained in a single block. The
solution proposed by Sherlock in [2] is to increase
the bandwidth (number of used angles)
proportionally as a singularity of the fingerprint is
approached. This method gives optimal results but
adds another step to the process. The new step is
based on a modified Poincaré index method [7] by
adding angular distances of neighboring blocks to
find singular points. After finding the singularities of
the image, they are expanded with a decreasing
value to fill the entire map. In the next figure the
resulting singularity map may be observed, darker
areas denote nearer singularities:

i +5 j +5
V x (i, j ) = ∑ ∑ 2 ⋅ ∂ (u, v ) ⋅ ∂ (u, v )
x y
u =i − 6 v = j − 6
j +5

∑ ∑ (∂ (u, v ) − ∂ (u, v ))
i +5
V y (i, j ) = 2
x
2
y
LRO Singularity Detection Output
u =i − 6 v = j − 6
The next step applies this output singularity
1 ⎛ V y (i, j ) ⎞
θ (i, j ) = ⋅ tan −1 ⎜⎜ ⎟⎟ map to the whole fingerprint image, substituting
2 ⎝ V x (i, j ) ⎠ nearness values with a number based on the angles
needed to interpolate in order to increase the
bandwidth at each individual block of the image.
The last step comprehends a smoothing
This step also takes into account the area occupied
process based on the fact that variations in ridge
by the fingerprint so that the bandwidth outside this
orientation are slow across the surface of the finger.
area is zero. The next figure shows a graphical
By applying a smoothing mask (low pass filter) of
representation of the output; in this case brighter
dimensions 3x3 a smoothed version of the ridge
areas denote higher bandwidths due to the proximity
orientation map results that is less susceptible to
of singularities.
errors due to damaged fingerprints.

Block Bandwidth of Output Image

LRO without (left) and with smoothing (right)
From the results of the latter process the values
With the ridge orientation map it is possible to
needed to allow the creation of the final filtered
define a common orientation for each 12x12 pixel
image are obtained, as a combination of the angular-
block of the fingerprint image. Thus, for each block
filtered initial image (more filtered images are taken
of the image, its corresponding orientation is used to
into account, starting from central frequency, as
bandwidth increases):
Filtering Output
The next necessary phase is, obviously, a
thresholding, in this case an adaptive one, for the
mean gray values differ from zone to zone in the
filtered image. The adaptive thresholding algorithm
uses a window of 32x32 pixels, as in [2].
Final thresholded image
This is the raw output of the algorithm, for the
neat test fingerprint image. In the case of worse
fingerprints, the results are still better than optimal.
The next figures show, to the left, the original
fingerprint and, to the right, the restored one after
the processing described in this paper :
Fingerprint with large cuts
Heavily damaged fingerprint
3. Minutiae Extraction
Just before feature extraction a thinning
process needs to be performed as indicated in [4], in
which two tests are run one after the other until none
of them find pixels that need to be removed.
However, this method did not meet the requirements
imposed to a thinning algorithm because it still left
some spurious structures that did not permit a single
point inside a line to have only two neighbors, a
ridge-end only one, and a bifurcation three.
The conformance to the established criteria
was obtained by the creation of a third test to be run
once after the former two are passed to test for
certain conditions in matrices of 3x3 pixels that
indicate a spurious structure that shall be properly
modified.
The thinning results without and with the third test
are shown below:
Thinning results (without, left, and with, right,
custom third test)
The minutiae extraction process, defined in
[5], uses matrices of 3x3 pixels to search for typical
minutiae, that is: ridge endings and ridge
bifurcations. This method incurs many errors as
there will be many ridge-ends in border regions and
spurious bifurcations and ridge-endings inside the
fingerprint.
Most of them are clearly recognizable to the
trained eye, but in the case of an automatic system, a
series of rules have to be used which have been
stated by Seonjoo, Dongjae, and Jaihie in [6] to
delete the so-called “false-minutiae”. Apart from
these rules, it was decided that a Region-Of-Interest
(or ROI) was to be used in which the fingerprint is
statistically less corrupt. This area makes all the
ridge-ends located in border blocks invalid and
marks them as false-minutiae because they are
almost always caused by the fact that only a finite
area of fingers can be in contact with the sensor
surface that is acquiring the fingerprint image. This
causes the apparent ending of many ridges in border
regions and is the reason why ridge-ends one block
away from the borders must be ignored.
The set of rules employed in false-minutiae
detection are able to efficiently find false minutiae
that form the following structures: broken ridges,
short ridges, hole structures and bridges while still
maintaining a low false-positive ratio.
The results obtained after simulations show a
mean reduction of around 30% of the originals,
removing almost all of the false minutiae due to
abnormal structures. This is shown in the next
figures:
Left image, in black all false minutiae. Right image,
fingerprint with resulting true minutiae.
4. Hardware Thinning
The most burdensome algorithm for the PCs
used, Pentium 4 running at 3 GHz and 2 GB RAM,
was the thinning one, which took, for most of the
fingerprints, between 60 and 90 seconds to
complete. The main reason is the high memory
interface requirements and the low performance of
MatLab itself. To improve calculation time the
conditions of the first two tests were reordered in
order to make memory accesses in fewer cases and
to process the harder parts of the tests only if pixels
have passed previous simpler conditions. However,
depending on the individual fingerprint, the two tests
are run from five to eight times each. Given the
simplicity of the tests themselves and the memory
throughput required, prone to simple optimizations
by defining a new architecture for them to run, it
became obvious that the best choice for hardware
implementation was this algorithm.
The selected hardware design environment was
Celoxica’s DK Design Suite 3.0 and the Handel-C
language because of its multiple libraries to easily
manage SRAM memories, PCI communication,
FPGA resources, and, mainly, because of its
simplicity in debugging code.
The communication between MatLab and the
FPGA, through the PCI bus, and its protocol will be
covered in the next section. Here the hardware
thinning algorithm itself will be expounded.
The starting point is the assumption that all the
necessary data, the image pixels, is already located
in the SRAM, row-wise, and ready to be accessed by
the algorithm. Less than one megabyte is needed, so
address 0h was used for the initial image and its
processing, and address 80000h (512 KB) when a
copy of the fingerprint is needed to perform the
tests.
The fingerprint image is usually around
388x374 pixels, one bit each, so the fingerprint may
occupy in memory up to 18,139 bytes. Image size is
only limited to 512 KB, but the maximum image
resolution found would be 512x512 pixels, that is
32,768 bytes.
As already explained, the thinning algorithm
comprehends three tests, the first two are run
sequentially as long as they find pixels that shall be
removed, usually 5-8 times. They operate by looking
for ridge pixels (value one) and checking a series of
conditions against the 3x3 pixel matrix of neighbors
(with the ridge pixel in its center):
- Number of transitions 0Æ1 = 1
- Number of 1 neighbors is between 2 and 6.
- Test 1: p2*p4*p6=0
Test 2 : p2*p4*p8=0
- Test 1: p4*p6*p8=0
Test 2 : p2*p6*p8=0
The implementation of these conditions has
been made to check them in parallel and take only
one cycle to compute once the matrix has been
extracted. The main burden of the algorithm is the
memory accesses. Although a ZBT SRAM is used,
there is still a latency of two cycles to read data.
Another problem that arises from the use of this kind
of RAM is the fact that a read/write operation
happens in word-size, that is, 32 bits at a time. A
situation may be encountered in which six 32 bit
accesses are needed to fill the 3x3 matrix because
each row of the matrix may cross a word boundary
(it shall be remembered that one pixel is represented
by one bit). To circumvent the problem, reads have
been overlapped and the final latency is smaller. The
hardware thinning has been separated into several
functions:
- Thinning : top function with the main loop
containing the three tests.
- Find_First_1 : looks for ridge pixels (1’s) in
the image after a given position.
- Read_mem : given a pixel address, makes the
necessary memory reads return the asked
pixel, the previous and the next one.
- Write_mem : given a pixel address, performs
a bit write by mixing it with the previous
written bits and the still unwritten bits of the
32 bit word.
- Extract_p_matrix : given a pixel address,
orders three memory reads to get the 3x3
pixel matrix for the tests.
- Mem_cpy : copies a fingerprint from one
place in memory to another place
- Test_1 : performs in two cycles test number
one for a given 3x3 matrix.
 - Test_2 : performs in two cycles test number
two for a given 3x3 matrix.
- Test_3 : performs in one cycle test number
three for a given 3x3 matrix.
The main loop located in the Thinning routine is
composed of one internal loop, containing the two
first tests’ loops (to search the entire image looking
for ridge pixels, then extract their matrices and
check Test_n conditions), and outside this internal
loop, another one for the test number three loop.
5. Hardware/Software Communication
The hardware bus that communicates the
FPGA with the computer is a standard 33 MHz 32
bit PCI. From the point of view of the FPGA there is
only a state machine for direct slave transfers
controlled by the Handel-C routines. It was decided
that the communication protocol would be
composed of a series of commands (mem_read,
mem_write, thin, end) and two registers on each
side. One of these registers would be a status/control
one, while the other would be a data in/data out
register.
The communication on the software part is
established thanks to an existing MatLab toolbox for
data transfer between the Alpha Data board and
MatLab. This library provides several initialization
and data transfer functions (read and write 32 bit
packets at selected addresses) which are used in
substitution of the original software thinning routine
to dynamically program the FPGA with the right
bitstream, transfer the data to the board from
MatLab (mem_write command), order the thinning
to start (thin command) and, finally, read back the
data (mem_read command) and order the FPGA to
go to idle state (end command).
6. Results & Conclusions
The time used in hardware for thinning is not
fixed, but varies depending on the number of ridge
pixels in the fingerprint image. The number of
passes of the first two tests depends also on the
image, however it usually goes from 5 to 8 passes,
while the number of cycles employed for the
complete task, including test number three, varies
from four and a half to six million. The clock rate at
which the board is runs is 65 MHz; taking less than
100 ms in time, contrasted with the 60-90 seconds of
the software thinning (in a Pentium 4 – 3 GHz).
The main bottleneck found in the design was
transfer throughput between the PC and the FPGA
because of the chosen communication method that
relies on a stop-and-go approach. This
implementation causes a delay of one second in data
transmission because of the protocol, which is too
conservative.
As explained above, the FPGA employed is a
Xilinx Virtex 2 XC2V6000-4. The synthesis results
for the Handel-C hardware thinning show that only
4% of the total FPGA slices are used, for a total
equivalent gate count of 44,906 gates.
The development of a matching algorithm is in
progress to test the goodness index of the extraction
and matching algorithms, although the individual
building blocks employed have been tested (see
references) and show remarkable performance.
7. Future Work
As it was shown in the last paragraph, the main
hardware/software bottleneck of the system is the
data transfer throughput. Future work will definitely
comprehend changing the protocol to make it more
light-weight or try a DMA (Direct Memory Access)
based implementation, although it may not be
worthwhile because of the small amount of data to
be transferred.
As already stated, another work in progress is
the implementation of an optimal matching
algorithm to test the quality of the minutiae
extraction.
Of course, future work will include porting the
complete algorithm to the hardware coprocessor,
possibly using a soft-core processor for certain
aspects. Also the interface to the software is going to
be ported to a dynamic link library in order to make
it accessible from within many software
development environments, such as Visual Basic,
Visual C/C++, Delphi, etc.
References
[1] L. Hong, Y. Wan, and A. Jain, "Fingerprint image
enhancement: Algorithm and performance evaluation"
IEEE Trans. Pattern Analysis and Machine Intell., vol.
20, no. 8, pp. 777--789, Aug. 1998.
[2] Sherlock,D., Monro,D.M. and Millard,K. "Fingerprint
Enhancement by Directional Fourier Filtering".
IEEE Proceedings on Visual Imaging Signal
Processing, 141: 87-94, 1994
[3] Sharat Chikkerur, Venu Govindaraju, "Fingerprint
Image Enhancement using Contextual Filtering in the
Fourier Domain". 17th annual CSE GSA Conference,
2004.
[4] T. Y. Zhang , C. Y. Suen, "A fast parallel algorithm
for thinning digital patterns", Communications of the
ACM, v.27 n.3, p.236-239, March 1984
[5] C.Arcelli and G.S.D.Baja, "A Width Independent Fast
Thinning Algorithm," IEEE Trans. Pattern Analysis
Machine Intelligence, vol. 7, no. 4, pp. 463-474, 1984.
[6] Kim Seonjoo, Lee Dongjae, Kim Jaihie, "Algorithm
for Detection and Elminiation of False Minutiae in
Fingerprint Images", 3rd International Conference on
Audio- and Video- based Biometric Person
Authentication, 2001.
[7] D. Maltoni and D. Maio, "Handbook of Fingerprint
Recognition. 3 .- Fingerprint Analysis and
Representation", Springer Verlag, ISBN 0-387-95431-
7, 2003.