Merge pull request #186 from worldcoin/dev

Dev merge

Author: ycbiometrics

pyproject.toml

@@ -22,12 +22,10 @@ inherit = false
 ignore = ["D100", "D104", "D203", "D205", "D211", "D213", "D406", "D407", "D413"]
 match = ".*.py"
 
-[tool.pytest]
-minversion = 6.0
+[tool.pytest.ini_options]
+minversion = "6.0"
 xfail_strict = true
 log_auto_indent = true
-
-[tool.pytest.ini_options]
 testpaths = ["tests"]
 
 [tool.black]

src/iris/_version.py

@@ -1 +1 @@
-__version__ = "1.9.7"
+__version__ = "1.9.8"

src/iris/nodes/eye_properties_estimation/bisectors_method.py

@@ -97,12 +97,12 @@ def _calculate_perpendicular_bisectors(
         Returns:
             Tuple[np.ndarray, np.ndarray]: Calculated perpendicular bisectors.
         """
-        np.random.seed(142857)
+        rng = np.random.RandomState(142857)
 
         bisectors_first_points = np.empty([0, 2])
         bisectors_second_points = np.empty([0, 2])
         for _ in range(self.params.max_iterations):
-            random_indices = np.random.choice(len(polygon), size=(self.params.num_bisectors, 2))
+            random_indices = rng.choice(len(polygon), size=(self.params.num_bisectors, 2))
 
             first_drawn_points = polygon[random_indices[:, 0]]
             second_drawn_points = polygon[random_indices[:, 1]]

src/iris/nodes/eye_properties_estimation/occlusion_calculator.py

@@ -1,12 +1,12 @@
-from typing import List, Tuple
+from typing import List
 
 import numpy as np
 from pydantic import Field
 
 from iris.callbacks.callback_interface import Callback
 from iris.io.class_configs import Algorithm
 from iris.io.dataclasses import EyeCenters, EyeOcclusion, EyeOrientation, GeometryPolygons, NoiseMask
-from iris.utils import common, math
+from iris.utils import common
 
 
 class OcclusionCalculator(Algorithm):
@@ -52,7 +52,6 @@ def run(
             extrapolated_polygons (GeometryPolygons): Extrapolated polygons contours.
             noise_mask (NoiseMask): Noise mask.
             eye_orientation (EyeOrientation): Eye orientation angle.
-            eye_centers (EyeCenters): Eye centers.
 
         Returns:
             EyeOcclusion: Visible iris fraction.
@@ -78,10 +77,8 @@ def run(
         pads = np.array([(-offset[1], overflow[1]), (-offset[0], overflow[0])]).astype(int)
         offseted_noise_mask = np.pad(noise_mask.mask, pads)
 
-        xs2mask, ys2mask = self._get_quantile_points(extrapolated_polygons.iris_array, eye_orientation, eye_centers)
-        iris_mask_quantile = common.contour_to_mask(
-            np.column_stack([xs2mask, ys2mask]) - offset, mask_shape=total_mask_shape
-        )
+        iris_quantile_polygon = self._get_quantile_points(extrapolated_polygons.iris_array, eye_orientation)
+        iris_mask_quantile = common.contour_to_mask(iris_quantile_polygon - offset, mask_shape=total_mask_shape)
         pupil_mask = common.contour_to_mask(extrapolated_polygons.pupil_array - offset, mask_shape=total_mask_shape)
         eyeball_mask = common.contour_to_mask(extrapolated_polygons.eyeball_array - offset, mask_shape=total_mask_shape)
         frame_mask = common.contour_to_mask(frame - offset, mask_shape=total_mask_shape)
@@ -97,46 +94,30 @@ def run(
         return EyeOcclusion(visible_fraction=visible_fraction)
 
     def _get_quantile_points(
-        self, iris_coords: np.ndarray, eye_orientation: EyeOrientation, eye_centers: EyeCenters
-    ) -> Tuple[np.ndarray, np.ndarray]:
+        self,
+        iris_coords: np.ndarray,
+        eye_orientation: EyeOrientation,
+    ) -> np.ndarray:
         """Get those iris's points which fall into a specified quantile.
 
         Args:
             iris_coords (np.ndarray): Iris polygon coordinates.
             eye_orientation: (EyeOrientation): Eye orientation.
-            eye_centers: (EyeCenters): Eye centers.
 
         Returns:
-            Tuple[np.ndarray, np.ndarray]: Tuple with xs and ys that falls into quantile region.
+            np.ndarray: Iris polygon coordinates that fall within the quantile regions.
         """
         orientation_angle = np.degrees(eye_orientation.angle)
         num_rotations = -round(orientation_angle * len(iris_coords) / 360.0)
-
-        iris_xs, iris_ys = iris_coords[:, 0], iris_coords[:, 1]
-        iris_rhos, iris_phis = math.cartesian2polar(iris_xs, iris_ys, eye_centers.iris_x, eye_centers.iris_y)
-
-        iris_phis = np.roll(iris_phis, num_rotations, axis=0)
-        iris_rhos = np.roll(iris_rhos, num_rotations, axis=0)
+        iris_coords = np.roll(iris_coords, num_rotations, axis=0)
 
         scaled_quantile = round(self.params.quantile_angle * len(iris_coords) / 360.0)
-
-        phis2mask = np.concatenate(
-            [
-                iris_phis[:scaled_quantile],
-                iris_phis[-scaled_quantile:],
-                iris_phis[len(iris_phis) // 2 : len(iris_phis) // 2 + scaled_quantile],
-                iris_phis[len(iris_phis) // 2 - scaled_quantile : len(iris_phis) // 2],
-            ]
-        )
-        rhos2mask = np.concatenate(
+        iris_quantile_coords = np.concatenate(
             [
-                iris_rhos[:scaled_quantile],
-                iris_rhos[-scaled_quantile:],
-                iris_rhos[len(iris_rhos) // 2 : len(iris_rhos) // 2 + scaled_quantile],
-                iris_rhos[len(iris_rhos) // 2 - scaled_quantile : len(iris_rhos) // 2],
+                iris_coords[0:scaled_quantile],
+                iris_coords[len(iris_coords) // 2 - scaled_quantile : len(iris_coords) // 2 + scaled_quantile],
+                iris_coords[len(iris_coords) - scaled_quantile :],
             ]
         )
-        phis2mask, rhos2mask = zip(*sorted(zip(phis2mask, rhos2mask)))
-        xs2mask, ys2mask = math.polar2cartesian(rhos2mask, phis2mask, eye_centers.iris_x, eye_centers.iris_y)
 
-        return xs2mask, ys2mask
+        return iris_quantile_coords

src/iris/nodes/geometry_estimation/fusion_extrapolation.py

@@ -113,6 +113,9 @@ def run(self, input_polygons: GeometryPolygons, eye_center: EyeCenters) -> Geome
         circle_poly = self.params.circle_extrapolation(input_polygons, eye_center)
         ellipse_poly = self.params.ellipse_fit(input_polygons)
 
+        if ellipse_poly is None:
+            return circle_poly
+
         circle_iris = circle_poly.iris_array
         circle_pupil = circle_poly.pupil_array
         ellipse_iris = ellipse_poly.iris_array

src/iris/nodes/geometry_estimation/lsq_ellipse_fit_with_refinement.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Union
 
 import cv2
 import numpy as np
@@ -33,45 +33,89 @@ def __init__(self, dphi: float = 1.0, callbacks: List[Callback] = []) -> None:
         """
         super().__init__(dphi=dphi, callbacks=callbacks)
 
-    def run(self, input_polygons: GeometryPolygons) -> GeometryPolygons:
+    def run(self, input_polygons: GeometryPolygons) -> Union[GeometryPolygons, None]:
         """Estimate extrapolated polygons with OpenCV's method fitEllipse.
 
         Args:
             input_polygons (GeometryPolygons): Smoothed polygons.
 
         Returns:
-            GeometryPolygons: Extrapolated polygons.
+            Union[GeometryPolygons, None]: Extrapolated polygons or None if pupil is not inside iris.
         """
-        extrapolated_pupil = self._extrapolate(input_polygons.pupil_array)
-        extrapolated_iris = self._extrapolate(input_polygons.iris_array)
+        extrapolated_polygons = self._extrapolate(input_polygons)
+
+        if extrapolated_polygons is None:
+            return None
 
         for point in input_polygons.pupil_array:
-            extrapolated_pupil[self._find_correspondence(point, extrapolated_pupil)] = point
+            extrapolated_polygons.pupil_array[
+                self._find_correspondence(point, extrapolated_polygons.pupil_array)
+            ] = point
 
-        return GeometryPolygons(
-            pupil_array=extrapolated_pupil, iris_array=extrapolated_iris, eyeball_array=input_polygons.eyeball_array
-        )
+        return extrapolated_polygons
+
+    def _is_pupil_inside_iris_ellipses(
+        self, px0: float, py0: float, pa: float, pb: float, ix0: float, iy0: float, ia: float, ib: float
+    ) -> bool:
+        """Fast conservative check using bounding circles.
+
+        Args:
+            px0 (float): elliptical fit pupil center x-coordinate
+            py0 (float): elliptical fit pupil center y-coordinate
+            pa (float): elliptical fit pupil major axis length
+            pb (float): elliptical fit pupil minor axis length
+            ix0 (float): elliptical fit iris center x-coordinate
+            iy0 (float): elliptical fit iris center y-coordinate
+            ia (float): elliptical fit iris major axis length
+            ib (float): elliptical fit iris minor axis length
+
+        Returns:
+            bool: True if pupil is likely inside iris (conservative estimate)
+        """
+        # Use max radius for pupil (worst case) and min radius for iris (best case)
+        pupil_max_radius = max(pa, pb) / 2
+        iris_min_radius = min(ia, ib) / 2
+
+        # Distance between centers
+        center_dist = np.sqrt((px0 - ix0) ** 2 + (py0 - iy0) ** 2)
+
+        # Conservative check: pupil's max reach < iris's min reach
+        # Add small safety margin (e.g., 5%)
+        safety_factor = 0.95
+        return (center_dist + pupil_max_radius) < (iris_min_radius * safety_factor)
 
-    def _extrapolate(self, polygon_points: np.ndarray) -> np.ndarray:
+    def _extrapolate(self, input_polygons: GeometryPolygons) -> Union[GeometryPolygons, None]:
         """Perform extrapolation for points in an array.
 
         Args:
-            polygon_points (np.ndarray): Smoothed polygon ready for applying extrapolation algorithm on it.
+            polygon_points (np.ndarray): Smoothed polygons ready for applying extrapolation algorithm on it.
 
         Returns:
-            np.ndarray: Estimated extrapolated polygon.
+            Union[GeometryPolygons, None]: Extrapolated polygons or None if pupil is not inside iris.
         """
-        (x0, y0), (a, b), theta = cv2.fitEllipse(polygon_points)
+        (px0, py0), (pa, pb), ptheta = cv2.fitEllipse(input_polygons.pupil_array)
+        (ix0, iy0), (ia, ib), itheta = cv2.fitEllipse(input_polygons.iris_array)
 
-        extrapolated_polygon = LSQEllipseFitWithRefinement.parametric_ellipsis(
-            a / 2, b / 2, x0, y0, np.radians(theta), round(360 / self.params.dphi)
+        if not self._is_pupil_inside_iris_ellipses(px0, py0, pa, pb, ix0, iy0, ia, ib):
+            return None
+        extrapolated_pupil_polygon = LSQEllipseFitWithRefinement.parametric_ellipsis(
+            pa / 2, pb / 2, px0, py0, np.radians(ptheta), round(360 / self.params.dphi)
+        )
+        extrapolated_iris_polygon = LSQEllipseFitWithRefinement.parametric_ellipsis(
+            ia / 2, ib / 2, ix0, iy0, np.radians(itheta), round(360 / self.params.dphi)
         )
 
         # Rotate such that 0 degree is parallel with x-axis and array is clockwise
-        roll_amount = round((-theta - 90) / self.params.dphi)
-        extrapolated_polygon = np.flip(np.roll(extrapolated_polygon, roll_amount, axis=0), axis=0)
+        roll_amount = round((-ptheta - 90) / self.params.dphi)
+        extrapolated_pupil_polygon = np.flip(np.roll(extrapolated_pupil_polygon, roll_amount, axis=0), axis=0)
+        roll_amount = round((-itheta - 90) / self.params.dphi)
+        extrapolated_iris_polygon = np.flip(np.roll(extrapolated_iris_polygon, roll_amount, axis=0), axis=0)
 
-        return extrapolated_polygon
+        return GeometryPolygons(
+            pupil_array=extrapolated_pupil_polygon,
+            iris_array=extrapolated_iris_polygon,
+            eyeball_array=input_polygons.eyeball_array,
+        )
 
     def _find_correspondence(self, src_point: np.ndarray, dst_points: np.ndarray) -> int:
         """Find correspondence with Euclidean distance.

src/iris/pipelines/confs/multiframe_iris_pipeline.yaml

@@ -1,12 +1,12 @@
 metadata:
   pipeline_name: multiframe_iris_pipeline
-  iris_version: 1.9.7
+  iris_version: 1.9.8
 
 # Configuration for individual image processing (IRISPipeline)
 iris_pipeline:
   metadata:
     pipeline_name: iris_pipeline
-    iris_version: 1.9.7
+    iris_version: 1.9.8
 
   pipeline:
     - name: segmentation
@@ -315,7 +315,7 @@ iris_pipeline:
 # Configuration for template aggregation (TemplatesAggregationPipeline)
 templates_aggregation_pipeline:
   metadata:
-    iris_version: 1.9.7
+    iris_version: 1.9.8
     pipeline_name: templates_aggregation
 
   pipeline:

src/iris/pipelines/confs/pipeline.yaml

@@ -1,6 +1,6 @@
 metadata:
   pipeline_name: iris_pipeline
-  iris_version: 1.9.7
+  iris_version: 1.9.8
 
 pipeline:
   - name: segmentation

src/iris/pipelines/confs/templates_aggregation_pipeline.yaml

@@ -1,6 +1,6 @@
 metadata:
   pipeline_name: iris_pipeline
-  iris_version: 1.9.7
+  iris_version: 1.9.8
 
 pipeline:
   - name: segmentation
@@ -307,7 +307,7 @@ pipeline:
 
 templates_aggregation:
   metadata:
-    iris_version: 1.9.7
+    iris_version: 1.9.8
     pipeline_name: templates_aggregation
 
   pipeline: