cellprofiler-library-nightly 5.0.0.dev411__tar.gz → 5.0.0.dev413__tar.gz

{cellprofiler_library_nightly-5.0.0.dev411 → cellprofiler_library_nightly-5.0.0.dev413}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev411
+Version: 5.0.0.dev413
 Summary: cellprofiler-library implements CellProfiler's image processing and mathematical code, and is usable as a standalone library
 Author: Anne Carpenter, Thouis (Ray) Jones, Lee Kamentsky, Vebjorn Ljosa, David Logan, Mark Bray, Madison Swain-Bowden, Allen Goodman, Claire McQuinn, Alice Lucas, Callum Tromans-Coia
 Author-email: Beth Cimini <bcimini@broadinstitute.org>, David Stirling <dstirling@glencoesoftware.com>, Nodar Gogoberidze <ngogober@broadinstitute.org>

{cellprofiler_library_nightly-5.0.0.dev411 → cellprofiler_library_nightly-5.0.0.dev413}/cellprofiler_library/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev411'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev411')
+__version__ = version = '5.0.0.dev413'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev413')
 
-__commit_id__ = commit_id = 'g5694c5021'
+__commit_id__ = commit_id = 'gd6becfb42'

{cellprofiler_library_nightly-5.0.0.dev411 → cellprofiler_library_nightly-5.0.0.dev413}/cellprofiler_library/functions/image_processing.py

@@ -3,21 +3,26 @@ import skimage.color
 import skimage.morphology
 import skimage.segmentation
 import skimage.util
+import skimage.transform
+import skimage
+import skimage.restoration
 import centrosome
 import centrosome.threshold
 import centrosome.filter
 import scipy
+import scipy.interpolate
 import matplotlib
 import math
 from numpy.typing import NDArray
 import centrosome.filter
 from typing import Any, Optional, Tuple, Callable, Union, List, TypeVar
-from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ImageAnyMask, ObjectSegmentation, Image2D, Image2DMask, StructuringElement, ObjectLabelSet, ImageColor
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ImageAnyMask, ObjectSegmentation, Image2D, Image2DMask, StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask
 from cellprofiler_library.opts import threshold as Threshold
 from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
 from cellprofiler_library.opts.overlayoutlines import BrightnessMode
 from cellprofiler_library.opts.crop import RemovalMethod
 from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
+from ..opts.resize import ResizingMethod, DimensionMethod, InterpolationMethod
 
 T = TypeVar("T", bound=ImageAny)
 MorphImageT = TypeVar("Union[ImageGrayscale, ImageGrayscaleMask]", bound=Union[ImageGrayscale, ImageGrayscaleMask])
@@ -221,6 +226,156 @@ def reduce_noise(image, patch_size, patch_distance, cutoff_distance, channel_axi
     return denoised
 
 
+################################################################################
+# Resize Functions
+################################################################################
+
+def resized_shape(
+    im_pixel_data: ImageAny,
+    im_dimensions: int,
+    size_method: str,
+    resizing_factor_x: float,
+    resizing_factor_y: float,
+    resizing_factor_z: Optional[float],
+    use_manual_or_image: DimensionMethod,
+    specific_width: Optional[int],
+    specific_height: Optional[int],
+    specific_planes: Optional[int],
+    reference_image_shape: Optional[Tuple[int, ...]] = None,
+) -> NDArray[numpy.int_]:
+    """Calculate target dimensions based on resize method."""
+    im_volumetric = True if im_dimensions == 3 else False
+    im_multichannel = True if im_pixel_data.ndim > im_dimensions else False
+    
+    
+    shape = numpy.array(im_pixel_data.shape).astype(float)
+
+    if size_method == ResizingMethod.BY_FACTOR:
+        factor_x = resizing_factor_x
+        factor_y = resizing_factor_y
+
+        if im_volumetric:
+            assert resizing_factor_z is not None, "Z-axis scaling factor must be specified when resizing by factor"
+            factor_z = resizing_factor_z
+            height, width = shape[1:3]
+            planes = shape[0]
+            planes = numpy.round(planes * factor_z)
+        else:
+            height, width = shape[:2]
+
+        height = numpy.round(height * factor_y)
+        width = numpy.round(width * factor_x)
+
+    else:
+        if use_manual_or_image == DimensionMethod.MANUAL:
+            assert specific_height is not None, "Specific height must be specified when using manual dimensions"
+            assert specific_width is not None, "Specific width must be specified when using manual dimensions"
+            height = specific_height
+            width = specific_width
+            if im_volumetric:
+                assert specific_planes is not None, "Specific planes must be specified when using manual dimensions"
+                planes = specific_planes
+        else:
+            assert reference_image_shape is not None, "Reference image shape must be provided when using image-based dimensions"
+
+            if im_volumetric:
+                planes, height, width = reference_image_shape[:3]
+            else:
+                height, width = reference_image_shape[:2]
+
+    new_shape = []
+
+    if im_volumetric:
+        new_shape += [planes]
+
+    new_shape += [height, width]
+
+    if im_multichannel:
+        new_shape += [shape[-1]]
+
+    return numpy.asarray(new_shape)
+
+
+def spline_order(interpolation_method: str) -> int:
+    """Determine interpolation order from method."""
+    
+    if interpolation_method == InterpolationMethod.NEAREST_NEIGHBOR:
+        return 0
+
+    if interpolation_method == InterpolationMethod.BILINEAR:
+        return 1
+
+    return 3
+
+
+def apply_resize(
+        im_pixel_data: ImageAny,
+        im_mask: ImageGrayscaleMask,
+        im_dimensions: int,
+        im_crop_mask: Optional[ImageGrayscaleMask],
+        size_method: str,
+        resizing_factor_x: float,
+        resizing_factor_y: float,
+        resizing_factor_z: Optional[float],
+        use_manual_or_image: DimensionMethod,
+        specific_width: Optional[int],
+        specific_height: Optional[int],
+        specific_planes: Optional[int],
+        reference_image_shape: Optional[Tuple[int, ...]] = None,
+        interpolation_method: str = "bilinear",
+    ) -> Tuple[ImageAny, ImageGrayscaleMask, Optional[ImageBinaryMask]]:
+    
+    new_shape = resized_shape(
+        im_pixel_data,
+        im_dimensions,
+        size_method,
+        resizing_factor_x,
+        resizing_factor_y,
+        resizing_factor_z,
+        use_manual_or_image,
+        specific_width,
+        specific_height,
+        specific_planes,
+        reference_image_shape,
+    )
+
+    order = spline_order(interpolation_method)
+    im_volumetric = True if im_dimensions == 3 else False
+    im_multichannel = True if im_pixel_data.ndim > im_dimensions else False
+    if im_volumetric and im_multichannel:
+        output_pixels = numpy.zeros(new_shape.astype(int), dtype=im_pixel_data.dtype)
+
+        for idx in range(int(new_shape[-1])):
+            output_pixels[:, :, :, idx] = skimage.transform.resize(
+                im_pixel_data[:, :, :, idx],
+                new_shape[:-1],
+                order=order,
+                mode="symmetric",
+            )
+    else:
+        output_pixels = skimage.transform.resize(
+            im_pixel_data, new_shape, order=order, mode="symmetric"
+        )
+
+    if im_multichannel and len(new_shape) > im_dimensions:
+        new_shape = new_shape[:-1]
+
+    mask = skimage.transform.resize(im_mask, new_shape, order=0, mode="constant")
+
+    mask = skimage.img_as_bool(mask)
+
+    if im_crop_mask is not None:
+        cropping = skimage.transform.resize(
+            im_crop_mask, new_shape, order=0, mode="constant"
+        )
+
+        cropping = skimage.img_as_bool(cropping)
+    else:
+        cropping = None
+
+    return output_pixels, mask, cropping
+
+
 def get_threshold_robust_background(
     image:                  ImageGrayscale,
     lower_outlier_fraction: float = 0.05,

cellprofiler_library_nightly-5.0.0.dev413/cellprofiler_library/modules/_resize.py

@@ -0,0 +1,50 @@
+"""Resize module core functionality.
+
+This module contains the extracted resize functions that implement
+the core image resizing algorithms.
+"""
+
+from typing import Annotated, Optional, Tuple
+from pydantic import Field, validate_call, ConfigDict
+
+from cellprofiler_library.types import ImageGrayscaleMask, ImageAny, ImageBinary
+from cellprofiler_library.functions.image_processing import apply_resize
+from cellprofiler_library.opts.resize import ResizingMethod, DimensionMethod, InterpolationMethod
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def resize_image(
+    im_pixel_data:          Annotated[ImageAny, Field(description="Input image pixel data array")],
+    im_mask:                Annotated[ImageGrayscaleMask, Field(description="Input image mask")],
+    im_dimensions:          Annotated[int, Field(description="Number of spatial dimensions in the image", ge=2, le=3)],
+    im_crop_mask:           Annotated[Optional[ImageBinary], Field(description="Image crop mask")],
+    size_method:            Annotated[ResizingMethod, Field(description="Method for determining resize dimensions")],
+    resizing_factor_x:      Annotated[float, Field(description="X-axis scaling factor", gt=0)],
+    resizing_factor_y:      Annotated[float, Field(description="Y-axis scaling factor", gt=0)],
+    resizing_factor_z:      Annotated[Optional[float], Field(description="Z-axis scaling factor", gt=0)],
+    use_manual_or_image:    Annotated[DimensionMethod, Field(description="Method for specifying dimensions")],
+    specific_width:         Annotated[Optional[int], Field(description="Specific width in pixels", ge=1)],
+    specific_height:        Annotated[Optional[int], Field(description="Specific height in pixels", ge=1)],
+    specific_planes:        Annotated[Optional[int], Field(description="Specific number of planes", ge=1)],
+    reference_image_shape:  Annotated[Optional[Tuple[int, ...]], Field(description="Shape of reference image for dimensions")],
+    interpolation_method:   Annotated[InterpolationMethod, Field(description="Interpolation method for resizing")],
+) -> Tuple[ImageAny, ImageGrayscaleMask, Optional[ImageBinary]]:
+    # Apply the resize operation using library
+    return apply_resize(
+        im_pixel_data,
+        im_mask,
+        im_dimensions,
+        im_crop_mask,
+        size_method,
+        resizing_factor_x,
+        resizing_factor_y,
+        resizing_factor_z,
+        use_manual_or_image,
+        specific_width,
+        specific_height,
+        specific_planes,
+        reference_image_shape,
+        interpolation_method,
+    )
+
+

cellprofiler_library_nightly-5.0.0.dev413/cellprofiler_library/opts/resize.py

@@ -0,0 +1,22 @@
+"""Resize module enums and configuration options."""
+
+from enum import Enum
+
+
+class ResizingMethod(str, Enum):
+    """Method for specifying resize dimensions."""
+    BY_FACTOR = "Resize by a fraction or multiple of the original size"
+    TO_SIZE = "Resize by specifying desired final dimensions"
+
+
+class DimensionMethod(str, Enum):
+    """Method for specifying target dimensions when resizing to size."""
+    MANUAL = "Manual"
+    IMAGE = "Image"
+
+
+class InterpolationMethod(str, Enum):
+    """Interpolation method for resize operation."""
+    NEAREST_NEIGHBOR = "Nearest Neighbor"
+    BILINEAR = "Bilinear"
+    BICUBIC = "Bicubic"

{cellprofiler_library_nightly-5.0.0.dev411 → cellprofiler_library_nightly-5.0.0.dev413}/cellprofiler_library_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev411
+Version: 5.0.0.dev413
 Summary: cellprofiler-library implements CellProfiler's image processing and mathematical code, and is usable as a standalone library
 Author: Anne Carpenter, Thouis (Ray) Jones, Lee Kamentsky, Vebjorn Ljosa, David Logan, Mark Bray, Madison Swain-Bowden, Allen Goodman, Claire McQuinn, Alice Lucas, Callum Tromans-Coia
 Author-email: Beth Cimini <bcimini@broadinstitute.org>, David Stirling <dstirling@glencoesoftware.com>, Nodar Gogoberidze <ngogober@broadinstitute.org>

{cellprofiler_library_nightly-5.0.0.dev411 → cellprofiler_library_nightly-5.0.0.dev413}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -40,6 +40,7 @@ cellprofiler_library/modules/_overlayobjects.py
 cellprofiler_library/modules/_overlayoutlines.py
 cellprofiler_library/modules/_reducenoise.py
 cellprofiler_library/modules/_removeholes.py
+cellprofiler_library/modules/_resize.py
 cellprofiler_library/modules/_savecroppedobjects.py
 cellprofiler_library/modules/_threshold.py
 cellprofiler_library/modules/_watershed.py
@@ -59,6 +60,7 @@ cellprofiler_library/opts/morph.py
 cellprofiler_library/opts/objectsizeshapefeatures.py
 cellprofiler_library/opts/overlayoutlines.py
 cellprofiler_library/opts/removeholes.py
+cellprofiler_library/opts/resize.py
 cellprofiler_library/opts/structuring_elements.py
 cellprofiler_library/opts/threshold.py
 cellprofiler_library_nightly.egg-info/PKG-INFO