cellprofiler-library-nightly 5.0.0.dev661__tar.gz → 5.0.0.dev674__tar.gz

{cellprofiler_library_nightly-5.0.0.dev661/cellprofiler_library_nightly.egg-info → cellprofiler_library_nightly-5.0.0.dev674}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev661
+Version: 5.0.0.dev674
 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.dev661 → cellprofiler_library_nightly-5.0.0.dev674}/cellprofiler_library/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '5.0.0.dev661'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev661')
+__version__ = version = '5.0.0.dev674'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev674')
 
-__commit_id__ = commit_id = 'g222155826'
+__commit_id__ = commit_id = 'g70806405c'

{cellprofiler_library_nightly-5.0.0.dev661 → cellprofiler_library_nightly-5.0.0.dev674}/cellprofiler_library/functions/image_processing.py

@@ -8,6 +8,7 @@ from skimage.util import invert as _invert
 import skimage.transform
 import skimage
 import skimage.restoration
+import skimage.exposure
 import centrosome
 import centrosome.threshold
 import centrosome.filter
@@ -23,6 +24,7 @@ from skimage.restoration import denoise_bilateral
 from centrosome.cpmorphology import get_line_pts, all_connected_components
 from scipy.ndimage import binary_erosion, binary_fill_holes
 from scipy.ndimage import mean as mean_of_labels
+from skimage.feature import peak_local_max
 from scipy.fftpack import fft2, ifft2
 from cellprofiler_library.types import (
     ImageGrayscale, ImageGrayscaleMask, 
@@ -31,7 +33,7 @@ from cellprofiler_library.types import (
     ImageAny, ImageAnyMask, 
     ObjectSegmentation, 
     Image2D, Image2DMask, 
-    StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask, Image2DBinary, ObjectLabel, ImageBinary, Pixel
+    StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask, Image2DBinary, ObjectLabel, ImageBinary, Pixel, PixelAny
 )
 from cellprofiler_library.opts import threshold as Threshold
 from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
@@ -42,7 +44,7 @@ from cellprofiler_library.opts.resize import ResizingMethod, DimensionMethod, In
 from cellprofiler_library.opts.imagemath import Operator
 from cellprofiler_library.opts.flipandrotate import RotationCoordinateAlignmnet
 from cellprofiler_library.opts.enhanceedges import EdgeDirection
-
+from cellprofiler_library.opts.rescaleintensity import MaximumIntensityMethod, MinimumIntensityMethod
 invert = cast(Callable[[ImageAny], ImageAny], _invert)
 isscalar = cast(Callable[[Optional[ImageAny]], bool], _isscalar)
 
@@ -2870,3 +2872,240 @@ def reshape_image(
     result[: source.shape[0], : source.shape[1]] = source
     return result
 
+
+###############################################################################
+# RescaleIntensity
+###############################################################################
+
+def rescale(
+        image_pixel_data: ImageAny, 
+        in_range: Tuple[float, float],
+        out_range: Tuple[float, float] = (0.0, 1.0)
+    ) -> ImageAny:
+    data = 1.0 * image_pixel_data
+
+    rescaled = skimage.exposure.rescale_intensity(
+        data, in_range=in_range, out_range=out_range
+    )
+
+    return rescaled
+
+
+def stretch_rescale(
+        data: ImageAny, 
+        mask: ImageAnyMask, 
+        multichannel: bool = False
+    ) -> ImageAny:
+    if multichannel:
+        splitaxis = data.ndim - 1
+        singlechannels = numpy.split(data, data.shape[-1], splitaxis)
+        newchannels = []
+        for channel in singlechannels:
+            channel = numpy.squeeze(channel, axis=splitaxis)
+            if (masked_channel := channel[mask]).size == 0:
+                in_range = (0, 1)
+            else:
+                in_range = (min(masked_channel), max(masked_channel))
+
+            rescaled = rescale(channel, in_range)
+
+            newchannels.append(rescaled)
+        full_rescaled = numpy.stack(newchannels, axis=-1)
+        return full_rescaled
+    if (masked_data := data[mask]).size == 0:
+        in_range = (0, 1)
+    else:
+        in_range = (min(masked_data), max(masked_data))
+    return rescale(data, in_range)
+
+
+def manual_input_range(
+        data: ImageAny, 
+        mask: Optional[ImageAnyMask], 
+        source_high: float, 
+        source_low: float, 
+        source_scale_min: float, 
+        source_scale_max: float, 
+        auto_high: MaximumIntensityMethod, 
+        auto_low: MinimumIntensityMethod, 
+        global_min: Optional[PixelAny],
+        global_max: Optional[PixelAny],
+    ) -> ImageAny:
+    return manual_io_range(
+        data, 
+        mask, 
+        source_high, 
+        source_low, 
+        source_scale_min, 
+        source_scale_max, 
+        auto_high, 
+        auto_low, 
+        global_min,
+        global_max
+    )
+
+
+def manual_io_range(
+        data: ImageAny, 
+        mask: Optional[ImageAnyMask], 
+        source_high: float, 
+        source_low: float, 
+        source_scale_min: float, 
+        source_scale_max: float, 
+        auto_high: MaximumIntensityMethod, 
+        auto_low: MinimumIntensityMethod, 
+        global_min: Optional[PixelAny],
+        global_max: Optional[PixelAny],
+        dest_scale_min: Optional[float]=None, 
+        dest_scale_max: Optional[float]=None
+    ) -> ImageAny:
+    in_range = get_source_range(data, mask, source_high, source_low, source_scale_min, source_scale_max, auto_high, auto_low, global_min, global_max)
+    if dest_scale_min is None and dest_scale_max is None:
+        return rescale(data, in_range)
+    else:
+        out_range = (dest_scale_min, dest_scale_max)
+        return rescale(data, in_range, out_range)
+
+
+def divide(data: ImageAny, value: float) -> ImageAny:
+    if value == 0.0:
+        raise ZeroDivisionError("Cannot divide pixel intensity by 0.")
+
+    return data / value
+
+
+def divide_by_image_minimum(data: ImageAny, mask: ImageAnyMask) -> ImageAny:
+    if (masked_data := data[mask]).size == 0:
+        src_min = numpy.float64(0)
+    else:
+        src_min = numpy.min(masked_data)
+
+    return divide(data, float(src_min))
+
+
+def divide_by_image_maximum(data: ImageAny, mask: ImageAnyMask) -> ImageAny:
+    if (masked_data := data[mask]).size == 0:
+        src_max = numpy.float64(1)
+    else:
+        src_max = numpy.max(masked_data)
+
+    return divide(data, float(src_max))
+
+
+def divide_by_value(data: ImageAny, divisor_value: float):
+    return divide(data, divisor_value)
+
+
+def scale_by_image_maximum(
+        data: ImageAny, 
+        mask: ImageAnyMask, 
+        reference_data: ImageAny, 
+        reference_mask: ImageGrayscaleMask
+    ) -> ImageAny:
+    ###
+    # Scale the image by the maximum of another image
+    #
+    # Find the maximum value within the unmasked region of the input
+    # and reference image. Multiply by the reference maximum, divide
+    # by the input maximum to scale the input image to the same
+    # range as the reference image
+    ###
+    if (masked_input := data[mask]).size == 0:
+        return data
+    else:
+        image_max = numpy.max(masked_input)
+
+    if image_max == 0:
+        return data
+
+
+    if (masked_ref := reference_data[reference_mask]).size == 0:
+        reference_max = 1
+    else:
+        reference_max = numpy.max(masked_ref)
+
+    return divide(data * reference_max, float(image_max))
+
+
+def get_source_range(
+        data: ImageAny, 
+        mask: Optional[ImageAnyMask], 
+        source_high: float, 
+        source_low: float, 
+        source_scale_min: float, 
+        source_scale_max: float, 
+        auto_high: MaximumIntensityMethod, 
+        auto_low: MinimumIntensityMethod, 
+        global_min: Optional[PixelAny],
+        global_max: Optional[PixelAny],
+    ) -> Tuple[float, float]:
+    """Get the source range, accounting for automatically computed values"""
+    input_pixels = None
+    if (
+        auto_high == MaximumIntensityMethod.CUSTOM_VALUE.value
+        and auto_low == MinimumIntensityMethod.CUSTOM_VALUE.value
+    ):
+        return source_scale_min, source_scale_max
+
+    if (
+        auto_low == MinimumIntensityMethod.EACH_IMAGE.value
+        or auto_high == MaximumIntensityMethod.EACH_IMAGE.value
+    ):
+        input_pixels = data
+        if mask is not None:
+            input_pixels = input_pixels[mask]
+            if input_pixels.size == 0:
+                return 0, 1
+
+    if auto_low == MinimumIntensityMethod.ALL_IMAGES.value:
+        src_min = float(global_min or 0)
+    elif auto_low == MinimumIntensityMethod.EACH_IMAGE.value:
+        assert input_pixels is not None, "Invalid settings for automatic minimum, please check your settings and data"
+        src_min = float(numpy.min(input_pixels))
+    else:
+        src_min = source_low
+
+    if auto_high == MaximumIntensityMethod.ALL_IMAGES.value:
+        src_max = float(global_max or 0)
+    elif auto_high == MaximumIntensityMethod.EACH_IMAGE.value:
+        assert input_pixels is not None, "Invalid settings for automatic maximum, please check your settings and data"
+        src_max = float(numpy.max(input_pixels))
+    else:
+        src_max = source_high
+        
+    return src_min, src_max
+
+################################################################################
+# FindMaxima
+################################################################################
+
+def find_maxima_in_data(
+        x_data: ImageAny, 
+        min_distance_value: int, 
+        label_maxima: bool, 
+        th_abs: Optional[float]=None
+    ) -> Union[ImageBinary, ObjectSegmentation]:
+    maxima_coords = peak_local_max(
+        x_data,
+        min_distance=min_distance_value,
+        threshold_abs=th_abs,
+    )
+    y_data = numpy.zeros(x_data.shape, dtype=bool)
+    y_data[tuple(maxima_coords.T)] = True
+
+    if label_maxima:
+        y_data = scipy.ndimage.label(y_data)[0]
+    return y_data
+
+def find_maxima_threshold(x_data: ImageAny) -> ImageAny:
+    """Identity function, just returns the input"""
+    return x_data
+
+def apply_target_mask(x_data: ImageAny, masking_image: Union[ImageAny,ObjectSegmentation]) -> ImageAny:
+    mask = masking_image.astype(bool)
+    x_data[~mask] = 0
+    return x_data
+
+
+
+

cellprofiler_library_nightly-5.0.0.dev674/cellprofiler_library/modules/_findmaxima.py

@@ -0,0 +1,31 @@
+import scipy.ndimage
+from typing import Optional, Annotated, Union
+from pydantic import validate_call, ConfigDict, Field
+from cellprofiler_library.types import ImageAny, ObjectSegmentation, ImageBinary
+from cellprofiler_library.opts.findmaxima import BackgroundExclusionMode
+from cellprofiler_library.functions.image_processing import find_maxima_in_data, find_maxima_threshold, apply_target_mask
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def find_maxima(
+        x_data:              Annotated[ImageAny, Field(description="Input image to search for maxima")],
+        exclude_mode:        Annotated[BackgroundExclusionMode, Field(description="Method for excluding background")],
+        min_distance_value:  Annotated[int, Field(description="Minimum distance between maxima")], #Minimum distance between maxima
+        label_maxima:        Annotated[bool, Field(description="Individually label maxima?")],
+        min_intensity_value: Annotated[Optional[float], Field(description="Specify the minimum intensity of a peak")],
+        target_mask:         Annotated[Optional[Union[ImageAny,ObjectSegmentation]], Field(description="The image or objects to search within")], 
+    ) -> Union[ImageBinary, ObjectSegmentation]:
+    th_abs = min_intensity_value
+
+    if exclude_mode.value == BackgroundExclusionMode.THRESHOLD.value:
+        x_data = find_maxima_threshold(x_data)
+    elif exclude_mode.value == BackgroundExclusionMode.MASK.value:
+        assert target_mask is not None, "Mask image is required for mask mode"
+        x_data = apply_target_mask(x_data, target_mask)
+    elif exclude_mode.value == BackgroundExclusionMode.OBJECTS.value:
+        assert target_mask is not None, "Objects are required for within objects mode"
+        x_data = apply_target_mask(x_data, target_mask)
+    else:
+        raise NotImplementedError("Invalid background method choice")
+    
+    return find_maxima_in_data(x_data, min_distance_value, label_maxima, th_abs)
+

cellprofiler_library_nightly-5.0.0.dev674/cellprofiler_library/modules/_rescaleintensity.py

@@ -0,0 +1,60 @@
+from typing import Optional, Annotated
+from pydantic import validate_call, ConfigDict, Field
+from cellprofiler_library.opts.rescaleintensity import RescaleMethod, MinimumIntensityMethod, MaximumIntensityMethod
+from cellprofiler_library.types import ImageAny, ImageAnyMask, ImageGrayscaleMask, PixelAny
+from cellprofiler_library.functions.image_processing import stretch_rescale, manual_input_range, manual_io_range, divide_by_image_maximum, divide_by_image_minimum, divide_by_value, scale_by_image_maximum
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def rescale_intensity(
+        rescale_method:         Annotated[RescaleMethod, Field(description="Method to rescale the image")],
+        in_pixel_data:          Annotated[ImageAny, Field(description="Input image data")],
+        in_mask:                Annotated[ImageAnyMask, Field(description="Input image mask")],
+        input_image_has_mask:   Annotated[bool, Field(description="Whether the input image has a mask")],
+        in_multichannel:        Annotated[bool, Field(description="Whether the input image is multichannel")],
+        divisor_value:          Annotated[float, Field(description="Value to divide the input image by (for divide by value)")],
+        auto_high:              Annotated[MaximumIntensityMethod, Field(description="Method to determine the maximum intensity")],
+        auto_low:               Annotated[MinimumIntensityMethod, Field(description="Method to determine the minimum intensity")],
+        source_high:            Annotated[float, Field(description="Upper intensity limit for the input image")],
+        source_low:             Annotated[float, Field(description="Lower intensity limit for the input image")],
+        source_scale_min:       Annotated[float, Field(description="Intensity range for the input image - minimum")],
+        source_scale_max:       Annotated[float, Field(description="Intensity range for the input image - maximum")],
+        global_min:             Annotated[Optional[PixelAny], Field(description="Intensity range for all images - minimum")],
+        global_max:             Annotated[Optional[PixelAny], Field(description="Intensity range for all images = maximum")],
+        dest_scale_min:         Annotated[Optional[float], Field(description="Intensity range for the output image - minimum")],
+        dest_scale_max:         Annotated[Optional[float], Field(description="Intensity range for the output image - maximum")],
+        reference_image_pixel_data: Annotated[Optional[ImageAny], Field(description="Reference image data - for scale by image maximum")],
+        reference_image_mask:   Annotated[Optional[ImageGrayscaleMask], Field(description="Reference image mask - for scale by image maximum")],
+    ) -> ImageAny:
+    if rescale_method == RescaleMethod.STRETCH.value:
+        output_image = stretch_rescale(in_pixel_data, in_mask, in_multichannel)
+    elif (rescale_method == RescaleMethod.MANUAL_INPUT_RANGE.value) or (rescale_method == RescaleMethod.MANUAL_IO_RANGE.value):
+        in_mask_manual_input = None if input_image_has_mask else in_mask # for this method, mask needs to be None if not present
+        if rescale_method == RescaleMethod.MANUAL_INPUT_RANGE.value:
+            output_image = manual_input_range(
+                in_pixel_data,
+                in_mask_manual_input,
+                source_high, source_low, source_scale_min, source_scale_max, auto_high, auto_low, global_min, global_max
+            )
+        else:
+            output_image = manual_io_range(
+                in_pixel_data,
+                in_mask_manual_input,
+                source_high, source_low, source_scale_min, source_scale_max, auto_high, auto_low, global_min, global_max, dest_scale_min, dest_scale_max
+                )
+    elif rescale_method == RescaleMethod.DIVIDE_BY_IMAGE_MINIMUM.value:
+        output_image = divide_by_image_minimum(in_pixel_data, in_mask)
+    elif rescale_method == RescaleMethod.DIVIDE_BY_IMAGE_MAXIMUM.value:
+        output_image = divide_by_image_maximum(in_pixel_data, in_mask)
+    elif rescale_method == RescaleMethod.DIVIDE_BY_VALUE.value:
+        output_image = divide_by_value(in_pixel_data, divisor_value)
+    elif rescale_method == RescaleMethod.DIVIDE_BY_MEASUREMENT.value:
+        # TODO: 5088 - update this once measurement format is finalized
+        raise NotImplementedError("Rescale by measurement not implemented in library yet")
+    elif rescale_method == RescaleMethod.SCALE_BY_IMAGE_MAXIMUM.value:
+        assert reference_image_pixel_data is not None, "Reference image is required for scale by image maximum"
+        assert reference_image_mask is not None, "Reference image mask is required for scale by image maximum"
+        output_image = scale_by_image_maximum(in_pixel_data, in_mask, reference_image_pixel_data, reference_image_mask)
+    else:
+        raise ValueError(f"Invalid rescale method: {rescale_method.value}")    
+    return output_image
+

cellprofiler_library_nightly-5.0.0.dev674/cellprofiler_library/opts/findmaxima.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class BackgroundExclusionMode(str, Enum):
+    """Background exclusion method"""
+    THRESHOLD = "Threshold"
+    MASK = "Mask"
+    OBJECTS = "Within Objects"

cellprofiler_library_nightly-5.0.0.dev674/cellprofiler_library/opts/rescaleintensity.py

@@ -0,0 +1,39 @@
+from enum import Enum
+
+class RescaleMethod(str, Enum):
+
+    STRETCH = "Stretch each image to use the full intensity range"
+    MANUAL_INPUT_RANGE = "Choose specific values to be reset to the full intensity range"
+    MANUAL_IO_RANGE = "Choose specific values to be reset to a custom range"
+    DIVIDE_BY_IMAGE_MINIMUM = "Divide by the image's minimum"
+    DIVIDE_BY_IMAGE_MAXIMUM = "Divide by the image's maximum"
+    DIVIDE_BY_VALUE = "Divide each image by the same value"
+    DIVIDE_BY_MEASUREMENT = "Divide each image by a previously calculated value"
+    SCALE_BY_IMAGE_MAXIMUM = "Match the image's maximum to another image's maximum"
+
+M_ALL = [
+    RescaleMethod.STRETCH,
+    RescaleMethod.MANUAL_INPUT_RANGE,
+    RescaleMethod.MANUAL_IO_RANGE,
+    RescaleMethod.DIVIDE_BY_IMAGE_MINIMUM,
+    RescaleMethod.DIVIDE_BY_IMAGE_MAXIMUM,
+    RescaleMethod.DIVIDE_BY_VALUE,
+    RescaleMethod.DIVIDE_BY_MEASUREMENT,
+    RescaleMethod.SCALE_BY_IMAGE_MAXIMUM,
+]
+
+_CUSTOM_VALUE = "Custom"
+
+class MinimumIntensityMethod(str, Enum):
+    CUSTOM_VALUE = _CUSTOM_VALUE
+    ALL_IMAGES = "Minimum of all images"
+    EACH_IMAGE = "Minimum for each image"
+
+LOW_ALL = [MinimumIntensityMethod.CUSTOM_VALUE, MinimumIntensityMethod.EACH_IMAGE, MinimumIntensityMethod.ALL_IMAGES]
+
+class MaximumIntensityMethod(str, Enum):
+    CUSTOM_VALUE = _CUSTOM_VALUE
+    ALL_IMAGES = "Maximum of all images"
+    EACH_IMAGE = "Maximum for each image"
+
+HIGH_ALL = [MaximumIntensityMethod.CUSTOM_VALUE, MaximumIntensityMethod.EACH_IMAGE, MaximumIntensityMethod.ALL_IMAGES]

{cellprofiler_library_nightly-5.0.0.dev661 → cellprofiler_library_nightly-5.0.0.dev674}/cellprofiler_library/types.py

@@ -82,25 +82,34 @@ def validate_object_segmentation_ijv(ijv: NDArray[np.int_]) -> NDArray[np.int_]:
         raise ValueError(f"Expected a 2-dimensional array with 3 columns, got {ijv.shape[1]}")
     return ijv
 
+PixelAny_ = Union[np.float32, np.float64, np.int_, np.int8, np.int16, np.int32, np.uint8, np.uint16, np.uint32, np.bool_]
+PixelAny = Annotated[PixelAny_, Field(description="Pixel value, before conversion to float")]
+Pixel_ = Union[np.float32, np.float64]
 Pixel = Annotated[Union[np.float32, np.float64], Field(description="Pixel value")]
 ObjectLabel =           Annotated[Union[np.int8, np.int16, np.int32], Field(description="Object label")]
 ObjectIndices =         Annotated[np.int32, Field(description="Object indices")]
 
-Image2DColor =          Annotated[NDArray[Pixel],       Field(description="2D image with multiple channels of type float32"), AfterValidator(create_type_validator(False, True, False, Union[np.float32, np.float64]))]
+Image2DColor =          Annotated[NDArray[Pixel],       Field(description="2D image with multiple channels of type float32"), AfterValidator(create_type_validator(False, True, False, Pixel_))]
+Image2DColorAny =          Annotated[NDArray[PixelAny],       Field(description="2D image with multiple channels of any type"), AfterValidator(create_type_validator(False, True, False, PixelAny_))]
 Image2DColorMask =      Annotated[NDArray[np.bool_],    Field(description="2D color mask"),        AfterValidator(create_type_validator(False, True, False, np.bool_))]
-Image2DGrayscale =      Annotated[NDArray[Pixel],       Field(description="2D grayscale image of type float32"), AfterValidator(create_type_validator(False, False, False, Union[np.float32, np.float64]))]
+Image2DGrayscale =      Annotated[NDArray[Pixel],       Field(description="2D grayscale image of type float32"), AfterValidator(create_type_validator(False, False, False, Pixel_))]
+Image2DGrayscaleAny =      Annotated[NDArray[PixelAny],       Field(description="2D grayscale image of any type"), AfterValidator(create_type_validator(False, False, False, PixelAny_))]
 Image2DGrayscaleMask =  Annotated[NDArray[np.bool_],    Field(description="2D grayscale mask"),    AfterValidator(create_type_validator(False, False, False, np.bool_))]
 Image2DBinary =         Annotated[NDArray[np.bool_],    Field(description="2D binary image"),      AfterValidator(create_type_validator(False, False, False, np.bool_))]
 Image2DBinaryMask =     Annotated[NDArray[np.bool_],    Field(description="2D binary mask"),       AfterValidator(create_type_validator(False, False, False, np.bool_))]
 Image2DInt =            Annotated[NDArray[np.int32],    Field(description="2D int32 image"),       AfterValidator(create_type_validator(False, False, False, np.int32))]
+Image2DUInt =           Annotated[NDArray[np.uint8],    Field(description="2D uint8 image"),       AfterValidator(create_type_validator(False, False, False, np.uint8))]
 
-Image3DColor =          Annotated[NDArray[Pixel],       Field(description="3D image with multiple channels of type float32"), AfterValidator(create_type_validator(True, True, False, Union[np.float32, np.float64]))]
+Image3DColor =          Annotated[NDArray[Pixel],       Field(description="3D image with multiple channels of type float32"), AfterValidator(create_type_validator(True, True, False, Pixel_))]
+Image3DColorAny =          Annotated[NDArray[PixelAny],       Field(description="3D image with multiple channels of any type"), AfterValidator(create_type_validator(True, True, False, PixelAny_))]
 Image3DColorMask =      Annotated[NDArray[np.bool_],    Field(description="3D image with multiple channels of type float32"), AfterValidator(create_type_validator(True, True, False, np.bool_))]
-Image3DGrayscale =      Annotated[NDArray[Pixel],       Field(description="3D grayscale image of type float32"), AfterValidator(create_type_validator(True, False, False, Union[np.float32, np.float64]))]
+Image3DGrayscale =      Annotated[NDArray[Pixel],       Field(description="3D grayscale image of type float32"), AfterValidator(create_type_validator(True, False, False, Pixel_))]
+Image3DGrayscaleAny =      Annotated[NDArray[PixelAny],       Field(description="3D grayscale image of any type"), AfterValidator(create_type_validator(True, False, False, PixelAny_))]
 Image3DGrayscaleMask =  Annotated[NDArray[np.bool_],    Field(description="3D grayscale mask"),    AfterValidator(create_type_validator(True, False, False, np.bool_))]
 Image3DBinary =         Annotated[NDArray[np.bool_],    Field(description="3D binary image"),      AfterValidator(create_type_validator(True, False, False, np.bool_))]
 Image3DBinaryMask =     Annotated[NDArray[np.bool_],    Field(description="3D binary mask"),       AfterValidator(create_type_validator(True, False, False, np.bool_))]
 Image3DInt =            Annotated[NDArray[np.int32],    Field(description="3D int32 image"),       AfterValidator(create_type_validator(True, False, False, np.int32))]
+Image3DUInt =           Annotated[NDArray[np.uint8],    Field(description="3D uint8 image"),       AfterValidator(create_type_validator(True, False, False, np.uint8))]
 
 # see cellprofiler_library.functions.segmentation._validate_<type> for more details 
 ObjectLabelsDense =     Annotated[NDArray[ObjectLabel], Field(description="Dense array of object labels"), AfterValidator(validate_object_labels_dense)]
@@ -118,7 +127,7 @@ ImageColorMask =        Union[Image2DColorMask, Image3DColorMask]
 ImageBinary =           Union[Image2DBinary, Image3DBinary]
 ImageBinaryMask =       Union[Image2DBinaryMask, Image3DBinaryMask]
 
-ImageAny =              Union[Image2DColor, Image3DColor, Image2DGrayscale, Image3DGrayscale, Image2DBinary, Image3DBinary, Image2DInt, Image3DInt]
+ImageAny =              Union[Image2DColorAny, Image3DColorAny, Image2DGrayscaleAny, Image3DGrayscaleAny, Image2DBinary, Image3DBinary, Image2DInt, Image3DInt]
 ImageAnyMask =          Union[Image2DColorMask, Image3DColorMask, Image2DGrayscaleMask, Image3DGrayscaleMask, Image2DBinaryMask, Image3DBinaryMask]
 
 Image2D =               Union[Image2DColor, Image2DGrayscale, Image2DBinary]

{cellprofiler_library_nightly-5.0.0.dev661 → cellprofiler_library_nightly-5.0.0.dev674/cellprofiler_library_nightly.egg-info}/PKG-INFO

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

@@ -31,6 +31,7 @@ cellprofiler_library/modules/_erodeobjects.py
 cellprofiler_library/modules/_expandorshrinkobjects.py
 cellprofiler_library/modules/_fillobjects.py
 cellprofiler_library/modules/_filterobjects.py
+cellprofiler_library/modules/_findmaxima.py
 cellprofiler_library/modules/_flipandrotate.py
 cellprofiler_library/modules/_gaussianfilter.py
 cellprofiler_library/modules/_graytocolor.py
@@ -62,6 +63,7 @@ cellprofiler_library/modules/_overlayobjects.py
 cellprofiler_library/modules/_overlayoutlines.py
 cellprofiler_library/modules/_reducenoise.py
 cellprofiler_library/modules/_removeholes.py
+cellprofiler_library/modules/_rescaleintensity.py
 cellprofiler_library/modules/_resize.py
 cellprofiler_library/modules/_savecroppedobjects.py
 cellprofiler_library/modules/_shrinktoobjectcenters.py
@@ -82,6 +84,7 @@ cellprofiler_library/opts/enhanceorsuppressfeatures.py
 cellprofiler_library/opts/erodeimage.py
 cellprofiler_library/opts/erodeobjects.py
 cellprofiler_library/opts/filterobjects.py
+cellprofiler_library/opts/findmaxima.py
 cellprofiler_library/opts/flipandrotate.py
 cellprofiler_library/opts/graytocolor.py
 cellprofiler_library/opts/identifydeadworms.py
@@ -106,6 +109,7 @@ cellprofiler_library/opts/morph.py
 cellprofiler_library/opts/objectsizeshapefeatures.py
 cellprofiler_library/opts/overlayoutlines.py
 cellprofiler_library/opts/removeholes.py
+cellprofiler_library/opts/rescaleintensity.py
 cellprofiler_library/opts/resize.py
 cellprofiler_library/opts/shrinktoobjectcenters.py
 cellprofiler_library/opts/smooth.py

{cellprofiler_library_nightly-5.0.0.dev661 → cellprofiler_library_nightly-5.0.0.dev674}/cellprofiler_library_nightly.egg-info/scm_file_list.json

@@ -28,6 +28,7 @@
     "cellprofiler_library/modules/_expandorshrinkobjects.py",
     "cellprofiler_library/modules/_fillobjects.py",
     "cellprofiler_library/modules/_filterobjects.py",
+    "cellprofiler_library/modules/_findmaxima.py",
     "cellprofiler_library/modules/_flipandrotate.py",
     "cellprofiler_library/modules/_gaussianfilter.py",
     "cellprofiler_library/modules/_graytocolor.py",
@@ -59,6 +60,7 @@
     "cellprofiler_library/modules/_overlayoutlines.py",
     "cellprofiler_library/modules/_reducenoise.py",
     "cellprofiler_library/modules/_removeholes.py",
+    "cellprofiler_library/modules/_rescaleintensity.py",
     "cellprofiler_library/modules/_resize.py",
     "cellprofiler_library/modules/_savecroppedobjects.py",
     "cellprofiler_library/modules/_shrinktoobjectcenters.py",
@@ -79,6 +81,7 @@
     "cellprofiler_library/opts/erodeimage.py",
     "cellprofiler_library/opts/erodeobjects.py",
     "cellprofiler_library/opts/filterobjects.py",
+    "cellprofiler_library/opts/findmaxima.py",
     "cellprofiler_library/opts/flipandrotate.py",
     "cellprofiler_library/opts/graytocolor.py",
     "cellprofiler_library/opts/identifydeadworms.py",
@@ -103,6 +106,7 @@
     "cellprofiler_library/opts/objectsizeshapefeatures.py",
     "cellprofiler_library/opts/overlayoutlines.py",
     "cellprofiler_library/opts/removeholes.py",
+    "cellprofiler_library/opts/rescaleintensity.py",
     "cellprofiler_library/opts/resize.py",
     "cellprofiler_library/opts/shrinktoobjectcenters.py",
     "cellprofiler_library/opts/smooth.py",

cellprofiler_library_nightly-5.0.0.dev674/cellprofiler_library_nightly.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "5.0.0.dev0",
+  "distance": 674,
+  "node": "g70806405c22aad5d5e470413232c1491aac2661d",
+  "dirty": true,
+  "branch": "main",
+  "node_date": "2026-08-24"
+}

cellprofiler_library_nightly-5.0.0.dev661/cellprofiler_library_nightly.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "5.0.0.dev0",
-  "distance": 661,
-  "node": "g222155826b53073e015588d1def75edb54970ad2",
-  "dirty": true,
-  "branch": "main",
-  "node_date": "2026-08-19"
-}