Since the advent of computers, people have been trying to make them perform tasks. The eventual goal being to make a computer perform a given task at above the level that a human can. For “simple” tasks (simple for a computer) such as math the computer can outperform humans many times over. For other “simple” tasks (simple for a human) such as telling people apart, computers are still struggling to a human level of recognition.
Facial recognition is one of those tasks that computers are struggling to obtain a human level of performance. Work began in the 1960’s to try to get computers to tell pictures of human faces apart.[1] The general process used still remains the same today. For a computer to tell faces apart first they must be able to break down a single face into something the computer understands. Then the computer compares the results of the breakdown of two different faces to see if they are the same or not.
The breakdown of the face has two parts to it. First the computer uses a face filter. This takes a picture and distinguishes the background from the face itself. As pictures are square and faces tend to be rounder, and that a given picture might not be of just a face, this step is important to make sure the computer just performs analysis on a face. The next and final step is to analyze the face. This is done via one of many different algorithms.[2] The algorithms differ greatly as well as the accuracy of their results. As of yet, there is no “best” algorithm for face recognition, but every day researchers get closer to the result.

The Project
The scope of the project is as such: To make a face recognition program of our own, creating both a new face filter and analyzer; and to compare the face recognition program we made to a professional face recognition program. In doing this the following will be answered:
1.
How well does the newly created face recognition program compare to the professional one?
2.
What kind of data causes the newly created face recognition program to fail?
3.
What kind of data causes the professional face recognition program to fail?
Data Collection
To obtain our data that consists entirely of mug-shots we executed the tried and true method of forcing the victims against a wall with the back of our sword while the photographer quickly setup his tripod, attached his camera, exposed the film and waited for the exposure. One may notice that we have digitally edited out the sword and any unbecoming facial expressions or wounds. After learning from the photographer that the victims could not move while the photo was exposed, and that the process was several minutes long, we changed tactics. The most noticeable change was to bagpipes from swords. The second was to use a Canon EOS 300D in place of the photographer and his slow glass film. For some of the pictures while the digital SLR was not handy we fell back upon Josh’s Samsung 1.3MP phone camera. These pictures were all saved in .jpg format with a compression level and resolution left to the individual camera's discretion.
Simulation Description – Professional Face Recognition

The professional program used is called “faint – the face annotation interface.”[3] It is an open source, java based face recognition program which has a similar structure to the newly created face recognizer.
For the face filter, it uses the Viola Jones Face Detector. This uses a cascading feature base system. This is where the program scans an image for a grouping of features, known as a classifier. If a particular spot passes the classifier, meaning it contains all the features in the classifier, then that spot is tested against a more rigorous classifier. When a particular spot passes all the classifier tests, then the Viola Jones Face Detector says that that spot is a face. It denotes this by giving a box around the face.[4]
For the face analysis, the Eigenface approach is used. This takes the faces received from the Viola Jones Face Detector and converts them into a set of Eigenfaces, which are all eigenvectors. This is done via a series of steps. First the set of faces are grouped together into a training set. Then the mean of the training set is found and subtracted from the training set. Next, the covariance matrix is calculated. From the covariance matrix eigenvectors (which contain the data of the faces, hence eigenfaces) and the eigenvalues for each vector are calculated. Lastly, the best eigenfaces are selected, which are the ones whose eigenvalues are the highest.[5] The found eigenfaces are compared against each other to tell which face is which. If two faces have similar eigenfaces, then they are more likely to be the same face, then if their eigenfaces were drastically different.
From the user’s standpoint, once starting up the program you select the pictures you want to analyze. You select the faces you want your program to train on. Then you give it more pictures, and it will identify the faces and then give you the percent chance that the given face is one of the training faces.
Simulation Description – newly created face recognition
-Filter

The Face Filter was created and developed by Sean McElroy and built largely using jhlabs' Java Image Filters library. After receiving a BufferedImage the Face Filter quickly turns it to grayscale and then applies a simple edge filter using the Sobel operator method.
Once this is completed the BufferedImage is turned into a 2D int Array using the selfwritten imgBuffTo2DIntArray() method. The next step is the important one where the face is found and filtered out. Since all the picture now contains is mostly black and a few white/gray lines, a tracing line is drawn across the horizontal middle. Brightness values greater than our chosen value of 55 (out of 255) are tagged. Then the first tagged item is designated the left side of the face. The last item is the right side of the face. Next a similar process is run from the top to bottom of the image down the middle. This finds the top and bottom of the head. Lastly these sizes are used to cut out the face and return a picture of just it. This method could use some tweaking, but still works most of the time.
-Face Analysis
After the face filtration step the image of the face is resized to a 100x100 pixel picture.
Then the “Gehring-Falangus modified reduced color face composition” algorithm, a technique that was specifically invented for this project, is applied. What this entails is first analyzing each of the 10000 pixels (from the 100x100 picture) individually. Their
RGB value is extracted and it is placed into a three dimensional color matrix. The location in the matrix is denoted by each of the individual RG and B values, 1 axis per value. This matrix is what uniquely defines the image of the face. When comparing two of the Gehring-Falangus matrixes the total number of pixels sorted into a particular location are taken from both images. Their difference is found and saved. After finding the difference for each location in the matrixes the differences are totaled, and that value represents the “distance between the faces”. When testing a face against a particular set of training data, the “distance between the faces” is computed for the testing face and each face in the training data set. The face that has the shortest distance from the testing face is considered a match.

Accuracy Trial #: Faint : Ours
Accuracy Trial 1: 69.8% : 69.8%
Accuracy Trial 2: 66.5% : 66.2%
Accuracy Trial 3: 83.5% : 89.6%
Accuracy Trial 4: 85.6% : 83.1%
Accuracy Trial 5: 85.6% : 75.2%
Accuracy Trial 6: 65.5% : 71.8%
Accuracy Trial 7: 61.2% : 70.9%
Accuracy Trial 8: 91.5% : 92.8%
Accuracy Trial 9: 87.6% : 86.3%
Accuracy Trial 10:96.5% : 91.0%
Discussion

Methods To Be Used <*<*incomplete*>*> :
Matched Pair T-Test to determine which one is better.
Confidence interval for each program to determine the programs accuracy.
T-Test compared to random showing they are significantly better than random guessing.
Graphs <*<*incomplete*>*> :
Scatter Plot of our’s vs theirs per trial
Summary stats per program
Box plot of each test
Summary

The program we created compares admirably to Faint. Over our ten tests the largest difference in accuracy was 10.4%. Eight out of the ten tests had roughly less then 6% separating the two program's accuracy. Five of the ten were roughly less then 2%. That said, since the programs operate in vastly different ways there were some sure trends seen.
Faint needs the facial expressions to be similar between the test image and a correct training image. If an incorrect training image has a closer match with regards to expression and tilt of head, Faint will usually choose that over the correct test image. This could be rectified if the training images composed of more images and with a wider range of expressions. On the other hand our program can usually pick a face out correctly as long as the training images has a correct one in the same lighting; expression and tilt of head do not matter. There is good evidence that our program appears to do much better with a smaller set of training images while Faint needs a larger set of training images and can still not handle large changes in lighting.
Although the newly created face recognition program performed comparable to the professional one, the problem is by no means complete. Facial recognition is still a ways off from even coming close to the recognition a human possesses, much less beyond it.
However, every year the algorithms become more accurate, and the tools become ever faster. With the eventual goal being to exceed the human capacity to recognize human faces. At that point its possible computers will be able to see through the most advanced disguises, or be able to pick an individual out of a crowd with only a momentary glimpse.
The possible applications are endless along with the endless amount of ways to tackle the problem.

Johnson, Ryan and Kevin Bonsor. “How Facial Recognition Systems Work.”
HowStuffWorks 31 May 2008 <http://computer.howstuffworks.com/facialrecognition.htm>.[1]
“Epic Face Recognition Info Page” EPIC 31 May 2008
<http://epic.org/privacy/facerecognition/>.[2]
Mathiszig Malte. “faint - The Face Annotation Interface. ” faint - The Face Annotation
Interface 3 June 2008 <http://faint.sourceforge.net>[3]
“Viola Jones Face Detector” CMUcam3: Open Source Programmable Embedded Color
Vision Platform 3 June 2008 < http://www.cmucam.org/wiki/viola-jones >[4]
Pissarenko, Dimitri. “Eigenface-based facial recognition”, Eigenface-based facial recognition 1993. 3 June 2008
<http://openbio.sourceforge.net/resources/eigenfaces/eigenfaceshtml/facesOptions.html>[5]