cellprofiler-library-nightly 5.0.0.dev313__py3-none-any.whl → 5.0.0.dev321__py3-none-any.whl

cellprofiler_library/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev313'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev313')
+__version__ = version = '5.0.0.dev321'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev321')
 
 __commit_id__ = commit_id = None

cellprofiler_library/functions/image_processing.py

@@ -5,10 +5,11 @@ import centrosome
 import centrosome.threshold
 import scipy
 import matplotlib
+import math
 from typing import Any, Optional, Tuple, Callable, Union, List
-from ..types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ObjectSegmentation
-from ..opts import threshold as Threshold
-
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Image2DColor, Image2DGrayscale, ImageAny, ObjectSegmentation, Image2D, Image2DMask
+from cellprofiler_library.opts import threshold as Threshold
+from cellprofiler_library.opts.crop import RemovalMethod
 
 def rgb_to_greyscale(image):
     if image.shape[-1] == 4:
@@ -616,4 +617,234 @@ def image_to_objects(
     if preserve_label and not cast_to_bool:
         return data
 
-    return skimage.measure.label(data, background=background, connectivity=connectivity)
+    return skimage.measure.label(data, background=background, connectivity=connectivity)
+
+###########################################################################
+# CorrectIlluminationApply
+###########################################################################
+
+def apply_divide(image_pixels: Image2D, illum_function_pixel_data: Image2D) -> Image2D:
+    return image_pixels / illum_function_pixel_data
+
+def apply_subtract(image_pixels: Image2D, illum_function_pixel_data: Image2D) -> Image2D:
+    output_image = image_pixels - illum_function_pixel_data
+    output_image[output_image < 0] = 0
+    return output_image
+
+def clip_low(output_pixels: Image2D) -> Image2D:
+    return numpy.where(output_pixels < 0, 0, output_pixels)
+
+def clip_high(output_pixels: Image2D) -> Image2D:
+    return numpy.where(output_pixels > 1, 1, output_pixels)
+
+################################################################################
+# Crop
+################################################################################
+
+def get_ellipse_cropping(
+        orig_image_pixels:  Image2D,
+        ellipse_center:     Tuple[float, float],
+        ellipse_radius:     Tuple[float, float]
+    ) -> Image2DMask:
+    x_center, y_center = ellipse_center
+    x_radius, y_radius = ellipse_radius
+    x_max = orig_image_pixels.shape[1]
+    y_max = orig_image_pixels.shape[0]
+    if x_radius > y_radius:
+        dist_x = math.sqrt(x_radius ** 2 - y_radius ** 2)
+        dist_y = 0
+        major_radius = x_radius
+    else:
+        dist_x = 0
+        dist_y = math.sqrt(y_radius ** 2 - x_radius ** 2)
+        major_radius = y_radius
+
+    focus_1_x, focus_1_y = (x_center - dist_x, y_center - dist_y)
+    focus_2_x, focus_2_y = (x_center + dist_x, y_center + dist_y)
+    y, x = numpy.mgrid[0:y_max, 0:x_max]
+    d1 = numpy.sqrt((x - focus_1_x) ** 2 + (y - focus_1_y) ** 2)
+    d2 = numpy.sqrt((x - focus_2_x) ** 2 + (y - focus_2_y) ** 2)
+    cropping = d1 + d2 <= major_radius * 2
+    return cropping
+
+
+def get_rectangle_cropping(
+    orig_image_pixels:      Image2D,
+    bounding_box:           Tuple[Optional[int], Optional[int], Optional[int], Optional[int]],
+    validate_boundaries:    bool = True
+) -> Image2DMask:
+    cropping = numpy.ones(orig_image_pixels.shape[:2], bool)
+    left, right, top, bottom = bounding_box
+    if validate_boundaries:
+        if left and left > 0:
+            cropping[:, :left] = False
+        if right and right < cropping.shape[1]:
+            cropping[:, right:] = False
+        if top and top > 0:
+            cropping[:top, :] = False
+        if bottom and bottom < cropping.shape[0]:
+            cropping[bottom:, :] = False
+    else:
+        cropping[:, :left] = False
+        cropping[:, right:] = False
+        cropping[:top, :] = False
+        cropping[bottom:, :] = False
+    return cropping
+
+
+def crop_image(
+        image:          Union[Image2D, Image2DMask],
+        crop_mask:      Image2DMask,
+        crop_internal:  Optional[bool]=False
+    ) -> Union[Image2D, Image2DMask]:
+    """Crop an image to the size of the nonzero portion of a crop mask"""
+    i_histogram = crop_mask.sum(axis=1)
+    i_cumsum = numpy.cumsum(i_histogram != 0)
+    j_histogram = crop_mask.sum(axis=0)
+    j_cumsum = numpy.cumsum(j_histogram != 0)
+    if i_cumsum[-1] == 0:
+        # The whole image is cropped away
+        return numpy.zeros((0, 0), dtype=image.dtype)
+    if crop_internal:
+        #
+        # Make up sequences of rows and columns to keep
+        #
+        i_keep = numpy.argwhere(i_histogram > 0)
+        j_keep = numpy.argwhere(j_histogram > 0)
+        #
+        # Then slice the array by I, then by J to get what's not blank
+        #
+        return image[i_keep.flatten(), :][:, j_keep.flatten()].copy()
+    else:
+        #
+        # The first non-blank row and column are where the cumsum is 1
+        # The last are at the first where the cumsum is it's max (meaning
+        # what came after was all zeros and added nothing)
+        #
+        i_first = numpy.argwhere(i_cumsum == 1)[0]
+        i_last = numpy.argwhere(i_cumsum == i_cumsum.max())[0]
+        i_end = i_last + 1
+        j_first = numpy.argwhere(j_cumsum == 1)[0]
+        j_last = numpy.argwhere(j_cumsum == j_cumsum.max())[0]
+        j_end = j_last + 1
+
+        if image.ndim == 3:
+            return image[i_first[0] : i_end[0], j_first[0] : j_end[0], :].copy()
+
+        return image[i_first[0] : i_end[0], j_first[0] : j_end[0]].copy()
+
+
+def get_cropped_mask(
+        cropping:           Image2DMask,
+        mask:               Optional[Image2DMask],
+        removal_method:     RemovalMethod = RemovalMethod.NO,
+) -> Image2DMask:
+    if removal_method == RemovalMethod.NO:
+        #
+        # Check for previous cropping's mask. If it doesn't exist, set it to the current cropping
+        #
+        if mask is None:
+            mask = cropping
+    elif removal_method in (RemovalMethod.EDGES, RemovalMethod.ALL):
+        crop_internal = removal_method == RemovalMethod.ALL
+        #
+        # Check for previous cropping's mask. If it doesn't exist, set it to the region of interest specified
+        # by the cropping. The final mask output size could be smaller as the crop_image function removes
+        # edges by default.
+        #
+        if mask is None:
+            mask = crop_image(cropping, cropping, crop_internal)
+    else:
+        raise NotImplementedError(f"Unimplemented removal method: {removal_method}")
+    assert mask is not None
+    return mask
+
+
+def get_cropped_image_mask(
+        cropping:           Image2DMask,
+        mask:               Optional[Image2DMask],
+        orig_image_mask:    Optional[Image2DMask] = None,
+        removal_method:     RemovalMethod = RemovalMethod.NO,
+) -> Image2DMask:
+    if mask is None:
+        mask = get_cropped_mask(cropping, mask, removal_method)
+    if removal_method == RemovalMethod.NO:
+        #
+        # Check if a mask has been set on the original image. If not, set it to the current mask
+        # This is a mask that could have been set by another module and this module "respects masks".
+        #
+        if orig_image_mask is not None:
+            # Image mask is the region of interest indicator for the final image object.
+            image_mask = orig_image_mask & mask
+        else:
+            image_mask = mask
+
+        return image_mask
+    elif removal_method in (RemovalMethod.EDGES, RemovalMethod.ALL):
+        crop_internal = removal_method == RemovalMethod.ALL
+        #
+        # Check if a mask has been set on the original image. If not, set it to the current mask
+        # This is a mask that could have been set by another module and this module "respects masks".
+        # The final mask output size could be smaller as the crop_image function removes edges by default.
+        #
+        if orig_image_mask is not None:
+            # Image mask is the region of interest indicator for the final image object.
+            image_mask = crop_image(orig_image_mask, cropping, crop_internal) & mask
+        else:
+            image_mask = mask
+    else:
+        raise NotImplementedError(f"Unimplemented removal method: {removal_method}")
+
+    return image_mask
+
+
+def get_cropped_image_pixels(
+        orig_image_pixels:  Image2D,
+        cropping:           Image2DMask,
+        mask:               Optional[Image2DMask],
+        removal_method:     RemovalMethod = RemovalMethod.NO,
+) -> Image2D:
+    if removal_method == RemovalMethod.NO:
+        cropped_pixel_data = apply_crop_keep_rows_and_columns(orig_image_pixels, cropping)
+    elif removal_method in (RemovalMethod.EDGES, RemovalMethod.ALL):
+        cropped_pixel_data = apply_crop_remove_rows_and_columns(orig_image_pixels, cropping, mask, removal_method)
+    else:
+        raise NotImplementedError(f"Unimplemented removal method: {removal_method}")
+    return cropped_pixel_data
+
+
+def apply_crop_keep_rows_and_columns(
+    orig_image_pixels:  Image2D,
+    final_cropping:     Image2DMask,
+) -> Image2D:
+    cropped_pixel_data = orig_image_pixels.copy()
+    cropped_pixel_data = erase_pixels(cropped_pixel_data, final_cropping)
+    return cropped_pixel_data
+
+
+def apply_crop_remove_rows_and_columns(
+        orig_image_pixels:  Image2D,
+        final_cropping:     Image2DMask,
+        mask:               Optional[Image2DMask],
+        removal_method: RemovalMethod = RemovalMethod.EDGES,
+) -> Image2D:
+    if mask is None:
+        mask = get_cropped_mask(final_cropping, mask, removal_method)
+    # Apply first level of cropping to get the region of interest that matches the original image
+    cropped_pixel_data = crop_image(orig_image_pixels, final_cropping, removal_method==RemovalMethod.ALL)
+    cropped_pixel_data = erase_pixels(cropped_pixel_data, mask)
+    return cropped_pixel_data
+
+
+def erase_pixels(
+        cropped_pixel_data: Image2D,
+        crop:               Image2DMask
+        ) -> Image2D:
+    #
+    # Apply crop to all channels automatically for color images
+    #
+    if cropped_pixel_data.ndim == 3:
+        cropped_pixel_data[~crop, :] = 0
+    else:
+        cropped_pixel_data[~crop] = 0
+    return cropped_pixel_data

cellprofiler_library/modules/_correctilluminationapply.py

@@ -0,0 +1,40 @@
+from typing import Annotated, Optional
+from pydantic import Field, validate_call, ConfigDict
+from cellprofiler_library.opts.correctilluminationapply import Method
+from ..types import Image2D
+from ..functions.image_processing import apply_divide, apply_subtract, clip_low, clip_high
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def correct_illumination_apply(
+        image_pixels:               Annotated[Image2D, Field(description="Pixel data of image to apply the illumination function to")],
+        illum_function_pixel_data:  Annotated[Image2D, Field(description="Pixel data of illumination function")],
+        method_divide_or_subtract:  Annotated[Method, Field(description="Method to apply the illumination function")],
+        truncate_low:               Annotated[Optional[bool], Field(description="Set output image values less than 0 equal to 0?")],
+        truncate_high:              Annotated[Optional[bool], Field(description="Set output image values greater than 1 equal to 1?")],
+        ) -> Annotated[Image2D, Field(description="Pixel data of image with illumination function applied")]:
+    """
+    Perform illumination according to the parameters of one image setting group
+    """
+    assert image_pixels.shape[:2] == illum_function_pixel_data.shape[:2], "Input image shape and illumination function shape must be equal"
+    #
+    # Either divide or subtract the illumination image from the original
+    #
+    if method_divide_or_subtract == Method.DIVIDE:
+        output_pixels = apply_divide(image_pixels, illum_function_pixel_data)
+    elif method_divide_or_subtract == Method.SUBTRACT:
+        output_pixels = apply_subtract(image_pixels, illum_function_pixel_data)
+    else:
+        raise ValueError(
+            "Unhandled option for divide or subtract: %s"
+            % method_divide_or_subtract.value
+        )
+    #
+    # Optionally, clip high and low values
+    #
+    if truncate_low:
+        output_pixels = clip_low(output_pixels)
+    if truncate_high:
+        output_pixels = clip_high(output_pixels)
+
+    return output_pixels

cellprofiler_library/modules/_crop.py

@@ -0,0 +1,45 @@
+from typing import Annotated, Optional, Tuple, List
+from pydantic import Field, validate_call, ConfigDict
+import numpy
+from cellprofiler_library.types import Image2D, Image2DMask
+from cellprofiler_library.functions.image_processing import get_cropped_mask, get_cropped_image_mask, get_cropped_image_pixels
+from cellprofiler_library.opts.crop import RemovalMethod, Measurement
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def crop(
+        orig_image_pixels:  Annotated[Image2D, Field(description="Pixel values of the original image")],
+        cropping:           Annotated[Image2DMask, Field(description="The region of interest to be kept. 1 for pixels to keep, 0 for pixels to remove")],
+        mask:               Annotated[Optional[Image2DMask], Field(description="Previous cropping's mask")],
+        orig_image_mask:    Annotated[Optional[Image2DMask], Field(description="Mask that may have been set on the original image")],
+        removal_method:     Annotated[RemovalMethod, Field(description="Removal method")],
+        ) -> Tuple[Image2D, Image2DMask, Image2DMask]:
+    #
+    # Crop the mask
+    #
+    mask = get_cropped_mask(cropping, mask, removal_method)
+
+    #
+    # Crop the image_mask 
+    image_mask = get_cropped_image_mask(cropping, mask, orig_image_mask, removal_method)
+
+    #
+    # Crop the image
+    #
+    cropped_pixel_data = get_cropped_image_pixels(orig_image_pixels, cropping, mask, removal_method)
+
+    return cropped_pixel_data, mask, image_mask
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def measure_area_retained_after_cropping(cropping: Image2DMask) -> int:
+    return numpy.sum(cropping.astype(float))
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def measure_original_image_area(orig_image_pixels: Image2D) -> int:
+    return numpy.product(orig_image_pixels.shape)
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def get_measurements(cropping: Image2DMask, orig_image_pixels:Image2D, cropped_image_name: str = "CroppedImage") -> List[Tuple[str, str, int]]:
+    orig_image_area = measure_original_image_area(orig_image_pixels)
+    area_retained_after_cropping = measure_area_retained_after_cropping(cropping)
+    return [("Image", str(Measurement.ORIGINAL_AREA % cropped_image_name), orig_image_area),
+            ("Image", str(Measurement.AREA_RETAINED % cropped_image_name), area_retained_after_cropping)]

cellprofiler_library/opts/correctilluminationapply.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class Method(str, Enum):
+    DIVIDE = "Divide"
+    SUBTRACT = "Subtract"

cellprofiler_library/opts/crop.py

@@ -0,0 +1,41 @@
+from enum import Enum
+
+class Shape(str, Enum):
+    RECTANGLE = "Rectangle"
+    ELLIPSE = "Ellipse"
+    IMAGE = "Image"
+    OBJECTS = "Objects"
+    CROPPING = "Previous cropping"
+
+class RemovalMethod(str, Enum):
+    NO = "No"
+    EDGES = "Edges"
+    ALL = "All"
+
+class Measurement(str, Enum):
+    AREA_RETAINED = "Crop_AreaRetainedAfterCropping_%s"
+    ORIGINAL_AREA = "Crop_OriginalImageArea_%s"
+
+class CroppingMethod(str, Enum):
+    COORDINATES = "Coordinates"
+    MOUSE = "Mouse"
+
+class CroppingPattern(str, Enum):
+    FIRST = "First"
+    INDIVIDUALLY = "Individually"
+
+class Limits(str, Enum):
+    ABSOLUTE = "Absolute"
+    FROM_EDGE = "From edge"
+
+class Ellipse(str, Enum):
+    XCENTER = "xcenter"
+    YCENTER = "ycenter"
+    XRADIUS = "xradius"
+    YRADIUS = "yradius"
+
+class Rectangle(str, Enum):
+    LEFT = "left"
+    TOP = "top"
+    RIGHT = "right"
+    BOTTOM = "bottom"

{cellprofiler_library_nightly-5.0.0.dev313.dist-info → cellprofiler_library_nightly-5.0.0.dev321.dist-info}/METADATA

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

@@ -1,10 +1,10 @@
 cellprofiler_library/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cellprofiler_library/_version.py,sha256=X4VkWpCY3W1OoL-UO0Ujz6sOnuBoWBDUvHRgT9ivJRQ,721
+cellprofiler_library/_version.py,sha256=mYUqqa6M-iE4MBhf8kLEwQQ_kh9UFT5QdUWnnrI5Hl0,721
 cellprofiler_library/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellprofiler_library/types.py,sha256=5cCxXOO_TE-uSF4ZB6sDG3eTZ1VWDSXUFifg0N4JYs8,8516
 cellprofiler_library/functions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cellprofiler_library/functions/file_processing.py,sha256=jumpdgxReyV5xzF4YXZWhkei9CQ9GtWD-VUCuFh-FZM,5168
-cellprofiler_library/functions/image_processing.py,sha256=qZLEVpG3IOfgPUH_cJ0k6HVWklHU08JJvxWPnO48qIo,24015
+cellprofiler_library/functions/image_processing.py,sha256=s13691o7-peaL-mVOA4J50ZynqXioSjfJ7vfTjfdm5M,33152
 cellprofiler_library/functions/measurement.py,sha256=8pXcEb1fLgwOEDiTJho1_O-fFGTtIp-Qn1lStjQBjbo,29221
 cellprofiler_library/functions/object_processing.py,sha256=3cKNq5ewBf_HWz6rdX3XR4WUbd6SklbHZ_H40xt9ODM,19443
 cellprofiler_library/functions/segmentation.py,sha256=LNE22ByY0X7GepQaHqLdxkzlmIXjD3EglAYJjtT2dGo,25257
@@ -14,6 +14,8 @@ cellprofiler_library/modules/_colortogray.py,sha256=UtiBgh7AXduRBMkHsv2L0u7FayOC
 cellprofiler_library/modules/_combineobjects.py,sha256=dZz0RXjvVukem3e46wPfQWOQCOfMLHaq0KoFzjKVQqs,830
 cellprofiler_library/modules/_convertimagetoobjects.py,sha256=_X2YWEHK4hFaP13LEBD-vIwwUUhgJEJLcTkhyMe4JBA,1075
 cellprofiler_library/modules/_convertobjectstoimage.py,sha256=PMYjH_prBKma4LNgUxmA5GzF7fQ6ko09XszKatTulB4,2274
+cellprofiler_library/modules/_correctilluminationapply.py,sha256=8bZC3AnQv3vpUrNSnLvcc_s0E-P63XbrfwMv7OZNjt4,2084
+cellprofiler_library/modules/_crop.py,sha256=0T0sQsK7o5dHVXMZ4OqvAJkskkyez1MXcnPlU5yqsV4,2422
 cellprofiler_library/modules/_enhanceedges.py,sha256=PaXZck8fPcxRf-IXCstu-OWmsvM_rDDPMMQ3cZFfVZc,2951
 cellprofiler_library/modules/_expandorshrinkobjects.py,sha256=A1oeW_O8C5NLJr-xU1R9pSulDau8XUeWaKiilpr-85g,856
 cellprofiler_library/modules/_fillobjects.py,sha256=1zvlZNJhG8kEzAnVyiSLGPNE338EB5wopD2eK0BVWrc,469
@@ -33,11 +35,13 @@ cellprofiler_library/opts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 cellprofiler_library/opts/colortogray.py,sha256=ptAanLQW9iMgQHgC7xvYlbIbshBd5d7uE48t2F0Z5e8,344
 cellprofiler_library/opts/convertimagetoobjects.py,sha256=9e3VOdpjd4084ATZyFtSQg_VpxbyXrYVFmEFJkrHakg,67
 cellprofiler_library/opts/convertobjectstoimage.py,sha256=U3jeVtKYFgfxbO7NYndanAyZFoEvbyScOq4T8cpjfX8,188
+cellprofiler_library/opts/correctilluminationapply.py,sha256=IkAqjMjaRdsoY2aXw5_dLI1iRYqCwvcNwCWEpWNZrN4,96
+cellprofiler_library/opts/crop.py,sha256=GaArWq3WZd_Ykunj1SSbFOYkqDQ6TXy2MDKxG4fA6ZE,879
 cellprofiler_library/opts/measureimageoverlap.py,sha256=uopQCJTX1Uk-NNDAISsdYEOuOtiEBYOyCwu57ZT7X84,134
 cellprofiler_library/opts/objectsizeshapefeatures.py,sha256=3GIntOH3qXs7F16Tpjmtg7opHYAmmOjEdEwW6q3ht_Y,6306
 cellprofiler_library/opts/threshold.py,sha256=yg_i5to22Nd9hTakaRxo9UIQZRYWFpavJimjl5JONx4,938
-cellprofiler_library_nightly-5.0.0.dev313.dist-info/licenses/LICENSE,sha256=QLWaBS7kAioYx7PmJNXAMJaY8NODcFAag60YlUWuyz0,2276
-cellprofiler_library_nightly-5.0.0.dev313.dist-info/METADATA,sha256=--nBROD-RBpNvkLYSVE2ZBgR00courMI1CoD_ShpwhI,5534
-cellprofiler_library_nightly-5.0.0.dev313.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cellprofiler_library_nightly-5.0.0.dev313.dist-info/top_level.txt,sha256=LXq0ApDeDD4gotb6YFTySzdyScvHfS_pqoTg1QsNLBs,21
-cellprofiler_library_nightly-5.0.0.dev313.dist-info/RECORD,,
+cellprofiler_library_nightly-5.0.0.dev321.dist-info/licenses/LICENSE,sha256=QLWaBS7kAioYx7PmJNXAMJaY8NODcFAag60YlUWuyz0,2276
+cellprofiler_library_nightly-5.0.0.dev321.dist-info/METADATA,sha256=Ib4P-ixq4tVByZcQfLqOeJ6ZbhOfoYEsXV4C0Z2qAa8,5534
+cellprofiler_library_nightly-5.0.0.dev321.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cellprofiler_library_nightly-5.0.0.dev321.dist-info/top_level.txt,sha256=LXq0ApDeDD4gotb6YFTySzdyScvHfS_pqoTg1QsNLBs,21
+cellprofiler_library_nightly-5.0.0.dev321.dist-info/RECORD,,