cellprofiler-library-nightly 5.0.0.dev318__py3-none-any.whl → 5.0.0.dev324__py3-none-any.whl

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.dev318'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev318')
+__version__ = version = '5.0.0.dev324'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev324')
 
 __commit_id__ = commit_id = None

cellprofiler_library/functions/image_processing.py

@@ -5,9 +5,12 @@ import centrosome
 import centrosome.threshold
 import scipy
 import matplotlib
+import math
 from typing import Any, Optional, Tuple, Callable, Union, List
-from ..types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ObjectSegmentation, Image2D
-from ..opts import threshold as Threshold
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ObjectSegmentation, Image2D, Image2DMask, StructuringElement
+from cellprofiler_library.opts import threshold as Threshold
+from cellprofiler_library.opts.crop import RemovalMethod
+from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
 
 def rgb_to_greyscale(image):
     if image.shape[-1] == 4:
@@ -117,6 +120,47 @@ def morphological_skeleton_3d(image):
     return skimage.morphology.skeletonize_3d(image)
 
 
+################################################################################
+# Morphological Operations Helpers
+################################################################################
+
+def get_structuring_element(shape: Union[StructuringElementShape2D, StructuringElementShape3D], size: int) -> StructuringElement:
+    return getattr(skimage.morphology, shape.value.lower())(size)
+
+################################################################################
+# ErodeImage
+################################################################################
+
+def morphology_erosion(image: ImageAny, structuring_element: StructuringElement) -> ImageAny:
+    """Apply morphological erosion to an image.
+    
+    Args:
+        image: Input image (2D or 3D)
+        structuring_element: Structuring element for erosion
+        
+    Returns:
+        Eroded image with same dimensions as input
+    """
+    is_strel_2d = structuring_element.ndim == 2
+    is_img_2d = image.ndim == 2
+    
+    if is_strel_2d and not is_img_2d:
+        # Apply 2D structuring element to 3D image planewise
+        y_data = numpy.zeros_like(image)
+        for index, plane in enumerate(image):
+            y_data[index] = skimage.morphology.erosion(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."
+        )
+    
+    # Apply erosion directly for matching dimensions
+    y_data = skimage.morphology.erosion(image, structuring_element)
+    return y_data
+
+
 def median_filter(image, window_size, mode):
     return scipy.ndimage.median_filter(image, size=window_size, mode=mode)
 
@@ -634,3 +678,215 @@ def clip_low(output_pixels: Image2D) -> Image2D:
 
 def clip_high(output_pixels: Image2D) -> Image2D:
     return numpy.where(output_pixels > 1, 1, output_pixels)
+
+################################################################################
+# Crop
+################################################################################
+
+def get_ellipse_cropping(
+        orig_image_pixels:  Image2D,
+        ellipse_center:     Tuple[float, float],
+        ellipse_radius:     Tuple[float, float]
+    ) -> Image2DMask:
+    x_center, y_center = ellipse_center
+    x_radius, y_radius = ellipse_radius
+    x_max = orig_image_pixels.shape[1]
+    y_max = orig_image_pixels.shape[0]
+    if x_radius > y_radius:
+        dist_x = math.sqrt(x_radius ** 2 - y_radius ** 2)
+        dist_y = 0
+        major_radius = x_radius
+    else:
+        dist_x = 0
+        dist_y = math.sqrt(y_radius ** 2 - x_radius ** 2)
+        major_radius = y_radius
+
+    focus_1_x, focus_1_y = (x_center - dist_x, y_center - dist_y)
+    focus_2_x, focus_2_y = (x_center + dist_x, y_center + dist_y)
+    y, x = numpy.mgrid[0:y_max, 0:x_max]
+    d1 = numpy.sqrt((x - focus_1_x) ** 2 + (y - focus_1_y) ** 2)
+    d2 = numpy.sqrt((x - focus_2_x) ** 2 + (y - focus_2_y) ** 2)
+    cropping = d1 + d2 <= major_radius * 2
+    return cropping
+
+
+def get_rectangle_cropping(
+    orig_image_pixels:      Image2D,
+    bounding_box:           Tuple[Optional[int], Optional[int], Optional[int], Optional[int]],
+    validate_boundaries:    bool = True
+) -> Image2DMask:
+    cropping = numpy.ones(orig_image_pixels.shape[:2], bool)
+    left, right, top, bottom = bounding_box
+    if validate_boundaries:
+        if left and left > 0:
+            cropping[:, :left] = False
+        if right and right < cropping.shape[1]:
+            cropping[:, right:] = False
+        if top and top > 0:
+            cropping[:top, :] = False
+        if bottom and bottom < cropping.shape[0]:
+            cropping[bottom:, :] = False
+    else:
+        cropping[:, :left] = False
+        cropping[:, right:] = False
+        cropping[:top, :] = False
+        cropping[bottom:, :] = False
+    return cropping
+
+
+def crop_image(
+        image:          Union[Image2D, Image2DMask],
+        crop_mask:      Image2DMask,
+        crop_internal:  Optional[bool]=False
+    ) -> Union[Image2D, Image2DMask]:
+    """Crop an image to the size of the nonzero portion of a crop mask"""
+    i_histogram = crop_mask.sum(axis=1)
+    i_cumsum = numpy.cumsum(i_histogram != 0)
+    j_histogram = crop_mask.sum(axis=0)
+    j_cumsum = numpy.cumsum(j_histogram != 0)
+    if i_cumsum[-1] == 0:
+        # The whole image is cropped away
+        return numpy.zeros((0, 0), dtype=image.dtype)
+    if crop_internal:
+        #
+        # Make up sequences of rows and columns to keep
+        #
+        i_keep = numpy.argwhere(i_histogram > 0)
+        j_keep = numpy.argwhere(j_histogram > 0)
+        #
+        # Then slice the array by I, then by J to get what's not blank
+        #
+        return image[i_keep.flatten(), :][:, j_keep.flatten()].copy()
+    else:
+        #
+        # The first non-blank row and column are where the cumsum is 1
+        # The last are at the first where the cumsum is it's max (meaning
+        # what came after was all zeros and added nothing)
+        #
+        i_first = numpy.argwhere(i_cumsum == 1)[0]
+        i_last = numpy.argwhere(i_cumsum == i_cumsum.max())[0]
+        i_end = i_last + 1
+        j_first = numpy.argwhere(j_cumsum == 1)[0]
+        j_last = numpy.argwhere(j_cumsum == j_cumsum.max())[0]
+        j_end = j_last + 1
+
+        if image.ndim == 3:
+            return image[i_first[0] : i_end[0], j_first[0] : j_end[0], :].copy()
+
+        return image[i_first[0] : i_end[0], j_first[0] : j_end[0]].copy()
+
+
+def get_cropped_mask(
+        cropping:           Image2DMask,
+        mask:               Optional[Image2DMask],
+        removal_method:     RemovalMethod = RemovalMethod.NO,
+) -> Image2DMask:
+    if removal_method == RemovalMethod.NO:
+        #
+        # Check for previous cropping's mask. If it doesn't exist, set it to the current cropping
+        #
+        if mask is None:
+            mask = cropping
+    elif removal_method in (RemovalMethod.EDGES, RemovalMethod.ALL):
+        crop_internal = removal_method == RemovalMethod.ALL
+        #
+        # Check for previous cropping's mask. If it doesn't exist, set it to the region of interest specified
+        # by the cropping. The final mask output size could be smaller as the crop_image function removes
+        # edges by default.
+        #
+        if mask is None:
+            mask = crop_image(cropping, cropping, crop_internal)
+    else:
+        raise NotImplementedError(f"Unimplemented removal method: {removal_method}")
+    assert mask is not None
+    return mask
+
+
+def get_cropped_image_mask(
+        cropping:           Image2DMask,
+        mask:               Optional[Image2DMask],
+        orig_image_mask:    Optional[Image2DMask] = None,
+        removal_method:     RemovalMethod = RemovalMethod.NO,
+) -> Image2DMask:
+    if mask is None:
+        mask = get_cropped_mask(cropping, mask, removal_method)
+    if removal_method == RemovalMethod.NO:
+        #
+        # Check if a mask has been set on the original image. If not, set it to the current mask
+        # This is a mask that could have been set by another module and this module "respects masks".
+        #
+        if orig_image_mask is not None:
+            # Image mask is the region of interest indicator for the final image object.
+            image_mask = orig_image_mask & mask
+        else:
+            image_mask = mask
+
+        return image_mask
+    elif removal_method in (RemovalMethod.EDGES, RemovalMethod.ALL):
+        crop_internal = removal_method == RemovalMethod.ALL
+        #
+        # Check if a mask has been set on the original image. If not, set it to the current mask
+        # This is a mask that could have been set by another module and this module "respects masks".
+        # The final mask output size could be smaller as the crop_image function removes edges by default.
+        #
+        if orig_image_mask is not None:
+            # Image mask is the region of interest indicator for the final image object.
+            image_mask = crop_image(orig_image_mask, cropping, crop_internal) & mask
+        else:
+            image_mask = mask
+    else:
+        raise NotImplementedError(f"Unimplemented removal method: {removal_method}")
+
+    return image_mask
+
+
+def get_cropped_image_pixels(
+        orig_image_pixels:  Image2D,
+        cropping:           Image2DMask,
+        mask:               Optional[Image2DMask],
+        removal_method:     RemovalMethod = RemovalMethod.NO,
+) -> Image2D:
+    if removal_method == RemovalMethod.NO:
+        cropped_pixel_data = apply_crop_keep_rows_and_columns(orig_image_pixels, cropping)
+    elif removal_method in (RemovalMethod.EDGES, RemovalMethod.ALL):
+        cropped_pixel_data = apply_crop_remove_rows_and_columns(orig_image_pixels, cropping, mask, removal_method)
+    else:
+        raise NotImplementedError(f"Unimplemented removal method: {removal_method}")
+    return cropped_pixel_data
+
+
+def apply_crop_keep_rows_and_columns(
+    orig_image_pixels:  Image2D,
+    final_cropping:     Image2DMask,
+) -> Image2D:
+    cropped_pixel_data = orig_image_pixels.copy()
+    cropped_pixel_data = erase_pixels(cropped_pixel_data, final_cropping)
+    return cropped_pixel_data
+
+
+def apply_crop_remove_rows_and_columns(
+        orig_image_pixels:  Image2D,
+        final_cropping:     Image2DMask,
+        mask:               Optional[Image2DMask],
+        removal_method: RemovalMethod = RemovalMethod.EDGES,
+) -> Image2D:
+    if mask is None:
+        mask = get_cropped_mask(final_cropping, mask, removal_method)
+    # Apply first level of cropping to get the region of interest that matches the original image
+    cropped_pixel_data = crop_image(orig_image_pixels, final_cropping, removal_method==RemovalMethod.ALL)
+    cropped_pixel_data = erase_pixels(cropped_pixel_data, mask)
+    return cropped_pixel_data
+
+
+def erase_pixels(
+        cropped_pixel_data: Image2D,
+        crop:               Image2DMask
+        ) -> Image2D:
+    #
+    # Apply crop to all channels automatically for color images
+    #
+    if cropped_pixel_data.ndim == 3:
+        cropped_pixel_data[~crop, :] = 0
+    else:
+        cropped_pixel_data[~crop] = 0
+    return cropped_pixel_data

cellprofiler_library/modules/_crop.py

@@ -0,0 +1,45 @@
+from typing import Annotated, Optional, Tuple, List
+from pydantic import Field, validate_call, ConfigDict
+import numpy
+from cellprofiler_library.types import Image2D, Image2DMask
+from cellprofiler_library.functions.image_processing import get_cropped_mask, get_cropped_image_mask, get_cropped_image_pixels
+from cellprofiler_library.opts.crop import RemovalMethod, Measurement
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def crop(
+        orig_image_pixels:  Annotated[Image2D, Field(description="Pixel values of the original image")],
+        cropping:           Annotated[Image2DMask, Field(description="The region of interest to be kept. 1 for pixels to keep, 0 for pixels to remove")],
+        mask:               Annotated[Optional[Image2DMask], Field(description="Previous cropping's mask")],
+        orig_image_mask:    Annotated[Optional[Image2DMask], Field(description="Mask that may have been set on the original image")],
+        removal_method:     Annotated[RemovalMethod, Field(description="Removal method")],
+        ) -> Tuple[Image2D, Image2DMask, Image2DMask]:
+    #
+    # Crop the mask
+    #
+    mask = get_cropped_mask(cropping, mask, removal_method)
+
+    #
+    # Crop the image_mask 
+    image_mask = get_cropped_image_mask(cropping, mask, orig_image_mask, removal_method)
+
+    #
+    # Crop the image
+    #
+    cropped_pixel_data = get_cropped_image_pixels(orig_image_pixels, cropping, mask, removal_method)
+
+    return cropped_pixel_data, mask, image_mask
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def measure_area_retained_after_cropping(cropping: Image2DMask) -> int:
+    return numpy.sum(cropping.astype(float))
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def measure_original_image_area(orig_image_pixels: Image2D) -> int:
+    return numpy.product(orig_image_pixels.shape)
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def get_measurements(cropping: Image2DMask, orig_image_pixels:Image2D, cropped_image_name: str = "CroppedImage") -> List[Tuple[str, str, int]]:
+    orig_image_area = measure_original_image_area(orig_image_pixels)
+    area_retained_after_cropping = measure_area_retained_after_cropping(cropping)
+    return [("Image", str(Measurement.ORIGINAL_AREA % cropped_image_name), orig_image_area),
+            ("Image", str(Measurement.AREA_RETAINED % cropped_image_name), area_retained_after_cropping)]

cellprofiler_library/modules/_erodeimage.py

@@ -0,0 +1,36 @@
+# coding=utf-8
+
+"""
+ErodeImage module for the CellProfiler library.
+
+This module contains the core algorithms for morphological erosion operations.
+"""
+
+from pydantic import validate_call, ConfigDict, Field
+from typing import Union, Tuple, Annotated
+from cellprofiler_library.types import ImageAny, StructuringElement
+from cellprofiler_library.functions.image_processing import morphology_erosion, 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 erode_image( 
+    image: Annotated[ImageAny, Field(description="Input image to perform erosion on")],
+    structuring_element: Annotated[Union[StructuringElement, StructuringElementParameters], Field(description="Structuring element for erosion operation as either an NDArray or a tuple of (StructuringElement[N]D, size)")]
+) -> ImageAny:
+    """Apply morphological erosion to an image.
+    
+    Args:
+        image: Input image (2D or 3D grayscale)
+        structuring_element: Structuring element for erosion operation as an NDArray or a tuple of (StructuringElement[N]D, size)
+        
+    Returns:
+        Eroded image with same dimensions and type as input
+        
+    Raises:
+        NotImplementedError: If trying to apply 3D structuring element to 2D image
+    """
+    if isinstance(structuring_element, tuple):
+        structuring_element = get_structuring_element(structuring_element[0], structuring_element[1])
+    return morphology_erosion(image, structuring_element)

cellprofiler_library/opts/crop.py

@@ -0,0 +1,41 @@
+from enum import Enum
+
+class Shape(str, Enum):
+    RECTANGLE = "Rectangle"
+    ELLIPSE = "Ellipse"
+    IMAGE = "Image"
+    OBJECTS = "Objects"
+    CROPPING = "Previous cropping"
+
+class RemovalMethod(str, Enum):
+    NO = "No"
+    EDGES = "Edges"
+    ALL = "All"
+
+class Measurement(str, Enum):
+    AREA_RETAINED = "Crop_AreaRetainedAfterCropping_%s"
+    ORIGINAL_AREA = "Crop_OriginalImageArea_%s"
+
+class CroppingMethod(str, Enum):
+    COORDINATES = "Coordinates"
+    MOUSE = "Mouse"
+
+class CroppingPattern(str, Enum):
+    FIRST = "First"
+    INDIVIDUALLY = "Individually"
+
+class Limits(str, Enum):
+    ABSOLUTE = "Absolute"
+    FROM_EDGE = "From edge"
+
+class Ellipse(str, Enum):
+    XCENTER = "xcenter"
+    YCENTER = "ycenter"
+    XRADIUS = "xradius"
+    YRADIUS = "yradius"
+
+class Rectangle(str, Enum):
+    LEFT = "left"
+    TOP = "top"
+    RIGHT = "right"
+    BOTTOM = "bottom"

cellprofiler_library/opts/erodeimage.py

@@ -0,0 +1,14 @@
+# coding=utf-8
+
+"""
+Options and enums for ErodeImage module
+"""
+
+# Note: ErodeImage 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 ErodeImage as it uses standard
+# StructuringElement configuration from cellprofiler_core. For structuring element shapes,
+# see cellprofiler_library.opts.structuring_elements

cellprofiler_library/opts/structuring_elements.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class StructuringElementShape2D(str, Enum):
+    DIAMOND = "Diamond"
+    DISK = "Disk"
+    SQUARE = "Square"
+    STAR = "Star"
+    
+class StructuringElementShape3D(str, Enum):
+    BALL = "Ball"
+    CUBE = "Cube"
+    OCTAHEDRON = "Octahedron"

cellprofiler_library/types.py

@@ -117,3 +117,5 @@ Image3D =               Union[Image3DColor, Image3DGrayscale, Image3DBinary]
 Image3DMask =           Union[Image3DColorMask, Image3DGrayscaleMask]
 
 ImageInt =              Union[Image2DInt, Image3DInt]
+
+StructuringElement =    NDArray[np.uint8]

{cellprofiler_library_nightly-5.0.0.dev318.dist-info → cellprofiler_library_nightly-5.0.0.dev324.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev318
+Version: 5.0.0.dev324
 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.dev318.dist-info → cellprofiler_library_nightly-5.0.0.dev324.dist-info}/RECORD

@@ -1,10 +1,10 @@
 cellprofiler_library/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellprofiler_library/_version.py,sha256=VKwI68zHVxr7qKLpGyfYE5ws8C3HO1sHftyVZcFWLQk,721
+cellprofiler_library/_version.py,sha256=X_dsIS438JBC3vSFB9YEnaGPIPrvCqTB7mibbwXlkv0,721
 cellprofiler_library/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellprofiler_library/types.py,sha256=5cCxXOO_TE-uSF4ZB6sDG3eTZ1VWDSXUFifg0N4JYs8,8516
+cellprofiler_library/types.py,sha256=cU38AwLLsMiI3XCwfrmWmDNpGWgLfpCpsuwnijaT8vU,8559
 cellprofiler_library/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellprofiler_library/functions/file_processing.py,sha256=jumpdgxReyV5xzF4YXZWhkei9CQ9GtWD-VUCuFh-FZM,5168
-cellprofiler_library/functions/image_processing.py,sha256=3mGdRhWaVUqCxIh1hjde6Ffnq_wJfJAWxZZU3MNfQkM,24780
+cellprofiler_library/functions/image_processing.py,sha256=SMt7vykb0nvEEFoo0VGNRDORSjLAZuxW2AQZOND-jjw,34874
 cellprofiler_library/functions/measurement.py,sha256=8pXcEb1fLgwOEDiTJho1_O-fFGTtIp-Qn1lStjQBjbo,29221
 cellprofiler_library/functions/object_processing.py,sha256=3cKNq5ewBf_HWz6rdX3XR4WUbd6SklbHZ_H40xt9ODM,19443
 cellprofiler_library/functions/segmentation.py,sha256=LNE22ByY0X7GepQaHqLdxkzlmIXjD3EglAYJjtT2dGo,25257
@@ -15,7 +15,9 @@ cellprofiler_library/modules/_combineobjects.py,sha256=dZz0RXjvVukem3e46wPfQWOQC
 cellprofiler_library/modules/_convertimagetoobjects.py,sha256=_X2YWEHK4hFaP13LEBD-vIwwUUhgJEJLcTkhyMe4JBA,1075
 cellprofiler_library/modules/_convertobjectstoimage.py,sha256=PMYjH_prBKma4LNgUxmA5GzF7fQ6ko09XszKatTulB4,2274
 cellprofiler_library/modules/_correctilluminationapply.py,sha256=8bZC3AnQv3vpUrNSnLvcc_s0E-P63XbrfwMv7OZNjt4,2084
+cellprofiler_library/modules/_crop.py,sha256=0T0sQsK7o5dHVXMZ4OqvAJkskkyez1MXcnPlU5yqsV4,2422
 cellprofiler_library/modules/_enhanceedges.py,sha256=PaXZck8fPcxRf-IXCstu-OWmsvM_rDDPMMQ3cZFfVZc,2951
+cellprofiler_library/modules/_erodeimage.py,sha256=nFHn4hdpjXJaPvnpSyfPAxWgd7UXi0fUUgPqEl26CCY,1802
 cellprofiler_library/modules/_expandorshrinkobjects.py,sha256=A1oeW_O8C5NLJr-xU1R9pSulDau8XUeWaKiilpr-85g,856
 cellprofiler_library/modules/_fillobjects.py,sha256=1zvlZNJhG8kEzAnVyiSLGPNE338EB5wopD2eK0BVWrc,469
 cellprofiler_library/modules/_gaussianfilter.py,sha256=zVt562oviuoyy6l85Tgg_rjyQdOFCEnYLuykHYnYni8,174
@@ -35,11 +37,14 @@ cellprofiler_library/opts/colortogray.py,sha256=ptAanLQW9iMgQHgC7xvYlbIbshBd5d7u
 cellprofiler_library/opts/convertimagetoobjects.py,sha256=9e3VOdpjd4084ATZyFtSQg_VpxbyXrYVFmEFJkrHakg,67
 cellprofiler_library/opts/convertobjectstoimage.py,sha256=U3jeVtKYFgfxbO7NYndanAyZFoEvbyScOq4T8cpjfX8,188
 cellprofiler_library/opts/correctilluminationapply.py,sha256=IkAqjMjaRdsoY2aXw5_dLI1iRYqCwvcNwCWEpWNZrN4,96
+cellprofiler_library/opts/crop.py,sha256=GaArWq3WZd_Ykunj1SSbFOYkqDQ6TXy2MDKxG4fA6ZE,879
+cellprofiler_library/opts/erodeimage.py,sha256=T3LCqu83rTqTDlc_7ebuPBKnr-FKomRHA8WD0uA9Y1g,584
 cellprofiler_library/opts/measureimageoverlap.py,sha256=uopQCJTX1Uk-NNDAISsdYEOuOtiEBYOyCwu57ZT7X84,134
 cellprofiler_library/opts/objectsizeshapefeatures.py,sha256=3GIntOH3qXs7F16Tpjmtg7opHYAmmOjEdEwW6q3ht_Y,6306
+cellprofiler_library/opts/structuring_elements.py,sha256=Q4pBdCgDmjPx05t61Zqi40Iof8Nj3UR5k-F7brImLZY,263
 cellprofiler_library/opts/threshold.py,sha256=yg_i5to22Nd9hTakaRxo9UIQZRYWFpavJimjl5JONx4,938
-cellprofiler_library_nightly-5.0.0.dev318.dist-info/licenses/LICENSE,sha256=QLWaBS7kAioYx7PmJNXAMJaY8NODcFAag60YlUWuyz0,2276
-cellprofiler_library_nightly-5.0.0.dev318.dist-info/METADATA,sha256=knZAToPornredt8suy093xlyBp6eTYhKl4A_wEElejs,5534
-cellprofiler_library_nightly-5.0.0.dev318.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cellprofiler_library_nightly-5.0.0.dev318.dist-info/top_level.txt,sha256=LXq0ApDeDD4gotb6YFTySzdyScvHfS_pqoTg1QsNLBs,21
-cellprofiler_library_nightly-5.0.0.dev318.dist-info/RECORD,,
+cellprofiler_library_nightly-5.0.0.dev324.dist-info/licenses/LICENSE,sha256=QLWaBS7kAioYx7PmJNXAMJaY8NODcFAag60YlUWuyz0,2276
+cellprofiler_library_nightly-5.0.0.dev324.dist-info/METADATA,sha256=v47gHLjhRnydgeEgCJO2nxodQTAvyIRGVILWkhb2CXs,5534
+cellprofiler_library_nightly-5.0.0.dev324.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cellprofiler_library_nightly-5.0.0.dev324.dist-info/top_level.txt,sha256=LXq0ApDeDD4gotb6YFTySzdyScvHfS_pqoTg1QsNLBs,21
+cellprofiler_library_nightly-5.0.0.dev324.dist-info/RECORD,,