iris.nodes.matcher package

Submodules

iris.nodes.matcher.hamming_distance_matcher module

class iris.nodes.matcher.hamming_distance_matcher.HammingDistanceMatcher(rotation_shift: ConstrainedIntValue = 15, normalise: bool = True, norm_mean: ConstrainedFloatValue = 0.45, norm_gradient: float = 5e-05, separate_half_matching: bool = True, weights: List[ndarray] | None = None)

Bases: Matcher

Hamming distance Matcher with additional optional features.

Algorithm steps:

1. Calculate counts of nonmatch irisbits (IB_Counts) in common unmasked region and the counts of common maskbits (MB_Counts) in common unmasked region for both upper and lower half of iris, respectively.

2. If parameter norm_mean is defined, calculate normalized Hamming distance (NHD) based on IB_Counts, MB_Counts and norm_mean.

3. If parameter weights is defined, calculate weighted Hamming distance (WHD) based on IB_Counts, MB_Counts and weights.

4. If parameters norm_mean and weights are both defined, calculate weighted normalized Hamming distance (WNHD) based on IB_Counts, MB_Counts, norm_mean and weights.

5. Otherwise, calculate Hamming distance (HD) based on IB_Counts and MB_Counts.

6. If parameter rotation_shift is > 0, repeat the above steps for additional rotations of the iriscode.

7. Return the minimium distance from above calculations.

class Parameters(*, rotation_shift: ConstrainedIntValue, normalise: bool, norm_mean: ConstrainedFloatValue, norm_gradient: float, separate_half_matching: bool, weights: List[ndarray] | None = None)

Bases: Parameters

HammingDistanceMatcher parameters.

norm_gradient: float

norm_mean: ConstrainedFloatValue

normalise: bool

rotation_shift: ConstrainedIntValue

separate_half_matching: bool

weights: List[ndarray] | None

run(template_probe: IrisTemplate, template_gallery: IrisTemplate) → float

Match iris templates using Hamming distance.

Parameters:

• template_probe (IrisTemplate) – Iris template from probe.

• template_gallery (IrisTemplate) – Iris template from gallery.

Returns:

matching distance.

Return type:

float

iris.nodes.matcher.hamming_distance_matcher_interface module

class iris.nodes.matcher.hamming_distance_matcher_interface.BatchMatcher(**kwargs: Any)

Bases: ABC

Parent Abstract class for 1-to-N matchers.

class Parameters(*, rotation_shift: ConstrainedIntValue)

Bases: ImmutableModel

IrisMatcherParameters parameters.

rotation_shift: ConstrainedIntValue

abstract gallery_to_gallery(template_gallery_1: List[IrisTemplate], template_gallery_2: List[IrisTemplate]) → List[List[float]]

Match iris templates using Hamming distance.

Parameters:

• template_gallery_1 (List[IrisTemplate]) – Iris template gallery.

• template_gallery_2 (List[IrisTemplate]) – Iris template gallery.

Returns:

matching distances.

Return type:

List[List[float]]

abstract intra_gallery(template_gallery: List[IrisTemplate]) → List[List[float]]

Match iris templates using Hamming distance.

Parameters:

template_gallery (List[IrisTemplate]) – Iris template gallery.

Returns:

matching distances.

Return type:

List[List[float]]

class iris.nodes.matcher.hamming_distance_matcher_interface.Matcher(**kwargs)

Bases: ABC

Parent Abstract class for 1-to-1 matchers.

class Parameters(*, rotation_shift: ConstrainedIntValue)

Bases: ImmutableModel

IrisMatcherParameters parameters.

rotation_shift: ConstrainedIntValue

abstract run(template_probe: IrisTemplate, template_gallery: IrisTemplate) → float

Match iris templates using Hamming distance.

Parameters:

• template_probe (IrisTemplate) – Iris template from probe.

• template_gallery (IrisTemplate) – Iris template from gallery.

Returns:

matching distance.

Return type:

float

iris.nodes.matcher.simple_hamming_distance_matcher module

class iris.nodes.matcher.simple_hamming_distance_matcher.SimpleHammingDistanceMatcher(rotation_shift: ConstrainedIntValue = 15, normalise: bool = False, norm_mean: ConstrainedFloatValue = 0.45, norm_gradient: float = 5e-05)

Bases: Matcher

Simple Hamming distance Matcher without the bells and whistles.

Algorithm steps:

1. Calculate counts of nonmatch irisbits (IB_Counts) in common unmasked region and the counts of common maskbits (MB_Counts) in common unmasked region.

2. Calculate Hamming distance (HD) based on IB_Counts and MB_Counts.

3. If parameter normalise is True, normalize Hamming distance based on parameter norm_mean.

4. If parameter rotation_shift is > 0, repeat the above steps for additional rotations of the iriscode.

5. Return the minimium distance from above calculations.

class Parameters(*, rotation_shift: ConstrainedIntValue, normalise: bool, norm_mean: ConstrainedFloatValue, norm_gradient: float)

Bases: Parameters

SimpleHammingDistanceMatcher parameters.

norm_gradient: float

norm_mean: ConstrainedFloatValue

normalise: bool

rotation_shift: ConstrainedIntValue

run(template_probe: IrisTemplate, template_gallery: IrisTemplate) → float

Match iris templates using Hamming distance.

Parameters:

• template_probe (IrisTemplate) – Iris template from probe.

• template_gallery (IrisTemplate) – Iris template from gallery.

Returns:

Matching distance.

Return type:

float

iris.nodes.matcher.utils module

iris.nodes.matcher.utils.count_nonmatchbits(irisbits: ndarray, maskbits: ndarray, half_width: List[int] | None = None, weights: List[ndarray] | None = None) → Tuple[int, int] | Tuple[List[int], List[int]]

Count nonmatch bits for Hammming distance.

Parameters:

• irisbits (np.ndarray) – Nonmatch irisbits.

• maskbits (np.ndarray) – Common maskbits.

• half_width (Optional[np.ndarray] = None) – List of half of code width. Optional paremeter for scoring the upper and lower halves separately. Defaults to None.

• weights (Optional[np.ndarray] = None) – List of weights table. Optional paremeter for weighted HD. Defaults to None.

Returns:

Total nonmatch iriscode bit count and common maskcode bit count, could be a list for top and bottom iris separately.

Return type:

Tuple[int, int]

iris.nodes.matcher.utils.get_bitcounts(template_probe: IrisTemplate, template_gallery: IrisTemplate, shift: int) → ndarray

Get bitcounts in iris and mask codes.

Parameters:

• template_probe (IrisTemplate) – Iris template from probe.

• template_gallery (IrisTemplate) – Iris template from gallery.

• shift (int) – Rotation shift (in columns)

Returns:

Bitcounts in iris and mask codes.

Return type:

np.ndarray

iris.nodes.matcher.utils.hamming_distance(template_probe: IrisTemplate, template_gallery: IrisTemplate, rotation_shift: int, normalise: bool = False, norm_mean: float = 0.45, norm_gradient: float = 5e-05, separate_half_matching: bool = False, weights: List[ndarray] | None = None) → Tuple[float, int]

Compute Hamming distance.

Parameters:

• template_probe (IrisTemplate) – Iris template from probe.

• template_gallery (IrisTemplate) – Iris template from gallery.

• rotation_shift (int) – Rotation allowed in matching, converted to columns.

• normalise (bool, optional) – Flag to normalize HD. Defaults to False.

• norm_mean (float, optional) – Nonmatch mean distance for normalized HD. Defaults to 0.45.

• norm_gradient (float) – Gradient for linear approximation of normalization term. Defaults to 0.00005.

• separate_half_matching (bool, optional) – Separate the upper and lower halves for matching. Defaults to False.

• weights (Optional[List[np.ndarray]], optional) – List of weights table. Optional paremeter for weighted HD. Defaults to None.

Raises:

MatcherError – If probe and gallery iris codes are of different sizes or number of columns of iris codes is not even or If weights (when defined) and iris codes are of different sizes.

Returns:

Miminum Hamming distance and corresonding rotation shift.

Return type:

Tuple[float, int]

iris.nodes.matcher.utils.normalized_HD(irisbitcount: int, maskbitcount: int, norm_mean: float, norm_gradient: float) → float

Perform normalized HD calculation.

Parameters:

• irisbitcount (int) – Nonmatched iriscode bit count.

• maskbitcount (int) – Common maskcode bit count.

• norm_mean (float) – Nonmatch distance used for normalized HD.

• norm_gradient (float) – Gradient for linear approximation of normalization term.

Returns:

Normalized Hamming distance.

Return type:

float

iris.nodes.matcher.utils.simple_hamming_distance(template_probe: IrisTemplate, template_gallery: IrisTemplate, rotation_shift: int = 15, normalise: bool = False, norm_mean: float = 0.45, norm_gradient: float = 5e-05) → Tuple[float, int]

Compute Hamming distance, without bells and whistles.

Parameters:

• template_probe (IrisTemplate) – Iris template from probe.

• template_gallery (IrisTemplate) – Iris template from gallery.

• rotation_shift (int) – Rotations allowed in matching, in columns. Defaults to 15.

• normalise (bool) – Flag to normalize HD. Defaults to False.

• norm_mean (float) – Peak of the non-match distribution. Defaults to 0.45.

• norm_gradient (float) – Gradient for linear approximation of normalization term. Defaults to 0.00005.

Returns:

Miminum Hamming distance and corresonding rotation shift.

Return type:

Tuple[float, int]

Module contents