Avoid skimage matmul divide by zero warnings (#148)

* avoid skimage matmul divide by zero

* Update coverage-badge.svg

Author: d33bs

media/coverage-badge.svg

@@ -116,8 +116,9 @@ lint.select = [
 ]
 # Ignore `E402` and `F401` (unused imports) in all `__init__.py` files
 lint.per-file-ignores."__init__.py" = [ "E402", "F401" ]
+lint.per-file-ignores."src/cytodataframe/image.py" = [ "PLR2004" ]
 # ignore typing rules for tests
-lint.per-file-ignores."tests/*" = [ "ANN201", "PLR0913", "PLR2004" ]
+lint.per-file-ignores."tests/*" = [ "ANN201", "PLR0913", "PLR2004", "SIM105" ]
 
 [tool.coverage.run]
 # settings to avoid errors with cv2 and coverage

pyproject.toml

@@ -11,6 +11,7 @@
 import skimage.measure
 from PIL import Image, ImageEnhance
 from skimage import draw, exposure
+from skimage import draw as skdraw
 from skimage.util import img_as_ubyte
 
 
@@ -116,15 +117,15 @@ def draw_outline_on_image_from_outline(
     # Create a mask for non-black areas (with threshold)
     threshold = 10  # Adjust as needed
     # Grayscale
-    if outline_image.ndim == 2:  # noqa: PLR2004
+    if outline_image.ndim == 2:
         non_black_mask = outline_image > threshold
     else:  # RGB/RGBA
         non_black_mask = np.any(outline_image[..., :3] > threshold, axis=-1)
 
     # Ensure the original image is RGB
-    if orig_image.ndim == 2:  # noqa: PLR2004
+    if orig_image.ndim == 2:
         orig_image = np.stack([orig_image] * 3, axis=-1)
-    elif orig_image.shape[-1] != 3:  # noqa: PLR2004
+    elif orig_image.shape[-1] != 3:
         raise ValueError("Original image must have 3 channels (RGB).")
 
     # Ensure uint8 data type
@@ -168,14 +169,14 @@ def draw_outline_on_image_from_mask(
 
     # Ensure the original image is RGB
     # Grayscale input
-    if orig_image.ndim == 2:  # noqa: PLR2004
+    if orig_image.ndim == 2:
         orig_image = np.stack([orig_image] * 3, axis=-1)
     # Unsupported input
-    elif orig_image.shape[-1] != 3:  # noqa: PLR2004
+    elif orig_image.shape[-1] != 3:
         raise ValueError("Original image must have 3 channels (RGB).")
 
     # Ensure the mask is 2D (binary)
-    if mask_image.ndim > 2:  # noqa: PLR2004
+    if mask_image.ndim > 2:
         mask_image = mask_image[..., 0]  # Take the first channel if multi-channel
 
     # Detect contours from the mask
@@ -248,17 +249,17 @@ def equalize_and_adjust(channel: np.ndarray) -> np.ndarray:
         gamma = 1.0 - brightness_shift * 0.8  # e.g. 1.8 → dark, 0.2 → bright
         return exposure.adjust_gamma(eq, gamma=gamma)
 
-    if image.ndim == 2:  # noqa: PLR2004
+    if image.ndim == 2:
         result = equalize_and_adjust(image)
         return img_as_ubyte(result)
 
-    elif image.ndim == 3 and image.shape[2] == 3:  # noqa: PLR2004
+    elif image.ndim == 3 and image.shape[2] == 3:
         result = np.stack(
             [equalize_and_adjust(image[:, :, i]) for i in range(3)], axis=-1
         )
         return img_as_ubyte(result)
 
-    elif image.ndim == 3 and image.shape[2] == 4:  # noqa: PLR2004
+    elif image.ndim == 3 and image.shape[2] == 4:
         rgb = image[:, :, :3]
         alpha = image[:, :, 3]
         result = np.stack(
@@ -322,17 +323,78 @@ def add_image_scale_bar(  # noqa: PLR0913
     margin_px: int = 10,
     **_: Dict[Any, Any],
 ) -> np.ndarray:
+    """
+    Add a scale bar to the lower or upper corner of an image.
+
+    The function overlays a solid rectangular scale bar onto a grayscale,
+    RGB, or RGBA image.  The bar's physical length in micrometers is
+    converted to pixels using the provided microns-per-pixel value.
+    Non-finite or out-of-range input values are sanitized before drawing.
+
+    Args:
+        img (np.ndarray):
+            Input image, either 2-D grayscale or 3-D RGB/RGBA.
+        um_per_pixel (float):
+            Micrometers per pixel.  If None or ≤ 0, the image is returned
+            unchanged.
+        length_um (float, optional):
+            Desired length of the scale bar in micrometers.  Defaults to
+            10.0.
+        thickness_px (int, optional):
+            Thickness of the bar in pixels.  Defaults to 4.
+        color (Tuple[int, int, int], optional):
+            RGB color of the bar.  Defaults to white ``(255, 255, 255)``.
+        location (str, optional):
+            Placement of the bar: ``"lower right"``, ``"lower left"``,
+            ``"upper right"``, or ``"upper left"``.  Defaults to
+            ``"lower right"``.
+        margin_px (int, optional):
+            Distance in pixels between the bar and the image edges.
+            Defaults to 10.
+        **_ (Dict[Any, Any]):
+            Additional keyword arguments ignored for forward
+            compatibility.
+
+    Returns:
+        np.ndarray:
+            A new RGB image with the scale bar drawn.  The array is always
+            of type ``uint8`` and has shape ``(H, W, 3)``.
+
+    Raises:
+        ValueError: If the input image has an unsupported number of
+            channels.
+
+    Notes:
+        The bar length is clamped to fit within image bounds after
+        margins.  The function does not rely on ``skimage.color`` and is
+        safe against NaN or Inf input values.
+    """
+
     if um_per_pixel is None or um_per_pixel <= 0:
         return img
 
-    out = img.copy()
-    # ensure RGB uint8
-    if out.ndim == 2:  # noqa: PLR2004
-        out = skimage.color.gray2rgb(out)
-    elif out.ndim == 3 and out.shape[2] == 4:  # noqa: PLR2004
-        out = out[:, :, :3]
+    # --- Sanitize input first: replace non-finite, clip to valid range, cast to uint8
+    out = np.nan_to_num(img, nan=0.0, posinf=255.0, neginf=0.0)
+
+    # If float image, try to guess range and bring to 0..255
+    if np.issubdtype(out.dtype, np.floating):
+        # If values look like 0..1, scale to 0..255; otherwise clip to 0..255
+        if out.max() <= 1.0:
+            out = out * 255.0
+        out = np.clip(out, 0, 255)
+
     out = out.astype(np.uint8, copy=False)
 
+    # ensure RGB without using skimage.color.* conversions
+    if out.ndim == 2:  # grayscale -> stack
+        out = np.dstack([out, out, out])
+    elif out.ndim == 3 and out.shape[2] == 4:  # RGBA -> drop alpha for drawing
+        out = out[:, :, :3]
+    elif out.ndim != 3 or out.shape[2] != 3:
+        raise ValueError(
+            "Unsupported image shape for scale bar; expected gray/RGB/RGBA."
+        )
+
     H, W = out.shape[:2]
     length_px = max(1, round(length_um / um_per_pixel))
     thickness_px = max(1, int(thickness_px))
@@ -343,8 +405,6 @@ def add_image_scale_bar(  # noqa: PLR0913
 
     loc = location.lower().strip()
 
-    # Compute starting corner (y0, x0) and use rectangle
-    # extent = (thickness_px, length_px)
     y0 = (
         max(0, H - margin_px - thickness_px)
         if "lower" in loc
@@ -358,7 +418,7 @@ def add_image_scale_bar(  # noqa: PLR0913
     if x0 + length_px > W:
         length_px = W - x0
 
-    rr, cc = skimage.draw.rectangle(
+    rr, cc = skdraw.rectangle(
         start=(y0, x0),
         extent=(thickness_px, length_px),
         shape=out.shape[:2],

src/cytodataframe/image.py

@@ -4,10 +4,12 @@
 
 import os
 import pathlib
+import warnings
 
 import imageio.v2 as imageio
 import numpy as np
 import pytest
+import skimage
 from PIL import Image
 from skimage.draw import disk
 
@@ -357,3 +359,75 @@ def test_add_image_scale_bar_lower_right_bbox_and_area(tmp_path: pathlib.Path):
     # optionally show (useful locally; safe-off in CI)
     if os.environ.get("SHOW_TEST_IMAGES") == "1":
         Image.fromarray(out).show()  # opens Preview/Photos/etc.
+
+
+def test_colorconv_control_may_emit_warning():
+    """
+    CONTROL: Try a few skimage color conversions on a bad array to see if any
+    emit the classic matmul divide-by-zero warning. If none do on this version
+    of skimage, skip the control.
+    """
+    bad = np.array([[0.0, np.inf], [np.nan, 1.0]], dtype=float)
+
+    funcs = [
+        lambda a: skimage.color.gray2rgb(a),
+        lambda a: skimage.color.rgb2lab(np.dstack([a, a, a])),
+        lambda a: skimage.color.lab2rgb(np.dstack([a * 100.0, a * 255.0, a * 255.0])),
+        lambda a: skimage.color.rgb2hsv(np.dstack([a, a, a])),
+    ]
+
+    saw_warning = False
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always", category=RuntimeWarning)
+        for fn in funcs:
+            try:
+                _ = fn(bad)
+            except Exception:
+                # We only care about warnings, not exceptions
+                pass
+
+    for w in caught:
+        if issubclass(
+            w.category, RuntimeWarning
+        ) and "divide by zero encountered in matmul" in str(w.message):
+            saw_warning = True
+            break
+
+    if not saw_warning:
+        pytest.skip(
+            "No skimage colorconv matmul warning emitted in this environment; "
+            "control not applicable."
+        )
+
+
+def test_add_image_scale_bar_avoids_colorconv_warning_with_bad_values():
+    """add_image_scale_bar should not emit the colorconv matmul warning."""
+    H, W = 60, 50
+    img = np.zeros((H, W), dtype=float)
+    img[0, 0] = np.nan
+    img[0, 1] = np.inf
+    img[1, 0] = -np.inf
+    img[1, 1] = 2.0
+
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always", category=RuntimeWarning)
+        out = add_image_scale_bar(
+            img,
+            um_per_pixel=0.5,
+            length_um=10.0,
+            thickness_px=3,
+            color=(255, 255, 255),
+            location="lower right",
+            margin_px=5,
+            label=False,  # ignored via **kwargs
+        )
+
+    assert not any(
+        (
+            issubclass(w.category, RuntimeWarning)
+            and "divide by zero encountered in matmul" in str(w.message)
+        )
+        for w in caught
+    ), "Should not trigger the skimage colorconv matmul warning."
+
+    assert out.ndim == 3 and out.shape == (H, W, 3) and out.dtype == np.uint8