add mean_and_std from paths/images

histoprep/_reader.py

@@ -387,12 +387,8 @@ def get_mean_and_std(
             num_workers=num_workers,
             return_exception=not raise_exception,
         )
-        return F._get_mean_and_std(
-            images=(
-                (tile, xywh)
-                for tile, xywh in iterable
-                if not isinstance(tile, Exception)
-            )
+        return F.get_mean_and_std_from_images(
+            images=(tile for tile, __ in iterable if not isinstance(tile, Exception))
         )
 
     def save_regions(

histoprep/functional/_mean_std.py

@@ -1,15 +1,64 @@
-__all__ = ["_get_mean_and_std"]
+from __future__ import annotations
+
+__all__ = [
+    "get_mean_and_std_from_images",
+    "get_mean_and_std_from_paths",
+    "_get_mean_and_std",
+]
 
 from collections.abc import Iterable
+from pathlib import Path
 
+import mpire
 import numpy as np
+from PIL import Image
 
 from ._check import check_image
 
+MEAN = tuple[float, ...]
+STD = tuple[float, ...]
+
+
+def get_mean_and_std_from_images(images: Iterable[np.ndarray]) -> tuple[MEAN, STD]:
+    """Get channel mean and std values for an iterable of images.
+
+    Args:
+        images: Iterable of array images.
+        verbose: Enable progress bar. Defaults to False.
+
+    Returns:
+        Tuple of channel mean and std values.
+    """
+    mean, std = [], []
+    for img in images:
+        m, s = _get_mean_and_std(img)
+        mean.append(m)
+        std.append(s)
+    return tuple(np.array(mean).mean(0)), tuple(np.array(std).mean(0))
+
 
-def _get_mean_and_std(
-    images: Iterable[np.ndarray],
-) -> tuple[tuple[float, ...], tuple[float, ...]]:
+def get_mean_and_std_from_paths(
+    filepaths: Iterable[str | Path], num_workers: int = 1
+) -> tuple[MEAN, STD]:
+    """Get channel mean and std values for an iterable of image paths.
+
+    Args:
+        images: Iterable of array image paths.
+        num_workers: Number of image reading processes.
+
+    Returns:
+        Tuple of channel mean and std values.
+    """
+    if num_workers <= 1:
+        return get_mean_and_std_from_images(_read_image(x) for x in filepaths)
+    with mpire.WorkerPool(n_jobs=num_workers) as pool:
+        images = pool.imap(
+            _read_image, ((x,) for x in filepaths), iterable_len=len(filepaths)
+        )
+        return get_mean_and_std_from_images(images)
+
+
+def _get_mean_and_std(image: np.ndarray) -> tuple[MEAN, STD]:
     """Calculate mean and standard deviation for each image channel (between [0, 1]).
 
     Args:
@@ -18,11 +67,14 @@ def _get_mean_and_std(
     Returns:
         Mean and standard deviation for each channel.
     """
-    mean, std = [], []
-    for image, __ in images:
-        check_image(image)
-        if image.ndim == 2:  # noqa
-            image = np.expand_dims(tile, -1)  # noqa
-        mean.append([image[..., i].mean() for i in range(image.shape[-1])])
-        std.append([image[..., i].std() for i in range(image.shape[-1])])
-    return tuple(np.array(mean).mean(0) / 255), tuple(np.array(std).mean(0) / 255)
+    check_image(image)
+    if image.ndim == 2:  # noqa
+        image = np.expand_dims(tile, -1)  # noqa
+    return (
+        tuple([image[..., i].mean() / 255 for i in range(image.shape[-1])]),
+        tuple([image[..., i].std() / 255 for i in range(image.shape[-1])]),
+    )
+
+
+def _read_image(path: str | Path) -> np.ndarray:
+    return np.array(Image.open(path))

tests/mean_and_std_test.py

@@ -0,0 +1,25 @@
+import histoprep.functional as F
+from histoprep import SlideReader
+
+from ._utils import SLIDE_PATH_JPEG, TMP_DIRECTORY, clean_temporary_directory
+
+
+def test_mean_and_std_from_images() -> None:
+    reader = SlideReader(SLIDE_PATH_JPEG)
+    tile_coords = reader.get_tile_coordinates(None, 512)
+    images = (tile for tile, __ in reader.yield_regions(tile_coords))
+    mean, std = F.get_mean_and_std_from_images(images)
+    assert [round(x, 2) for x in mean] == [0.84, 0.70, 0.78]
+    assert [round(x, 2) for x in std] == [0.14, 0.19, 0.14]
+
+
+def test_mean_and_std_from_paths() -> None:
+    reader = SlideReader(SLIDE_PATH_JPEG)
+    tile_coords = reader.get_tile_coordinates(None, 512)
+    clean_temporary_directory()
+    reader.save_regions(TMP_DIRECTORY, tile_coords)
+    paths = list((TMP_DIRECTORY / "slide" / "tiles").iterdir())
+    mean, std = F.get_mean_and_std_from_paths(paths)
+    clean_temporary_directory()
+    assert [round(x, 2) for x in mean] == [0.84, 0.70, 0.78]
+    assert [round(x, 2) for x in std] == [0.14, 0.19, 0.14]

tests/reader_test.py

@@ -472,5 +472,5 @@ def test_save_regions_with_metrics() -> None:
 def test_estimate_mean_and_std() -> None:
     reader = SlideReader(SLIDE_PATH_JPEG)
     mean, std = reader.get_mean_and_std(reader.get_tile_coordinates(None, 512))
-    assert mean == (0.8447404647527956, 0.7014915950999541, 0.779204397164139)
-    assert std == (0.1367226593250863, 0.18658047647561957, 0.1402206641594302)
+    assert [round(x, 2) for x in mean] == [0.84, 0.70, 0.78]
+    assert [round(x, 2) for x in std] == [0.14, 0.19, 0.14]