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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev661
+Version: 5.0.0.dev669
 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.dev669}/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.dev669'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev669')
 
-__commit_id__ = commit_id = 'g222155826'
+__commit_id__ = commit_id = 'g51250caf3'

{cellprofiler_library_nightly-5.0.0.dev661 → cellprofiler_library_nightly-5.0.0.dev669}/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
@@ -31,7 +32,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 +43,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 +2871,205 @@ 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

cellprofiler_library_nightly-5.0.0.dev669/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.dev669/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.dev669}/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.dev669/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.dev669
 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.dev669}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -62,6 +62,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
@@ -106,6 +107,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.dev669}/cellprofiler_library_nightly.egg-info/scm_file_list.json

@@ -59,6 +59,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",
@@ -103,6 +104,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.dev669/cellprofiler_library_nightly.egg-info/scm_version.json

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

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"
-}