cellprofiler-library-nightly 5.0.0.dev328__py3-none-any.whl → 5.0.0.dev336__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.dev328'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev328')
+__version__ = version = '5.0.0.dev336'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev336')
 
 __commit_id__ = commit_id = None

cellprofiler_library/functions/image_processing.py

@@ -6,12 +6,17 @@ import centrosome.threshold
 import scipy
 import matplotlib
 import math
-from typing import Any, Optional, Tuple, Callable, Union, List
-from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ObjectSegmentation, Image2D, Image2DMask, StructuringElement
+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
 from cellprofiler_library.opts import threshold as Threshold
+from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
 from cellprofiler_library.opts.crop import RemovalMethod
 from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
 
+T = TypeVar("T", bound=ImageAny)
+
 def rgb_to_greyscale(image):
     if image.shape[-1] == 4:
         output = skimage.color.rgba2rgb(image)
@@ -924,3 +929,202 @@ def erase_pixels(
     else:
         cropped_pixel_data[~crop] = 0
     return cropped_pixel_data
+
+
+###############################################################################
+# EnhanceOrSuppressFeatures
+###############################################################################
+
+def __mask(
+        pixel_data: T,
+        mask:       ImageAnyMask,
+        ) -> T:
+    data = numpy.zeros_like(pixel_data)
+    data[mask] = pixel_data[mask]
+    return data
+
+def __unmask(
+        data:       T,
+        pixel_data: T, 
+        mask:       ImageAnyMask,
+        ) -> T:
+    data[~mask] = pixel_data[~mask]
+    return data
+
+def __structuring_element(
+        radius, 
+        volumetric
+        ) -> NDArray[numpy.uint8]:
+    if volumetric:
+        return skimage.morphology.ball(radius)
+
+    return skimage.morphology.disk(radius)
+
+
+def enhance_speckles(
+        im_pixel_data:  ImageGrayscale,
+        im_mask:        ImageGrayscaleMask,
+        im_volumetric:  bool,
+        radius:         float,
+        accuracy:       SpeckleAccuracy,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+    footprint = __structuring_element(radius, im_volumetric)
+
+    if accuracy == SpeckleAccuracy.SLOW or radius <= 3:
+        result = skimage.morphology.white_tophat(data, footprint=footprint)
+    else:
+        #
+        # white_tophat = img - opening
+        #              = img - dilate(erode)
+        #              = img - maximum_filter(minimum_filter)
+        #
+        minimum = scipy.ndimage.filters.minimum_filter(data, footprint=footprint)
+        maximum = scipy.ndimage.filters.maximum_filter(minimum, footprint=footprint)
+        result = data - maximum
+        
+    return __unmask(result, im_pixel_data, im_mask)
+
+
+def enhance_neurites(
+        im_pixel_data:      ImageGrayscale,
+        im_mask:            ImageGrayscaleMask,
+        im_volumetric:      bool,
+        im_spacing:         Tuple[float, ...],
+        smoothing_value:    float,
+        radius:             float,
+        method:             NeuriteMethod,
+        neurite_rescale:    bool,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+
+    if method == NeuriteMethod.GRADIENT:
+        # desired effect = img + white_tophat - black_tophat
+        footprint = __structuring_element(radius, im_volumetric)
+        white = skimage.morphology.white_tophat(data, footprint=footprint)
+        black = skimage.morphology.black_tophat(data, footprint=footprint)
+        result = data + white - black
+        result[result > 1] = 1
+        result[result < 0] = 0
+    else:
+        sigma = smoothing_value
+        smoothed = scipy.ndimage.gaussian_filter(data, numpy.divide(sigma, im_spacing))
+
+        if im_volumetric:
+            result = numpy.zeros_like(smoothed)
+            for index, plane in enumerate(smoothed):
+                hessian = centrosome.filter.hessian(plane, return_hessian=False, return_eigenvectors=False)
+                result[index] = (-hessian[:, :, 0] * (hessian[:, :, 0] < 0) * (sigma ** 2))
+        else:
+            hessian = centrosome.filter.hessian(smoothed, return_hessian=False, return_eigenvectors=False)
+            #
+            # The positive values are darker pixels with lighter
+            # neighbors. The original ImageJ code scales the result
+            # by sigma squared - I have a feeling this might be
+            # a first-order correction for e**(-2*sigma), possibly
+            # because the hessian is taken from one pixel away
+            # and the gradient is less as sigma gets larger.
+            #
+            result = -hessian[:, :, 0] * (hessian[:, :, 0] < 0) * (sigma ** 2)
+            
+    result = __unmask(result, im_pixel_data, im_mask)
+    if neurite_rescale:
+        result = skimage.exposure.rescale_intensity(result)
+    return result
+
+
+def enhance_circles(
+        im_pixel_data:  ImageGrayscale,
+        im_mask:        ImageGrayscaleMask,
+        im_volumetric:  bool,
+        radius:         float,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+    if im_volumetric:
+        result = numpy.zeros_like(data)
+        for index, plane in enumerate(data):
+            result[index] = skimage.transform.hough_circle(plane, radius)[0]
+    else:
+        result = skimage.transform.hough_circle(data, radius)[0]
+    return __unmask(result, im_pixel_data, im_mask)
+
+
+def enhance_texture(
+        im_pixel_data:  ImageGrayscale,
+        im_mask:        ImageGrayscaleMask,
+        sigma:          float,
+        ) -> ImageGrayscale:
+    mask = im_mask
+    data = __mask(im_pixel_data, mask)
+    gmask = skimage.filters.gaussian(mask.astype(float), sigma, mode="constant")
+    img_mean = (skimage.filters.gaussian(data, sigma, mode="constant") / gmask)
+    img_squared = (skimage.filters.gaussian(data ** 2, sigma, mode="constant")/ gmask)
+    result = img_squared - img_mean ** 2
+    return __unmask(result, im_pixel_data, mask)
+
+
+def enhance_dark_holes(
+        im_pixel_data:          ImageGrayscale,
+        im_mask:                ImageGrayscaleMask,
+        im_volumetric:          bool,
+        dark_hole_radius_min:   int,
+        dark_hole_radius_max:   int,
+        min_radius:             Optional[int] = None,
+        max_radius:             Optional[int] = None,
+        ) -> ImageGrayscale:
+    if min_radius is None:
+        min_radius = max(1, int(dark_hole_radius_min / 2))
+    if max_radius is None:
+        max_radius = int((dark_hole_radius_max + 1) / 2)
+
+    pixel_data = im_pixel_data
+    mask = im_mask
+    se = __structuring_element(1, im_volumetric)
+    inverted_image = pixel_data.max() - pixel_data
+    previous_reconstructed_image = inverted_image
+    eroded_image = inverted_image
+    smoothed_image = numpy.zeros(pixel_data.shape)
+
+    for i in range(max_radius + 1):
+        eroded_image = skimage.morphology.erosion(eroded_image, se)
+        if mask is not None:
+            eroded_image *= mask
+        reconstructed_image = skimage.morphology.reconstruction(eroded_image, inverted_image, "dilation", se)
+        output_image = previous_reconstructed_image - reconstructed_image
+        if i >= min_radius:
+            smoothed_image = numpy.maximum(smoothed_image, output_image)
+        previous_reconstructed_image = reconstructed_image
+    return smoothed_image
+
+
+def enhance_dic(
+        im_pixel_data:  ImageGrayscale,
+        im_volumetric:  bool,
+        angle:          float,
+        decay:          float,
+        smoothing:      float,
+        ) -> ImageGrayscale:
+    pixel_data = im_pixel_data
+
+    if im_volumetric:
+        result = numpy.zeros_like(pixel_data).astype(numpy.float64)
+        for index, plane in enumerate(pixel_data):
+            result[index] = centrosome.filter.line_integration(plane, angle, decay, smoothing)
+        return result
+
+    if smoothing == 0:
+        smoothing = float(numpy.finfo(float).eps)
+
+    return centrosome.filter.line_integration(pixel_data, angle, decay, smoothing)
+
+
+def suppress(
+        im_pixel_data:  ImageGrayscale, 
+        im_mask:        ImageGrayscaleMask,
+        im_volumetric:  bool,
+        radius:         float,
+        ) -> ImageGrayscale:
+    data = __mask(im_pixel_data, im_mask)
+    footprint = __structuring_element(radius, im_volumetric)
+    result = skimage.morphology.opening(data, footprint)
+    return __unmask(result, im_pixel_data, im_mask)

cellprofiler_library/functions/object_processing.py

@@ -3,12 +3,12 @@ import centrosome.cpmorphology
 import numpy
 import scipy.ndimage
 import skimage.morphology
+import cellprofiler.utilities.morphology
 import mahotas
 import matplotlib.cm
 from numpy.typing import NDArray
 from typing import Optional, Literal, Tuple
-from cellprofiler_library.types import ObjectSegmentation, ImageAnyMask, ObjectLabel, ImageColor, ImageGrayscale, ImageBinary
-
+from cellprofiler_library.types import ImageAnyMask, ObjectLabel, ImageColor, ImageGrayscale, ImageBinary, ObjectSegmentation, StructuringElement
 
 def shrink_to_point(labels, fill):
     """
@@ -532,3 +532,100 @@ def image_mode_uint16(
     alpha[mask] = 1
     return pixel_data, alpha
 
+
+################################################################################
+# Morphological Operations Helpers
+################################################################################
+
+def morphological_gradient(x_data: ObjectSegmentation, structuring_element: StructuringElement) -> ObjectSegmentation:
+    is_strel_2d = structuring_element.ndim == 2
+
+    is_img_2d = x_data.ndim == 2
+
+    if is_strel_2d and not is_img_2d:
+        y_data = numpy.zeros_like(x_data)
+
+        for index, plane in enumerate(x_data):
+            y_data[index] = scipy.ndimage.morphological_gradient(
+                plane, footprint=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 = scipy.ndimage.morphological_gradient(x_data, footprint=structuring_element)
+
+    return y_data
+
+
+################################################################################
+# ErodeObjects
+################################################################################
+
+def erode_objects_with_structuring_element(
+    labels: ObjectSegmentation,
+    structuring_element: StructuringElement,
+    preserve_midpoints: bool = True,
+    relabel_objects: bool = False
+) -> ObjectSegmentation:
+    """Erode objects based on the structuring element provided.
+    
+    This function is similar to the "Shrink" function of ExpandOrShrinkObjects,
+    with two major distinctions:
+    1. ErodeObjects supports 3D objects
+    2. An object smaller than the structuring element will be removed entirely
+       unless preserve_midpoints is enabled.
+    
+    Args:
+        labels: Input labeled objects array
+        structuring_element: Structuring element for erosion operation
+        preserve_midpoints: If True, preserve central pixels to prevent object removal
+        relabel_objects: If True, assign new label numbers to resulting objects
+        
+    Returns:
+        Eroded objects array with same dimensions as input
+    """
+    
+    
+    # Calculate morphological gradient to identify object boundaries
+    contours = morphological_gradient(
+        labels, structuring_element
+    )
+    
+    # Erode by removing pixels at object boundaries (where contours != 0)
+    y_data = labels * (contours == 0)
+    
+    # Preserve midpoints if requested to prevent object removal
+    if preserve_midpoints:
+        missing_labels = numpy.setxor1d(labels, y_data)
+        
+        # Check if structuring element is disk with size 1 (special case optimization)
+        # Check based on the actual array properties since we're dealing with numpy array
+        is_simple_disk = (
+            structuring_element.ndim == 2 and 
+            structuring_element.shape == (3, 3) and
+            numpy.array_equal(structuring_element, skimage.morphology.disk(1))
+        )
+        
+        if is_simple_disk:
+            # For simple disk,1 case, restore missing pixels directly
+            y_data += labels * numpy.isin(labels, missing_labels)
+        else:
+            # For other structuring elements, find and preserve the most central pixels
+            for label in missing_labels:
+                binary = labels == label
+                # Find pixels furthest from the object's edge using distance transform
+                midpoint = scipy.ndimage.morphology.distance_transform_edt(binary)
+                # Preserve pixels at maximum distance (most central)
+                y_data[midpoint == numpy.max(midpoint)] = label
+    
+    # Relabel objects if requested
+    if relabel_objects:
+        y_data = skimage.morphology.label(y_data)
+    
+    return y_data
+

cellprofiler_library/modules/_enhanceorsuppressfeatures.py

@@ -0,0 +1,55 @@
+from cellprofiler_library.functions.image_processing import enhance_speckles, enhance_neurites, enhance_circles, enhance_texture, enhance_dark_holes, enhance_dic, suppress
+from pydantic import Field, ConfigDict, validate_call
+from typing import Annotated
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask
+from ..opts.enhanceorsuppressfeatures import OperationMethod, EnhanceMethod, SpeckleAccuracy, NeuriteMethod
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def enhance_or_suppress_features(
+        im_pixel_data:          Annotated[ImageGrayscale, Field(description="Image pixel data")],  
+        im_mask:                Annotated[ImageGrayscaleMask, Field(description="Image mask")],
+        im_volumetric:          Annotated[bool, Field(description="Image is volumetric")] = False,
+        im_spacing:             Annotated[tuple[float, ...], Field(description="Image spacing")] = (1.0, 1.0, 1.0),
+        radius:                 Annotated[float, Field(description="Feature size")] = 10,
+        method:                 Annotated[OperationMethod, Field(description="Operation method")] = OperationMethod.ENHANCE,
+        enhance_method:         Annotated[EnhanceMethod, Field(description="Feature type")] = EnhanceMethod.SPECKLES,
+        speckle_accuracy:       Annotated[SpeckleAccuracy, Field(description="Speed and accuracy")] = SpeckleAccuracy.FAST,
+        neurite_choice:         Annotated[NeuriteMethod, Field(description="Neurite choice")] = NeuriteMethod.GRADIENT,
+        neurite_rescale:        Annotated[bool, Field(description="Rescale result image")] = False,
+        dark_hole_radius_min:   Annotated[int, Field(description="Dark hole radius min")] = 1,
+        dark_hole_radius_max:   Annotated[int, Field(description="Dark hole radius max")] = 10,
+        smoothing_value:        Annotated[float, Field(description="Smoothing value")] = 2.0,
+        dic_angle:              Annotated[float, Field(description="Angle")] = 0.0,
+        dic_decay:              Annotated[float, Field(description="Decay")] = 0.95,
+        ) -> ImageGrayscale:
+    if method == OperationMethod.ENHANCE:
+        if enhance_method == EnhanceMethod.SPECKLES:
+            result = enhance_speckles(im_pixel_data, im_mask, im_volumetric, radius, speckle_accuracy)
+
+        elif enhance_method == EnhanceMethod.NEURITES:
+            result = enhance_neurites(im_pixel_data, im_mask, im_volumetric, im_spacing, smoothing_value, radius, neurite_choice, neurite_rescale)
+            
+        elif enhance_method == EnhanceMethod.DARK_HOLES:
+            result = enhance_dark_holes(im_pixel_data, im_mask, im_volumetric, dark_hole_radius_min, dark_hole_radius_max)
+
+        elif enhance_method == EnhanceMethod.CIRCLES:
+            result = enhance_circles(im_pixel_data, im_mask, im_volumetric, radius)
+
+        elif enhance_method == EnhanceMethod.TEXTURE:
+            result = enhance_texture(im_pixel_data, im_mask, smoothing_value)
+
+        elif enhance_method == EnhanceMethod.DIC:
+            result = enhance_dic(im_pixel_data, im_volumetric, dic_angle, dic_decay, smoothing_value)
+        
+        else:
+            raise NotImplementedError("Unimplemented enhance method: %s" % enhance_method)
+        
+    elif method == OperationMethod.SUPPRESS:
+        result = suppress(im_pixel_data, im_mask, im_volumetric, radius)
+
+    else:
+        raise ValueError("Unknown filtering method: %s" % method)
+    
+    return result
+
+

cellprofiler_library/modules/_erodeobjects.py

@@ -0,0 +1,50 @@
+# coding=utf-8
+
+"""
+ErodeObjects module for the CellProfiler library.
+
+This module contains the core algorithms for object erosion 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 erode_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 erode_objects(
+    labels: Annotated[ObjectSegmentation, Field(description="Input object segmentations")],
+    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)")],
+    preserve_midpoints: Annotated[bool, Field(description="If set to True, the central pixels for each object will not be eroded. This ensures that objects are not lost.")] = False,
+    relabel_objects: Annotated[bool, Field(description="Selecting True will assign new label numbers to resulting objects")] = False
+) -> ObjectSegmentation:
+    """Erode objects based on the structuring element provided.
+    
+    This function is similar to the "Shrink" function of ExpandOrShrinkObjects,
+    with two major distinctions:
+    1. ErodeObjects supports 3D objects, unlike ExpandOrShrinkObjects.
+    2. An object smaller than the structuring element will be removed entirely
+       unless preserve_midpoints is enabled.
+    
+    Args:
+        labels: Input labeled objects array
+        structuring_element: Structuring element for erosion operation
+        preserve_midpoints: If set to True, the central pixels for each object will not be eroded. This ensures that objects are not lost.
+        relabel_objects: If set to True, the resulting objects will be relabeled with new label numbers
+        
+    Returns:
+        Eroded objects array with same dimensions as input
+    """
+    if isinstance(structuring_element, tuple):
+        structuring_element = get_structuring_element(structuring_element[0], structuring_element[1])
+    return erode_objects_with_structuring_element(
+        labels=labels,
+        structuring_element=structuring_element,
+        preserve_midpoints=preserve_midpoints,
+        relabel_objects=relabel_objects
+    )

cellprofiler_library/opts/enhanceorsuppressfeatures.py

@@ -0,0 +1,21 @@
+from enum import Enum
+
+class OperationMethod(str, Enum):
+    ENHANCE = "Enhance"
+    SUPPRESS = "Suppress"
+
+class EnhanceMethod(str, Enum):
+    SPECKLES = "Speckles"
+    NEURITES = "Neurites"
+    DARK_HOLES = "Dark holes"
+    CIRCLES = "Circles"
+    TEXTURE = "Texture"
+    DIC = "DIC"
+
+class SpeckleAccuracy(str, Enum):
+    SLOW = "Slow"
+    FAST = "Fast"
+
+class NeuriteMethod(str, Enum):
+    GRADIENT = "Line structures"
+    TUBENESS = "Tubeness"

cellprofiler_library/opts/erodeobjects.py

@@ -0,0 +1,15 @@
+# coding=utf-8
+
+"""
+Options and enums for ErodeObjects module
+"""
+
+# Note: ErodeObjects 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 ErodeObjects 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.dev328.dist-info → cellprofiler_library_nightly-5.0.0.dev336.dist-info}/METADATA

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

@@ -1,12 +1,12 @@
 cellprofiler_library/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellprofiler_library/_version.py,sha256=PsxcwOzzb9oolouEbYbSgdrb1UXw3VQZXFhGnok7G2U,721
+cellprofiler_library/_version.py,sha256=vnxlYqRhiedLOL6RtUPR0CE0S0pD8ly0U9lQv_qIKec,721
 cellprofiler_library/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=AqOq2Sf6YykX7wv2o4i94QehaCkUpamNLigqSMtWJ4g,36077
+cellprofiler_library/functions/image_processing.py,sha256=d9T0Ro2BaOS9Y9CrNgqUlOjUHTJVLnxOG696IWeLQeg,43556
 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/object_processing.py,sha256=5yHR_toKMH0KfWPAtEESQfK9JOdaD3L7WZskjGyoZ2o,23209
 cellprofiler_library/functions/segmentation.py,sha256=LNE22ByY0X7GepQaHqLdxkzlmIXjD3EglAYJjtT2dGo,25257
 cellprofiler_library/modules/__init__.py,sha256=Z4Wy42OTD9ujAON4g1oyLJ0oA6K7h3XQiV66JzHGkOw,789
 cellprofiler_library/modules/_closing.py,sha256=aIqIE0IcT2OcrOmTSWjFzu4iIQKk2yDC9qPHARqRIkc,204
@@ -18,7 +18,9 @@ cellprofiler_library/modules/_correctilluminationapply.py,sha256=8bZC3AnQv3vpUrN
 cellprofiler_library/modules/_crop.py,sha256=0T0sQsK7o5dHVXMZ4OqvAJkskkyez1MXcnPlU5yqsV4,2422
 cellprofiler_library/modules/_dilateimage.py,sha256=9mdB3Ft7muCkArTcEebs-Dz7_Ptg3YZsdL1qkr9K_0o,1812
 cellprofiler_library/modules/_enhanceedges.py,sha256=PaXZck8fPcxRf-IXCstu-OWmsvM_rDDPMMQ3cZFfVZc,2951
+cellprofiler_library/modules/_enhanceorsuppressfeatures.py,sha256=UkcJ2qM32hmnB_68yyjKmdaus78OXcpWi7E5OwRz9R8,3469
 cellprofiler_library/modules/_erodeimage.py,sha256=nFHn4hdpjXJaPvnpSyfPAxWgd7UXi0fUUgPqEl26CCY,1802
+cellprofiler_library/modules/_erodeobjects.py,sha256=ru0n0wdLeBevN4Y1LwO98KltPQO1X6kpfu0LMRUzxGE,2781
 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
@@ -40,13 +42,15 @@ cellprofiler_library/opts/convertobjectstoimage.py,sha256=U3jeVtKYFgfxbO7NYndanA
 cellprofiler_library/opts/correctilluminationapply.py,sha256=IkAqjMjaRdsoY2aXw5_dLI1iRYqCwvcNwCWEpWNZrN4,96
 cellprofiler_library/opts/crop.py,sha256=GaArWq3WZd_Ykunj1SSbFOYkqDQ6TXy2MDKxG4fA6ZE,879
 cellprofiler_library/opts/dilateimage.py,sha256=KsRf7gTKzFcTcylfIBrwue9csKBtJZdbVPFT5P_OjOM,588
+cellprofiler_library/opts/enhanceorsuppressfeatures.py,sha256=8Ej5TFUX-EKTbUcV3AidcIaomwh_A9A5lNJVRu76pc4,449
 cellprofiler_library/opts/erodeimage.py,sha256=T3LCqu83rTqTDlc_7ebuPBKnr-FKomRHA8WD0uA9Y1g,584
+cellprofiler_library/opts/erodeobjects.py,sha256=jOooDWqy01qdh17nAF0nbluU1lPToO2ZZqqsAzj2iNg,591
 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.dev328.dist-info/licenses/LICENSE,sha256=QLWaBS7kAioYx7PmJNXAMJaY8NODcFAag60YlUWuyz0,2276
-cellprofiler_library_nightly-5.0.0.dev328.dist-info/METADATA,sha256=13FKaSOrSkR-hnmCuPWJ6v2wW5AbcscIqxuN586eV2A,5534
-cellprofiler_library_nightly-5.0.0.dev328.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cellprofiler_library_nightly-5.0.0.dev328.dist-info/top_level.txt,sha256=LXq0ApDeDD4gotb6YFTySzdyScvHfS_pqoTg1QsNLBs,21
-cellprofiler_library_nightly-5.0.0.dev328.dist-info/RECORD,,
+cellprofiler_library_nightly-5.0.0.dev336.dist-info/licenses/LICENSE,sha256=QLWaBS7kAioYx7PmJNXAMJaY8NODcFAag60YlUWuyz0,2276
+cellprofiler_library_nightly-5.0.0.dev336.dist-info/METADATA,sha256=BQRHsQwGxyIEwjnINX6OLPJEzhsP2ZXEOlH-WGrBJbA,5534
+cellprofiler_library_nightly-5.0.0.dev336.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cellprofiler_library_nightly-5.0.0.dev336.dist-info/top_level.txt,sha256=LXq0ApDeDD4gotb6YFTySzdyScvHfS_pqoTg1QsNLBs,21
+cellprofiler_library_nightly-5.0.0.dev336.dist-info/RECORD,,