open-iris

The iris.io package is the primary interface for handling I/O operations within the Iris Recognition Inference System. It is organized into several specialized submodules to handle configuration, data structures, error handling, and validation:

• iris.io.class_configs: Manages class-specific configurations.
• iris.io.dataclasses: Provides the core data structures used throughout the I/O process.
• iris.io.errors: Defines the exception hierarchy for I/O-related failures.
• iris.io.validators: Contains logic for validating data integrity and schema compliance.
• iris.io: The main entry point for the package.

The iris.utils package provides utility functions for the Iris Recognition Inference System. It is organized into several specialized submodules:

• iris.utils.base64_encoding: Handles Base64 encoding and decoding operations.
• iris.utils.common: Contains general-purpose utility functions used across the system.
• iris.utils.math: Provides mathematical helper functions for iris processing.
• iris.utils.visualisation: Contains tools for visualizing iris data or processing results.

The iris package is organized into several specialized subpackages. Depending on your use case, you will interact with one or more of the following:

• iris.callbacks: For handling event-driven logic or lifecycle hooks.
• iris.io: For input/output operations, such as reading or writing data.
• iris.nodes: For working with individual processing units or nodes within the system.
• iris.orchestration: For managing the execution and coordination of tasks.
• iris.pipelines: For defining and executing sequences of processing steps.
• iris.utils: For general utility functions and helpers.

The iris.nodes.normalization package provides various modules for normalizing iris images, which is a critical step in the Iris Recognition Inference System (IRIS) pipeline. The package is organized into specialized submodules based on the type of normalization required:

• linear_normalization: For applying linear transformations to the iris data.
• nonlinear_normalization: For applying non-linear transformations.
• perspective_normalization: For correcting perspective distortions in iris images.
• utils: Contains utility functions supporting the normalization processes.

Developers should select the appropriate submodule based on whether the image distortion is linear, non-linear, or perspective-based.

The iris.nodes.iris_response package is a core component of the IRIS (Iris Recognition Inference System) used for handling iris recognition responses. It is organized into subpackages for image processing and schema definitions, and includes specialized modules for convolutional filter banks.

Key subpackages include:

• iris.nodes.iris_response.image_filters: Contains tools for image-based processing.
• iris.nodes.iris_response.probe_schemas: Defines the schemas used for iris probes.

The iris.nodes.geometry_refinement package provides tools for refining iris geometry. It is composed of several submodules specialized for different stages of geometric refinement:

• contour_interpolation: Handles interpolation of iris contours.
• contour_points_filter: Provides functionality to filter points within iris contours.
• smoothing: Implements smoothing algorithms for geometric shapes.

Developers can use these modules to clean, interpolate, or smooth iris-related geometric data as part of an inference or processing pipeline.

The iris.nodes package is organized into specialized subpackages that handle different stages of the iris recognition pipeline. Developers can use these subpackages to build or extend iris inference workflows. The available subpackages include:

• Processing & Estimation: segmentation, normalization, geometry_estimation, geometry_refinement, eye_properties_estimation.
• Feature Extraction: encoder, vectorization, binarization.
• Template Management: templates_aggregation, templates_alignment, templates_filter.
• Matching & Comparison: matcher, iris_response, iris_response_refinement.
• Data & Validation: aggregation, validators.

The Iris Recognition Inference System (IRIS) is a biometric verification pipeline designed for large-scale uniqueness verification. The system processes iris images through a multi-step pipeline to produce a verification result with a confidence score.

The high-level pipeline steps are:

1. Iris Image Input: Provide an iris image for verification.
2. Iris Segmentation: Identify and isolate the iris region within the image.
3. Feature Extraction: Extract unique features from the iris to create a template (iris code).
4. Scalable Matching: Efficiently compare extracted features for large-scale uniqueness verification.
5. Result: Receive the verification result with a confidence score.

The project uses a specific optimized version called IRIS* when working with high-resolution images (e.g., 1440x1080) captured by the Orb.

Key characteristics of IRIS:*

• Optimized to accommodate high-resolution imagery.
• Leverages effective iris encoding.
• Achieves high accuracy in controlled environments (like the WLD-InHouse-v2 dataset) with FNMR < 0.0001 at FMR of 0.000001.