zea 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

zea/ops.py

@@ -380,7 +380,8 @@ class Pipeline:
         validate=True,
         timed: bool = False,
     ):
-        """Initialize a pipeline
+        """
+        Initialize a pipeline.
 
         Args:
             operations (list): A list of Operation instances representing the operations
@@ -388,15 +389,22 @@ class Pipeline:
             with_batch_dim (bool, optional): Whether operations should expect a batch dimension.
                 Defaults to True.
             jit_options (str, optional): The JIT options to use. Must be "pipeline", "ops", or None.
-                - "pipeline" compiles the entire pipeline as a single function.
-                    This may be faster but, does not preserve python control flow, such as caching.
-                - "ops" compiles each operation separately. This preserves python control flow and
-                    caching functionality, but speeds up the operations.
-                - None disables JIT compilation.
+
+                - "pipeline": compiles the entire pipeline as a single function.
+                  This may be faster but does not preserve python control flow, such as caching.
+
+                - "ops": compiles each operation separately. This preserves python control flow and
+                  caching functionality, but speeds up the operations.
+
+                - None: disables JIT compilation.
+
                 Defaults to "ops".
+
             jit_kwargs (dict, optional): Additional keyword arguments for the JIT compiler.
             name (str, optional): The name of the pipeline. Defaults to "pipeline".
             validate (bool, optional): Whether to validate the pipeline. Defaults to True.
+            timed (bool, optional): Whether to time each operation. Defaults to False.
+
         """
         self._call_pipeline = self.call
         self.name = name
@@ -1162,11 +1170,16 @@ class PatchedGrid(Pipeline):
     With this class you can form a pipeline that will be applied to patches of the grid.
     This is useful to avoid OOM errors when processing large grids.
 
-    Somethings to NOTE about this class:
-        - The ops have to use flatgrid and flat_pfield as inputs, these will be patched.
-        - Changing anything other than `self.output_data_type` in the dict will not be propagated!
-        - Will be jitted as a single operation, not the individual operations.
-        - This class handles the batching.
+    Some things to NOTE about this class:
+
+    - The ops have to use flatgrid and flat_pfield as inputs, these will be patched.
+
+    - Changing anything other than `self.output_data_type` in the dict will not be propagated!
+
+    - Will be jitted as a single operation, not the individual operations.
+
+    - This class handles the batching.
+
     """
 
     def __init__(self, *args, num_patches=10, **kwargs):
@@ -1376,20 +1389,6 @@ class Mean(Operation):
         return kwargs
 
 
-@ops_registry("transpose")
-class Transpose(Operation):
-    """Transpose the input data along the specified axes."""
-
-    def __init__(self, axes, **kwargs):
-        super().__init__(**kwargs)
-        self.axes = axes
-
-    def call(self, **kwargs):
-        data = kwargs[self.key]
-        transposed_data = ops.transpose(data, axes=self.axes)
-        return {self.output_key: transposed_data}
-
-
 @ops_registry("simulate_rf")
 class Simulate(Operation):
     """Simulate RF data."""
@@ -1578,19 +1577,6 @@ class PfieldWeighting(Operation):
         return {self.output_key: weighted_data}
 
 
-@ops_registry("sum")
-class Sum(Operation):
-    """Sum data along a specific axis."""
-
-    def __init__(self, axis, **kwargs):
-        super().__init__(**kwargs)
-        self.axis = axis
-
-    def call(self, **kwargs):
-        data = kwargs[self.key]
-        return {self.output_key: ops.sum(data, axis=self.axis)}
-
-
 @ops_registry("delay_and_sum")
 class DelayAndSum(Operation):
     """Sums time-delayed signals along channels and transmits."""
@@ -2124,29 +2110,37 @@ class Demodulate(Operation):
 class Lambda(Operation):
     """Use any function as an operation."""
 
-    def __init__(self, func, func_kwargs=None, **kwargs):
-        super().__init__(**kwargs)
-        func_kwargs = func_kwargs or {}
-        self.func = partial(func, **func_kwargs)
+    def __init__(self, func, **kwargs):
+        # Split kwargs into kwargs for partial and __init__
+        op_kwargs = {k: v for k, v in kwargs.items() if k not in func.__code__.co_varnames}
+        func_kwargs = {k: v for k, v in kwargs.items() if k in func.__code__.co_varnames}
+        Lambda._check_if_unary(func, **func_kwargs)
 
-    def call(self, **kwargs):
-        data = kwargs[self.key]
-        data = self.func(data)
-        return {self.output_key: data}
-
-
-@ops_registry("clip")
-class Clip(Operation):
-    """Clip the input data to a given range."""
+        super().__init__(**op_kwargs)
+        self.func = partial(func, **func_kwargs)
 
-    def __init__(self, min_value=None, max_value=None, **kwargs):
-        super().__init__(**kwargs)
-        self.min_value = min_value
-        self.max_value = max_value
+    @staticmethod
+    def _check_if_unary(func, **kwargs):
+        """Checks if the kwargs are sufficient to call the function as a unary operation."""
+        sig = inspect.signature(func)
+        # Remove arguments that are already provided in func_kwargs
+        params = list(sig.parameters.values())
+        remaining = [p for p in params if p.name not in kwargs]
+        # Count required positional arguments (excluding self/cls)
+        required_positional = [
+            p
+            for p in remaining
+            if p.default is p.empty and p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+        ]
+        if len(required_positional) != 1:
+            raise ValueError(
+                f"Partial of {func.__name__} must be callable with exactly one required "
+                f"positional argument, we still need: {required_positional}."
+            )
 
     def call(self, **kwargs):
         data = kwargs[self.key]
-        data = ops.clip(data, self.min_value, self.max_value)
+        data = self.func(data)
         return {self.output_key: data}
 
 
@@ -2685,6 +2679,7 @@ class AnisotropicDiffusion(Operation):
         return result
 
 
+@ops_registry("channels_to_complex")
 class ChannelsToComplex(Operation):
     def call(self, **kwargs):
         data = kwargs[self.key]
@@ -2692,6 +2687,7 @@ class ChannelsToComplex(Operation):
         return {self.output_key: output}
 
 
+@ops_registry("complex_to_channels")
 class ComplexToChannels(Operation):
     def __init__(self, axis=-1, **kwargs):
         super().__init__(**kwargs)

zea/scan.py

@@ -149,12 +149,13 @@ class Scan(Parameters):
             Defaults to 0.0.
         attenuation_coef (float, optional): Attenuation coefficient in dB/(MHz*cm).
             Defaults to 0.0.
-        selected_transmits (None, str, int, list, or np.ndarray, optional):
+        selected_transmits (None, str, int, list, slice, or np.ndarray, optional):
             Specifies which transmit events to select.
             - None or "all": Use all transmits.
             - "center": Use only the center transmit.
             - int: Select this many evenly spaced transmits.
             - list/array: Use these specific transmit indices.
+            - slice: Use transmits specified by the slice (e.g., slice(0, 10, 2)).
         grid_type (str, optional): Type of grid to use for beamforming.
             Can be "cartesian" or "polar". Defaults to "cartesian".
         dynamic_range (tuple, optional): Dynamic range for image display.
@@ -171,13 +172,14 @@ class Scan(Parameters):
         "pixels_per_wavelength": {"type": int, "default": 4},
         "pfield_kwargs": {"type": dict, "default": {}},
         "apply_lens_correction": {"type": bool, "default": False},
-        "lens_sound_speed": {"type": (float, int)},
+        "lens_sound_speed": {"type": float},
         "lens_thickness": {"type": float},
         "grid_type": {"type": str, "default": "cartesian"},
         "polar_limits": {"type": (tuple, list)},
         "dynamic_range": {"type": (tuple, list), "default": DEFAULT_DYNAMIC_RANGE},
+        "selected_transmits": {"type": (type(None), str, int, list, slice, np.ndarray)},
         # acquisition parameters
-        "sound_speed": {"type": (float, int), "default": 1540.0},
+        "sound_speed": {"type": float, "default": 1540.0},
         "sampling_frequency": {"type": float},
         "center_frequency": {"type": float},
         "n_el": {"type": int},
@@ -359,6 +361,7 @@ class Scan(Parameters):
                 - "center": Use only the center transmit
                 - int: Select this many evenly spaced transmits
                 - list/array: Use these specific transmit indices
+                - slice: Use transmits specified by the slice (e.g., slice(0, 10, 2))
 
         Returns:
             The current instance for method chaining.
@@ -416,6 +419,10 @@ class Scan(Parameters):
             self._invalidate_dependents("selected_transmits")
             return self
 
+        # Handle slice - convert to list of indices
+        if isinstance(selection, slice):
+            selection = list(range(n_tx_total))[selection]
+
         # Handle list of indices
         if isinstance(selection, list):
             # Validate indices

zea/tensor_ops.py

@@ -130,6 +130,102 @@ def extend_n_dims(arr, axis, n_dims):
     return ops.reshape(arr, new_shape)
 
 
+def vmap(fun, in_axes=0, out_axes=0):
+    """Vectorized map.
+
+    For torch and jax backends, this uses the native vmap implementation.
+    For other backends, this a wrapper that uses `ops.vectorized_map` under the hood.
+
+    Args:
+        fun: The function to be mapped.
+        in_axes: The axis or axes to be mapped over in the input.
+            Can be an integer, a tuple of integers, or None.
+            If None, the corresponding argument is not mapped over.
+            Defaults to 0.
+        out_axes: The axis or axes to be mapped over in the output.
+            Can be an integer, a tuple of integers, or None.
+            If None, the corresponding output is not mapped over.
+            Defaults to 0.
+
+    Returns:
+        A function that applies `fun` in a vectorized manner over the specified axes.
+
+    Raises:
+        ValueError: If the backend does not support vmap.
+    """
+    if keras.backend.backend() == "jax":
+        import jax
+
+        return jax.vmap(fun, in_axes=in_axes, out_axes=out_axes)
+    elif keras.backend.backend() == "torch":
+        import torch
+
+        return torch.vmap(fun, in_dims=in_axes, out_dims=out_axes)
+    else:
+        return manual_vmap(fun, in_axes=in_axes, out_axes=out_axes)
+
+
+def manual_vmap(fun, in_axes=0, out_axes=0):
+    """Manual vectorized map for backends that do not support vmap."""
+
+    def find_map_length(args, in_axes):
+        """Find the length of the axis to map over."""
+        # NOTE: only needed for numpy, the other backends can handle a singleton dimension
+        for arg, axis in zip(args, in_axes):
+            if axis is None:
+                continue
+
+            return ops.shape(arg)[axis]
+        return 1
+
+    def _moveaxes(args, in_axes, out_axes):
+        """Move axes of the input arguments."""
+        args = list(args)
+        for i, (arg, in_axis, out_axis) in enumerate(zip(args, in_axes, out_axes)):
+            if in_axis is not None:
+                args[i] = ops.moveaxis(arg, in_axis, out_axis)
+            else:
+                args[i] = ops.repeat(arg[None], find_map_length(args, in_axes), axis=out_axis)
+        return tuple(args)
+
+    def _fun(args):
+        return fun(*args)
+
+    def wrapper(*args):
+        # If in_axes or out_axes is an int, convert to tuple
+        if isinstance(in_axes, int):
+            _in_axes = (in_axes,) * len(args)
+        else:
+            _in_axes = in_axes
+        if isinstance(out_axes, int):
+            _out_axes = (out_axes,) * len(args)
+        else:
+            _out_axes = out_axes
+        zeros = (0,) * len(args)
+
+        # Check that in_axes and out_axes are tuples
+        if not isinstance(_in_axes, tuple):
+            raise ValueError("in_axes must be an int or a tuple of ints.")
+        if not isinstance(_out_axes, tuple):
+            raise ValueError("out_axes must be an int or a tuple of ints.")
+
+        args = _moveaxes(args, _in_axes, zeros)
+        outputs = ops.vectorized_map(_fun, tuple(args))
+
+        tuple_output = isinstance(outputs, (tuple, list))
+        if not tuple_output:
+            outputs = (outputs,)
+
+        outputs = _moveaxes(outputs, zeros, _out_axes)
+
+        if not tuple_output:
+            outputs = outputs[0]
+
+        return outputs
+
+    return wrapper
+
+
 def func_with_one_batch_dim(
     func,
     tensor,
@@ -1270,6 +1366,14 @@ def L2(x):
     return ops.sqrt(ops.sum(x**2))
 
 
+def L1(x):
+    """L1 norm of a tensor.
+
+    Implementation of L1 norm: https://mathworld.wolfram.com/L1-Norm.html
+    """
+    return ops.sum(ops.abs(x))
+
+
 def linear_sum_assignment(cost):
     """Greedy linear sum assignment.
 
@@ -1325,3 +1429,150 @@ else:
     def safe_vectorize(pyfunc, excluded=None, signature=None):
         """Just a wrapper around ops.vectorize."""
         return ops.vectorize(pyfunc, excluded=excluded, signature=signature)
+
+
+def apply_along_axis(func1d, axis, arr, *args, **kwargs):
+    """Apply a function to 1D array slices along an axis.
+
+    Keras implementation of numpy.apply_along_axis using keras.ops.vectorized_map.
+
+    Args:
+        func1d: A callable function with signature ``func1d(arr, /, *args, **kwargs)``
+            where ``*args`` and ``**kwargs`` are the additional positional and keyword
+            arguments passed to apply_along_axis.
+        axis: Integer axis along which to apply the function.
+        arr: The array over which to apply the function.
+        *args: Additional positional arguments passed through to func1d.
+        **kwargs: Additional keyword arguments passed through to func1d.
+
+    Returns:
+        The result of func1d applied along the specified axis.
+    """
+    # Convert to keras tensor
+    arr = ops.convert_to_tensor(arr)
+
+    # Get array dimensions
+    num_dims = len(arr.shape)
+
+    # Canonicalize axis (handle negative indices)
+    if axis < 0:
+        axis = num_dims + axis
+
+    if axis < 0 or axis >= num_dims:
+        raise ValueError(f"axis {axis} is out of bounds for array of dimension {num_dims}")
+
+    # Create a wrapper function that applies func1d with the additional arguments
+    def func(slice_arr):
+        return func1d(slice_arr, *args, **kwargs)
+
+    # Recursively build up vectorized maps following the JAX pattern
+    # For dimensions after the target axis (right side)
+    for i in range(1, num_dims - axis):
+        prev_func = func
+
+        def make_func(f, dim_offset):
+            def vectorized_func(x):
+                # Move the dimension we want to map over to the front
+                perm = list(range(len(x.shape)))
+                perm[0], perm[dim_offset] = perm[dim_offset], perm[0]
+                x_moved = ops.transpose(x, perm)
+                result = ops.vectorized_map(f, x_moved)
+                # Move the result dimension back if needed
+                if len(result.shape) > 0:
+                    result_perm = list(range(len(result.shape)))
+                    if len(result_perm) > dim_offset:
+                        result_perm[0], result_perm[dim_offset] = (
+                            result_perm[dim_offset],
+                            result_perm[0],
+                        )
+                        result = ops.transpose(result, result_perm)
+                return result
+
+            return vectorized_func
+
+        func = make_func(prev_func, i)
+
+    # For dimensions before the target axis (left side)
+    for i in range(axis):
+        prev_func = func
+
+        def make_func(f):
+            return lambda x: ops.vectorized_map(f, x)
+
+        func = make_func(prev_func)
+
+    return func(arr)
+
+
+def correlate(x, y, mode="full"):
+    """
+    Complex correlation via splitting real and imaginary parts.
+    Equivalent to np.correlate(x, y, mode).
+
+    NOTE: this function exists because tensorflow does not support complex correlation.
+    NOTE: tensorflow also handles padding differently than numpy, so we manually pad the input.
+
+    Args:
+        x: np.ndarray (complex or real)
+        y: np.ndarray (complex or real)
+        mode: "full", "valid", or "same"
+    """
+    x = ops.convert_to_tensor(x)
+    y = ops.convert_to_tensor(y)
+
+    is_complex = "complex" in ops.dtype(x) or "complex" in ops.dtype(y)
+
+    # Cast to complex64 if real
+    if not is_complex:
+        x = ops.cast(x, "complex64")
+        y = ops.cast(y, "complex64")
+
+    # Split into real and imaginary
+    xr, xi = ops.real(x), ops.imag(x)
+    yr, yi = ops.real(y), ops.imag(y)
+
+    # Pad to do full correlation
+    pad_left = ops.shape(y)[0] - 1
+    pad_right = ops.shape(y)[0] - 1
+    xr = ops.pad(xr, [[pad_left, pad_right]])
+    xi = ops.pad(xi, [[pad_left, pad_right]])
+
+    # Correlation: sum over x[n] * conj(y[n+k])
+    rr = ops.correlate(xr, yr, mode="valid")
+    ii = ops.correlate(xi, yi, mode="valid")
+    ri = ops.correlate(xr, yi, mode="valid")
+    ir = ops.correlate(xi, yr, mode="valid")
+
+    real_part = rr + ii
+    imag_part = ir - ri
+
+    real_part = ops.cast(real_part, "complex64")
+    imag_part = ops.cast(imag_part, "complex64")
+
+    complex_tensor = real_part + 1j * imag_part
+
+    # Extract relevant part based on mode
+    full_length = ops.shape(real_part)[0]
+    x_len = ops.shape(x)[0]
+    y_len = ops.shape(y)[0]
+
+    if mode == "same":
+        # Return output of length max(M, N)
+        target_len = ops.maximum(x_len, y_len)
+        start = ops.floor((full_length - target_len) / 2)
+        start = ops.cast(start, "int32")
+        end = start + target_len
+        complex_tensor = complex_tensor[start:end]
+    elif mode == "valid":
+        # Return output of length max(M, N) - min(M, N) + 1
+        target_len = ops.maximum(x_len, y_len) - ops.minimum(x_len, y_len) + 1
+        start = ops.ceil((full_length - target_len) / 2)
+        start = ops.cast(start, "int32")
+        end = start + target_len
+        complex_tensor = complex_tensor[start:end]
+    # For "full" mode, use the entire result (no slicing needed)
+
+    if is_complex:
+        return complex_tensor
+    else:
+        return ops.real(complex_tensor)

zea/tools/fit_scan_cone.py

@@ -83,8 +83,7 @@ def filter_edge_points_by_boundary(edge_points, is_left=True, min_cone_half_angl
 
 
 def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
-    """
-    Detect the ultrasound cone parameters from a grayscale image.
+    """Detect the ultrasound cone parameters from a grayscale image.
 
     This function performs the following steps:
     1. Thresholds the image to create a binary mask
@@ -209,6 +208,7 @@ def detect_cone_parameters(image, min_cone_half_angle_deg=20, threshold=15):
     apex_x = left_a + left_b * apex_y
 
     # Calculate cone height
+    max_y = ops.cast(max_y, apex_y.dtype)
     cone_height = max_y - apex_y
 
     # Calculate opening angle from the line slopes

zea/tools/selection_tool.py

@@ -250,10 +250,13 @@ def add_shape_from_mask(ax, mask, **kwargs):
     Returns:
         plt.ax: matplotlib axis with shape added
     """
-    # Create a Path patch
-    contours = measure.find_contours(mask, 0.5)
+    # Pad mask to ensure edge contours are found
+    padded_mask = np.pad(mask, pad_width=1, mode="constant", constant_values=0)
+    contours = measure.find_contours(padded_mask, 0.5)
     patches = []
     for contour in contours:
+        # Remove padding offset
+        contour -= 1
         path = pltPath(contour[:, ::-1])
         patch = PathPatch(path, **kwargs)
         patches.append(ax.add_patch(patch))
@@ -593,10 +596,11 @@ def interpolate_masks(
     assert all(mask.shape == mask_shape for mask in masks), "All masks must have the same shape."
 
     # distribute number of frames over number of masks
-    num_frames_per_segment = [num_frames // (number_of_masks - 1)] * (number_of_masks - 1)
-    if num_frames % num_frames_per_segment[0] != 0:
-        # make sure that number of frames per mask adds up to total number of frames
-        num_frames_per_segment[-1] += num_frames - sum(num_frames_per_segment)
+    base_frames = num_frames // (number_of_masks - 1)
+    remainder = num_frames % (number_of_masks - 1)
+    num_frames_per_segment = [base_frames] * (number_of_masks - 1)
+    for i in range(remainder):
+        num_frames_per_segment[i] += 1
 
     if rectangle:
         # get the rectangles
@@ -615,7 +619,6 @@ def interpolate_masks(
         for _rectangle in rectangles:
             interpolated_masks.append(reconstruct_mask_from_rectangle(_rectangle, mask_shape))
         return interpolated_masks
-
     # get the contours
     polygons = []
     for mask in masks:
@@ -726,6 +729,17 @@ def update_imshow_with_mask(
     return imshow_obj, mask_obj
 
 
+def ask_for_title():
+    print("What are you selecting?")
+    title = input("Enter a title for the selection: ")
+    if not title:
+        raise ValueError("Title cannot be empty.")
+    # Convert title to snake_case
+    title = title.strip().replace(" ", "_").lower()
+    print(f"Title set to: {title}")
+    return title
+
+
 def main():
     """Main function for interactive selector on multiple images."""
     print(
@@ -751,6 +765,7 @@ def main():
             raise e
         print("No more images selected. Continuing...")
 
+    title = ask_for_title()
     selector = ask_for_selection_tool()
 
     if same_images is True:
@@ -829,6 +844,10 @@ def main():
         else:
             add_shape_from_mask(axs, interpolated_masks[0], alpha=0.5)
 
+        filestem = Path(file.parent / f"{file.stem}_{title}_annotations.gif")
+        np.save(filestem.with_suffix(".npy"), interpolated_masks)
+        print(f"Succesfully saved interpolated masks to {log.yellow(filestem.with_suffix('.npy'))}")
+
         fps = ask_save_animation_with_fps()
 
         ani = FuncAnimation(
@@ -838,9 +857,9 @@ def main():
             fargs=(axs, imshow_obj, images, interpolated_masks, selector),
             interval=1000 / fps,
         )
-        filename = Path(file.parent.stem + "_" + f"{file.stem}_interpolated_masks.gif")
+        filename = filestem.with_suffix(".gif")
         ani.save(filename, writer="pillow")
-        print(f"Succesfully saved animation as {filename}")
+        print(f"Succesfully saved animation as {log.yellow(filename)}")
 
 
 if __name__ == "__main__":

{zea-0.0.4.dist-info → zea-0.0.6.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: zea
-Version: 0.0.4
+Version: 0.0.6
 Summary: A Toolbox for Cognitive Ultrasound Imaging. Provides a set of tools for processing of ultrasound data, all built in your favorite machine learning framework.
+License-File: LICENSE
 Keywords: ultrasound,machine learning,beamforming
 Author: Tristan Stevens
 Author-email: t.s.w.stevens@tue.nl
@@ -21,6 +22,7 @@ Provides-Extra: display
 Provides-Extra: display-headless
 Provides-Extra: docs
 Provides-Extra: jax
+Provides-Extra: models
 Provides-Extra: tests
 Requires-Dist: IPython ; extra == "dev"
 Requires-Dist: IPython ; extra == "docs"
@@ -33,13 +35,14 @@ Requires-Dist: furo ; extra == "dev"
 Requires-Dist: furo ; extra == "docs"
 Requires-Dist: h5py (>=3.11)
 Requires-Dist: huggingface_hub (>=0.26)
+Requires-Dist: imageio[ffmpeg] (>=2.0)
 Requires-Dist: ipykernel (>=6.29.5) ; extra == "dev"
 Requires-Dist: ipykernel (>=6.29.5) ; extra == "tests"
 Requires-Dist: ipywidgets ; extra == "dev"
 Requires-Dist: ipywidgets ; extra == "tests"
 Requires-Dist: jax ; extra == "backends"
 Requires-Dist: jax[cuda12-pip] (>=0.4.26) ; extra == "jax"
-Requires-Dist: keras (>=3.9)
+Requires-Dist: keras (>=3.11)
 Requires-Dist: matplotlib (>=3.8)
 Requires-Dist: mock ; extra == "dev"
 Requires-Dist: mock ; extra == "docs"
@@ -48,6 +51,8 @@ Requires-Dist: myst-parser ; extra == "docs"
 Requires-Dist: nbsphinx ; extra == "dev"
 Requires-Dist: nbsphinx ; extra == "docs"
 Requires-Dist: numpy (>=1.24)
+Requires-Dist: onnxruntime (>=1.15) ; extra == "dev"
+Requires-Dist: onnxruntime (>=1.15) ; extra == "models"
 Requires-Dist: opencv-python (>=4) ; extra == "display"
 Requires-Dist: opencv-python-headless (>=4) ; extra == "dev"
 Requires-Dist: opencv-python-headless (>=4) ; extra == "display-headless"
@@ -69,6 +74,8 @@ Requires-Dist: scikit-learn (>=1.4)
 Requires-Dist: scipy (>=1.13)
 Requires-Dist: sphinx ; extra == "dev"
 Requires-Dist: sphinx ; extra == "docs"
+Requires-Dist: sphinx-argparse ; extra == "dev"
+Requires-Dist: sphinx-argparse ; extra == "docs"
 Requires-Dist: sphinx-autobuild ; extra == "dev"
 Requires-Dist: sphinx-autobuild ; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints ; extra == "dev"