Open Source Iris Recognition Hardware and Software
with Presentation Attack Detection

Figure 1 (a-b) shows the setup of our hardware. The design is simple: an IR-sensitive camera (with the IR filter) is used to capture the iris images, and a circuit controlled by the Raspberry Pi output pins is used for illumination purposes. Since OSPAD-3D requires two iris images taken when the eye is illuminated from two different directions, two near-infrared LEDs (with a power peak around 850 nm) are placed equidistant to the lens and on both sides of the lens. At test time, the first picture is taken with the left LED turned on (and right LED turned off), and then the second picture is taken with the left LED turned off (and right LED turned on). Then, both LEDs will go off and the iris segmentation, recognition, and presentation attack detection steps are carried out.

Table 1 lists the main components used to construct the system and their current prices. The Raspberry Pi model version is 3B+. The NIR LEDs have emission wavelengths of 850mm, but any LEDs with wavelength in the range between 700mm and 900mm, as recommended by ISO [16], will work. Four 220 Ohm resistors are used for circuit protection purposes. For the software part, all software modules are implemented in Python. One may optionally use a protective metal sleeve, as shown in Fig. 1, or skip using the NIR filter at all, if the camera has an embedded IR-cut filter.

The complete package (segmentation model, source codes, hardware specifications, and assembly instructions) can be obtained at https://github.com/CVRL/RaspberryPiOpenSourceIris. Note that all software components can be easily run outside the Raspberry Pi environment, and thus serve as a rapid iris recognition implementation with presentation attack detection. The optional OSIRIS-based segmentation module (attached to the software release for comparisons and replication purposes) is written in C++.

This evaluation has two goals. One is obviously an assessment of the overall iris recognition accuracy offered by algorithms working in low-resource setup. The second goal is to compare the adapted, light-weight CC-Net-based segmentation with three other open-sourced segmenters: U-Net-based [23], SegNet-based [36] and OSIRIS-based [29]. In order to make a fair comparison, the iris images in the test set are first segmented by each segmentation method separately. Then, the same human-driven BSIF-based iris recognition algorithm [7] is used to generate the genuine and imposter comparison scores using segmentation results of each segmentation method. It is noteworthy that all segmentation and iris coding methods used different, subject-disjoint datasets for training and hyperparameters setting, so this experimental protocol is the best available option.

The datasets used in training of both iris segmenters and the BSIF-based encoding method are subject-disjoint with the NDIris3D-LG corpus (samples collected by the LG 4000 iris sensor) used for testing in this work. Table 2 reports the $d^{\prime}$ between genuine and imposter distributions, Equal Error Rate (EER), and False Non-Match Rate (FNMR) at different levels of False Match Rate (FMR). As it can be seen, CC-Net, OSIRIS, and SegNet all achieve high $d^{\prime}$ and low EER, which means that they give high-quality masks. Note that CC-Net achieves similar FMR as the state-of-the-art CNN-based segmentation method (SegNet). U-Net-based segmentation results in lackluster overall accuracy. This may be due to the fact that the CASIA-V1 dataset is small in size, and fine-tuning the U-Net weights with only 160 images (according to the original paper) may be insufficient to generalize on non-CASIA and ISO-compliant samples. Although it is possible to re-train it on a larger dataset, which would certainly lead to better performance, we will show in Section 4.3 that the structure of this network is prohibitively large to be deployable on low-resource platforms, such as Raspberry Pi.

We also present selected qualitative results of the segmentation results of different methods. Figure 2 shows two examples from CASIA-V1 and NDIris3D-LG. It can be seen that U-Net [23] performs perfectly on CASIA-V1, but fails to generalize onto NDIris3D-LG. OSIRIS misclassified part of the iris and sclera region for CASIA-V1 but achieves a robust performance overall. SegNet- and CC-Net-based methods generate masks that are close to the ground truth. Note that SegNet predicts finer details for the CASIA-V1 when compared to CC-Net segmentation, and we conjecture that this is because SegNet is a richer model, trained on a variety of data, and is therefore able to capture more low-level features. Both SegNet and CC-Net demonstrate very good segmentation results for iris images captured by the hardware proposed in this work. These qualitative observations correspond with our quantitative assessment.

Placing textured contact lenses on the cornea to interfere with actual iris pattern, and thus conceal one’s identity, is a well-known presentation attack type. A close observation of images may reveal that textured contact lenses cover only part of the iris, leaving some regions of the iris observable, as shown in Figure 3. This fractional authentic iris area is, however, too small to obtain reliable recognition. Indeed, Table 3 and Figure 4 demonstrate that when the genuine irises are covered by textured contact lenses, the genuine score distribution (denoted as “Genuine vs Real-Contact”) is shifted towards imposter score distribution, significantly increasing the probability of false non-match. Such attempts should be detected, and thus presentation attack detection is necessary.

In this subsection, we compare the PAD methods implemented in our system (OSPAD-fusion, OSPAD-3D, and OSPAD-2D) to all currently available open-source baselines, by either following download instructions offered in original papers, or – in some cases – asking the corresponding authors for source codes. We evaluated all methods under the same protocol: all algorithms are trained according to the training schedule in the original papers / the schedules suggested by the authors, with the NDCLD’15 dataset [10] as the training set, and the entire NDIris3D-LG as the testing set. Again, our goal was to use a subject-disjoint train and test sets of images. Since OSPAD-3D generates one prediction for each pair of images, we use a validation subset from the training set NDCLD’15 to search for the best fusion strategy for the other methods. As a result, all methods now generate one prediction for each pair of images, so their performance could be evaluated fairly. Results in Table 4 show that the adopted methods achieve state-of-the-art accuracy in iris presentation attack detection.

In order for an open-source system to be deployable in real-world application scenarios, the most important feature is fast running time. A slow system is not desirable, even if it is cost-effective, open software, and open hardware. Table 5 presents the average and standard deviation of the running times (in seconds) of each module in our system, on both NDCLD’15 and NDIris3D-LG sets. Note that all the times are for a pair of iris images, as required by the OSPAD-3D method. So processing times per a single iris image are approximately half of those reported in Table 5. All modules have fast running time because our implementation takes advantage of all four cores of the Raspberry Pi through multiprocessing. We can further parallelize OSPAD-2D with the other modules, since it does not depend on segmentation results. Note that while the running times for the other modules are roughly comparable for the two datasets, both the average and standard deviation of the OSPAD-2D running time are significantly higher on NDIris3D-LG than on NDCLD’15. This is because the training set of OSPAD-2D models partially overlaps with our subset of NDCLD’15. This makes OSPAD-2D decisions on NDCLD’15 more confident, thus triggering the early stopping more frequently on NDCLD’15 than on NDIris3D-LG.

We also compare the running times of CC-Net, compared to the other three candidate segmentation tools: OSIRIS segmentation module, SegNet-based and U-Net-based. Table 6 shows the running times of each method, along with the number of trainable parameters. Results show that CC-Net is the fastest segmentation method, around $3.5\times$ faster than OSIRIS and $38.2\times$ faster than SegNet. The running time of U-Net is not reported because the model is too large to be run on Raspberry Pi. The huge speed advantage of CC-Net is due to the fact that the number of its trainable parameters is significantly less than SegNet and U-Net. Though OSIRIS does not need to tune any parameters, it requires a lot of computation to perform the Viterbi algorithm. Therefore, CC-Net is left as the segmentation component in the final prototype.