Iris Recognition Repository / file revision

 \chapter{Conclusions}

 \section{Final Product}

 The final prototype is a functional iris detection application, which provides the 

 user with visual prompts and feedback and also some supplementary information about 

 the loaded image for debugging purposes.

 The final product can read in an 8-bit indexed, greyscale image and will attempt to

 automatically best-fit parameters for the location of the pupil, iris and eyelids with 

 consideration for specular highlights and padding for eyelash interference. The entire auto-detection process takes a matter of milliseconds. The user may 

 choose to manually enter points to specify all of these locations; if the user does, he 

 or she will receive appropriate visual feedback cues for repositioning elements in a 

 manner intuitive to any casual computer user.

 From this point, the user input is complete and the application will process the

 image data, unwrap the iris using polar co-ordinates and mask appropriate

 regions of the unwrapped iris based on the auto-detection sequence or user

 input.  This information is then extracted using Gabor wavelet convolution

 filters and the final output is a 2048-bit iris code containing phase

 information of the valid iris pixel data.

 The iris code is stored in a local, new line delimited text database if unique

 or the prototype reports that the code has already been located in the database

 and a successful match dialog is given.

 \section{Auto Detection}

 %\subsubsection{Pupil}

 Pupil detection in the application works to a very high degree of accuracy in

 every seen case.  The pupil has a fairly unique shade in comparison to the rest

 of the eye and its surrounding area; this enables an intelligent threshold to

 be carried out with information from the image histogram to isolate the pupil.

 This, unfortunately, is not a property shared by the iris, making it significantly more

 difficult to isolate than the pupil.

 %\subsubsection{Iris}

 Currently the prototype makes an estimation of the location of the iris based on

 concentricity (a potential source of error) with the pupil, and assumes

 a detectable gradient ramp between the iris and the sclera. These complications

 hamper the accuracy of our current estimates and produce a successful detection

 rate on the CASIA database of around 70\%, though potential improvements to this

 method are suggested in future work (\ref{furtherwork}).

 %\subsubsection{Eyelids}

 The prototype manages to detect the top edge of the eyelids in the vast

 majority of cases. With the small amount of padding added to accommodate the

 thickness of the top eyelid, it can be seen that, although not perfect, a very

 reasonable estimate of the eyelid boundary is found automatically.

 \chapter{Final Results}

 With the batch command line option of the application, it is possible to

 process a large amount of images of eyes. Using this option, 108 images of eyes

 from the CASIA database were loaded into the application; the pupil, iris and eyelids were auto-detected to generate a bitcode and store it in the database. These were then compared to an alternative image of each eye 

 to check for matches.

 To further test primarily for false matches, the first three images of each eye were

 loaded into the database, and then compared to a fourth

 image for each eye. As there were originally three images for each eye, and

 then a comparison was performed on all of the extra 108 images, roughly 35,000

 iris comparisons took place ($(108 * 3) * 108$). 

 Our results of these tests are as follows: \begin{itemize} \item 0 false

 		matches in $\sim$35,000 comparisons \item 70\% (75 out of 108) match rate

 		with Professor Daugman's suggested 0.32 Hamming distance.

 \end{itemize}

 The complete lack of any false matches and the incredibly high match rate are a

 testament to the robustness and feasibility of an iris recognition system. The

 tests have suggested that in virtually any case where the iris boundary is

 correctly located, the iris should be correctly identified.

 As a roughly 70\% match rate was achieved for the iris location, this percentage has, as

 predicted, been reflected in the overall match rate in the

 database of images. Similarly to Daugman, we can also observe that the Hamming

 distances produced by comparing different irides tends to follow a binomial distribution, with a mean around 0.46; see

 figure \ref{hd}.

 \begin{figure}

   \centering

     \includegraphics[width=0.55\textwidth]{hd}

     \caption{The distribution of Hamming distances for one run of all the irides in the database}

     \label{hd}

 \end{figure}

 \newpage

 \section{Source Code}

 The source code is freely available under the GPL licence from \url{http://projectiris.co.uk}.

 \chapter{Future Work}

 \label{furtherwork}

 Throughout development the focus was on producing a functioning piece of software capable of 

 fast, consistent and reliable iris recognition. There are other possible routes for extension

 and exploration within this project. There are alternative ideas for the format of the

 application and unexplored avenues within auto-detection techniques.

 \section{Otsu Thresholding for Iris/Sclera Separation}

 As we have seen before on average the iris has a lower intensity than the

 sclera. Hence it could potentially be beneficial to explore the use of Otsu

 thresholding for separation of the iris and sclera. Similar to the methods

 implemented for eyelid detection, if we remove eyelids and pupil intensities

 from the Otsu thresholding process then we obtain the image shown in figure

 \ref{otsu-iris}. Although to the human eye this image looks to hold more

 information than the implemented technique (see figure \ref{iris-threshold})

 the image contains a large amount of noise and would require further filtering

 and refinement to be useful.

 \begin{figure}

   \centering

     \includegraphics[width=0.35\textwidth]{anothereye}

         \hspace{1cm}

     \includegraphics[width=0.35\textwidth]{otsui}

     \caption{Image before and after an Otsu threshold.}

     \label{otsu-iris}

 \end{figure}

 This would be the first recommended route for extension since, during the

 testing phase, the software tended to fail recognition on images where it could

 not adequately locate the iris.

 \section{Eyelashes}

 In some images eyelashes can obscure parts of the iris. Detection and removal

 (marking as bad bits) of eyelashes could potentially improve the detection

 rate. A method is given in \cite{min2009} for eyelash detection. The method

 relies on two characteristics of eyelashes: firstly, that they have a relatively

 low intensity compared to surrounding features, and secondly that the eyelash

 regions have a large variation in intensity due to the thin shape of the

 eyelashes (see figure \ref{justaneye}). The method uses these characteristics

 by combining a standard-deviation filter and a thresholding technique.

 \begin{figure}

   \centering

 	\includegraphics[width=0.35\textwidth]{justaneye}

 	\caption{The eyelashes have a relatively low intensity and the eyelash region has high variation in intensity.}

     \label{justaneye}

 \end{figure}

 \section{Eyelids}

 The implementation of eyelid detection is based on the region obtained from the

 thresholding technique, as we saw in figure \ref{otsu-eyelids}. The system

 currently constructs a parabola from three points on the boundary of this

 region. Accuracy in eyelid detection could potentially be improved by using the

 Hough technique for parabolas. This again would allow more accurate marking of

 non-iris regions and hence improve overall recognition rate.

 %TODO:? \subsection{Gaussian Derivative Encodings}

 \section{Application Format}

 Currently the system has a text file for storing iris encodings. This could be

 improved to mirror a real-world application deployment by interfacing with a

 database. Although due to the one-to-many searches involved with iris

 recognition database querying could potentially become a bottle neck.

 Another area worth exploring is implementing the software with a client/server

 architecture whereby the iris is encoded client side, and compared server side.

 Again, this more accurately mirrors real-world deployment of an iris recognition

 software. This would then require further investigation into security and encryption methods

 for the system.