cellprofiler-library-nightly 5.0.0.dev340__tar.gz → 5.0.0.dev351__tar.gz

{cellprofiler_library_nightly-5.0.0.dev340 → cellprofiler_library_nightly-5.0.0.dev351}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev340
+Version: 5.0.0.dev351
 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.dev340 → cellprofiler_library_nightly-5.0.0.dev351}/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.dev340'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev340')
+__version__ = version = '5.0.0.dev351'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev351')
 
-__commit_id__ = commit_id = 'g1e60a51df'
+__commit_id__ = commit_id = 'gf1998bdae'

{cellprofiler_library_nightly-5.0.0.dev340 → cellprofiler_library_nightly-5.0.0.dev351}/cellprofiler_library/functions/image_processing.py

@@ -16,6 +16,7 @@ from cellprofiler_library.opts.crop import RemovalMethod
 from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
 
 T = TypeVar("T", bound=ImageAny)
+MorphImageT = TypeVar("Union[ImageGrayscale, ImageGrayscaleMask]", bound=Union[ImageGrayscale, ImageGrayscaleMask])
 
 def rgb_to_greyscale(image):
     if image.shape[-1] == 4:
@@ -1128,3 +1129,219 @@ def suppress(
     footprint = __structuring_element(radius, im_volumetric)
     result = skimage.morphology.opening(data, footprint)
     return __unmask(result, im_pixel_data, im_mask)
+
+
+################################################################################
+# Morphological Operations (from Morph module)
+################################################################################
+
+
+def apply_branchpoints(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        ) -> MorphImageT:
+    """Apply branchpoints morphological operation.
+    
+    Removes all pixels except those that are the branchpoints of a skeleton.
+    This operation should be applied to an image after skeletonizing.
+    """
+    return centrosome.cpmorphology.branchpoints(pixel_data, mask)
+
+def apply_bridge(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> MorphImageT:
+    """Apply bridge morphological operation.
+    
+    Sets a pixel to 1 if it has two non-zero neighbors that are on
+    opposite sides of this pixel.
+    """
+    return centrosome.cpmorphology.bridge(pixel_data, mask, count)
+
+def apply_clean(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply clean morphological operation.
+    
+    Removes isolated pixels.
+    """
+    return centrosome.cpmorphology.clean(pixel_data, mask, count)
+
+def apply_convex_hull(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        ) -> ImageGrayscale:
+    """Apply convex hull morphological operation.
+    
+    Finds the convex hull of a binary image.
+    """
+    if mask is None:
+        return centrosome.cpmorphology.convex_hull_image(pixel_data)
+    else:
+        return centrosome.cpmorphology.convex_hull_image(pixel_data & mask)
+
+def apply_diag(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply diag morphological operation.
+    
+    Fills in pixels whose neighbors are diagonally connected to 4-connect
+    pixels that are 8-connected.
+    """
+    return centrosome.cpmorphology.diag(pixel_data, mask, count)
+
+def apply_distance(
+        pixel_data: MorphImageT,
+        rescale_values: bool,
+        ) -> ImageGrayscale:
+    """Apply distance transform morphological operation.
+    
+    Computes the distance transform of a binary image.
+    """
+    image = scipy.ndimage.distance_transform_edt(pixel_data)
+    if rescale_values:
+        image = image / numpy.max(image)
+    return image
+
+def apply_endpoints(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        ) -> ImageGrayscale:
+    """Apply endpoints morphological operation.
+    
+    Removes all pixels except the ones that are at the end of a skeleton.
+    """
+    return centrosome.cpmorphology.endpoints(pixel_data, mask)
+
+def apply_fill(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply fill morphological operation.
+    
+    Sets a pixel to 1 if all of its neighbors are 1.
+    """
+    return centrosome.cpmorphology.fill(pixel_data, mask, count)
+
+def apply_hbreak(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply hbreak morphological operation.
+    
+    Removes pixels that form vertical bridges between horizontal lines.
+    """
+    return centrosome.cpmorphology.hbreak(pixel_data, mask, count)
+
+def apply_majority(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply majority morphological operation.
+    
+    Each pixel takes on the value of the majority that surround it.
+    """
+    return centrosome.cpmorphology.majority(pixel_data, mask, count)
+
+def apply_openlines(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        linelength: int,
+        ) -> ImageGrayscale:
+    """Apply openlines morphological operation.
+    
+    Performs an erosion followed by a dilation using rotating linear structural
+    elements.
+    """
+    return centrosome.cpmorphology.openlines(pixel_data, linelength=linelength, mask=mask)
+
+def apply_remove(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply remove morphological operation.
+    
+    Removes pixels that are otherwise surrounded by others (4 connected).
+    """
+    return centrosome.cpmorphology.remove(pixel_data, mask, count)
+
+def apply_shrink(
+        pixel_data: MorphImageT,
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply shrink morphological operation.
+    
+    Performs a thinning operation that erodes unless that operation would change
+    the image's Euler number.
+    """
+    return centrosome.cpmorphology.binary_shrink(pixel_data, count)
+
+def apply_skelpe(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        ) -> ImageGrayscale:
+    """Apply skelpe morphological operation.
+    
+    Performs a skeletonizing operation using the metric, PE * D to control the
+    erosion order.
+    """
+    return centrosome.cpmorphology.skeletonize(
+        pixel_data,
+        mask,
+        scipy.ndimage.distance_transform_edt(pixel_data)
+        * centrosome.filter.poisson_equation(pixel_data),
+    )
+
+def apply_spur(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply spur morphological operation.
+    
+    Removes spur pixels, i.e., pixels that have exactly one 8-connected neighbor.
+    """
+    return centrosome.cpmorphology.spur(pixel_data, mask, count)
+
+def apply_thicken(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply thicken morphological operation.
+    
+    Dilates the exteriors of objects where that dilation does not 8-connect the
+    object with another.
+    """
+    return centrosome.cpmorphology.thicken(pixel_data, mask, count)
+
+def apply_thin(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        count: int,
+        ) -> ImageGrayscale:
+    """Apply thin morphological operation.
+    
+    Thin lines preserving the Euler number using the thinning algorithm.
+    """
+    return centrosome.cpmorphology.thin(pixel_data, mask, count)
+
+def apply_vbreak(
+        pixel_data: MorphImageT,
+        mask: Optional[ImageGrayscaleMask],
+        ) -> ImageGrayscale:
+    """Apply vbreak morphological operation.
+    
+    Removes pixels that form horizontal bridges between vertical lines.
+    """
+    return centrosome.cpmorphology.vbreak(pixel_data, mask)
+

{cellprofiler_library_nightly-5.0.0.dev340 → cellprofiler_library_nightly-5.0.0.dev351}/cellprofiler_library/functions/object_processing.py

@@ -629,3 +629,50 @@ def erode_objects_with_structuring_element(
     
     return y_data
 
+################################################################################
+# DilateObjects
+################################################################################
+
+def dilate_objects_with_structuring_element(
+    labels: ObjectSegmentation,
+    structuring_element: StructuringElement
+) -> ObjectSegmentation:
+    """Dilate objects based on the structuring element provided.
+    
+    This function is similar to the "Expand" function of ExpandOrShrinkObjects,
+    with two major distinctions:
+    1. DilateObjects supports 3D objects, unlike ExpandOrShrinkObjects.
+    2. In ExpandOrShrinkObjects, two objects closer than the expansion distance
+       will expand until they meet and then stop there. In this module, the object with
+       the larger object number (the object that is lower in the image) will be expanded
+       on top of the object with the smaller object number.
+    
+    Args:
+        labels: Input labeled objects array
+        structuring_element: Structuring element for dilation operation
+        
+    Returns:
+        Dilated objects array with same dimensions as input
+    """
+    is_strel_2d = structuring_element.ndim == 2
+
+    is_img_2d = labels.ndim == 2
+
+    if is_strel_2d and not is_img_2d:
+        y_data = numpy.zeros_like(labels)
+
+        for index, plane in enumerate(labels):
+
+            y_data[index] = skimage.morphology.dilation(plane, structuring_element)
+
+        return y_data
+
+    if not is_strel_2d and is_img_2d:
+        raise NotImplementedError(
+            "A 3D structuring element cannot be applied to a 2D image."
+        )
+
+    y_data = skimage.morphology.dilation(labels, structuring_element)
+    
+    return y_data
+

cellprofiler_library_nightly-5.0.0.dev351/cellprofiler_library/modules/_dilateobjects.py

@@ -0,0 +1,46 @@
+# coding=utf-8
+
+"""
+DilateObjects module for the CellProfiler library.
+
+This module contains the core algorithms for object dilation operations.
+"""
+
+from pydantic import validate_call, ConfigDict, Field
+from typing import Union, Tuple, Annotated
+from cellprofiler_library.types import StructuringElement, ObjectSegmentation
+from cellprofiler_library.functions.object_processing import dilate_objects_with_structuring_element
+from cellprofiler_library.functions.image_processing import get_structuring_element
+from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
+
+StructuringElementSize = Annotated[int, Field(description="Size of structuring element", gt=0)]
+StructuringElementParameters = Tuple[Union[StructuringElementShape2D, StructuringElementShape3D], StructuringElementSize]
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def dilate_objects(
+    labels: Annotated[ObjectSegmentation, Field(description="Input object segmentations")],
+    structuring_element: Annotated[Union[StructuringElement, StructuringElementParameters], Field(description="Structuring element for dilation operation as either an NDArray or a tuple of (StructuringElement[N]D, size)")],
+) -> ObjectSegmentation:
+    """Dilate objects based on the structuring element provided.
+    
+    This function is similar to the "Expand" function of ExpandOrShrinkObjects,
+    with two major distinctions:
+    1. DilateObjects supports 3D objects, unlike ExpandOrShrinkObjects.
+    2. In ExpandOrShrinkObjects, two objects closer than the expansion distance
+       will expand until they meet and then stop there. In this module, the object with
+       the larger object number (the object that is lower in the image) will be expanded
+       on top of the object with the smaller object number.
+    
+    Args:
+        labels: Input labeled objects array
+        structuring_element: Structuring element for dilation operation
+        
+    Returns:
+        Dilated objects array with same dimensions as input
+    """
+    if isinstance(structuring_element, tuple):
+        structuring_element = get_structuring_element(structuring_element[0], structuring_element[1])
+    return dilate_objects_with_structuring_element(
+        labels=labels,
+        structuring_element=structuring_element
+    )

cellprofiler_library_nightly-5.0.0.dev351/cellprofiler_library/modules/_morph.py

@@ -0,0 +1,128 @@
+import logging
+from typing import Annotated, Optional, List, Dict, Any
+from pydantic import validate_call, Field, ConfigDict
+
+from ..opts.morph import MorphFunction
+from ..functions.image_processing import (
+    apply_branchpoints,
+    apply_bridge, 
+    apply_clean,
+    apply_convex_hull,
+    apply_diag,
+    apply_distance,
+    apply_endpoints,
+    apply_fill,
+    apply_hbreak,
+    apply_majority,
+    apply_openlines,
+    apply_remove,
+    apply_shrink,
+    apply_skelpe,
+    apply_spur,
+    apply_thicken,
+    apply_thin,
+    apply_vbreak,
+    MorphImageT
+)
+from ..types import ImageGrayscaleMask
+
+LOGGER = logging.getLogger(__name__)
+
+def morph_operation(
+        pixel_data:     Annotated[MorphImageT, Field(description="Image array supporting binary, integer, or float types")],
+        mask:           Annotated[Optional[ImageGrayscaleMask], Field(description="Optional boolean mask array")],
+        function_name:  Annotated[MorphFunction, Field(description="Morphological operation to perform")],
+        repeat_count:   Annotated[int, Field(description="Number of times to repeat the operation", ge=1)],
+        custom_repeats: Annotated[int, Field(description="Custom repeat value for specific operations", ge=1)],
+        rescale_values: Annotated[bool, Field(description="Whether to rescale distance values from 0 to 1")],
+        ) -> MorphImageT:
+    """Apply a morphological operation to the image, routing to appropriate function from functions layer."""
+    count = repeat_count
+
+    is_binary = pixel_data.dtype.kind == "b"
+
+    if (
+        function_name != MorphFunction.OPENLINES and not is_binary
+    ):
+        # Apply a very crude threshold to the image for binary algorithms
+        LOGGER.warning(
+            "Warning: converting image to binary for %s\n" % function_name
+        )
+        pixel_data = pixel_data != 0
+
+    # Route to appropriate function from functions layer
+    if function_name == MorphFunction.BRANCHPOINTS:
+        return apply_branchpoints(pixel_data, mask)
+    elif function_name == MorphFunction.BRIDGE:
+        return apply_bridge(pixel_data, mask, count)
+    elif function_name == MorphFunction.CLEAN:
+        return apply_clean(pixel_data, mask, count)
+    elif function_name == MorphFunction.CONVEX_HULL:
+        return apply_convex_hull(pixel_data, mask)
+    elif function_name == MorphFunction.DIAG:
+        return apply_diag(pixel_data, mask, count)
+    elif function_name == MorphFunction.DISTANCE:
+        return apply_distance(pixel_data, rescale_values)
+    elif function_name == MorphFunction.ENDPOINTS:
+        return apply_endpoints(pixel_data, mask)
+    elif function_name == MorphFunction.FILL:
+        return apply_fill(pixel_data, mask, count)
+    elif function_name == MorphFunction.HBREAK:
+        return apply_hbreak(pixel_data, mask, count)
+    elif function_name == MorphFunction.MAJORITY:
+        return apply_majority(pixel_data, mask, count)
+    elif function_name == MorphFunction.OPENLINES:
+        return apply_openlines(pixel_data, mask, custom_repeats)
+    elif function_name == MorphFunction.REMOVE:
+        return apply_remove(pixel_data, mask, count)
+    elif function_name == MorphFunction.SHRINK:
+        return apply_shrink(pixel_data, count)
+    elif function_name == MorphFunction.SKELPE:
+        return apply_skelpe(pixel_data, mask)
+    elif function_name == MorphFunction.SPUR:
+        return apply_spur(pixel_data, mask, count)
+    elif function_name == MorphFunction.THICKEN:
+        return apply_thicken(pixel_data, mask, count)
+    elif function_name == MorphFunction.THIN:
+        return apply_thin(pixel_data, mask, count)
+    elif function_name == MorphFunction.VBREAK:
+        return apply_vbreak(pixel_data, mask)
+    else:
+        raise NotImplementedError(
+            "Unimplemented morphological function: %s" % function_name
+        )
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def apply_morphological_operations(
+        pixel_data:         Annotated[MorphImageT, Field(description="Image array supporting binary, integer, or float types")],
+        mask:               Annotated[Optional[ImageGrayscaleMask], Field(description="Optional boolean mask array")] = None,
+        operations_list:    Annotated[List[Dict[str, Any]], Field(description="List of morphological operations to apply sequentially")] = [],
+        ) -> MorphImageT:
+    """Apply a sequence of morphological operations to the image.
+    
+    Args:
+        pixel_data: Input image pixel data to process
+        mask: Optional image mask to constrain operations
+        operations_list: List of operation dictionaries, each containing:
+            - function_name: Name of morphological operation (MorphFunction enum)
+            - repeat_count: Number of times to repeat the operation
+            - custom_repeats: Custom repeat value for specific operations
+            - rescale_values: Whether to rescale distance values from 0 to 1
+    
+    Returns:
+        Processed pixel data array with applied morphological operations
+    """
+    result_pixel_data = pixel_data
+    
+    for operation in operations_list:
+        result_pixel_data = morph_operation(
+            result_pixel_data,
+            mask,
+            operation["function_name"],
+            operation["repeat_count"],
+            operation["custom_repeats"],
+            operation["rescale_values"]
+        )
+    
+    return result_pixel_data

cellprofiler_library_nightly-5.0.0.dev351/cellprofiler_library/opts/dilateobjects.py

@@ -0,0 +1,15 @@
+# coding=utf-8
+
+"""
+Options and enums for DilateObjects module
+"""
+
+# Note: DilateObjects is a simple morphological operation module that doesn't require
+# complex enums. The main configuration is handled through the StructuringElement
+# setting which is managed by the core framework. This file is created for 
+# consistency with the refactoring pattern but may be minimal.
+
+# Currently no custom enums needed for DilateObjects as it uses standard
+# StructuringElement configuration from cellprofiler_core. For structuring element shapes,
+# see cellprofiler_library.opts.structuring_elements
+

cellprofiler_library_nightly-5.0.0.dev351/cellprofiler_library/opts/morph.py

@@ -0,0 +1,44 @@
+from enum import Enum
+
+
+class MorphFunction(str, Enum):
+    """Morphological operations available in the Morph module."""
+    BRANCHPOINTS = "branchpoints"
+    BRIDGE = "bridge"
+    CLEAN = "clean"
+    CONVEX_HULL = "convex hull"
+    DIAG = "diag"
+    DISTANCE = "distance"
+    ENDPOINTS = "endpoints"
+    FILL = "fill"
+    HBREAK = "hbreak"
+    MAJORITY = "majority"
+    OPENLINES = "openlines"
+    REMOVE = "remove"
+    SHRINK = "shrink"
+    SKELPE = "skelpe"
+    SPUR = "spur"
+    THICKEN = "thicken"
+    THIN = "thin"
+    VBREAK = "vbreak"
+
+MorphFunctions_All = [
+    MorphFunction.BRANCHPOINTS.value,
+    MorphFunction.BRIDGE.value,
+    MorphFunction.CLEAN.value,
+    MorphFunction.CONVEX_HULL.value,
+    MorphFunction.DIAG.value,
+    MorphFunction.DISTANCE.value,
+    MorphFunction.ENDPOINTS.value,
+    MorphFunction.FILL.value,
+    MorphFunction.HBREAK.value,
+    MorphFunction.MAJORITY.value,
+    MorphFunction.OPENLINES.value,
+    MorphFunction.REMOVE.value,
+    MorphFunction.SHRINK.value,
+    MorphFunction.SKELPE.value,
+    MorphFunction.SPUR.value,
+    MorphFunction.THICKEN.value,
+    MorphFunction.THIN.value,
+    MorphFunction.VBREAK.value,
+]

{cellprofiler_library_nightly-5.0.0.dev340 → cellprofiler_library_nightly-5.0.0.dev351}/cellprofiler_library_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev340
+Version: 5.0.0.dev351
 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.dev340 → cellprofiler_library_nightly-5.0.0.dev351}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ cellprofiler_library/modules/_convertobjectstoimage.py
 cellprofiler_library/modules/_correctilluminationapply.py
 cellprofiler_library/modules/_crop.py
 cellprofiler_library/modules/_dilateimage.py
+cellprofiler_library/modules/_dilateobjects.py
 cellprofiler_library/modules/_enhanceedges.py
 cellprofiler_library/modules/_enhanceorsuppressfeatures.py
 cellprofiler_library/modules/_erodeimage.py
@@ -32,6 +33,7 @@ cellprofiler_library/modules/_measureimageoverlap.py
 cellprofiler_library/modules/_measureobjectsizeshape.py
 cellprofiler_library/modules/_medialaxis.py
 cellprofiler_library/modules/_medianfilter.py
+cellprofiler_library/modules/_morph.py
 cellprofiler_library/modules/_morphologicalskeleton.py
 cellprofiler_library/modules/_opening.py
 cellprofiler_library/modules/_overlayobjects.py
@@ -46,10 +48,12 @@ cellprofiler_library/opts/convertobjectstoimage.py
 cellprofiler_library/opts/correctilluminationapply.py
 cellprofiler_library/opts/crop.py
 cellprofiler_library/opts/dilateimage.py
+cellprofiler_library/opts/dilateobjects.py
 cellprofiler_library/opts/enhanceorsuppressfeatures.py
 cellprofiler_library/opts/erodeimage.py
 cellprofiler_library/opts/erodeobjects.py
 cellprofiler_library/opts/measureimageoverlap.py
+cellprofiler_library/opts/morph.py
 cellprofiler_library/opts/objectsizeshapefeatures.py
 cellprofiler_library/opts/structuring_elements.py
 cellprofiler_library/opts/threshold.py