Update Polus-rolling-ball-plugin (PolusAI#600)

* add pyproject.toml, update pakcages for cp313, pass unittest

* update main.py and tests functions to pass pre-commit

* add a bumpversion file

* bump release

* update gitignore

* update Dockerfile, pyproject.toml

Author: vanlam2308

transforms/images/polus-rolling-ball-plugin/.bumpversion.cfg

@@ -0,0 +1,8 @@
+[bumpversion]
+current_version = 1.0.3
+commit = False
+tag = False
+
+[bumpversion:file:VERSION]
+
+[bumpversion:file:plugin.json]

transforms/images/polus-rolling-ball-plugin/Dockerfile

@@ -1,15 +1,14 @@
-FROM polusai/bfio:2.1.9
-
-COPY VERSION /
-		
-ARG EXEC_DIR="/opt/executables"
-ARG DATA_DIR="/data"
-
-RUN mkdir -p ${EXEC_DIR} && mkdir -p ${DATA_DIR}/{input, output}
-
-COPY src ${EXEC_DIR}/
+# Build from repo root (monorepo) or from this tool directory — both work.
+FROM polusai/bfio:2.5.0
+ENV EXEC_DIR="/opt/executables" POLUS_IMG_EXT=".ome.tif" POLUS_TAB_EXT=".csv" POLUS_LOG="INFO"
 WORKDIR ${EXEC_DIR}
-
-RUN pip3 install -r ${EXEC_DIR}/requirements.txt --no-cache-dir
-
-ENTRYPOINT ["python3", "/opt/executables/main.py"]
+ENV TOOL_DIR="transforms/images/polus-rolling-ball-plugin"
+RUN mkdir -p image-tools
+COPY . ${EXEC_DIR}/image-tools
+RUN pip3 install -U pip setuptools wheel \
+  && python3 -c 'import sys; assert sys.version_info>=(3,11)' \
+  && R="${EXEC_DIR}/image-tools" && M="$R/$TOOL_DIR" \
+  && if [ -f "$M/pyproject.toml" ]; then pip3 install --no-cache-dir "$M"; \
+     else pip3 install --no-cache-dir "$R"; fi
+ENTRYPOINT ["python3", "-m", "main"]
+CMD ["--help"]

transforms/images/polus-rolling-ball-plugin/VERSION

@@ -1 +1 @@
-1.0.2
+1.0.3

transforms/images/polus-rolling-ball-plugin/plugin.json

@@ -1,14 +1,14 @@
 {
   "name": "Rolling Ball",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "title": "Rolling Ball",
   "description": "A WIPP plugin to perform background subtraction using the rolling-ball algorithm.",
   "author": "Najib Ishaq (najib.ishaq@axleinfo.com)",
   "institution": "National Center for Advancing Translational Sciences, National Institutes of Health",
   "repository": "https://github.com/labshare/polus-plugins",
   "website": "https://ncats.nih.gov/preclinical/core/informatics",
   "citation": "",
-  "containerId": "polusai/rolling-ball-plugin:1.0.2",
+  "containerId": "polusai/rolling-ball-plugin:1.0.3",
   "inputs": [
     {
       "name": "inputDir",
@@ -55,4 +55,4 @@
       "default": false
     }
   ]
-}
+}

transforms/images/polus-rolling-ball-plugin/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "polus-rolling-ball-plugin"
+version = "1.0.2"
+requires-python = ">=3.11"
+dependencies = [
+    "bfio>=2.5.0",
+    "scikit-image>=0.18.1",
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.setuptools]
+py-modules = ["main", "rolling_ball"]

transforms/images/polus-rolling-ball-plugin/src/__init__.py

@@ -0,0 +1 @@
+"""Rolling-ball background subtraction plugin package."""

transforms/images/polus-rolling-ball-plugin/src/main.py

@@ -1,113 +1,125 @@
+"""CLI entrypoint for rolling-ball background subtraction on image collections."""
+from __future__ import annotations
+
 import argparse
 import logging
 from multiprocessing import cpu_count
 from pathlib import Path
 
 from bfio.bfio import BioReader
 from bfio.bfio import BioWriter
-
 from rolling_ball import rolling_ball
 
 # Initialize the logger
-logging.basicConfig(format='%(asctime)s - %(name)-8s - %(levelname)-8s - %(message)s',
-                    datefmt='%d-%b-%y %H:%M:%S')
+logging.basicConfig(
+    format="%(asctime)s - %(name)-8s - %(levelname)-8s - %(message)s",
+    datefmt="%d-%b-%y %H:%M:%S",
+)
 logger = logging.getLogger("main")
 logger.setLevel(logging.INFO)
 
 
 def main(
-        input_dir: Path,
-        ball_radius: int,
-        light_background: bool,
-        output_dir: Path,
+    input_dir: Path,
+    ball_radius: int,
+    light_background: bool,
+    output_dir: Path,
 ) -> None:
-    """ Main execution function
+    """Process each image in ``input_dir`` and write results to ``output_dir``.
 
     Args:
-        input_dir: path to directory containing the input images.
-        ball_radius: radius of ball to use for the rolling-ball algorithm.
-        light_background: whether the image has a light or dark background.
-        output_dir: path to directory where to store the output images.
+        input_dir: Directory containing input images.
+        ball_radius: Radius for the rolling-ball algorithm.
+        light_background: Whether the image has a light or dark background.
+        output_dir: Directory for output images.
     """
-
-    for in_path in input_dir.iterdir():
-        in_path = Path(in_path)
+    for path in input_dir.iterdir():
+        in_path = Path(path)
         out_path = Path(output_dir).joinpath(in_path.name)
 
         # Load the input image
         with BioReader(in_path) as reader:
-            logger.info(f'Working on {in_path.name} with shape {reader.shape}')
+            logger.info(f"Working on {in_path.name} with shape {reader.shape}")
 
             # Initialize the output image
-            with BioWriter(out_path, metadata=reader.metadata, max_workers=cpu_count()) as writer:
+            with BioWriter(
+                out_path,
+                metadata=reader.metadata,
+                max_workers=cpu_count(),
+            ) as writer:
                 rolling_ball(
                     reader=reader,
                     writer=writer,
                     ball_radius=ball_radius,
                     light_background=light_background,
                 )
-    return
 
 
 if __name__ == "__main__":
-    """ Argument parsing """
     logger.info("Parsing arguments...")
-    parser = argparse.ArgumentParser(prog='main', description='A WIPP plugin to perform background subtraction using the rolling-ball algorithm.')
-    
+    parser = argparse.ArgumentParser(
+        prog="main",
+        description=(
+            "A WIPP plugin to perform background subtraction using the "
+            "rolling-ball algorithm."
+        ),
+    )
+
     # Input arguments
     parser.add_argument(
-        '--inputDir',
-        dest='input_dir',
+        "--inputDir",
+        dest="input_dir",
         type=str,
-        help='Input image collection to be processed by this plugin.',
+        help="Input image collection to be processed by this plugin.",
         required=True,
     )
     parser.add_argument(
-        '--ballRadius',
-        dest='ball_radius',
+        "--ballRadius",
+        dest="ball_radius",
         type=str,
-        default='25',
-        help='Radius of the ball used to perform background subtraction.',
+        default="25",
+        help="Radius of the ball used to perform background subtraction.",
         required=False,
     )
     parser.add_argument(
-        '--lightBackground',
-        dest='light_background',
+        "--lightBackground",
+        dest="light_background",
         type=str,
-        default='false',
-        help='Whether the image has a light or dark background.',
+        default="false",
+        help="Whether the image has a light or dark background.",
         required=False,
     )
     # Output arguments
     parser.add_argument(
-        '--outputDir',
-        dest='output_dir',
+        "--outputDir",
+        dest="output_dir",
         type=str,
-        help='Output collection',
+        help="Output collection",
         required=True,
     )
-    
+
     # Parse the arguments
     args = parser.parse_args()
 
     _input_dir = Path(args.input_dir).resolve()
-    if _input_dir.joinpath('images').is_dir():
+    if _input_dir.joinpath("images").is_dir():
         # switch to images folder if present
-        _input_dir = _input_dir.joinpath('images').resolve()
-    logger.info(f'inputDir = {_input_dir}')
+        _input_dir = _input_dir.joinpath("images").resolve()
+    logger.info(f"inputDir = {_input_dir}")
 
     _ball_radius = int(args.ball_radius)
-    logger.info(f'ballRadius = {_ball_radius}')
+    logger.info(f"ballRadius = {_ball_radius}")
 
     _light_background = args.light_background
-    if _light_background in {'true', 'false'}:
-        _light_background = (_light_background == 'true')
+    if _light_background in {"true", "false"}:
+        _light_background = _light_background == "true"
     else:
-        raise ValueError(f'lightBackground must be either \'true\' or \'false\'')
-    logger.info(f'lightBackground = {_light_background}')
+        msg = "lightBackground must be either 'true' or 'false'"
+        raise ValueError(msg)
+    logger.info(f"lightBackground = {_light_background}")
 
     _output_dir = args.output_dir
-    logger.info(f'outputDir = {_output_dir}')
+    logger.info(f"outputDir = {_output_dir}")
 
     main(
         input_dir=_input_dir,

transforms/images/polus-rolling-ball-plugin/src/rolling_ball.py

@@ -1,4 +1,7 @@
-import numpy
+"""Tiled rolling-ball background subtraction using scikit-image."""
+from __future__ import annotations
+
+import numpy as np
 from bfio.bfio import BioReader
 from bfio.bfio import BioWriter
 from skimage import restoration
@@ -8,43 +11,58 @@
 TILE_SIZE = 1024
 
 
-def _rolling_ball(tile, ball_radius: int, light_background: bool):
-    """ Applies the rolling-ball algorithm to a single tile.
+def _rolling_ball(
+    tile: np.ndarray,
+    ball_radius: int,
+    light_background: bool,
+) -> np.ndarray:
+    """Apply rolling-ball to a single tile.
 
     Args:
         tile: A tile, usually from an ome.tif file.
-        ball_radius: The radius of the ball to use for calculating the background.
+        ball_radius: Radius of the ball for background estimation.
         light_background: Whether the image has a light background.
 
     Returns:
-        An image with its background subtracted away.
+        Image with background subtracted.
     """
     # Get the shape of the original image, so we can reshape the result at the end.
-    shape = numpy.shape(tile)
+    shape = np.shape(tile)
 
     # squeeze the image into a 2-d array
-    tile = numpy.squeeze(tile)
+    tile = np.squeeze(tile)
 
     # invert the image if it has a light background
     if light_background:
         tile = util.invert(tile)
 
-    # use the rolling ball algorithm to calculate the background and subtract it from the image.
+    # rolling ball background, then subtract from the image
     background = restoration.rolling_ball(tile, radius=ball_radius)
     tile = tile - background
 
-    # if the image had a light backend, invert the result.
+    # if the image had a light background, invert the result.
     result = util.invert(tile) if light_background else tile
 
-    result = numpy.reshape(result, shape)
-    return result
+    return np.reshape(result, shape)
+
 
+def _bounds(
+    x: int,
+    x_max: int,
+    ball_radius: int,
+) -> tuple[int, int, int, int, int]:
+    """Compute tile and padding indices along one axis.
 
-def _bounds(x, x_max, ball_radius):
-    """ Calculates the indices for handling the edges of tiles.
+    Each tile is padded with up to ``ball_radius`` pixels from the full image along
+    the edges.
+
+    Args:
+        x: Start index along the axis.
+        x_max: Image extent along the axis.
+        ball_radius: Ball radius used for padding.
 
-    We pad each tile with 'ball_radius' pixels from the full image along the
-     top, bottom, left, and right edges of each tile.
+    Returns:
+        ``row_max, pad_left, pad_right, tile_left, tile_right``
     """
     row_max = min(x_max, x + TILE_SIZE)
     pad_left = max(0, x - ball_radius)
@@ -56,33 +74,39 @@ def _bounds(x, x_max, ball_radius):
 
 
 def rolling_ball(
-        reader: BioReader,
-        writer: BioWriter,
-        ball_radius: int,
-        light_background: bool,
-):
-    """ Applies the rolling-ball algorithm from skimage to perform background subtraction.
+    reader: BioReader,
+    writer: BioWriter,
+    ball_radius: int,
+    light_background: bool,
+) -> None:
+    """Apply rolling-ball per Z slice, tiled in XY, and write to ``writer``.
 
-    This function processes the image in tiles and, therefore, scales to images of any size.
-    It writes the resulting image to the given BioWriter object.
+    Processes the image in tiles so it scales to large images.
 
     Args:
-        reader: BioReader object from which to read the image.
-        writer: BioWriter object to which to write the image.
-        ball_radius: The radius of the ball to use for calculating the background.
-                     This should be greater than the radii of relevant objects in the image.
-        light_background: Whether the image has a light background.
-
+        reader: Source image reader.
+        writer: Destination writer (metadata should match reader).
+        ball_radius: Rolling-ball radius; should exceed object radii of interest.
+        light_background: Whether the scene has a light background.
     """
     for z in range(reader.Z):
-
         for y in range(0, reader.Y, TILE_SIZE):
-            y_max, pad_top, pad_bottom, tile_top, tile_bottom = _bounds(y, reader.Y, ball_radius)
+            y_max, pad_top, pad_bottom, tile_top, tile_bottom = _bounds(
+                y,
+                reader.Y,
+                ball_radius,
+            )
 
             for x in range(0, reader.X, TILE_SIZE):
-                x_max, pad_left, pad_right, tile_left, tile_right = _bounds(x, reader.X, ball_radius)
+                x_max, pad_left, pad_right, tile_left, tile_right = _bounds(
+                    x,
+                    reader.X,
+                    ball_radius,
+                )
 
-                tile = reader[pad_top:pad_bottom, pad_left:pad_right, z:z + 1, 0, 0]
+                tile = reader[pad_top:pad_bottom, pad_left:pad_right, z : z + 1, 0, 0]
                 result = _rolling_ball(tile, ball_radius, light_background)
-                writer[y:y_max, x:x_max, z:z + 1, 0, 0] = result[tile_top:tile_bottom, tile_left:tile_right]
-    return
+                writer[y:y_max, x:x_max, z : z + 1, 0, 0] = result[
+                    tile_top:tile_bottom,
+                    tile_left:tile_right,
+                ]