Storage Space Reduction of Biometric Iris Databases by Successive Images Differences and Quadtree Decomposition

Each individual's iris, the delicate, ring-shaped portion of the eye uniquely patterned and nestled between the sclera and pupil, functions much like an immutable, organic password. While fingerprints, facial features, and voice patterns have long been utilized as identifiers [1], the iris's pattern offers superior reliability, non-invasiveness, and a higher precision rate in recognition. Remarkably, the iris pattern remains largely unchanged throughout an individual's lifetime, with the left and right eyes each boasting distinct patterns [2]. The high degree of individuality inherent to each eye's iris [3] affords iris recognition advantages over other recognition systems [4].

Among biometric identifiers, iris recognition stands as one of the most precise for human identification, and its application is expanding globally. The rise of portable systems using iris recognition is particularly noticeable in law enforcement applications. Many of these applications necessitate a portable device capable of transmitting an iris image or template over a limited bandwidth communication channel. To ensure accurate recognition results, a full-resolution image (e.g., VGA) is typically required to provide sufficient pixel density across the iris [5].

While Iris Code templates are substantially smaller (600 times) than standard iris images, there is a practical preference for storing, transmitting, and integrating iris data using images rather than templates [6]. Image compression can effectively reduce the file size of an iris image, thereby decreasing the transfer time for large data volumes over narrow bandwidth communication channels [4].

In 2007, Matschitsch et al. [7] explored the impact of several lossy compression algorithms on the accuracy of iris recognition systems. They found that the PSNR, accurately predicted by JPEG2000 and SPIHT compression algorithms, was aptly suited for iris recognition systems. Fractal compression was found to be least appropriate for the considered recognition system, while PRVQ compression performed remarkably well, delivering the best matching scores in one scenario despite ranking third in PSNR performance.

Later, in 2010, Ives et al. [8] studied the influence of JPEG-2000 image compression on the performance of recognition systems employing Daugman's algorithm. Their findings suggested that recognition performance was minimally impacted despite significant compression.

In 2015, Shaikh and Mukane [9] used a compression scheme combining region-of-interest isolation with JPEG compression at various qualities to compress iris images. Their investigation into the scheme's effect on recognition performance revealed minimal impact when using compressed iris images.

Similarly, in 2015, Ramadan [10] introduced an automated 3D iris compression and recognition system using spherical wavelet coefficients rooted in effective 3D iris representation. The results demonstrated that spherical wavelet coefficients yield impressive compression abilities with minimal features.

Čorić et al. in 2014 [11] applied Classified Vector Quantization (CVQ) and ordinary Vector Quantization (V.Q.) to compress grayscale iris images sourced from a public iris image database. Their findings confirmed that, given the uniformity and low contrast levels of iris images, both compression methods are markedly more efficient when applied to them than to standard images from everyday environments.

Shaikh and Mukane in 2015 [12], utilized JPEG compression for iris images and studied its impact on recognition performance.

In 2017, Kapoor and Rawat [13] proposed a scheme that combines ROI (region-of-interest) isolation with JPEG 2000 compression at varying levels. They concluded that JPEG 2000 compression yields superior results with iris images normalized using the Biomechanical model, with minimal impact on recognition performance.

Al-Khafaji and Ali [14] introduced a method in 2019 for compressing biometric iris grayscale images, combining the DWT base's multiresolution scheme and the zipper transformation base techniques. Further, in 2022, Jalilian et al. [15] examined the feasibility of a deep learning-based compression model for iris data compression.

Lossy image compression can significantly reduce the space and bandwidth requirements for image storage and transmission, a feature highly sought after by developers of iris recognition systems. While deep learning techniques, with their various methods, are rapidly emerging as the preferred tool for general image compression tasks, their application for iris image compression demands meeting specific critical quality criteria. These include high perceptual quality, spatial accuracy of the images, and storage space efficiency.

In this paper, we examine and evaluate the effectiveness of a method grounded in successive image differencing, quadtree decomposition, and post-compression Huffman coding. When compared to its performance with familiar and broadly used lossy compression methods, this approach could offer efficient compression without substantial data loss. We conduct a comprehensive comparison and analysis of compression and recognition results to pinpoint the optimal compression algorithm for iris recognition systems.

The remainder of this paper is structured as follows: Section 2 will delve into the concept of quadtree decomposition. Section 3 will outline the steps of the proposed system. Section 4 will detail the experimental framework, testing, and analysis. Finally, Section 5 will conclude the paper.

At first, the different images are found for each class in the iris dataset by subtracting the successive images of a person from the first image in the same class. Then the quadtree decomposition is employed to compress these different images due to the close correlation of images belonging to each class. The Huffman encoding is used for extra compression to compress the quadtree data result.

3.1 Image differences

Image differencing is used in image processing to detect differences between images. The difference between two images is calculated by subtracting the pixels in each image and then producing an image based on the result.

The following are the differences between the two images:

$\begin{gathered}{ImgDiff}(i, j, k)=firstimg(i, j, 1)-{img}_k(i, j, k) \\ for\,\,i=1, \ldots, w, for\,\,j=1, \ldots, h,\,\, k=2 \ldots, 5\end{gathered}$               (1)

where, firstimg is the first image belonging to each class in the iris dataset, w and h are the dimensions of the iris image, and k is the number of iris images in each class.

Figure 3 shows the five images for 'chualsr' from the MMU1 database. Figure 4 shows the differences between the first and the remaining four images.

3.png

Figure 3. Class from MMU1 database [1]

4.png

Figure 4. Successive differences: (a) The first and second images difference; (b) The first and the second image difference; (c) The first and the third image; (d) The first and fourth image difference

3.2 A negative/positive map

By this step, the complication resulting from negative values is removed. These negative values are continually modified to positive by applying the following mapping equation:

$X_i= \begin{cases}2 X_i & if\,\, X_i \geq 0 \\ -2 X_i-1 & if\,\, X_i<0\end{cases}$                      (2)

where, X_iis a negative number, by the above equation, the negative values are changed to be odd while all positive values become even in the difference image ImgDiff.

To return the numbers (X_i) to their original signs, perform the following inverse equation:

$X_i=\left\{\begin{array}{cc}X_i \,\,div\,\, 2 & if\,\, X_i \,\, is\,\, even \\ -\left(X_i+1\right) \,\, div \,\, 2 & if \,\, X_i \,\, is\,\, odd \end{array}\right.$                         (3)

where, $X_i$ is the i^th element, the above equation converts all odd values to negative while converting even values to positive.

3.3 Quadtree decomposition

The quadtree decomposition is done with the Mean of each block in the image as a measure. The Mean of a block such as the following:

$\mu(X)=\frac{1}{n} \sum_{i=1}^n X_i$                  (4)

where, X_i is the i^th element and n is the number of elements.

At first, the $\mu(x)$  of the parent block is computed first, and the max value in each block is found. Then the breakup children's blocks are specified separately. Now find the maximum value of the separate block; if it is more than its Mean block $\mu$, further resolve the child block. Or else, if there is no further division, the block/node is left as a leave—the division results in decomposing the image with unequal size partitioned blocks. Figure 5 shows the homogeneous and inhomogeneous quadrants of a decomposed quadtree image, and the minimum block size is 4×4 and th=0 (i.e., lossless compression). Because non-homogeneous quadrants have more than one luminance value, individually saving each pixel (total of 16 pixels in a minimum size quadrant) is not valuable. As we note, there are a lot of regions with equal or close intensity values, and with quadtree decomposition, we can exhaust to compress. The result after Huffman coding for extra compression is shown in Figure 6.

5.png

Figure 5. Quadtree decomposition and the minimum block size is 4×4 for Figure 3 (a-d)

6.png

Figure 6. Huffman coding for Figure 5

Figure 7 depicts the proposed compression flowchart based on quadtree decomposition and Huffman coding.

7.png

Figure 7. The flowchart of the proposed compression method

In the suggested system, a regular quadrant is a segment in which all values are different by a minimal amount (max difference MaxDiff)<=1,2) if the quadrant is lossy or the same if it is lossless (MaxDiff=0). The output from the quadtree is a list of block sizes, (x, y) coordinates, and the means of quadrants. After that, the list is compressed using Huffman coding. The details of all steps of the proposed method are explained in the algorithm 1.

Algorithm 1: Encoding

Input

   ImgDiff,      //  The difference between two images

   w, h,           //  width and height of ImgDiff

Output

   COMP  // Compressed data

Step 1: If the size of the sub-image ImgDiff is not square, then the borders of ImgDiff are padded with 0's. Assume that J is the padded image with size w′×h′.

Step 2: Determine the minimum block size BkSize quadtree decomposition's threshold. Then if BkSize=4, the minimum block size became 4×4.

Step 3: Specify a threshold for divided blocks th.

  Step 4: Compute the max value of the block elements MaxDiff.

                If MaxDiff > th then

                           ImgDiff image is split into four blocks.

               Else

               Store in H.Q. the following:

1. The quadrant size is because the dimensions of a quadrant (i.e., height and width) are all the time equal, so only one value is desired to store.
2. (x, y) coordinates of the quadrant's upper left corner.
3. Mean of the quadrant.

The threshold th represents the bare minimum (0 for lossless encoding). Because the quadrants have many equivalent sizes, a list of sizes is created to ensure adequate storage capacity for each list item, regarding (ii) and (iii) for all quadrants whose size is equal to the corresponding component in the list. It is not necessary to store the data of any quadrant in J that is entirely outside of the original image I. It is simple to determine by comparing the coordinates of the quadrant's upper left corner with the values of w and h.

Step 5: Huffman encodes H.Q. to obtain COMP.

The decoding by Huffman is applied to COMP for retrieving the homogeneous quadrants H.Q., and then the inverse of mapping is performed by the following equation:

3.4 Decoding phase

The inverse of the encoding phase is used in the decoding stage. To retrieve the difference images, the inverse of quadtree decomposition is used. Algorithm 2 illustrates the steps of the encoding phase.

Algorithm 2: Decoding

Input

      H.Q., w′, h′.

Output:

     ImgDiff′.

Step 1: Inverse the quadtree decomposition on the H.Q. by performing the sub-steps such as:

Step 1.1: Form an image of zeros called ImgDiff' of size w′×h′. The size of ImgDiff ′ is equivalent to the padded image J.

Step 1.2: Fill the homogeneous quadrants of ImgDiff′ using the Means of each homogeneous quadrant block saved in step 4 of the encoding process in H.Q., besides its size and coordinates.

Step 2: Resize the ImgDiff' to size w×h, i.e., equal to the size of the original sub-image of ImgDiff and then generate the decoded image.

3.5 Image addition

All the successive differences images are added with the first image firtimg for each class to reveal the original images. The following is the image addition:

$\begin{gathered}img_k=firtimg(i, j)+ImgDiff^{\prime(i, j)} \\ \text { for } i=1, \ldots, w, for\,\, j=1, \ldots, h, k=2, . .5\end{gathered}$                      (5)