cellprofiler-library-nightly 5.0.0.dev466__tar.gz → 5.0.0.dev478__tar.gz

{cellprofiler_library_nightly-5.0.0.dev466 → cellprofiler_library_nightly-5.0.0.dev478}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev466 → cellprofiler_library_nightly-5.0.0.dev478}/cellprofiler_library/functions/image_processing.py

@@ -17,7 +17,8 @@ import matplotlib
 import math
 from typing import Any, Optional, Tuple, Callable, Union, List, cast, Dict, TypeVar
 from numpy.typing import NDArray
-from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ImageAnyMask, ObjectSegmentation, Image2D, Image2DMask, StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask
+from skimage.restoration import denoise_bilateral
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, Image2DGrayscaleMask, 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
@@ -25,8 +26,9 @@ from cellprofiler_library.opts.crop import RemovalMethod
 from cellprofiler_library.opts.structuring_elements import StructuringElementShape2D, StructuringElementShape3D
 from cellprofiler_library.opts.resize import ResizingMethod, DimensionMethod, InterpolationMethod
 from cellprofiler_library.opts.imagemath import Operator
+from cellprofiler_library.opts.flipandrotate import RotationCoordinateAlignmnet
+from cellprofiler_library.opts.enhanceedges import EdgeDirection
 
-# TODO: python_latest - remove this if later skimage versions update types
 invert = cast(Callable[[ImageAny], ImageAny], _invert)
 isscalar = cast(Callable[[Optional[ImageAny]], bool], _isscalar)
 
@@ -49,30 +51,46 @@ def medial_axis(image):
     return skimage.morphology.medial_axis(image)
 
 
-def enhance_edges_sobel(image, mask=None, direction="all"):
-    if direction.casefold() == "all":
+###############################################################################
+# EnhanceEdges
+###############################################################################
+
+def enhance_edges_sobel(
+        image: Image2DGrayscale, 
+        mask: Optional[Image2DGrayscaleMask]=None, 
+        direction: EdgeDirection=EdgeDirection.ALL
+        ):
+    if direction == EdgeDirection.ALL:
         output_pixels = centrosome.filter.sobel(image, mask)
-    elif direction.casefold() == "horizontal":
+    elif direction == EdgeDirection.HORIZONTAL:
         output_pixels = centrosome.filter.hsobel(image, mask)
-    elif direction.casefold() == "vertical":
+    elif direction == EdgeDirection.VERTICAL:
         output_pixels = centrosome.filter.vsobel(image, mask)
     else:
         raise NotImplementedError(f"Unimplemented direction for Sobel: {direction}")
     return output_pixels
 
 
-def enhance_edges_log(image, mask=None, sigma=2.0):
+def enhance_edges_log(
+        image: Image2DGrayscale, 
+        mask: Optional[Image2DGrayscaleMask]=None, 
+        sigma: float=2.0
+        ) -> Image2DGrayscale:
     size = int(sigma * 4) + 1
     output_pixels = centrosome.filter.laplacian_of_gaussian(image, mask, size, sigma)
     return output_pixels
 
 
-def enhance_edges_prewitt(image, mask=None, direction="all"):
-    if direction.casefold() == "all":
+def enhance_edges_prewitt(
+        image: Image2DGrayscale, 
+        mask: Optional[Image2DGrayscaleMask]=None, 
+        direction: EdgeDirection=EdgeDirection.ALL
+        ) -> Image2DGrayscale:
+    if direction == EdgeDirection.ALL:
         output_pixels = centrosome.filter.prewitt(image, mask)
-    elif direction.casefold() == "horizontal":
+    elif direction == EdgeDirection.HORIZONTAL:
         output_pixels = centrosome.filter.hprewitt(image, mask)
-    elif direction.casefold() == "vertical":
+    elif direction == EdgeDirection.VERTICAL:
         output_pixels = centrosome.filter.vprewitt(image, mask)
     else:
         raise NotImplementedError(f"Unimplemented direction for Prewitt: {direction}")
@@ -80,15 +98,15 @@ def enhance_edges_prewitt(image, mask=None, direction="all"):
 
 
 def enhance_edges_canny(
-    image,
-    mask=None,
-    auto_threshold=True,
-    auto_low_threshold=True,
-    sigma=1.0,
-    low_threshold=0.1,
-    manual_threshold=0.2,
-    threshold_adjustment_factor=1.0,
-):
+    image: Image2DGrayscale,
+    mask: Optional[Image2DGrayscaleMask] = None,
+    auto_threshold: bool = True,
+    auto_low_threshold: bool = True,
+    sigma: float = 1.0,
+    low_threshold: float = 0.1,
+    manual_threshold: float = 0.2,
+    threshold_adjustment_factor: float = 1.0,
+    ) -> Image2DGrayscale:
 
     if auto_threshold or auto_low_threshold:
         sobel_image = centrosome.filter.sobel(image)
@@ -104,6 +122,26 @@ def enhance_edges_canny(
     output_pixels = centrosome.filter.canny(image, mask, sigma, low_th, high_th)
     return output_pixels
 
+def stretched_rgb_from_components(
+        r: Image2DGrayscale, 
+        g: Optional[Image2DGrayscale]=None, 
+        b: Optional[Image2DGrayscale]=None
+    ):
+    if g:
+        assert r.shape == g.shape
+    if b:
+        assert r.shape == b.shape
+
+    color_image = numpy.zeros((r.shape[0], r.shape[1], 3))
+    color_image[:, :, 0] = centrosome.filter.stretch(r)
+    
+    if g:
+        color_image[:, :, 1] = centrosome.filter.stretch(g)
+    if b:
+        color_image[:, :, 2] = centrosome.filter.stretch(b)
+
+    return color_image
+
 
 def morphology_closing(image, structuring_element=skimage.morphology.disk(1)):
     if structuring_element.ndim == 3 and image.ndim == 2:
@@ -1939,3 +1977,137 @@ def gray_to_stacked_color(
     source_channels = pixel_data_arr
     rgb_pixel_data = numpy.dstack(source_channels)
     return rgb_pixel_data
+
+
+################################################################################
+# FlipAndRotate
+################################################################################
+
+def flip_image_left_to_right(pixel_data: Image2D) -> NDArray[numpy.int_]:
+    i, j = numpy.mgrid[
+        0 : pixel_data.shape[0], pixel_data.shape[1] - 1 : -1 : -1
+    ]
+    return i, j
+
+def flip_image_top_to_bottom(pixel_data: Image2D) ->  NDArray[numpy.int_]:
+    i, j = numpy.mgrid[
+        pixel_data.shape[0] - 1 : -1 : -1, 0 : pixel_data.shape[1]
+    ]
+    return i, j
+
+def flip_image_both(pixel_data: Image2D) ->  NDArray[numpy.int_]:
+    i, j = numpy.mgrid[
+        pixel_data.shape[0] - 1 : -1 : -1, pixel_data.shape[1] - 1 : -1 : -1
+    ]
+    return i, j
+
+
+def rotate_image_angle(pixel_data: Image2D, mask: Image2DMask, rotate_angle: float, wants_crop: bool) -> Tuple[Image2D, Image2DMask, Optional[Image2DMask]]:
+    angle = rotate_angle
+    mask = scipy.ndimage.rotate(mask.astype(float), angle, reshape=True) > 0.50
+    crop = (
+        scipy.ndimage.rotate(
+            numpy.ones(pixel_data.shape[:2]), angle, reshape=True
+        )
+        > 0.50
+    )
+    mask = mask & crop
+    pixel_data = scipy.ndimage.rotate(pixel_data, angle, reshape=True)
+    if wants_crop:
+        #
+        # We want to find the largest rectangle that fits inside
+        # the crop. The cumulative sum in the i and j direction gives
+        # the length of the rectangle in each direction and
+        # multiplying them gives you the area.
+        #
+        # The left and right halves are symmetric, so we compute
+        # on just two of the quadrants.
+        #
+        half = (numpy.array(crop.shape) / 2).astype(int)
+        #
+        # Operate on the lower right
+        #
+        quartercrop = crop[half[0] :, half[1] :]
+        ci = numpy.cumsum(quartercrop, 0)
+        cj = numpy.cumsum(quartercrop, 1)
+        carea_d = ci * cj
+        carea_d[quartercrop == 0] = 0
+        #
+        # Operate on the upper right by flipping I
+        #
+        quartercrop = crop[crop.shape[0] - half[0] - 1 :: -1, half[1] :]
+        ci = numpy.cumsum(quartercrop, 0)
+        cj = numpy.cumsum(quartercrop, 1)
+        carea_u = ci * cj
+        carea_u[quartercrop == 0] = 0
+        carea = carea_d + carea_u
+        max_carea = numpy.max(carea)
+        max_area = numpy.argwhere(carea == max_carea)[0] + half
+        min_i = max(crop.shape[0] - max_area[0] - 1, 0)
+        max_i = max_area[0] + 1
+        min_j = max(crop.shape[1] - max_area[1] - 1, 0)
+        max_j = max_area[1] + 1
+        ii = numpy.index_exp[min_i:max_i, min_j:max_j]
+        crop = numpy.zeros(pixel_data.shape, bool)
+        crop[ii] = True
+        mask = mask[ii]
+        pixel_data = pixel_data[ii]
+    else:
+        crop = None
+    return pixel_data, mask, crop
+
+
+def rotate_image_coordinates(pixel_data: Image2D, mask: Image2DMask, rotate_point_1: Tuple[float, float], rotate_point_2: Tuple[float, float], rotate_coordinate_alignment: RotationCoordinateAlignmnet) -> float:
+    xdiff = rotate_point_2[0] - rotate_point_1[0]
+    ydiff = rotate_point_2[1] - rotate_point_1[1]
+
+    if rotate_coordinate_alignment == RotationCoordinateAlignmnet.VERTICALLY:
+        angle = -numpy.arctan2(ydiff, xdiff) * 180.0 / numpy.pi
+    elif rotate_coordinate_alignment == RotationCoordinateAlignmnet.HORIZONTALLY:
+        angle = numpy.arctan2(xdiff, ydiff) * 180.0 / numpy.pi
+    else:
+        raise NotImplementedError(
+            "Unknown axis: %s" % rotate_coordinate_alignment.value
+        )
+    return angle
+
+
+###############################################################################
+# Smoothing
+###############################################################################
+
+def smoothing_gaussian(pixel_data: Image2D, mask: Optional[Image2DMask], sigma: float) -> Image2D:
+    def fn(image: Image2D) -> Image2D:
+            return scipy.ndimage.gaussian_filter(
+                image, sigma, mode="constant", cval=0
+            )
+    return centrosome.smooth.smooth_with_function_and_mask(pixel_data, fn, mask)
+     
+
+def smoothing_median(pixel_data: Image2D, mask: Optional[Image2DMask], obj_size: float) -> Image2D:
+    return centrosome.filter.median_filter(pixel_data, mask, obj_size / 2 + 1)
+
+
+def smoothing_keeping_edges(pixel_data: Image2D, multichannel: bool, sigma_range: float, sigma: float) -> Image2D:
+    assert sigma_range is not None, "sigma_range must be provided for smooth_keeping_edges"
+    return denoise_bilateral(
+        image=pixel_data.astype(float),
+        channel_axis=2 if multichannel else None,
+        sigma_color=sigma_range,
+        sigma_spatial=sigma,
+    )
+
+
+def smoothing_fit_polynomial(pixel_data: Image2D, mask: Optional[Image2DMask], clip: bool) -> Image2D:
+    return centrosome.smooth.fit_polynomial(pixel_data, mask, clip)
+
+
+def smoothing_circular_average(pixel_data: Image2D, mask: Optional[Image2DMask], obj_size: float) -> Image2D:
+    return centrosome.filter.circular_average_filter(pixel_data, obj_size / 2 + 1, mask)
+
+def smoothing_smooth_to_average(pixel_data: Image2D, mask: Optional[Image2DMask]) -> Image2D:
+    if mask is not None:
+        mean = numpy.mean(pixel_data[mask])
+    else:
+        mean = numpy.mean(pixel_data)
+    return numpy.ones(pixel_data.shape, pixel_data.dtype) * mean

{cellprofiler_library_nightly-5.0.0.dev466 → cellprofiler_library_nightly-5.0.0.dev478}/cellprofiler_library/modules/_enhanceedges.py

@@ -2,28 +2,30 @@ import warnings
 
 import numpy
 import centrosome
-
+from pydantic import Field, validate_call, ConfigDict
+from typing import Annotated, Optional
 from ..functions.image_processing import (
     enhance_edges_sobel,
     enhance_edges_log,
     enhance_edges_prewitt,
     enhance_edges_canny,
 )
+from ..opts.enhanceedges import EdgeFindingMethod, EdgeDirection
+from ..types import Image2DGrayscale, Image2DGrayscaleMask
 
-
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
 def enhanceedges(
-    image,
-    mask=None,
-    method="sobel",
-    automatic_threshold=True,
-    direction="all",
-    automatic_gaussian=True,
-    sigma=10,
-    manual_threshold=0.2,
-    threshold_adjustment_factor=1.0,
-    automatic_low_threshold=True,
-    low_threshold=0.1,
-):
+    image:                          Annotated[Image2DGrayscale, Field(description="Input image")],
+    mask:                           Annotated[Optional[Image2DGrayscaleMask], Field(description="Mask of the input image")] = None,
+    method:                         Annotated[EdgeFindingMethod, Field(description="Edge finding method")] = EdgeFindingMethod.SOBEL,
+    automatic_threshold:            Annotated[bool, Field(description="Automatically calculate the threshold?")] = True,
+    direction:                      Annotated[EdgeDirection, Field(description="Select edge direction to enhance")] = EdgeDirection.ALL,
+    sigma:                          Annotated[int, Field(description="Gaussian's sigma value")] = 10,
+    manual_threshold:               Annotated[float, Field(description="Absolute threshold")] = 0.2,
+    threshold_adjustment_factor:    Annotated[float, Field(description="Threshold adjustment factor")] = 1.0,
+    automatic_low_threshold:        Annotated[bool, Field(description="Automatically calculate the low / soft threshold cutoff for the Canny method?")] = True,
+    low_threshold:                  Annotated[float, Field(description="Low threshold value")] = 0.1,
+) -> Image2DGrayscale:
     """EnhanceEdges module
 
     Parameters
@@ -64,13 +66,13 @@ def enhanceedges(
     if mask is None:
         mask = numpy.ones(image.shape, bool)
 
-    if method.casefold() == "sobel":
+    if method == EdgeFindingMethod.SOBEL:
         output_pixels = enhance_edges_sobel(image, mask, direction)
-    elif method.casefold() == "log":
+    elif method == EdgeFindingMethod.LOG:
         output_pixels = enhance_edges_log(image, mask, sigma)
-    elif method.casefold() == "prewitt":
+    elif method == EdgeFindingMethod.PREWITT:
         output_pixels = enhance_edges_prewitt(image, mask, direction)
-    elif method.casefold() == "canny":
+    elif method == EdgeFindingMethod.CANNY:
         output_pixels = enhance_edges_canny(
             image,
             mask,
@@ -81,9 +83,9 @@ def enhanceedges(
             manual_threshold=manual_threshold,
             threshold_adjustment_factor=threshold_adjustment_factor,
         )
-    elif method.casefold() == "roberts":
+    elif method == EdgeFindingMethod.ROBERTS:
         output_pixels = centrosome.filter.roberts(image, mask)
-    elif method.casefold() == "kirsch":
+    elif method == EdgeFindingMethod.KIRSCH:
         output_pixels = centrosome.kirsch.kirsch(image)
     else:
         raise NotImplementedError(f"{method} edge detection method is not implemented.")

cellprofiler_library_nightly-5.0.0.dev478/cellprofiler_library/modules/_flipandrotate.py

@@ -0,0 +1,89 @@
+import numpy
+from pydantic import Field, validate_call, ConfigDict
+from typing import Annotated, Optional, Tuple, Dict, Callable
+from numpy.typing import NDArray
+from cellprofiler_library.functions.image_processing import flip_image_both, flip_image_left_to_right, flip_image_top_to_bottom, rotate_image_angle, rotate_image_coordinates
+from cellprofiler_library.types import Image2D, Image2DMask
+from cellprofiler_library.opts.flipandrotate import FlipDirection, RotateMethod, RotationCoordinateAlignmnet
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def flip_and_rotate(
+        pixel_data:                 Annotated[Image2D, Field(description="Pixel data of image to be flipped and/or rotated")],
+        mask:                       Annotated[Image2DMask, Field(description="Mask of the image to be flipped and/or rotated")],
+        flip_choice:                Annotated[FlipDirection, Field(description="Direction to flip the image")],
+        rotate_choice:              Annotated[RotateMethod, Field(description="Rotation method")],
+        rotate_angle:               Annotated[Optional[float], Field(description="Angle to rotate the image")],
+        rotate_point_1:             Annotated[Optional[Tuple[float, float]], Field(description="Point to rotate the image around")],
+        rotate_point_2:             Annotated[Optional[Tuple[float, float]], Field(description="Second point to rotate the image around")],
+        rotate_coordinate_alignment: Annotated[Optional[RotationCoordinateAlignmnet], Field(description="Alignment of the rotated points. The points you select will be aligned horizontally or vertically after the rotation is complete.")],
+        wants_crop:                 Annotated[bool, Field(description="Whether to crop the image")],
+        ) -> Tuple[Image2D, Image2DMask, Optional[Image2DMask], float]:
+    #
+    # Perform flip
+    #
+    pixel_data, mask = flip_image(pixel_data, mask, flip_choice) 
+    
+    #
+    # Perform rotation
+    #
+    pixel_data, mask, crop, angle = rotate_image(pixel_data, mask, rotate_choice, rotate_angle, rotate_point_1, rotate_point_2, rotate_coordinate_alignment, wants_crop)
+    
+    return pixel_data, mask, crop, angle
+
+
+def flip_image(
+        pixel_data: Image2D, 
+        mask: Image2DMask, 
+        flip_choice: FlipDirection
+        ) -> Tuple[Image2D, Image2DMask]:
+    flip_dispatch: Dict[FlipDirection, Callable[[Image2D],  NDArray[numpy.int_]]] = {
+        FlipDirection.LEFT_TO_RIGHT: flip_image_left_to_right,
+        FlipDirection.TOP_TO_BOTTOM: flip_image_top_to_bottom,
+        FlipDirection.BOTH: flip_image_both,
+    }
+    if flip_choice != FlipDirection.NONE:
+        if flip_choice in flip_dispatch.keys():
+            i, j = flip_dispatch[flip_choice](pixel_data)
+        else:
+            raise NotImplementedError(
+                "Unknown flipping operation: %s" % flip_choice.value
+            )
+        mask = mask[i, j]
+        if pixel_data.ndim == 2:
+            pixel_data = pixel_data[i, j]
+        else:
+            pixel_data = pixel_data[i, j, :]
+    return pixel_data, mask
+
+
+def rotate_image(
+        pixel_data: Image2D, 
+        mask: Image2DMask, 
+        rotate_choice: RotateMethod, 
+        rotate_angle: Optional[float],
+        rotate_point_1: Optional[Tuple[float, float]],
+        rotate_point_2: Optional[Tuple[float, float]],
+        rotate_coordinate_alignment: Optional[RotationCoordinateAlignmnet],
+        wants_crop: bool,
+        ) -> Tuple[Image2D, Image2DMask, Optional[Image2DMask], float]:
+    if rotate_choice != RotateMethod.NONE:
+        if rotate_choice == RotateMethod.ANGLE:
+            assert rotate_angle is not None, "rotate_angle must be provided for rotate_choice == RotateMethod.ANGLE"
+            angle = rotate_angle
+        elif rotate_choice == RotateMethod.COORDINATES:
+            assert rotate_point_1 is not None, "rotate_point_1 must be provided for rotate_choice == RotateMethod.COORDINATES"
+            assert rotate_point_2 is not None, "rotate_point_2 must be provided for rotate_choice == RotateMethod.COORDINATES"
+            assert rotate_coordinate_alignment is not None, "rotate_coordinate_alignment must be provided for rotate_choice == RotateMethod.COORDINATES"
+            angle = rotate_image_coordinates(pixel_data, mask, rotate_point_1, rotate_point_2, rotate_coordinate_alignment)
+
+        else:
+            raise NotImplementedError(
+                "Unknown rotation method: %s" % rotate_choice.value
+            )
+        # rangle = angle * numpy.pi / 180.0
+        pixel_data, mask, crop = rotate_image_angle(pixel_data, mask, angle, wants_crop)
+
+    else:
+        crop = None
+        angle = 0.0
+    return pixel_data, mask, crop, angle

cellprofiler_library_nightly-5.0.0.dev478/cellprofiler_library/modules/_smooth.py

@@ -0,0 +1,44 @@
+import numpy
+from typing import Annotated, Optional
+from pydantic import Field, validate_call, ConfigDict
+
+from cellprofiler_library.functions.image_processing import smoothing_gaussian, smoothing_median, smoothing_keeping_edges, smoothing_fit_polynomial, smoothing_circular_average, smoothing_smooth_to_average
+from cellprofiler_library.opts.smooth import SmoothingMethod
+from cellprofiler_library.types import Image2D, Image2DMask
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def smooth(
+        pixel_data:         Annotated[Image2D, Field(description="Pixel data of image to be smoothed")],
+        mask:               Annotated[Optional[Image2DMask], Field(description="Mask of the pixel data")],
+        multichannel:       Annotated[bool, Field(description="Set to true if image is multichannel")],
+        object_size:        Annotated[Optional[float], Field(description="Object size")],
+        smoothing_method:   Annotated[SmoothingMethod, Field(description="Smoothing method")],
+        sigma_range:        Annotated[Optional[float], Field(description="Sigma range")],
+        clip:               Annotated[Optional[bool], Field(description="Clip intensities to 0 and 1")] = True,
+) -> Image2D:
+    if object_size is not None:
+        obj_size = float(object_size)
+    else:
+        obj_size = float(min(30, max(1, numpy.mean(pixel_data.shape) / 40)))
+    sigma = obj_size / 2.35
+
+    if smoothing_method == SmoothingMethod.GAUSSIAN_FILTER:
+        output_pixels = smoothing_gaussian(pixel_data, mask, sigma)
+    elif smoothing_method == SmoothingMethod.MEDIAN_FILTER:
+        output_pixels = smoothing_median(pixel_data, mask, obj_size)
+    elif smoothing_method == SmoothingMethod.SMOOTH_KEEPING_EDGES:
+        assert sigma_range is not None, "sigma_range must be provided for smooth_keeping_edges"
+        output_pixels = smoothing_keeping_edges(pixel_data, multichannel, sigma_range, sigma)
+    elif smoothing_method == SmoothingMethod.FIT_POLYNOMIAL:
+        assert clip is not None, "clip must be provided for fit_polynomial"
+        output_pixels = smoothing_fit_polynomial(pixel_data, mask, clip)
+    elif smoothing_method == SmoothingMethod.CIRCULAR_AVERAGE_FILTER:
+        output_pixels = smoothing_circular_average(pixel_data, mask, obj_size)
+    elif smoothing_method == SmoothingMethod.SM_TO_AVERAGE:
+        output_pixels = smoothing_smooth_to_average(pixel_data, mask)
+    else:
+        raise ValueError(
+            "Unsupported smoothing method: %s" % smoothing_method
+        )
+    return output_pixels

cellprofiler_library_nightly-5.0.0.dev478/cellprofiler_library/opts/enhanceedges.py

@@ -0,0 +1,14 @@
+from enum import Enum
+
+class EdgeFindingMethod(str, Enum):
+    SOBEL = "Sobel"
+    PREWITT = "Prewitt"
+    ROBERTS = "Roberts"
+    LOG = "Log"
+    CANNY = "Canny"
+    KIRSCH = "Kirsch"
+
+class EdgeDirection(str, Enum):
+    ALL = "All"
+    HORIZONTAL = "Horizontal"
+    VERTICAL = "Vertical"

cellprofiler_library_nightly-5.0.0.dev478/cellprofiler_library/opts/flipandrotate.py

@@ -0,0 +1,29 @@
+from enum import Enum
+
+class FlipDirection(str, Enum):
+    NONE = "Do not flip"
+    LEFT_TO_RIGHT = "Left to right"
+    TOP_TO_BOTTOM = "Top to bottom"
+    BOTH = "Left to right and top to bottom"
+
+class RotateMethod(str, Enum):
+    NONE = "Do not rotate"
+    ANGLE = "Enter angle"
+    COORDINATES = "Enter coordinates"
+
+class RotationCoordinateAlignmnet(str, Enum):
+    HORIZONTALLY = "Horizontally"
+    VERTICALLY = "Vertically"
+
+D_ANGLE = "angle"
+
+"""Rotation measurement category"""
+M_ROTATION_CATEGORY = "Rotation"
+"""Rotation measurement format (+ image name)"""
+M_ROTATION_F = "%s_%%s" % M_ROTATION_CATEGORY
+
+FLIP_ALL = [FlipDirection.NONE, FlipDirection.LEFT_TO_RIGHT, FlipDirection.TOP_TO_BOTTOM, FlipDirection.BOTH]
+
+ROTATE_ALL = [RotateMethod.NONE, RotateMethod.ANGLE, RotateMethod.COORDINATES]
+
+C_ALL = [RotationCoordinateAlignmnet.HORIZONTALLY, RotationCoordinateAlignmnet.VERTICALLY]

cellprofiler_library_nightly-5.0.0.dev478/cellprofiler_library/opts/smooth.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class SmoothingMethod(str, Enum):
+    FIT_POLYNOMIAL = "Fit Polynomial"
+    MEDIAN_FILTER = "Median Filter"
+    GAUSSIAN_FILTER = "Gaussian Filter"
+    SMOOTH_KEEPING_EDGES = "Smooth Keeping Edges"
+    CIRCULAR_AVERAGE_FILTER = "Circular Average Filter"
+    SM_TO_AVERAGE = "Smooth to Average"

{cellprofiler_library_nightly-5.0.0.dev466 → cellprofiler_library_nightly-5.0.0.dev478}/cellprofiler_library_nightly.egg-info/PKG-INFO

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

@@ -28,6 +28,7 @@ cellprofiler_library/modules/_erodeimage.py
 cellprofiler_library/modules/_erodeobjects.py
 cellprofiler_library/modules/_expandorshrinkobjects.py
 cellprofiler_library/modules/_fillobjects.py
+cellprofiler_library/modules/_flipandrotate.py
 cellprofiler_library/modules/_gaussianfilter.py
 cellprofiler_library/modules/_graytocolor.py
 cellprofiler_library/modules/_identifyprimaryobjects.py
@@ -48,6 +49,7 @@ cellprofiler_library/modules/_removeholes.py
 cellprofiler_library/modules/_resize.py
 cellprofiler_library/modules/_savecroppedobjects.py
 cellprofiler_library/modules/_shrinktoobjectcenters.py
+cellprofiler_library/modules/_smooth.py
 cellprofiler_library/modules/_threshold.py
 cellprofiler_library/modules/_watershed.py
 cellprofiler_library/opts/__init__.py
@@ -58,9 +60,11 @@ cellprofiler_library/opts/correctilluminationapply.py
 cellprofiler_library/opts/crop.py
 cellprofiler_library/opts/dilateimage.py
 cellprofiler_library/opts/dilateobjects.py
+cellprofiler_library/opts/enhanceedges.py
 cellprofiler_library/opts/enhanceorsuppressfeatures.py
 cellprofiler_library/opts/erodeimage.py
 cellprofiler_library/opts/erodeobjects.py
+cellprofiler_library/opts/flipandrotate.py
 cellprofiler_library/opts/graytocolor.py
 cellprofiler_library/opts/identifyprimaryobjects.py
 cellprofiler_library/opts/identifysecondaryobjects.py
@@ -73,6 +77,7 @@ cellprofiler_library/opts/overlayoutlines.py
 cellprofiler_library/opts/removeholes.py
 cellprofiler_library/opts/resize.py
 cellprofiler_library/opts/shrinktoobjectcenters.py
+cellprofiler_library/opts/smooth.py
 cellprofiler_library/opts/structuring_elements.py
 cellprofiler_library/opts/threshold.py
 cellprofiler_library_nightly.egg-info/PKG-INFO