cellprofiler-library-nightly 5.0.0.dev462__tar.gz → 5.0.0.dev475__tar.gz

{cellprofiler_library_nightly-5.0.0.dev462 → cellprofiler_library_nightly-5.0.0.dev475}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev462 → cellprofiler_library_nightly-5.0.0.dev475}/cellprofiler_library/functions/image_processing.py

@@ -17,7 +17,7 @@ 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 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 +25,8 @@ 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
-
-# TODO: python_latest - remove this if later skimage versions update types
+from cellprofiler_library.opts.flipandrotate import RotationCoordinateAlignmnet
+from cellprofiler_library.opts.enhanceedges import EdgeDirection
 invert = cast(Callable[[ImageAny], ImageAny], _invert)
 isscalar = cast(Callable[[Optional[ImageAny]], bool], _isscalar)
 
@@ -49,30 +49,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 +96,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 +120,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:
@@ -1854,3 +1890,181 @@ def imagemath_apply_unary_operation(
             "The operation %s has not been implemented" % opval
         )
     return output_pixel_data, output_mask
+
+
+###############################################################################
+# GrayToColor
+###############################################################################
+
+def gray_to_rgb(
+        pixel_data_arr: List[Optional[Image2DGrayscale]],
+        adjustment_factor_array: List[float],
+        intensities: List[Tuple[float, ...]]=[(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)],
+        wants_rescale: bool=True,
+        ) -> Image2DColor:
+    assert(len(pixel_data_arr) == len(adjustment_factor_array)), f"pixel_data_arr and adjustment_factor_array must be the same length. pixel_data_arr has {len(pixel_data_arr)} elements, adjustment_factor_array has {len(adjustment_factor_array)} elements."
+    assert(len(pixel_data_arr) == len(intensities)), f"pixel_data_arr and intensities must be the same length. pixel_data_arr has {len(pixel_data_arr)} elements, intensities has {len(intensities)} elements."
+
+    parent_image = None
+    rgb_pixel_data = None
+    for pixel_data, adjustment_factor, intensity_triplet in zip(pixel_data_arr, adjustment_factor_array, intensities):
+        if pixel_data is None:
+            continue
+        multiplier = numpy.array(intensity_triplet) * adjustment_factor
+        if wants_rescale:
+            pixel_data = pixel_data /numpy.max(pixel_data)
+        if parent_image is not None:
+            if parent_image.shape != pixel_data.shape:
+                raise ValueError(
+                    "The input images have different sizes (%s vs %s)"
+                    % (
+                        parent_image.shape, 
+                        pixel_data.shape,
+                    )
+                )
+            rgb_pixel_data += numpy.dstack([pixel_data] * 3) * multiplier
+        else:
+            parent_image = pixel_data
+            rgb_pixel_data = numpy.dstack([pixel_data] * 3) * multiplier
+    return rgb_pixel_data
+
+def gray_to_cmyk(*args, **kwargs):
+    # gray to cmyk has the same implementation as gray to rgb but with different intensities
+    return gray_to_rgb(*args, **kwargs)
+
+
+def gray_to_composite_color(
+        pixel_data_arr: List[Optional[Image2DGrayscale]],
+        color_array: List[Tuple[int, int, int]],
+        weight_array: List[float],
+        wants_rescale: bool,
+) -> Image2DColor:
+    source_channels = pixel_data_arr
+    parent_image = pixel_data_arr[0]
+    for idx, pd in enumerate(source_channels):
+        if pd is None:
+            continue
+        if pd.shape != source_channels[0].shape:
+            raise ValueError(
+                "The input images have different sizes (%s vs %s)"
+                % (
+                    source_channels[0].shape,
+                    pd.shape,
+                )
+            )
+
+    colors: List[NDArray[numpy.float32]] = []
+    pixel_data = parent_image
+    if wants_rescale:
+        pixel_data = pixel_data / numpy.max(pixel_data)
+    for color_tuple, weight in zip(color_array, weight_array):
+        color = (weight * numpy.array(color_tuple).astype(pixel_data.dtype) / 255)
+        colors += [color[numpy.newaxis, numpy.newaxis, :]]
+    rgb_pixel_data = pixel_data[:, :, numpy.newaxis] * colors[0]
+    for image, color in zip(source_channels[1:], colors[1:]):
+        if wants_rescale:
+            image = image / numpy.max(image)
+        rgb_pixel_data = rgb_pixel_data + image[:, :, numpy.newaxis] * color
+
+    return rgb_pixel_data
+    
+
+def gray_to_stacked_color(
+    pixel_data_arr: List[Optional[Image2DGrayscale]]
+) -> Image2DColor:
+    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

{cellprofiler_library_nightly-5.0.0.dev462 → cellprofiler_library_nightly-5.0.0.dev475}/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.dev475/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.dev475/cellprofiler_library/modules/_graytocolor.py

@@ -0,0 +1,58 @@
+import numpy
+from numpy.typing import NDArray
+from typing import List, Tuple, Optional
+from pydantic import validate_call, ConfigDict
+from cellprofiler_library.opts.graytocolor import Scheme
+from cellprofiler_library.types import Image2DGrayscale, Image2DColor
+from cellprofiler_library.functions.image_processing import gray_to_rgb, gray_to_cmyk, gray_to_composite_color, gray_to_stacked_color
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def gray_to_color(
+    pixel_data_arr: List[Optional[Image2DGrayscale]],
+    scheme: Scheme,
+    color_array: Optional[List[Tuple[int, int, int]]] = None,
+    weight_array: Optional[List[float]] = None,
+    adjustment_factor_array: Optional[List[float]] = None,
+    intensities: List[Tuple[float, ...]]=[(1.0, 0.0, 0.0), (0.0, 1.0, 0.0), (0.0, 0.0, 1.0)],
+    wants_rescale: bool=True,
+) -> Image2DColor:
+    rgb_pixel_data = None
+    if scheme == Scheme.RGB:
+        assert adjustment_factor_array is not None, "adjustment_factor_array must be provided for RGB mode"
+        assert intensities is not None, "intensities must be provided for RGB mode"
+        rgb_pixel_data = gray_to_rgb(
+            pixel_data_arr = pixel_data_arr,
+            adjustment_factor_array = adjustment_factor_array,
+            intensities = intensities,
+            wants_rescale = wants_rescale,
+        )
+    elif scheme == Scheme.CMYK:
+        assert adjustment_factor_array is not None, "adjustment_factor_array must be provided for CMYK mode"
+        assert intensities is not None, "intensities must be provided for CMYK mode"
+        rgb_pixel_data = gray_to_cmyk(
+            pixel_data_arr = pixel_data_arr,
+            adjustment_factor_array = adjustment_factor_array,
+            intensities = intensities,
+            wants_rescale = wants_rescale,
+        )
+    elif scheme == Scheme.COMPOSITE:
+        assert color_array is not None, "color_array must be provided for composite mode"
+        assert weight_array is not None, "weight_array must be provided for composite mode"
+        rgb_pixel_data = gray_to_composite_color(
+            pixel_data_arr = pixel_data_arr,
+            color_array = color_array,
+            weight_array = weight_array,
+            wants_rescale = wants_rescale,
+        )
+    elif scheme == Scheme.STACK:
+        assert pixel_data_arr is not None, "pixel_data_arr must be provided for stack mode"
+        rgb_pixel_data = gray_to_stacked_color(
+            pixel_data_arr = pixel_data_arr,
+        )
+    else:
+        raise ValueError(f"Unimplemented scheme: {scheme}")
+    if scheme.value != Scheme.STACK and wants_rescale:
+        # If we rescaled, clip values that went out of range after multiplication
+        rgb_pixel_data[rgb_pixel_data > 1] = 1
+    return rgb_pixel_data
+

cellprofiler_library_nightly-5.0.0.dev475/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.dev475/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.dev475/cellprofiler_library/opts/graytocolor.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+class Scheme(str, Enum):
+    RGB = "RGB"
+    CMYK = "CMYK"
+    STACK = "Stack"
+    COMPOSITE = "Composite"
+    LEAVE_THIS_BLACK = "Leave this black"
+
+DEFAULT_COLORS = [
+    "#%02x%02x%02x" % color
+    for color in (
+        (255, 0, 0),
+        (0, 255, 0),
+        (0, 0, 255),
+        (128, 128, 0),
+        (128, 0, 128),
+        (0, 128, 128),
+    )
+]

{cellprofiler_library_nightly-5.0.0.dev462 → cellprofiler_library_nightly-5.0.0.dev475}/cellprofiler_library_nightly.egg-info/PKG-INFO

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

@@ -28,7 +28,9 @@ 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
 cellprofiler_library/modules/_identifysecondaryobjects.py
 cellprofiler_library/modules/_identifytertiaryobjects.py
@@ -57,9 +59,12 @@ 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
 cellprofiler_library/opts/identifytertiaryobjects.py