Project Report<Fingerprint Recognition>

Supervisor: Nigel WhyteStudent: Dayu Chen

Student ID: C00131022Submit date: 2010-4-8

1

Contents

1. Introduction......................................................................................................................3

2. Problems encountered and resolved................................................................................4

2.1Variance in Normalization Algorithm...............................................................................4

2.1 Orientation Estimation....................................................................................................5

2.3 Image Enhancement.......................................................................................................8

2.4 Fix Ridge........................................................................................................................19

2.5 Core Point Detection.....................................................................................................20

2.6 Problems in Match........................................................................................................24

3. What I achieved..............................................................................................................25

4. What I did not achieve....................................................................................................26

5. What I learned................................................................................................................27

6. What I would do differently if starting again..................................................................27

7. Update my earlier report................................................................................................28

7.1 Update My Earlier Research.........................................................................................28

7.2 Update My Earlier Design Manual................................................................................29

8. Module description.........................................................................................................30

9. Data Structures and data record.....................................................................................31

10. Conclusion...................................................................................................................34

Reference...............................................................................................................................35

2

1. Introduction

This project is fingerprint recognition. During the development of this project, I met many problems, and made some changes of my earlier idea. From the development of this project, I learned more about algorithm in graphic pre-processing and how to fix problems in these algorithms. I also got more experience in researching, software design, coding and so on.

This report is written as a conclusion for the development of this project. It includes: problems that I met during project developing and how I solved it, what I achieved and what I did not achieved, what I learned from this project, what I will do different if this project starting again, the different things from my earlier report and some description of module, data structure.

3

2. Problems encountered and resolved

As I mentioned before, during this project, I met many algorithms about graphic pre-processing. Almost this algorithm is expressed by some complex mathematical formulas, these formulas I had never seen before. During the developing time, I spent most of time to learn these formulas.

2.1Variance in Normalization Algorithm

Normalization is for scale the gray level and variance of an image; let them nearby the desired average gray level and variance, so that can omit some noisy point about finger pressure in scanning. In this phase, how to choose a desired variance confused me a few times. I was using 100 as the desired variance which I mentioned in my earlier report, but the result was unclear. After change some variance, I found that: if the desired variance is too small, the output image will be unclear, but it can omit the noisy point. If the desired variance is too big, the output image will very clear, but it cannot omit the noisy point. An unclear image will make a big influence to next algorithms. I tried to use many values as the desired variance to test this algorithm, and found that when the variance is 150 the result is the best (Figure 1).

4

Figure 1 Image (a) is the original image, the red circle marks the noisy point of the finger pressure. Image (b) is normalized image which variance is 1500; the noisy point cannot be omitted (red circle in (b)). Image (c) is normalized image which variance is 150; most the pressure noisy point can be omitted (red circle in (c)).

2.1 Orientation Estimation

Orientation is the most important parameters in this project. Image enhancement algorithm, core point detection algorithm and generate feature vector in matching need to use orientation parameters. In this phase, I follow the algorithm which I wrote in my earlier research manual. This algorithm computes the orientation base on image gray gradient, but the last step is unclear (Figure2 [1]).

5

Figure 2 the last step of Orientation estimationIt is said that the last step is to compute the consistency of the orientation filed. There is a sentence said “If the consistency level is above a certain threshold Tc, then the local orientations around this region are re-estimated at a lower resolution level until C(i, j) is below a certain level.”[1] In this sentence, author did not give a very clear standard for me, he did not give a clear threshold and did not give an answer that if cannot find a certain value, what is the standard to decrease the neighborhood block D until find a certain level of C(I,j). It is difficult for me to implement the last step in this algorithm. I tried to omit this step, but the result is inconsistency (Figure 3).

Figure 3 Image (a) is the input image, image (b) is the Orientation filed without the last stepFrom Figure 3, I found that although a compute the orientation, but it still cannot be used in the next algorithm, because it is inconsistency. This orientation filed cannot express the direction of a fingerprint ridge.

After that, I did some research; found two ways to fix the orientation. One way is using a Gaussian low pass filter to smooth the orientation [2], the process of the algorithm is:(1) Compute the orientation base on image gray gradient.(2) Convert the orientation filed into a continuous vector filed using the follow formulas:

6

(3) Using Gaussian low pass filter to filter these two result. In the following formulas, wΦ is the size of the Gaussian filter and G is Gaussian filter.

(4) Generate the new Orientation filed with the result which gets from the above formulas.

I tried to implement this algorithm, but it still cannot get a good result (Figure 4).

Figure 4 Image (a) is the inconsistency Orientation filed in Figure 3. Image (b) is after smoothing. (a) and (b) are both computed from the same image in Figure 3.

After I check my code, I think I was following the algorithm correctly, and my Gaussian filter is true (I also do the Gaussian smoothing in another step, I will mention it after), I could not find out any incorrect in the coding logic, so I gave up this way. I used the second way to solve this problem, the second way is very easy for understanding and easy to implement. I used the following formulas to compute the orientation without consistency.

7

I found that, the range of the output direction is [-PI/4, PI/4], I think this is the reason why the orientation is inconsistency, because I think the angle between –PI/4 to PI/4 cannot contain all the direction in a fingerprint image, thus I convert the range [-PI/4, PI/4] to [0, PI]. After research I found a rule to convert this angle [3]. The rule is using the following formula to convert the angle:

After implement this way, the problem is solved (Figure 5)

Figure 5 Image (a) is the input image; it is the same image in Figure 3. Image (b) is the orientation witch range is [0, PI]

8

2.3 Image Enhancement

Image enhancement is the most important stage in image pre-processing. The enhancement problem stucks me during the developing time. As I mentioned in my earlier research, I choose Gabor filter to implement image enhancement. I spent most of time to learn the formulas in Gabor filter. Although it was working, but its result was not good. In this phase, I have tried to implement image enhancement with three ways: Sobel edge detector, Gabor filter and OGorman filter.

I spent most of time to improve the Gabor filter. Gabor filter is a direction filter that generated by the input image’s direction (orientation) and frequency. The mathematical formulas about Gabor filter shows in following.

δx and δy are the space constants of the Gaussian envelope. Typically, these two parameters can be a fixed value [2]. I assign both of them is 4. Φ is the direction of the centre pixel and f is the frequency of the centre pixel. From the formulas, I know that there are two parameters will make an influence the Gabor filter. At first, in order to implement it easily, I using a fixed frequency value to generate the Gabor filter, but result cannot be used (Figure 6).

9

Figure 6 Image (a) is the input image, Image (b) is the enhanced image which frequency is a fixed value, and where f = 0.14

With this result, I think the frequency cannot be a fixed value, so I tried to calculate the frequency with the following formulas [2]:

The theory of these formulas is the count the gray value of every pixel in each block (divided the image into several blocks). The theory shows in Figure 7.

10

Figure 7 Every ridge will expression as a sine wave, to compute sine wave in each block, and the average distance of the peaks is the average weight of the ridge and the frequency of current

block f = 1/weight.

After I implemented this way, I found that in an image, some block may be will contain the core point or feature point, thus there will not appear any peaks in this block, so when I want to enhance the pixel in this kind of block, I cannot generate the Gabor filter for this kind of pixel, because this pixel have no frequency. Figure 8 is the output frequency of each block (I using 11*11 as the block size).

Figure 8 output frequency about image (a) in Figure 6In figure 8, this is the first nine blocks’ frequency. The first value is -1.0, it means it cannot find out a sine wave peaks in this block (The first block is background, not ridge appear in Figure 6 image (a)). After research, this essay also provides a way to solve this problem. [2] The author said that can use a mathematic method called Interpolation. “The frequency values for these blocks need to be interpolated from the frequency of the neighboring blocks which have a well-defined frequency.” [2] In interpolation, I only know how to do linear interpolation, because I learned it in Graphic class, but after I learned some information about interpolation, this kind of problem cannot be solved by linear interpolation only, it needs another kind of interpolation, but it is so difficult for me to understand, so I gave up to compute the frequency. For the frequency, I computed each blocks’ frequency, and carry all the frequency which is usable (not equals to -1.0), and then compute the sum of the usable frequency, count the sum of how many blocks can have frequency, at last to compute the average frequency for this image. After this way, I computed

11

the average frequency is 0.1 to 0.12, and I choose 0.1 as the average frequency to generate the Gabor filter. The result shows in Figure 9.

Figure 9 Image (a) is input image, and image b is enhanced image which frequency is 1.0 and filter size is 3*3

Gabor was working so far, but result is not good. Another essay said that filter size,δx and δy also need to generated dynamically .[4] The relationship between frequency and δx δy shows in the next formula

Kx and Ky is a fixed value, in this essay, author provided both of them is 0.5. [4] The relationship between block size and frequency shows in the following formulas:

I also have tried this way, but the result is worst than which I showed it in Figure 9. Figure 10 is the result of Gabor filter which change the size of the filter. The result is too bad.

12

Figure 10, the result of image (a) in Figure 9, which Gabor filter size is 7*7

When I was go to the next algorithm (ridge detection and thinning), I found that although the Gabor is not good in Figure 9, but actually it is working. Figure 11 shows the Gabor filter is working.

13

Figure 11 Image (a) is input image; Image (b) is doing the binarization directly. Image (c) is doing the binarization after normalization and Image (d) is doing the binarization after Gabor filter.

Next figure shows the different result after thinning algorithm.

14

Figure 12 Image (a) is doing the thinning without any process. Image (b) is the thinning result after normalization. Image (c) is the thinning result after Gabor filter

From figure 11 and figure 12, it proofs the Gabor filter is actually working.

In Image enhancement, I also did some attempts using another algorithm, one is Sobel edge detection.[5] This is a simple algorithm. It is easy to implement and its theory is easy for understanding. In Sobel edge detection, I use Sobel edge detector to compute the gradient in X axis and Y axis, and then detect the edge base on these two gradients. After I implement this way, I found this algorithm seems not suits to fingerprint image. I used some typical image to test it, the result is good, but when I was running this algorithm in fingerprint image, the result is bad. Figure 13 shows the Soble edge detection in typical gray image, and Figure 14 shows the Sobel edge detection in fingerprint image.

15

Figure 13 Image (a) is the input gray image, Image (b) is the result of Sobel edge detection

Figure 14 Image (a) is the input fingerprint image; Image (b) is the result of Sobel edge detection

Al the pre-processing are the same in Figure 13 and Figure 14. The pre-processing is that doing the Gaussian smoothing at first and the doing the Sobel edge detection. From Figure 13 and Figure 14, I though Sobel edge detection is not suitable for fingerprint image, so I gave up this way.

After I finished the basic functions about my project, I went back to improve the Gabor filter. I researched some essays, I found a filter called O’Gorman filter [6] is suits to fingerprint image. It is a direction filter. Similar with Gabor filter, O’Gorman filter need to using pixel’s direction to generate the filter, but it does not need the frequency. It is easier to implement. In developing this direction filter, I only need to identify a 7*7 matrix in 0 degree direction, and then rotate this filter base on each pixel’s orientation; I do not need to considered about the frequency. I only need to do is computing the rotate filter’s coordinate, and find out the weight for the rotated

16

filter from the 0 degree direction filter depend on the rotated coordinate. The rule of generate this direction filter shows in following:

Where:U>X>Y>ZMy 0 degree direction filter is follow with this [7]:

And the rotate formulas are the typical rotate formula:

Most times I’ and j’ will not be an integer, so I can find out the weight from the 0 degree direction filter. This problem can be solved by linear interpolation. Figure 15 express this situation.

Figure 15 linear interpolation to find out (X,Y).

17

Suppose A, B, C, D are four points which coordinates are integer numbers and A, B, C, D can find out corresponding weight in the 0 degree direction filter. A, B, C, D are neighbors with point (X,Y) where is the rotate coordinate. I using linear interpolation to compute the weight E, F and then doing the linear interpolation again to compute the point (X, Y)’s weight base on E, F. This processes it easier than Gabor. After I implement this algorithm, I found that the result is better than before. The following figures show the Image enhancement result with Gabor filter and O’Gorman filter.

Figure 16 Image (a) is Image enhancement with Gabor filter. Image (b) is Image enhancement with O’Gorman filter.

Figure 17 Image (a) is binarization after Gabor filter and Image (b) is binarization after O’Gorman filter.

From Figure 16 and Figure 17, I can see that Gabor filter can get a clear result in image enhancement stage, but O’Gorman filter is more suitable to the next pre-processing algorithm. In

18

Figure 17, the ridge in image (b) is smoother than image (a). Image (b) can link some break ridge, but image (a) cannot (the red circle in figure 17) and image (b) can remove some bridge link (blue circle in figure 17). Figure 18 will shows the different in thinning image.

Figure 18 Image (a) is thinning image which image enhancement using Gabor filter. Image (b) is thinning image which image enhancement using O’Gorman filter.

After I tried to implement these three algorithms in image enhancement (Gabor filter, Sobel edge detection and O’Gorman filter). I found O’Gorman is the best in my program. Gabor filter is the most traditional and famous algorithm in fingerprint recognition, but it is too complex and difficult for me, so I gave up using Gabor filter to implement image enhancement and choose O’Gorman filter to do image enhancement.

19

2.4 Fix Ridge

After thinning, I found that there are some new noisy points caused by thinning. (Figure 19)

Figure 19 thinning imageIn figure 19, there are some holds in the thinned image (red circle). This kind of noisy point will leads to two false bifurcations. There are some dots in the thinned image (blue circle). This kind of noisy point will leads to false ridge ending. At first, I thought this is due to my thinning algorithm is not good, so I draw an image to do the thinning algorithm, but I find that the thinning algorithm is fine. (Figure 20)

Figure 20 Image (a) I draw using windows graphics. Image (b) is using my application to thin it

In Figure 20, there is no any hold and dot, so I thought the problem maybe occur in the earlier algorithm. I do two operations to solve this problem. At first, I add a Gaussian smoothing filter after normalization, so that can remove some dots. Next, I add a fix ridge algorithm after binarization. The algorithm like that: Using a 3*3 matrix to check each pixel on the binary image.

20

P1 P2 P3P8 P P4

P7 P6 P5If p is foreground and all its neighbors are background, and then remove p. If p is background and check its four neighbors, if there are more than 3 neighbors is foreground and then mark p is foreground. E.g.:

1

1 P 1

1

After test, I found that when I do fix ridge operation three times, almost noisy point can be removed. (Figure 21)

Figure 21 the thin image after fix ridgeCompare Figure 21 with Figure 19, most hold and dot be removed.

2.5 Core Point Detection

I used core point as the reference point to do the matching. In the core point detection, I met a big problem; I have tried many ways to solved it. At last, it is working, but the result is not good. Firstly, I implement core point detection using the algorithm which I mentioned in my earlier research report. The result is bad, I have tested 20 images, only one image can find out the core point. After I think about this algorithm carefully, I found that there are two reasons will lead to this bad result: one is the orientation is not very accuracy another one is the method which I choose to compute the orientation. This core point detection algorithm is very sensitive for orientation accurate. In core point detection, I search each pixel and its eight neighbors. If the change angle of its neighbors equals 180 degree, then centre pixel is core. This algorithm is not

21

satisfying my orientation algorithm, because I compute the orientation base on gradient, I divided the input image into several blocks, each pixel in the same block will have the same direction, thus, if the core occur in the centre of a block, its neighbors will have the same angle, so the change of the angle is 0 degree. I think this is why I cannot find out the core by this algorithm.

I had tried to change another core detection algorithm, after research, I found a core detection algorithm, this algorithm is curvature based. [8] This algorithm is that:After get the orientation block, find each block’s eight neighbor, and then computing the different of the direction components using the following formulas:

If both diffy and diff x are negative, current point is core point. If cannot find the core point, decrease the size of the input image, and do the detection again.

I have implemented this algorithm, but still cannot find out the core point. Most of pixel will get both diff y and diff x are negative. I decrease the image and then do the algorithm again, but is still not working. Figure 22 is the result of this algorithm in different size image.

Figure 22 input image size is 110*120Figure 22 probably cannot be clear after print on paper, this is because my program scales its variance in a low level (150) and this image’s size is deceased from 260*300 to 110*120, but in the windows word it is clear. If you are interested in this, please go to down load my doc in my project web page.When I decrease the size become 110*120, only one pixel have both negative diff x and diff y, but this point is not the core point. I have checked the logic of my code; I think I follow this algorithm correctly, so at last, I gave up this way.

After that, I went back to my first algorithm, and then tried to improve the accurate of the orientation. In this core detection algorithm, I decided do not use the orientation which I computed in orientation estimation, because it is block orientation, I need the point orientation. I compute the orientation using another algorithm, this algorithm compute the orientation for each pixel base on the change of gray level in its neighbors. [11] This algorithm I will describe in the update earlier report stage. After this algorithm, I can get a point orientation filed. I also got a method to detect the core from some essays [9][10]. This algorithm base on my first algorithm,

22

just make some change. At my first algorithm in core detection, I check the point’s eight neighbors’ direction, count their change. In the improve version, I used two matrixes to check the neighbors’ direction change, one is 2*2 matrixes, shows in the following:

I, j-1 I-1, j-1

I, j I+1, j

Where (I, j) is the point be checkedAnother matrix is bigger than this one, it is 9*9 matrix, in this matrix, only 24 pixel will be checked. It shows in the following:

P5 P6 P7 P8 P9P4 P10

P3 P11P2 P12P1 I , j P13P24 P14P23 P15

P22 P16P21 P20 P19 P18 P17

In this matrix, 24 pixel is the neighbor of point (I,j), and I check the change of these 24 pixels’ direction. If the change of neighbors’ direction in matrix one equal to 180 degree and change of neighbors’ direction in matrix two equal or bigger than 180 degree, then point (I ,j) is core point.Compute change of neighbors’ direction follow these formulas:

δis the different angle between to link pixel, Poincare (I, j) is the change of neighbors’ direction in point (I ,j).

After improve the first algorithm using this way, the core point detection is working. The result is better than before, but the result still not good. I have tested 40 fingerprint images; only 22 images can get an accurate core point. (Figure 23)

23

Figure 23 Images which detect an accurate core point

Some of images have a big deviation. Some image will have two cores, but only can compute one(Figure 24)

Figure 24 Images which have two cores but only can compute one and Images which has a big deviation.

Without these two kinds of situation there are almost ten images cannot detect the core point. I think the biggest problem is the orientation cannot be 100% accurate. I output the point orientation filed to check it’s accurate, I found that the point orientation is worst than block orientation (Figure 25), but I still cannot find out a perfect way to solve this problem, to make the accurate more accuracy.

24

Figure 25 point orientation filedI using different color to mark different direction, from this fields, I found that the accurate is worst than block orientation which I shows in the orientation estimation, but it is more suitable to my core detection algorithm.

2.6 Problems in Match

As I said blow, the core point detection is not very accuracy, it will make a big influence in match algorithm. At first, when I did this match algorithm, I tried to make a big accept deviation in the matching; I thought that probably can decrease the influence which came from the core point detection. After I did that, the algorithm is working. My supervisor told me that I need to highlight the minutiae which are matched, using the same color to mark them, so that can proof my match algorithm. After I did this, I found that most matched minutiae are false. I feed back the match algorithm with this result, found that, two reasons due to this result. One is the accuracy of core point detection, one is I made a too big deviation for the accept range. I thought I have no enough time to change a core point detection algorithm, so I just focus on the second reason. I tried to decrease the accept range for the match deviation, but with this way, the influence which came from the core point detection cannot be decreased.

After I check the output result from the match algorithm, I found that, with the big deviation, sometimes 1 minutia in input image can find out more than 1 minutia in the template image, this is the problem, so I tried to add one more condition into the match algorithm. In my original match algorithm, I match a minutia with four conditions, the type of a minutia, the distance to core point and the slope angle between minutia and core point (I using the core point to establish the coordinates system, the direction of core point is the positive direction of x axis in this coordinates system, and then using these two fields to detect the local position of a minutia) and the different angle between minutia and core point. After match with this four conditions with a big accept deviation range, sometimes a minutia will have more than one matched minutia, so I add one more condition. This condition is count how many ridges between minutia and core point. I using Bresenham's line algorithm [12] to detection a line from core point to minutia, and count the change of 0 to 1 to computed how many ridges in that line. With this way, most matched minutiae are correct, but it is more sensitive about the core point accuracy. Most

25

images cannot be recognized, so I gave up this way to improve my match algorithm.I went back to see the image, find that, the deviation of different minutiae in different distance will be different. If a minutia near by the core point, when the core point has deviation, the slope angle of this minutia will have a big change, but the distance of this minutia will not have big influence. If a minutia far from the core point, when the core point, when the core point has deviation, the slope angle will not have big change, but the distance will have a big influence. With this idea, I make the accept range for each conditions depend on the distance of a minutia. If the distance is close to core, I make a big accept deviation in slope angle and a lower accept deviation in distance. If the distance is far away, I make a big accept deviation range in distance and a lower deviation range in slope angle. After that, the result is better, in most image, most matched minutiae are true, but still have some false.(Figure 26)

Figure 26 Match result which be improved, most minutiae are true, but still have some false.

3. What I achieved

Input imageMy application allow user to input an external fingerprint image.

NormalizationThis is the first step of my application, it can completely to scale a image which has a accept average gray and accept variance.

Orientation estimationMy application can compute the orientation about a fingerprint image. From the output orientation file, I think this result is good, and it can express the fingerprint ridge direction

Image enhancementAfter I change the O’Gorman filter to do this stage, the result is good, some break ridges can

26

be linked, and some bridge linked can be removed. The enhancement result is suitable for the next stage.

BinarizationBinarization function works, it can extract the ridge and valley, the result of this step is good and can be used in the next stage.

ThinningThe thinned is completed; the result is true, not any big problem occur in this stage. It is working well.

Minutiae extractionI achieved this function. It can extract the minutiae correctly, in this phase, I using two different color to show the different minutia (red is ridge ending and blue is bifurcation).

Remove false minutiaeThis function I have achieved, but the accuracy is not 100%. Some of the false minutiae cannot be removed correctly; a few true minutiae will be remoed. After test, I think it will not make a big influence to the final result, because after this stage, there are more than 80% true minutiae will be keep, it is enough to do the matching algorithm. (Figure 27)

Figure 27 most minutiae is true Core detection

As I mentioned, core detection is working, but accuracy is not good, some of them have a big deviation and some of them is correct.

MatchingThe matching function is depending on the core detection. It can distinguish two input image. The accuracy of this function is good, but it is impacted by core detection.

Database managementUser can enroll, match, delete, and update a fingerprint image in database.

4. What I did not achieve

I have one function which I mentioned in my functional specification cannot achieved. This function is capturing a fingerprint image from the scanner. It due to two reasons one is the

27

programming language. I using Java to implement this project, Java is running in Java virtual machine, but the driver program of the scanner is provide for window operating system. Java cannot invoke the scanner driver program cross Java virtual machine, so I need to use a technique called Java Native Interface [12], this technique enables Java program which running in JVM to call or be called by a native application (programs specific to a hardware and operating system platform). I have not used this technique before, so I need some times to learn it. The second reason is times. I finished all the basic algorithm in April 3th and I still need some time to finish the database and write the report. During the developing time, I always will stuck a problem in a long time, I will not want to change another way to implement it at first, so it waste many my times. This is my weakness, this lead to me have not enough time to do the next stage. I am very sorry that I cannot achieve this function.

Another thing what I did not achieve is a high accuracy. As I mentioned, core detection algorithm have a bad accuracy, it make a big influence in matching algorithm. As I said before, there 22 images can detect a good core, in these 22 image, there three image cannot match correctly, so I am not happy with the accuracy of the last algorithm in my project.

5. What I learned

Firstly, I think this project give me a big opportunity to learn much knowledge about computer graphics, especially the image preprocessing. During this project, I learned much knowledge in image preprocessing, such as I learned two algorithms in orientation estimation, what is the different from these algorithms and what the theory of them is. I think this is the great things what I learned from this project.

Next, I got a great experience in software developing. During this project, I improve my skill in documentation. This project let me know how important of research, for example, I choose a core point detection algorithm that is not suitable for my orientation algorithm. This is my mistake in research, next time I will be more careful in research. I also know the important of the time schedule, this project give me more experience in time schedule, let me know that don’t stuck in a problem too much time, if the current way is not suitable for me, I have to change it quickly, time waits for no one.

Thirdly, this project also gives me a big challenge to improve my coding skill. I got more experience in Java coding and solved problems in coding. Make me more familiar with Java programming.

At last, this project also let me know my weakness and push me to improve myself.

28

6. What I would do differently if starting again

If this project starting again, I will do the following different:1. Change using another programming language, such as C++ or C#, so that I think I can

implement the scanner function more easily.2. Choose the algorithm which is easy to understanding. Do not choose the complex algorithm,

although it is famous for this project (e. g Gabor filter), so that I can finish coding earlier and leave more time for me to testing and debugging.

3. I will change the matching algorithm, do not uses the core point based match, change to detect the reference point dynamically or minutiae neighbor based match.

4. Improve the accurate. To make the result more accurate.5. I will try to add a segmentation step into this project, so that if there is another thing in a

fingerprint image background, I can remove it.6. I will try to make some additional function into it. For example allow user to print out the

match result. Mark the some pair minutiae in the image after matching.

7. Update my earlier report

7.1 Update My Earlier Research

As I mentioned before, I computed the orientation again in core detection. This algorithm is different from my orientation estimation algorithm which I implement before.In this algorithm[11], I using a 9*9 matrix to check each pixel’s eight direction, the 9*9 block shows in the following:

29

For each pixel in this matrix, compute the average gray in eight different directions. Gmean(i), where I is the number of each direction (e.g. 0,1,2,3,…,7). After that, organized them into four groups (e.g. 0 and 4, 1 and 5, 2 and 6, 3 and 7), compute the different gray in each group, (e.g. G[i] = Gmean(i)-Gmean(i+4) where I = 0,1,2,3). Find out the biggest absolute value G[i_max] in these groups, for each centre pixel(x,y):If abs(gary(x,y)-Gmean(i_max))-abs(gray(x,y)-Gmean(i_max+4));

Direction(x,y) = i_maxOtherwise

Direction(x,y) = i_max+4;

After compute all pixel of an image, divide image into several blocks, this block size is w*w, count the direction of each block, identify the block direction as the direction which occur the most in this block. After get the block orientation, and then need to smooth it. Using a more big W*W block, which center is pixel(I, j), count which direction occur the most in this block, and set the centre pixel’s direction as this occur most direction.

7.2 Update My Earlier Design Manual

I have not do any big change in my design manual, I only remove one button from the GUI, because I have not achieve the scanner function and I add two GUI into on windows. Figure 28 and 29 are my new GUI.

30

Figure 28 new GUI in fingerprint recognition

Figure 29 new GUI in fingerprint database management

31

8. Module description

Figure 29 module of systemThere are four modules in this system, user interface, and preprocessing, match and database management module. User interface: This module is for user to control this system, access this system. Preprocessing: This module is for image preprocessing, in this module, it contains six sub-

modules, normalization, orientation estimation, image enhancement, ridge detection, thinning and minutiae module, each sub-module running each step in image pre-processing.

Match: This module is for the matching algorithm, it includes three sub-modules: core point detection, match image, and match DB. Match image is for match two input image, and match DB is for match a image in database..

Database management: This module is for access the database. It includes enroll, update and select. The select parameter came from the Match module.

9. Data Structures and data record

There four data structures need to be identifiedPixel structures for express the Pixel object in image.Pixel { int x,y; // pixel coordinate int rgb; // pixel gray value

32

double gx,gy; // pixel gradient in x axes and y axes double angle = 0;// pixel direction int mask = 0; //mark binarization int type = 0;//mark type 1 is ending 2 is bifurcation

private int check = 0;// mark this pixel has not be checked}

Minutia is for hold the minutia dataMinutia { double angle; //minutia direction int x,y; // minutia coordiate int type; // minutia type boolean mark = true; // mark minutia is not a false minutia}

Point structure is for compute the point orientation, it is similar with pixel, in order to distinguish point orientation and block orientation.Point { int x, y; // point coordinate int d; // point direction int rgb; // point gray value}

Featrue structure is generate as a feature vector, it is used for do the match and enroll it into databse.Featrue { Minutia m; // the corresponding minutia int distance;// distance from the core point

double angle;// Polar angle, using polar angle and distance to identify the local location of a minutiae

double diffAngel;// the different angle between minutia and core point int type; // type of the minutia boolean isMatch = false; // it is use for macth algorithm String image = null; // it is use for enroll into database int id = 0; // id in database}

FingerprintImage is for enroll a fingerprint image into database.FingerprintImage { String image_id; // image id String image_directory;// image directory in which file String description;// description of this image int core_x,core_y;// core coordinate double core_angle;// core angle;

33

There two table in database to storage the fingerprint informationFingerprint Image tableFiled Type CommentFringerprint_ID Varchar Mark the fingerprint image id

in databseImage_directory Varchar The directory in fileDescription Varchar Description of this imageCore_x Int Core x coordinateCore_y Int Core y coordinateCore_angle Double Core direction

Fingerprint Minutiae tableFiled Type CommentID Int Primary key minutia idFingerprint_ID String Mark corresponding

fingerprint imageX_coor Int X coordinate of a minutiaY_coor Int Y coordinate of a minutiaAngle Double Direction of a minutiaType Int Type of a minutiaDistance Int Distance to core pointPolar angle Double Gradient of the line which

from minutia to coreDiff_angle Double Different angle from core

point

34

10.Conclusion

My project is finished; I think I implement all algorithms, and I satisfy almost requirement except scanner function. I am happy I can achieve this. Actually, I am not happy with the accuracy of this project, especially the core point detection algorithm, but I am very happy with the preprocessing algorithm, I think the preprocessing algorithm is fine. I spent most of my private time to work on this project; I think I already tried my best to do this project.

As I mentioned, from this project, I learned most of things in different kind of area. I am happy I can have this challenge to do this project. Thanks for my supervisor Mr. Nigel Whyte, during the developing time, he gave me many help and good suggestions. Thank you very much.

35

Reference

[1] Anil Jain and Sharath Pankanti. Fingerprint Classification and Matching [online] available:

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.83.3331&rep=rep1&type=pdf

[accessed 4 April 2011]

[2] Lin Hong, Yifei Wan and Anil Jain (1998). Fingerprint Image Enhancement: Algorithm and Performance

Evaluation [online] available:

http://ai.pku.edu.cn/aiwebsite/research.files/collected%20papers%20-%20fingerprint/Fingerprint%20image

%20enhancement%20-%20algorithm%20and%20performance%20evaluation.pdf

[accessed 4 April 2011]

[3] Yuan Mei, Huaijiang Sun, and Deshen Xia (2006). A Gradient-Based Robust Method for Estimation of

Fingerprint Orientation Field

[4] RayMond Thai (2003). Fingerprint Image Enhancement and Minutiae Extraction

36

[5] Wikipedia. (2011). Sobel Operator, available: http://en.wikipedia.org/wiki/Sobel_operator

[accessed 3 April 2011]

[6] O’Gorman L, Nickerson J V (1989). An approach to fingerprint filter design [J]. Pattern Recognition.

[7] Gui Ke (2010). Fingerprint Image processing and algorithm research. (Chinese version)

[8] Atipat Julasayvake and Smosak Choomchuay (2007). An algorithm for fingerprint core point detection.

[9] Dey T K Hudson J. PM R (2002) Point to mesh rendering, a featruebased approach

[10] Guijun Nie, Jian Wang, Zhenhui Wu, Yuanting Li and Rongqing Xu (2006). Fingerprint Singularith Detection

Based On continuously Distributed Directional Image.

[11]Luo Xiping and Tian Jie (2002), Image Enhancment and Minutia Matching in Fingerprint Verification.

[12] Wikipedia. (2011). Bresenham's line algorithm, available: http://en.wikipedia.org/wiki/Bresenham

%27s_line_algorithm [accessed 8 April 2011]

37