Open Iris Recognition Inference System

https://github.com/worldcoin/open-iris
Admin
IRIS is an advanced iris recognition pipeline for robust and secure biometric verification,...
Tokens:26,541
Snippets:126
Trust Score:9.5
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Verify open-iris installation (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Imports the `iris` package and prints its version to confirm successful installation. This step ensures the package is correctly installed and accessible. Requires the `iris` package to be installed.

```python
import iris

print(iris.__version__)
```

--------------------------------

### Install open-iris package (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Installs the `open-iris` package using pip. This is the first step to set up the environment for using the IRIS pipeline. Requires a Python environment with pip.

```python
!pip install open-iris
```

--------------------------------

### Initializing the IRISVisualizer

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Shows the simple step of creating an instance of the IRISVisualizer class, which is the prerequisite for using its methods to plot intermediate results from the IRIS pipeline.

```python
iris_visualizer = iris.visualisation.IRISVisualizer()
```

--------------------------------

### Using IRISPipeline with DEBUGGING_ENVIRONMENT

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Demonstrates how to instantiate the IRISPipeline using the predefined DEBUGGING_ENVIRONMENT and execute it with sample image data and eye side, capturing the detailed output provided by this environment.

```python
iris_pipeline = iris.IRISPipeline(env=iris.IRISPipeline.DEBUGGING_ENVIRONMENT)
output = iris_pipeline(img_data=img_pixels, eye_side="right")
```

--------------------------------

### Plotting Intermediate Results with IRISVisualizer

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Provides examples of using the initialized IRISVisualizer to plot specific data structures like IRImage and iris_template, demonstrating how to generate visualization canvases and display them using Matplotlib.

```python
import matplotlib.pyplot as plt

canvas = iris_visualizer.plot_ir_image(iris.IRImage(img_data=img_pixels, eye_side="right"))
plt.show()

canvas = iris_visualizer.plot_iris_template(output["iris_template"])
plt.show()
```

--------------------------------

### Install open-iris (Server) from GitHub

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/quickstart/installation.rst

Installs the open-iris package for server environments directly from the GitHub repository using pip, explicitly setting the IRIS_ENV flag to SERVER.

```bash
IRIS_ENV=SERVER pip install git+https://github.com/worldcoin/open-iris.git
```

--------------------------------

### Install open-iris (Development) from GitHub

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/quickstart/installation.rst

Installs the open-iris package along with necessary development dependencies directly from the GitHub repository using pip and setting the IRIS_ENV flag to DEV.

```bash
IRIS_ENV=DEV pip install git+https://github.com/worldcoin/open-iris.git
```

--------------------------------

### Install open-iris (Server) from PyPI

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/quickstart/installation.rst

Installs the open-iris package for server environments from the Python Package Index using pip. This is the default installation method when the IRIS_ENV flag is omitted.

```bash
pip install open-iris
```

--------------------------------

### Defining the DEBUGGING_ENVIRONMENT

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Shows the definition of the predefined DEBUGGING_ENVIRONMENT within IRISPipeline, which is configured with specific output builders, error managers, and a list of disabled QA validators useful for debugging.

```python
DEBUGGING_ENVIRONMENT = Environment(
    pipeline_output_builder=build_debugging_output,
    error_manager=store_error_manager,
    disabled_qa=[
        iris.nodes.validators.object_validators.Pupil2IrisPropertyValidator,
        iris.nodes.validators.object_validators.OffgazeValidator,
        iris.nodes.validators.object_validators.OcclusionValidator,
        iris.nodes.validators.object_validators.IsPupilInsideIrisValidator,
        iris.nodes.validators.object_validators.IsMaskTooSmallValidator,
        iris.nodes.validators.cross_object_validators.EyeCentersInsideImageValidator,
        iris.nodes.validators.cross_object_validators.ExtrapolatedPolygonsInsideImageValidator,
    ],
    call_trace_initialiser=PipelineCallTraceStorage.initialise,
)
```

--------------------------------

### Verify open-iris Installation

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/quickstart/installation.rst

Verifies the successful installation of the iris package by attempting to import it in Python and printing its version using a bash command.

```bash
python3 -c "import iris; print(iris.__version__)"
```

--------------------------------

### Instantiating and Running IRISPipeline with DEBUGGING_ENVIRONMENT in Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Demonstrates how to create an instance of `IRISPipeline` using the predefined `DEBUGGING_ENVIRONMENT` and then execute the pipeline by calling the instance with input data (`img_data`, `eye_side`).

```python
iris_pipeline = iris.IRISPipeline(env=iris.IRISPipeline.DEBUGGING_ENVIRONMENT)

output = iris_pipeline(img_data=img_pixels, eye_side="right")
```

--------------------------------

### Install open-iris (Orb) from GitHub

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/quickstart/installation.rst

Installs the open-iris package with dependencies required for running inference on the Orb, directly from the GitHub repository using pip and setting the IRIS_ENV flag to ORB.

```bash
IRIS_ENV=ORB pip install git+https://github.com/worldcoin/open-iris.git
```

--------------------------------

### Plotting IR Image and Iris Template (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Shows examples of using the `iris_visualizer` to plot an infrared image (`plot_ir_image`) and an iris template (`plot_iris_template`). It requires importing `matplotlib.pyplot` and uses `plt.show()` to display the generated plots.

```python
import matplotlib.pyplot as plt

canvas = iris_visualizer.plot_ir_image(iris.IRImage(img_data=img_pixels, eye_side="right"))
plt.show()

canvas = iris_visualizer.plot_iris_template(output["iris_template"])
plt.show()
```

--------------------------------

### Initializing IRISPipeline in Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Shows the constructor signature for the `IRISPipeline` class, highlighting the `config` and `env` parameters used for configuring the pipeline graph and runtime environment, respectively.

```python
def __init__(
    self,
    config: Union[Dict[str, Any], Optional[str]] = None,
    env: Environment = Environment(
        pipeline_output_builder=build_orb_output,
        error_manager=store_error_manager,
        call_trace_initialiser=PipelineCallTraceStorage.initialise,
    ),
) -> None:
```

--------------------------------

### Example IRISPipeline Error Dictionary (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Shows the structure of the dictionary returned in the 'error' key of the pipeline output when an exception occurs during inference. It includes keys for 'error_type', 'message', and 'traceback'.

```python
{
    'error_type': 'TypeError',
    'message': "run() got an unexpected keyword argument 'segmentation_map2'",
    'traceback': 'Very long exception traceback'
}
```

--------------------------------

### IRISPipeline Constructor Signature (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Displays the method signature for the `IRISPipeline` constructor (`__init__`). It highlights the `config` and `env` parameters which allow customization of the pipeline's graph and runtime environment.

```python
def __init__(
    self,
    config: Union[Dict[str, Any], Optional[str]] = None,
    env: Environment = Environment(
        pipeline_output_builder=build_orb_output,
        error_manager=store_error_manager,
        call_trace_initialiser=PipelineCallTraceStorage.initialise,
    ),
) -> None:
```

--------------------------------

### Download sample IR image (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Downloads a sample infrared image (`example_orb_image_1.png`) from a public S3 bucket using `wget` and saves it locally as `sample_ir_image.png`. This image is used as input for the IRIS pipeline. Requires `wget` to be available in the environment.

```python
!wget https://wld-ml-ai-data-public.s3.amazonaws.com/public-iris-images/example_orb_image_1.png -O ./sample_ir_image.png
```

--------------------------------

### Running IRISPipeline Inference (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Demonstrates the three equivalent methods (`__call__`, `run`, `estimate`) for performing inference with the `IRISPipeline` object. It shows how to pass the image data (`img_data`) and specify the eye side (`eye_side`).

```python
# Options for the `eye_side` argument are: ["left", "right"]
output = iris_pipeline(img_data=img_pixels, eye_side="right")
output = iris_pipeline.run(img_data=img_pixels, eye_side="right")
output = iris_pipeline.estimate(img_data=img_pixels, eye_side="right")
```

--------------------------------

### Setup Development Environment with Conda (Bash)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/quickstart/setup_for_development.rst

This bash script provides the commands to set up the development environment for the 'iris' project. It includes cloning the repository, navigating into the directory, creating and activating a dedicated conda environment using the provided environment file, and optionally installing pre-commit hooks to maintain code formatting standards.

```bash
# Clone the iris repo
git clone https://github.com/worldcoin/open-iris

# Go to the repo directory
cd open-iris

# Create and activate conda environment
IRIS_ENV=DEV conda env create -f ./conda/environment_dev.yml
conda activate iris_dev

# (Optional, but recommended) Install git hooks to preserve code format consistency
pre-commit install
nb-clean add-filter --remove-empty-cells
```

--------------------------------

### Creating IRISPipeline Object (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Imports the `iris` package and instantiates the `IRISPipeline` class. This object is the main entry point for performing iris recognition tasks.

```python
import iris
iris_pipeline = iris.IRISPipeline()
```

--------------------------------

### Create IRISPipeline object (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Instantiates the `IRISPipeline` class from the `iris` package. This creates the main object used to perform iris inference on images. Requires the `iris` package.

```python
iris_pipeline = iris.IRISPipeline()
```

--------------------------------

### Loading IR Image with OpenCV (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Loads an infrared image from a file using OpenCV. The image is read in grayscale format and stored in the `img_pixels` variable for subsequent processing.

```python
import cv2
img_pixels = cv2.imread("./sample_ir_image.png", cv2.IMREAD_GRAYSCALE)
```

--------------------------------

### Defining the IRISPipeline Environment Class

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Defines the structure of the Environment class used to configure IRISPipeline's behavior, including call trace initialization, output building, error management, and disabling quality assurance nodes.

```python
class Environment(ImmutableModel):
    call_trace_initialiser: Callable[[Dict[str, Algorithm], List[PipelineNode]], PipelineCallTraceStorage]
    pipeline_output_builder: Callable[[PipelineCallTraceStorage], Any]
    error_manager: Callable[[PipelineCallTraceStorage, Exception], None]
    disabled_qa: List[type] = []
```

--------------------------------

### Setup Development Environment with Conda - Bash

Source: https://github.com/worldcoin/open-iris/blob/main/README.md

Steps to set up a development environment for the iris package using conda. This involves cloning the repository, creating and activating a dedicated conda environment, and optionally installing git hooks.

```bash
# Clone the iris repo
git clone https://github.com/worldcoin/open-iris

# Go to the repo directory
cd open-iris

# Create and activate conda environment
IRIS_ENV=DEV conda env create -f ./conda/environment_dev.yml
conda activate iris_dev

# (Optional, but recommended) Install git hooks to preserve code format consistency
pre-commit install
nb-clean add-filter --remove-empty-cells
```

--------------------------------

### Load and display sample IR image (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Loads the downloaded sample infrared image (`sample_ir_image.png`) using OpenCV (`cv2`) in grayscale mode and displays it using Matplotlib (`plt`). This visualizes the input image before processing. Requires `opencv-python` and `matplotlib` packages.

```python
import cv2
import matplotlib.pyplot as plt

img_pixels = cv2.imread("./sample_ir_image.png", cv2.IMREAD_GRAYSCALE)
plt.imshow(img_pixels, cmap='gray')
```

--------------------------------

### Defining the DEBUGGING_ENVIRONMENT for IRISPipeline in Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Shows the definition of a predefined `Environment` instance, `DEBUGGING_ENVIRONMENT`, configured with specific output builders and a list of disabled quality assurance validators, useful for debugging the pipeline execution.

```python
DEBUGGING_ENVIRONMENT = Environment(
    pipeline_output_builder=build_debugging_output,
    error_manager=store_error_manager,
    disabled_qa=[
        iris.nodes.validators.object_validators.Pupil2IrisPropertyValidator,
        iris.nodes.validators.object_validators.OffgazeValidator,
        iris.nodes.validators.object_validators.OcclusionValidator,
        iris.nodes.validators.object_validators.IsPupilInsideIrisValidator,
        iris.nodes.validators.object_validators.IsMaskTooSmallValidator,
        iris.nodes.validators.cross_object_validators.EyeCentersInsideImageValidator,
        iris.nodes.validators.cross_object_validators.ExtrapolatedPolygonsInsideImageValidator,
    ],
    call_trace_initialiser=PipelineCallTraceStorage.initialise,
)
```

--------------------------------

### Inspecting IRISPipeline Output Keys in Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Shows how to access the keys of the dictionary returned by the `IRISPipeline` execution, allowing inspection of the available intermediate results and final output, particularly useful when using environments like `DEBUGGING_ENVIRONMENT`.

```python
output.keys()
```

--------------------------------

### Get IrisTemplate code dimensions (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Calculates and prints the number of iris codes and the shape of the first iris code stored in the `IrisTemplate` object. This provides information about the dimensions and quantity of the generated iris features. Requires the `output` dictionary from a pipeline run.

```python
num_codes = len(output["iris_template"].iris_codes)
code_shape = output["iris_template"].iris_codes[0].shape

f"""Number of returned iris codes is equal to {num_codes} and each code shape is {code_shape}"""
```

--------------------------------

### Plotting Iris Template (Encoder) (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Plots the final iris template using the `iris_visualizer`. It takes the output of the 'encoder' step from the pipeline's `call_trace` as input.

```python
canvas = iris_visualizer.plot_iris_template(
    iris_template=iris_pipeline.call_trace['encoder'],
)
plt.show()
```

--------------------------------

### Verifying iris Installation Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Imports the installed `iris` package and prints its version to confirm successful installation.

```python
import iris

print(iris.__version__)
```

--------------------------------

### Instantiating IRIS Visualizer (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Creates an instance of the `IRISVisualizer` class from the `iris.visualisation` module. This object is used to call various plotting methods to visualize intermediate results from the iris processing pipeline.

```python
iris_visualizer = iris.visualisation.IRISVisualizer()
```

--------------------------------

### Installing iris package Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Installs the `open-iris` package using pip, typically executed in a notebook or server environment.

```python
!pip install open-iris
```

--------------------------------

### Plotting Normalized Iris (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Plots the normalized iris image using the `iris_visualizer`. It takes the result of the 'normalization' step from the pipeline's `call_trace` as input.

```python
canvas = iris_visualizer.plot_normalized_iris(
    normalized_iris=iris_pipeline.call_trace['normalization'],
)
plt.show()
```

--------------------------------

### Inspect IRISPipeline metadata (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Prints the content of the "metadata" key in the `output` dictionary. This dictionary contains additional information generated during the pipeline run that can be useful for analysis or quality assessment. Requires the `output` dictionary from a pipeline run.

```python
output["metadata"]
```

--------------------------------

### Plotting Segmentation Map (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Uses the `iris_visualizer` to plot the segmentation map obtained from the pipeline's `call_trace`. It requires the original IR image data and the segmentation map result.

```python
canvas = iris_visualizer.plot_segmentation_map(
    ir_image=iris.IRImage(img_data=img_pixels, eye_side="right"),
    segmap=iris_pipeline.call_trace['segmentation'],
)
plt.show()
```

--------------------------------

### Run IRISPipeline inference methods (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Demonstrates the different methods available to run the `IRISPipeline` inference: using the `__call__` operator, the `run` method, and the `estimate` method. All methods perform the same core inference process. Requires an `IRISPipeline` object and image data (`img_pixels`). The `eye_side` argument specifies which eye is being processed.

```python
# Options for the `eye_side` argument are: ["left", "right"]
output = iris_pipeline(img_data=img_pixels, eye_side="right")
output = iris_pipeline.run(img_data=img_pixels, eye_side="right")
output = iris_pipeline.estimate(img_data=img_pixels, eye_side="right")
```

--------------------------------

### Accessing Eye Side Metadata (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Demonstrates how to access the 'eye_side' information stored within the 'metadata' dictionary of the `output` object, which typically contains results from the iris processing pipeline.

```python
output['metadata']['eye_side']
```

--------------------------------

### Accessing IRIS Pipeline Configuration (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Shows how to access the `pipeline` attribute within the `params` object of an `iris_pipeline` instance. This attribute typically holds the configuration or graph defining the sequence of algorithms used in the pipeline.

```python
iris_pipeline.params.pipeline
```

--------------------------------

### Defining the IRISPipeline Environment Class in Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Defines the `Environment` class, an `ImmutableModel`, which encapsulates callable functions for managing call trace initialization, pipeline output building, error handling, and a list of disabled quality assurance steps.

```python
class Environment(ImmutableModel):
    call_trace_initialiser: Callable[[Dict[str, Algorithm], List[PipelineNode]], PipelineCallTraceStorage]
    pipeline_output_builder: Callable[[PipelineCallTraceStorage], Any]
    error_manager: Callable[[PipelineCallTraceStorage, Exception], None]
    disabled_qa: List[type] = []
```

--------------------------------

### Inspect IrisTemplate fields (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Accesses the `iris_template` object within the `output` and prints its available fields using `__fields__`. This reveals the structure of the `IrisTemplate` object, which holds the generated iris and mask codes. Requires the `output` dictionary from a pipeline run.

```python
"""Available fields in `output["iris_template"]` are: """ + str(output["iris_template"].__fields__)
```

--------------------------------

### Defining the Canvas Type for Visualization

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/getting_started.rst

Specifies the expected type hint for the output of visualization functions in the iris.visualisation module, indicating it returns a tuple containing a Matplotlib Figure and Axes (or an array of Axes).

```python
Canvas = Tuple[matplotlib.figure.Figure, Union[matplotlib.axes._axes.Axes, np.ndarray]]
```

--------------------------------

### Plotting All Geometry (Geometry Estimation) (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Similar to the previous snippet, this plots geometric features using the `iris_visualizer`, but it uses the results from the 'geometry_estimation' step instead of 'vectorization', along with 'eye_orientation' and 'eye_center_estimation'.

```python
canvas = iris_visualizer.plot_all_geometry(
    ir_image=iris.IRImage(img_data=img_pixels, eye_side="right"),
    geometry_polygons=iris_pipeline.call_trace['geometry_estimation'],
    eye_orientation=iris_pipeline.call_trace['eye_orientation'],
    eye_center=iris_pipeline.call_trace['eye_center_estimation'],
)
plt.show()
```

--------------------------------

### Inspect IRISPipeline output keys (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Prints the keys of the dictionary returned by the `IRISPipeline` inference call. This shows the top-level structure of the output, which typically includes keys like "error", "iris_template", and "metadata". Requires the `output` dictionary from a pipeline run.

```python
output.keys()
```

--------------------------------

### Accessing Segmentation Result from Call Trace (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Demonstrates accessing the result of the 'segmentation' step from the `call_trace` attribute of the `iris_pipeline` object. The `call_trace` stores intermediate results from the latest pipeline execution.

```python
iris_pipeline.call_trace['segmentation']
```

--------------------------------

### Verifying open-iris Installation (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Imports the `iris` library and prints its version to confirm successful installation. Requires the `iris` package to be installed.

```python
import iris

print(iris.__version__)
```

--------------------------------

### Plotting All Geometry (Vectorization) (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Plots various geometric features (polygons, orientation, center) using the `iris_visualizer`, specifically using the results from the 'vectorization', 'eye_orientation', and 'eye_center_estimation' steps stored in the pipeline's `call_trace`.

```python
canvas = iris_visualizer.plot_all_geometry(
    ir_image=iris.IRImage(img_data=img_pixels, eye_side="right"),
    geometry_polygons=iris_pipeline.call_trace['vectorization'],
    eye_orientation=iris_pipeline.call_trace['eye_orientation'],
    eye_center=iris_pipeline.call_trace['eye_center_estimation'],
)
plt.show()
```

--------------------------------

### Run Simple Iris Inference - Python

Source: https://github.com/worldcoin/open-iris/blob/main/README.md

Example Python code to perform a simple iris inference using the IRISPipeline. It demonstrates creating the pipeline object, loading an image, and calling the pipeline with image data and eye side.

```python
import cv2
import iris

# 1. Create IRISPipeline object
iris_pipeline = iris.IRISPipeline()

# 2. Load IR image of an eye
img_pixels = cv2.imread("/path/to/ir/image", cv2.IMREAD_GRAYSCALE)

# 3. Perform inference
# Options for the `eye_side` argument are: ["left", "right"]
output = iris_pipeline(img_data=img_pixels, eye_side="left")
```

--------------------------------

### Install open-iris for Server (Local) - Bash

Source: https://github.com/worldcoin/open-iris/blob/main/README.md

Install the open-iris package for running inference on a local machine. This uses the SERVER environment configuration. You can install from PyPI or directly from the GitHub repository.

```bash
# On a local machine
pip install open-iris
# or directly from GitHub
IRIS_ENV=SERVER pip install git+https://github.com/worldcoin/open-iris.git
```

--------------------------------

### Installing open-iris Package (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Installs the `open-iris` Python package using pip. This is the first step to use the IRIS library. Requires an environment with pip installed.

```python
!pip install open-iris
```

--------------------------------

### Verify iris Installation - Bash

Source: https://github.com/worldcoin/open-iris/blob/main/README.md

Verify that the iris package has been successfully installed and is importable by running a simple Python command from the terminal.

```bash
python3 -c "import iris; print(iris.__version__)"
```

--------------------------------

### Verify IRISPipeline error status (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Checks if the "error" key in the `output` dictionary is `None`. A `None` value indicates that the `IRISPipeline` inference completed successfully without raising any exceptions. Requires the `output` dictionary from a pipeline run.

```python
# Verify IRISPipeline inference call finished without any exception being raised
output["error"] is None
```

--------------------------------

### Install open-iris for Development - Bash

Source: https://github.com/worldcoin/open-iris/blob/main/README.md

Install the open-iris package along with necessary dependencies for developing the package itself. This uses the DEV environment configuration.

```bash
# For development
IRIS_ENV=DEV pip install git+https://github.com/worldcoin/open-iris.git
```

--------------------------------

### IRIS Algorithm Class Signature Example (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Shows the beginning of the '__init__' method signature for an IRIS 'Algorithm' class ('MultilabelSegmentationBinarization'). This illustrates where parameters defined in the YAML configuration's 'params' section are received by the algorithm implementation.

```python
class MultilabelSegmentationBinarization(Algorithm):
    def __init__(
        self,
```

--------------------------------

### Citing the Worldcoin Open-IRIS Project

Source: https://github.com/worldcoin/open-iris/blob/main/README.md

Provides the standard BibTeX entry for citing the Worldcoin Open-IRIS project in academic or research contexts.

```BibTeX
@misc{wldiris,
  author =       {Worldcoin AI},
  title =        {IRIS: Iris Recognition Inference System of the Worldcoin project},
  year =         {2023},
  url =          {https://github.com/worldcoin/open-iris}
}
```

--------------------------------

### Install open-iris for Orb - Bash

Source: https://github.com/worldcoin/open-iris/blob/main/README.md

Install the open-iris package with dependencies required for running inference on the Orb. This uses the ORB environment configuration.

```bash
# On the Orb
IRIS_ENV=ORB pip install git+https://github.com/worldcoin/open-iris.git
```

--------------------------------

### Run IRISPipeline inference using call operator (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Executes the `IRISPipeline` inference using the `__call__` operator with the loaded image data and specifying the eye side as "right". This is one of the standard ways to trigger the pipeline's processing. Requires an `IRISPipeline` object and image data (`img_pixels`). The output is a dictionary containing results and metadata.

```python
output = iris_pipeline(img_data=img_pixels, eye_side="right")
```

--------------------------------

### IRIS Pipeline YAML Node Input with Index (YAML)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Provides an example of defining a node input in the IRIS configuration YAML that uses the 'index' key. This is necessary when the source node outputs a list or tuple and a specific element needs to be selected as input.

```yaml
- name: vectorization
        algorithm:
          class_name: iris.ContouringAlgorithm
          params: {}
        inputs:
          - name: geometry_mask
            source_node: segmentation_binarization
            index: 0
        callbacks:
```

--------------------------------

### Running Inference with IRISPipeline in Python

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/quickstart/running_inference.rst

This snippet shows the basic steps to run inference using the iris package. It requires the cv2 and iris libraries. It initializes the IRISPipeline, loads a grayscale eye image using OpenCV, and then calls the pipeline with the image data and eye side ('left' or 'right') to get the inference output.

```python
import cv2
import iris

# 1. Create IRISPipeline object
iris_pipeline = iris.IRISPipeline()

# 2. Load IR image of an eye
img_pixels = cv2.imread("/path/to/ir/image", cv2.IMREAD_GRAYSCALE)

# 3. Perform inference
# Options for the `eye_side` argument are: ["left", "right"]
output = iris_pipeline(img_data=img_pixels, eye_side="left")
```

--------------------------------

### Defining IRIS Visualizer Canvas Type (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/GettingStarted.ipynb

Defines the `Canvas` type alias used by the `IRISVisualizer` module, representing a tuple containing a Matplotlib Figure and an Axes object or a NumPy array. This type is used for the output of plotting functions.

```python
Canvas = Tuple[matplotlib.figure.Figure, Union[matplotlib.axes._axes.Axes, np.ndarray]]
```

--------------------------------

### Instantiating and Running IRIS Pipeline (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Demonstrates how to create an instance of the IRISPipeline class using a configuration dictionary and execute it with image data and eye side information. Includes an assertion to check for errors.

```python
iris_pipeline = iris.IRISPipeline(config=new_pipeline_conf)

assert iris_pipeline(img_data=img_pixels, eye_side="left")["error"] is None
```

--------------------------------

### Downloading Sample IR Images Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Downloads three sample infrared iris images from a public S3 bucket using `wget` for use as input data in the tutorial.

```python
!wget https://wld-ml-ai-data-public.s3.amazonaws.com/public-iris-images/example_orb_image_1.png -O ./subject1_first_image.png
!wget https://wld-ml-ai-data-public.s3.amazonaws.com/public-iris-images/example_orb_image_2.png -O ./subject1_second_image.png
!wget https://wld-ml-ai-data-public.s3.amazonaws.com/public-iris-images/example_orb_image_3.png -O ./subject2_image.png
```

--------------------------------

### Instantiating and Running IRIS Pipeline (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Demonstrates how to instantiate the `IRISPipeline` object with a configuration and execute it with image data and eye side information, asserting that the execution completes without errors.

```python
iris_pipeline = iris.IRISPipeline(config=default_pipeline_conf)

assert iris_pipeline(img_data=img_pixels, eye_side="left")["error"] is None
```

--------------------------------

### Instantiating and Running IRISPipeline - Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Demonstrates how to reinstantiate the IRISPipeline with a new configuration and execute it with image data, asserting that no error occurred.

```python
iris_pipeline = iris.IRISPipeline(config=new_pipeline_conf)

assert iris_pipeline(img_data=img_pixels, eye_side="left")["error"] is None
```

--------------------------------

### Downloading Sample IR Image (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Downloads a sample infrared image file from a public S3 bucket using the `wget` command. The image is saved as `./sample_ir_image.png`. Requires `wget` to be available in the environment.

```python
!wget https://wld-ml-ai-data-public.s3.amazonaws.com/public-iris-images/example_orb_image_1.png -O ./sample_ir_image.png
```

--------------------------------

### Instantiate and Run IRIS Pipeline (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Creates an instance of the IRISPipeline using a default configuration dictionary and runs it with sample image data ('img_pixels') for the 'left' eye side, asserting that the execution completed without errors.

```python
iris_pipeline = iris.IRISPipeline(config=default_pipeline_conf)

assert iris_pipeline(img_data=img_pixels, eye_side="left")["error"] is None
```

--------------------------------

### Instantiating IRIS Pipeline Object - Python

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/custom_pipeline.rst

This snippet demonstrates how to create an instance of the `iris.IRISPipeline` class, passing a configuration dictionary (`default_pipeline_conf`) to its constructor. This initializes the pipeline with the specified nodes and algorithms.

```python
iris_pipeline = iris.IRISPipeline(config=default_pipeline_conf)
```

--------------------------------

### Loading Images with OpenCV

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/matching_entities.rst

Loads grayscale IR images from files using the `cv2.imread` function from the `opencv-python` package. Requires image files named 'subject1_first_image.png', 'subject1_second_image.png', and 'subject2_image.png' in the current directory.

```python
import cv2

subject1_first_image = cv2.imread("./subject1_first_image.png", cv2.IMREAD_GRAYSCALE)
subject1_second_image = cv2.imread("./subject1_second_image.png", cv2.IMREAD_GRAYSCALE)
subject2_image = cv2.imread("./subject2_image.png", cv2.IMREAD_GRAYSCALE)
```

--------------------------------

### Instantiating IRIS Pipeline (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/custom_pipeline.rst

Creates an instance of the IRISPipeline class, passing a configuration dictionary (new_pipeline_conf) that defines the structure and nodes of the pipeline.

```python
iris_pipeline = iris.IRISPipeline(config=new_pipeline_conf)
```

--------------------------------

### Generating Iris Templates with IRISPipeline Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Initializes an `IRISPipeline` object and processes each loaded image to extract and generate an `IrisTemplate`, which is a binary representation of the iris pattern.

```python
import iris

iris_pipeline = iris.IRISPipeline()

output_1 = iris_pipeline(subject1_first_image, eye_side="left")
subject1_first_code = output_1['iris_template']

output_2 = iris_pipeline(subject1_second_image, eye_side="left")
subject1_second_code = output_2['iris_template']

output_3 = iris_pipeline(subject2_image, eye_side="left")
subject2_code = output_3['iris_template']
```

--------------------------------

### Processing Images with IRISPipeline

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/matching_entities.rst

Creates an `iris.IRISPipeline` object and processes the loaded images to compute iris templates using the `eye_side="left"` parameter. Stores the resulting templates in variables `subject1_first_code`, `subject1_second_code`, and `subject2_code`.

```python
import iris

iris_pipeline = iris.IRISPipeline()

output_1 = iris_pipeline(subject1_first_image, eye_side="left")
subject1_first_code = output_1["iris_template"]

output_2 = iris_pipeline(subject1_second_image, eye_side="left")
subject1_second_code = output_2["iris_template"]

output_3 = iris_pipeline(subject2_image, eye_side="left")
subject2_code = output_3["iris_template"]
```

--------------------------------

### Instantiating IRISPipeline in Python

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/custom_pipeline.rst

Initializes an IRISPipeline object using a predefined configuration dictionary. This sets up the processing pipeline with its specified nodes and algorithms.

```python
iris_pipeline = iris.IRISPipeline(config=default_pipeline_conf)
```

--------------------------------

### Loading IR Images with OpenCV Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Uses the `opencv-python` library (`cv2`) to load the downloaded infrared iris images into memory as grayscale images.

```python
import cv2

subject1_first_image = cv2.imread("./subject1_first_image.png", cv2.IMREAD_GRAYSCALE)
subject1_second_image = cv2.imread("./subject1_second_image.png", cv2.IMREAD_GRAYSCALE)
subject2_image = cv2.imread("./subject2_image.png", cv2.IMREAD_GRAYSCALE)
```

--------------------------------

### Initializing IRISPipeline Object (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/custom_pipeline.rst

This snippet demonstrates how to create a new instance of the `IRISPipeline` class in Python, using a previously defined configuration dictionary (`new_pipeline_conf`). This is typically done after modifying the configuration.

```python
iris_pipeline = iris.IRISPipeline(config=new_pipeline_conf)
```

--------------------------------

### Loading IR Image with OpenCV (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Demonstrates how to load a grayscale image from a file using the OpenCV library in Python. This image can then be used as input for the IRIS pipeline.

```python
import cv2

img_pixels = cv2.imread("./sample_ir_image.png", cv2.IMREAD_GRAYSCALE)
```

--------------------------------

### Instantiating HammingDistanceMatcher

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/matching_entities.rst

Creates an instance of the `iris.HammingDistanceMatcher` class. The constructor supports parameters like `rotation_shift` (default 15), `normalise` (default True), `nm_dist` (default 0.45), `separate_half_matching` (default True), and optional `weights`. This snippet uses the default parameters.

```python
matcher = iris.HammingDistanceMatcher()
```

--------------------------------

### IRIS Pipeline YAML Node Definition - Basic (YAML)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Illustrates the basic structure for defining nodes within the 'pipeline' section of the IRIS configuration YAML. Each node specifies an algorithm, its parameters, and its inputs from other nodes.

```yaml
pipeline:
    - name: segmentation
        algorithm:
          class_name: iris.MultilabelSegmentation.create_from_hugging_face
          params: {}
        inputs:
          - name: image
            source_node: input
        callbacks:
    - name: segmentation_binarization
        algorithm:
            class_name: iris.MultilabelSegmentationBinarization
            params: {}
        inputs:
          - name: segmentation_map
            source_node: segmentation
        callbacks:
    ...
```

--------------------------------

### Displaying Loaded Images with Matplotlib Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Displays the loaded grayscale iris images using `matplotlib.pyplot` to visually inspect the data before further processing.

```python
import matplotlib.pyplot as plt

plt.imshow(subject1_first_image, cmap='gray')
plt.title('Subject 1, image 1')
plt.show()

plt.imshow(subject1_second_image, cmap='gray')
plt.title('Subject 1, image 2')
plt.show()

plt.imshow(subject2_image, cmap='gray')
plt.title('Subject 2, image 1')
plt.show()
```

--------------------------------

### IRIS Pipeline YAML Metadata (YAML)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Shows the metadata section of the IRIS pipeline configuration YAML file, including the pipeline name and IRIS version. This section provides descriptive information and compatibility checks.

```yaml
metadata:
  pipeline_name: iris_pipeline
  iris_version: 1.1.1
```

--------------------------------

### Defining the Algorithm Base Class

Source: https://github.com/worldcoin/open-iris/blob/main/docs/source/examples/custom_pipeline.rst

This snippet defines the abstract base class `Algorithm` for the iris package. It includes an inner `Parameters` class for default parameters, an `__init__` method to handle parameters and callbacks, `__call__` and `execute` methods to manage the execution flow with callback hooks, and an abstract `run` method that must be implemented by subclasses.

```python
class Algorithm(abc.ABC):
    """Base class of every node of the iris recognition pipeline."""

    class Parameters(ImmutableModel):
        """Default parameters."""

        pass

    __parameters_type__ = Parameters

    def __init__(self, **kwargs: Any) -> None:
        """Init function."""
        self._callbacks: List[Callback] = []

        if "callbacks" in kwargs.keys():
            self._callbacks = deepcopy(kwargs["callbacks"])
            del kwargs["callbacks"]

        self.params = self.__parameters_type__(**kwargs)

    def __call__(self, *args: Any, **kwargs: Any) -> Any:
        """Make an object a functor.

        Returns:
            Any: Object specified by an interface.
        """
        return self.execute(*args, **kwargs)

    def execute(self, *args: Any, **kwargs: Any) -> Any:
        """Execute method and wrapped with hooks if such are specified.

        Returns:
            Any: Object specified by an interface.
        """
        for callback_func in self._callbacks:
            callback_func.on_execute_start(*args, **kwargs)

        result = self.run(*args, **kwargs)

        for callback_func in self._callbacks:
            callback_func.on_execute_end(result)

        return result

    def run(self, *args: Any, **kwargs: Any) -> Any:
        """Implement method design pattern. Not overwritten by subclass will raise an error.

        Raises:
            NotImplementedError: Raised if subclass doesn't implement `run` method.

        Returns:
            Any: Return value by concrete implementation of the `run` method.
        """
        raise NotImplementedError(f"{self.__class__.__name__}.run method not implemented!")
```

--------------------------------

### Pipeline Node Configuration - Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Configuration snippet for a pipeline node named 'bounding_box_estimation', specifying its algorithm class, input dependencies, and callbacks.

```python
"name": "bounding_box_estimation",
            "algorithm": {"class_name": "iris.IrisBBoxCalculator", "params": {}},
            "inputs": [
                {"name": "ir_image", "source_node": "input"},
                {"name": "geometry_polygons", "source_node": "geometry_estimation"},
            ],
            "callbacks": None,
        },
```

--------------------------------

### Instantiating HammingDistanceMatcher Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Creates an instance of the `HammingDistanceMatcher` class using its default initialization parameters.

```python
matcher = iris.HammingDistanceMatcher()
```

--------------------------------

### Define Bounding Box Estimation Node Configuration (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Defines the configuration for a 'bounding_box_estimation' node within an IRIS pipeline, specifying its algorithm, input sources ('ir_image' from 'input', 'geometry_polygons' from 'geometry_estimation'), and lack of callbacks.

```python
"name": "bounding_box_estimation",
            "algorithm": {"class_name": "iris.IrisBBoxCalculator", "params": {}},
            "inputs": [
                {"name": "ir_image", "source_node": "input"},
                {"name": "geometry_polygons", "source_node": "geometry_estimation"},
            ],
            "callbacks": None,
        },
    ],
}
```

--------------------------------

### Calling Function to Print Segmentation Thresholds (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Executes the previously defined `print_segmentation_binarization_thresholds` function to display the configuration parameters of the segmentation binarization node within the IRIS pipeline.

```python
print_segmentation_binarization_thresholds()
```

--------------------------------

### Define Modified IRIS Pipeline Configuration (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Provides a complete configuration dictionary for an IRIS pipeline, detailing multiple processing nodes (segmentation, binarization, vectorization, filtering, estimation, etc.) and their interconnections, demonstrating how to specify input sources for each node, including modifying the 'geometry_estimation' node's 'input_polygons' source.

```python
new_pipeline_conf = {
    "metadata": {"pipeline_name": "iris_pipeline", "iris_version": "1.1.1"},
    "pipeline": [
        {
            "name": "segmentation",
            "algorithm": {"class_name": "iris.MultilabelSegmentation.create_from_hugging_face", "params": {}},
            "inputs": [{"name": "image", "source_node": "input"}],
            "callbacks": None,
        },
        {
            "name": "segmentation_binarization",
            "algorithm": {"class_name": "iris.MultilabelSegmentationBinarization", "params": {
                "eyeball_threshold": 0.1,
                "iris_threshold": 0.1,
                "pupil_threshold": 0.1,
                "eyelashes_threshold": 0.1}},
            "inputs": [{"name": "segmentation_map", "source_node": "segmentation"}],
            "callbacks": None,
        },
        {
            "name": "vectorization",
            "algorithm": {"class_name": "iris.ContouringAlgorithm", "params": {}},
            "inputs": [{"name": "geometry_mask", "source_node": "segmentation_binarization", "index": 0}],
            "callbacks": None,
        },
        {
            "name": "specular_reflection_detection",
            "algorithm": {"class_name": "iris.SpecularReflectionDetection", "params": {}},
            "inputs": [{"name": "ir_image", "source_node": "input"}],
            "callbacks": None,
        },
        {
            "name": "interpolation",
            "algorithm": {"class_name": "iris.ContourInterpolation", "params": {}},
            "inputs": [{"name": "polygons", "source_node": "vectorization"}],
            "callbacks": None,
        },
############################### A NODE, WHICH PARAMETERS WE WANT TO MODIFY ################################
        {
            "name": "distance_filter",
            "algorithm": {"class_name": "iris.ContourPointNoiseEyeballDistanceFilter", "params": {}},
            "inputs": [
                {"name": "polygons", "source_node": "interpolation"},
                {"name": "geometry_mask", "source_node": "segmentation_binarization", "index": 1},
            ],
            "callbacks": None,
        },
        {
            "name": "eye_orientation",
            "algorithm": {"class_name": "iris.MomentOfArea", "params": {}},
            "inputs": [{"name": "geometries", "source_node": "distance_filter"}],
            "callbacks": None,
        },
        {
            "name": "eye_center_estimation",
            "algorithm": {"class_name": "iris.BisectorsMethod", "params": {}},
            "inputs": [{"name": "geometries", "source_node": "distance_filter"}],
            "callbacks": None,
        },
        {
            "name": "smoothing",
            "algorithm": {"class_name": "iris.Smoothing", "params": {}},
            "inputs": [
                {"name": "polygons", "source_node": "distance_filter"},
                {"name": "eye_centers", "source_node": "eye_center_estimation"},
            ],
            "callbacks": None,
        },
        {
            "name": "geometry_estimation",
            "algorithm": {
                "class_name": "iris.FusionExtrapolation",
                "params": {
                    "circle_extrapolation": {"class_name": "iris.LinearExtrapolation", "params": {"dphi": 0.703125}},
                    "ellipse_fit": {"class_name": "iris.LSQEllipseFitWithRefinement", "params": {"dphi": 0.703125}},
                    "algorithm_switch_std_threshold": 3.5,
                },
            },
            "inputs": [
                {"name": "input_polygons", "source_node": "distance_filter"},
                {"name": "eye_center", "source_node": "eye_center_estimation"},
            ],
            "callbacks": None,
        }
    ]
}
```

--------------------------------

### HammingDistanceMatcher Constructor Definition Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Provides the constructor signature and docstring for the `HammingDistanceMatcher` class, detailing parameters like `rotation_shift`, `nm_dist`, and `weights` for customizing the matching process.

```python
def __init__(
        self,
        rotation_shift: int = 15,
        nm_dist: Optional[confloat(ge=0, le=1, strict=True)] = None,
        weights: Optional[List[np.ndarray]] = None,
    ) -> None:
        """Assign parameters.

        Args:
            rotation_shift (int): rotations allowed in matching, converted to shifts in columns. Defaults to 15.
            nm_dist (Optional[confloat(ge=0, le = 1, strict=True)]): nonmatch distance used for normalized HD. Optional paremeter for normalized HD. Defaults to None.
            weights (Optional[List[np.ndarray]]): list of weights table. Optional paremeter for weighted HD. Defaults to None.
        """
```

--------------------------------

### HammingDistanceMatcher run Method Definition Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/MatchingEntities.ipynb

Shows the method signature for the `run` method of the `HammingDistanceMatcher`, which takes two `IrisTemplate` objects and returns a float representing the computed Hamming distance.

```python
def run(self, template_probe: IrisTemplate, template_gallery: IrisTemplate) -> float:
```

--------------------------------

### Printing Segmentation Thresholds (Python)

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Calls a function `print_segmentation_binarization_thresholds` to display threshold values used in the segmentation binarization step of the pipeline.

```python
print_segmentation_binarization_thresholds()
```

--------------------------------

### Base Algorithm Class Definition - Python

Source: https://github.com/worldcoin/open-iris/blob/main/colab/ConfiguringCustomPipeline.ipynb

Defines the abstract base class 'Algorithm' for pipeline nodes, outlining the structure, parameter handling, execution flow with callbacks, and the required 'run' method.

```python
class Algorithm(abc.ABC):
    """Base class of every node of the iris recognition pipeline."""

    class Parameters(ImmutableModel):
        """Default parameters."""

        pass

    __parameters_type__ = Parameters

    def __init__(self, **kwargs: Any) -> None:
        """Init function."""
        self._callbacks: List[Callback] = []

        if "callbacks" in kwargs.keys():
            self._callbacks = deepcopy(kwargs["callbacks"])
            del kwargs["callbacks"]

        self.params = self.__parameters_type__(**kwargs)

    def __call__(self, *args: Any, **kwargs: Any) -> Any:
        """Make an object a functor.

        Returns:
            Any: Object specified by an interface.
        """
        return self.execute(*args, **kwargs)

    def execute(self, *args: Any, **kwargs: Any) -> Any:
        """Execute method and wrapped with hooks if such are specified.

        Returns:
            Any: Object specified by an interface.
        """
        for callback_func in self._callbacks:
            callback_func.on_execute_start(*args, **kwargs)

        result = self.run(*args, **kwargs)

        for callback_func in self._callbacks:
            callback_func.on_execute_end(result)

        return result

    def run(self, *args: Any, **kwargs: Any) -> Any:
        """Implement method design pattern. Not overwritten by subclass will raise an error.

        Raises:
            NotImplementedError: Raised if subclass doesn't implement `run` method.

        Returns:
            Any: Return value by concrate implementation of the `run` method.
        """
        raise NotImplementedError(f"{self.__class__.__name__}.run method not implemented!")
```
Tokens:
Raw