cellprofiler-library-nightly 5.0.0.dev416__tar.gz → 5.0.0.dev454__tar.gz

{cellprofiler_library_nightly-5.0.0.dev416 → cellprofiler_library_nightly-5.0.0.dev454}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev416 → cellprofiler_library_nightly-5.0.0.dev454}/cellprofiler_library/functions/image_processing.py

@@ -382,7 +382,7 @@ def get_threshold_robust_background(
     upper_outlier_fraction: float = 0.05,
     averaging_method:       Threshold.AveragingMethod = Threshold.AveragingMethod.MEAN,
     variance_method:        Threshold.VarianceMethod = Threshold.VarianceMethod.STANDARD_DEVIATION,
-    number_of_deviations:   int = 2,
+    number_of_deviations:   float = 2.0,
 ) -> float:
     """Calculate threshold based on mean & standard deviation.
     The threshold is calculated by trimming the top and bottom 5% of

{cellprofiler_library_nightly-5.0.0.dev416 → cellprofiler_library_nightly-5.0.0.dev454}/cellprofiler_library/functions/object_processing.py

@@ -1,14 +1,16 @@
-
-import centrosome.cpmorphology
 import numpy
+from numpy.typing import NDArray
 import scipy.ndimage
 import skimage.morphology
-import cellprofiler.utilities.morphology
-import mahotas
 import matplotlib.cm
-from numpy.typing import NDArray
-from typing import Optional, Literal, Tuple
-from cellprofiler_library.types import ImageAnyMask, ObjectLabel, ImageColor, ImageGrayscale, ImageBinary, ObjectSegmentation, StructuringElement
+import mahotas
+import centrosome.cpmorphology
+import cellprofiler.utilities.morphology
+from typing import Optional, Literal, Tuple, Union
+from cellprofiler_library.types import ImageAnyMask, ObjectLabel, ImageColor, ImageGrayscale, Image2DGrayscale, Image2DGrayscaleMask, ImageBinary, ObjectSegmentation, StructuringElement
+from cellprofiler_library.types import Image2DBinary
+from cellprofiler_library.opts.identifyprimaryobjects import UnclumpMethod, WatershedMethod, FillHolesMethod
+
 
 def shrink_to_point(labels, fill):
     """
@@ -17,22 +19,22 @@ def shrink_to_point(labels, fill):
     """
 
     if fill:
-        labels=centrosome.cpmorphology.fill_labeled_holes(labels)
+        labels = centrosome.cpmorphology.fill_labeled_holes(labels)
     return centrosome.cpmorphology.binary_shrink(labels)
 
+
 def shrink_defined_pixels(labels, fill, iterations):
     """
     Remove pixels around the perimeter of an object unless
-    doing so would change the object’s Euler number `iterations` times. 
+    doing so would change the object’s Euler number `iterations` times.
     Processing stops automatically when there are no more pixels to
     remove.
     """
 
     if fill:
-        labels=centrosome.cpmorphology.fill_labeled_holes(labels)
-    return centrosome.cpmorphology.binary_shrink(
-                labels, iterations=iterations
-            )
+        labels = centrosome.cpmorphology.fill_labeled_holes(labels)
+    return centrosome.cpmorphology.binary_shrink(labels, iterations=iterations)
+
 
 def add_dividing_lines(labels):
     """
@@ -51,20 +53,21 @@ def add_dividing_lines(labels):
 
     return out_labels
 
+
 def skeletonize(labels):
     """
     Erode each object to its skeleton.
     """
     return centrosome.cpmorphology.skeletonize_labels(labels)
 
+
 def despur(labels, iterations):
     """
     Remove or reduce the length of spurs in a skeletonized
     image. The algorithm reduces spur size by `iterations` pixels.
     """
-    return centrosome.cpmorphology.spur(
-                labels, iterations=iterations
-            )
+    return centrosome.cpmorphology.spur(labels, iterations=iterations)
+
 
 def expand(labels, distance):
     """
@@ -85,6 +88,7 @@ def expand(labels, distance):
 
     return out_labels
 
+
 def expand_until_touching(labels):
     """
     Expand objects, assigning every pixel in the
@@ -94,22 +98,23 @@ def expand_until_touching(labels):
     distance = numpy.max(labels.shape)
     return expand(labels, distance)
 
+
 def expand_defined_pixels(labels, iterations):
     """
     Expand each object by adding background pixels
-    adjacent to the image `iterations` times. Processing stops 
+    adjacent to the image `iterations` times. Processing stops
     automatically if there are no more background pixels.
     """
     return expand(labels, iterations)
 
 def merge_objects(labels_x, labels_y, dimensions):
     """
-    Make overlapping objects combine into a single object, taking 
+    Make overlapping objects combine into a single object, taking
     on the label of the object from the initial set.
 
-    If an object overlaps multiple objects, each pixel of the added 
-    object will be assigned to the closest object from the initial 
-    set. This is primarily useful when the same objects appear in 
+    If an object overlaps multiple objects, each pixel of the added
+    object will be assigned to the closest object from the initial
+    set. This is primarily useful when the same objects appear in
     both sets.
     """
     output = numpy.zeros_like(labels_x)
@@ -129,7 +134,7 @@ def merge_objects(labels_x, labels_y, dimensions):
     output = numpy.where(mask, labels_y, output)
     labels_y[mask] = 0
     to_segment = numpy.logical_or(labels_x > 0, labels_y > 0)
-    if dimensions == 2: 
+    if dimensions == 2:
         distances, (i, j) = scipy.ndimage.distance_transform_edt(
             labels_x == 0, return_indices=True
         )
@@ -139,18 +144,20 @@ def merge_objects(labels_x, labels_y, dimensions):
             labels_x == 0, return_indices=True
         )
         output[to_segment] = labels_x[i[to_segment], j[to_segment], v[to_segment]]
-    
+
     return output
 
+
 def preserve_objects(labels_x, labels_y):
     """
-    Preserve the initial object set. Any overlapping regions from 
-    the second set will be ignored in favour of the object from 
-    the initial set. 
+    Preserve the initial object set. Any overlapping regions from
+    the second set will be ignored in favour of the object from
+    the initial set.
     """
     labels_y[labels_y > 0] += labels_x.max()
     return numpy.where(labels_x > 0, labels_x, labels_y)
 
+
 def discard_objects(labels_x, labels_y):
     """
     Discard objects that overlap with objects in the initial set
@@ -173,6 +180,7 @@ def discard_objects(labels_x, labels_y):
 
     return numpy.where(labels_x > 0, labels_x, output)
 
+
 def segment_objects(labels_x, labels_y, dimensions):
     """
     Combine object sets and re-draw segmentation for overlapping
@@ -440,6 +448,7 @@ def fill_object_holes(labels, diameter, planewise=False):
             array[filled_mask] = obj
     return array
 
+
 def fill_convex_hulls(labels):
     data = skimage.measure.regionprops(labels)
     output = numpy.zeros_like(labels)
@@ -455,6 +464,491 @@ def fill_convex_hulls(labels):
             ] = label
     return output
 
+################################################################################
+# IdentifyPrimaryObjects IdentifySecondaryObjects IdentifyTertiaryObjects
+################################################################################
+
+# Rename to get_maxima_from_foreground?
+def get_maxima(
+    image:          Image2DGrayscale,
+    labeled_image:  Optional[ObjectSegmentation]=None,
+    footprint:      Optional[StructuringElement]=None,
+    image_resize_factor:float=1.0,
+    ) -> Image2DBinary:
+    """_summary_
+
+    Parameters
+    ----------
+    image : _type_
+        _description_
+    labeled_image : _type_
+        Binary threshold of the input image
+    """
+    if image_resize_factor < 1.0:
+        shape = numpy.array(image.shape) * image_resize_factor
+        i_j = (
+            numpy.mgrid[0 : shape[0], 0 : shape[1]].astype(float) / image_resize_factor
+        )
+        resized_image = scipy.ndimage.map_coordinates(image, i_j)
+        resized_labels = scipy.ndimage.map_coordinates(
+            labeled_image, i_j, order=0
+        ).astype(labeled_image.dtype)
+    else:
+        resized_image = image
+        resized_labels = labeled_image
+    #
+    # find local maxima
+    #
+    if footprint is not None:
+        binary_maxima_image = centrosome.cpmorphology.is_local_maximum(
+            resized_image, resized_labels, footprint
+        )
+        binary_maxima_image[resized_image <= 0] = 0
+    else:
+        binary_maxima_image = (resized_image > 0) & (labeled_image > 0)
+    if image_resize_factor < 1.0:
+        inverse_resize_factor = float(image.shape[0]) / float(
+            binary_maxima_image.shape[0]
+        )
+        i_j = (
+            numpy.mgrid[0 : image.shape[0], 0 : image.shape[1]].astype(float)
+            / inverse_resize_factor
+        )
+        binary_maxima_image = (
+            scipy.ndimage.map_coordinates(binary_maxima_image.astype(float), i_j) > 0.5
+        )
+        assert binary_maxima_image.shape[0] == image.shape[0]
+        assert binary_maxima_image.shape[1] == image.shape[1]
+
+    # Erode blobs of touching maxima to a single point
+    shrunk_image = centrosome.cpmorphology.binary_shrink(binary_maxima_image)
+    return shrunk_image
+
+
+def smooth_image(
+        image: Image2DGrayscale, 
+        mask: Optional[Image2DGrayscaleMask]=None, 
+        filter_size: Optional[float]=None, 
+        min_obj_size: Optional[int]=10
+    ) -> Image2DGrayscale:
+    """Apply the smoothing filter to the image"""
+
+    if mask is None:
+        mask = numpy.ones_like(image, dtype=bool)
+
+    if filter_size is None:
+        filter_size = 2.35 * min_obj_size / 3.5
+
+    if filter_size == 0:
+        return image
+    sigma = filter_size / 2.35
+    #
+    # We not only want to smooth using a Gaussian, but we want to limit
+    # the spread of the smoothing to 2 SD, partly to make things happen
+    # locally, partly to make things run faster, partly to try to match
+    # the Matlab behavior.
+    #
+    filter_size = max(int(float(filter_size) / 2.0), 1)
+    f = (
+        1
+        / numpy.sqrt(2.0 * numpy.pi)
+        / sigma
+        * numpy.exp(
+            -0.5 * numpy.arange(-filter_size, filter_size + 1) ** 2 / sigma ** 2
+        )
+    )
+
+    def fgaussian(image):
+        output = scipy.ndimage.convolve1d(image, f, axis=0, mode="constant")
+        return scipy.ndimage.convolve1d(output, f, axis=1, mode="constant")
+
+    #
+    # Use the trick where you similarly convolve an array of ones to find
+    # out the edge effects, then divide to correct the edge effects
+    #
+    edge_array = fgaussian(mask.astype(float))
+    masked_image = image.copy()
+    masked_image[~mask] = 0
+    smoothed_image = fgaussian(masked_image)
+    masked_image[mask] = smoothed_image[mask] / edge_array[mask]
+    return masked_image
+
+
+def filter_on_size(
+    labeled_image: ObjectSegmentation, 
+    min_size: int, 
+    max_size: int, 
+    return_only_small: bool=False
+    ) -> ObjectSegmentation:
+    """Filter the labeled image based on the size range
+
+    labeled_image - pixel image labels
+    object_count - # of objects in the labeled image
+    returns the labeled image, and the labeled image with the
+    small objects removed
+    """
+    labeled_image = labeled_image.copy()
+
+    # Take the max since objects may have been removed, but their label number
+    # has not been adjusted accordingly. eg. array [2, 1, 0, 3] has label 2
+    # removed due to being on the border, so the array is [0, 1, 0, 3].
+    # Object numbers/indices will be used for slicing in areas[labeled_image]
+    object_count = numpy.max(labeled_image)
+    # Check if there are no labelled objects
+    if object_count > 0:
+        areas = scipy.ndimage.measurements.sum(
+            numpy.ones(labeled_image.shape),
+            labeled_image,
+            numpy.array(list(range(0, object_count + 1)), dtype=numpy.int32),
+        )
+        areas = numpy.array(areas, dtype=int)
+        min_allowed_area = numpy.pi * (min_size * min_size) / 4
+        max_allowed_area = numpy.pi * (max_size * max_size) / 4
+        # area_image has the area of the object at every pixel within the object
+        area_image = areas[labeled_image]
+        labeled_image[area_image < min_allowed_area] = 0
+        if return_only_small:
+            small_removed_labels = labeled_image.copy()
+            labeled_image[area_image > max_allowed_area] = 0
+            return labeled_image, small_removed_labels
+        else:
+            labeled_image[area_image > max_allowed_area] = 0
+            return labeled_image
+    else:
+        if return_only_small:
+            small_removed_labels = labeled_image.copy()
+            return labeled_image, small_removed_labels
+        else:
+            return labeled_image
+
+
+def filter_on_border(
+    labeled_image: ObjectSegmentation, 
+    mask: Optional[Image2DGrayscaleMask]=None
+    ) -> ObjectSegmentation:
+    """Filter out objects touching the border
+
+    In addition, if the image has a mask, filter out objects
+    touching the border of the mask.
+    """
+    labeled_image = labeled_image.copy()
+
+    border_labels = list(labeled_image[0, :])
+    border_labels.extend(labeled_image[:, 0])
+    border_labels.extend(labeled_image[labeled_image.shape[0] - 1, :])
+    border_labels.extend(labeled_image[:, labeled_image.shape[1] - 1])
+    border_labels = numpy.array(border_labels)
+    #
+    # the following histogram has a value > 0 for any object
+    # with a border pixel
+    #
+    histogram = scipy.sparse.coo_matrix(
+        (
+            numpy.ones(border_labels.shape),
+            (border_labels, numpy.zeros(border_labels.shape)),
+        ),
+        shape=(numpy.max(labeled_image) + 1, 1),
+    ).todense()
+    histogram = numpy.array(histogram).flatten()
+    if any(histogram[1:] > 0):
+        histogram_image = histogram[labeled_image]
+        labeled_image[histogram_image > 0] = 0
+    elif mask is not None:
+        # The assumption here is that, if nothing touches the border,
+        # the mask is a large, elliptical mask that tells you where the
+        # well is. That's the way the old Matlab code works and it's duplicated here
+        #
+        # The operation below gets the mask pixels that are on the border of the mask
+        # The erosion turns all pixels touching an edge to zero. The not of this
+        # is the border + formerly masked-out pixels.
+        mask_border = numpy.logical_not(scipy.ndimage.binary_erosion(mask))
+        mask_border = numpy.logical_and(mask_border, mask)
+        border_labels = labeled_image[mask_border]
+        border_labels = border_labels.flatten()
+        histogram = scipy.sparse.coo_matrix(
+            (
+                numpy.ones(border_labels.shape),
+                (border_labels, numpy.zeros(border_labels.shape)),
+            ),
+            shape=(numpy.max(labeled_image) + 1, 1),
+        ).todense()
+        histogram = numpy.array(histogram).flatten()
+        if any(histogram[1:] > 0):
+            histogram_image = histogram[labeled_image]
+            labeled_image[histogram_image > 0] = 0
+    return labeled_image
+
+
+def separate_neighboring_objects(
+    image: Image2DGrayscale,
+    labeled_image: ObjectSegmentation,
+    mask: Optional[Image2DGrayscaleMask] = None,
+    unclump_method: UnclumpMethod = UnclumpMethod.INTENSITY,
+    watershed_method: WatershedMethod = WatershedMethod.INTENSITY,
+    fill_holes_method: FillHolesMethod = FillHolesMethod.THRESHOLDING,
+    filter_size: Optional[float] = None,
+    min_size: int = 10,
+    max_size: int = 40,
+    low_res_maxima: bool = False,
+    maxima_suppression_size: float = 7,
+    automatic_suppression: bool = False,
+    return_cp_output: bool = False,
+    ) -> Union[
+        ObjectSegmentation,
+        Tuple[
+            ObjectSegmentation,
+            ObjectSegmentation,
+            float
+        ]
+    ]:
+
+    if unclump_method == UnclumpMethod.NONE or watershed_method == WatershedMethod.NONE:
+        if return_cp_output:
+            return labeled_image, numpy.zeros_like(labeled_image), 7
+        else:
+            return labeled_image
+
+    blurred_image = smooth_image(image, mask, filter_size, min_size)
+
+    # For image resizing, the min_size must be larger than 10
+    if min_size > 10 and low_res_maxima:
+        image_resize_factor = 10.0 / float(min_size)
+        if automatic_suppression:
+            maxima_suppression_size = 7
+        else:
+            maxima_suppression_size = (
+                maxima_suppression_size * image_resize_factor + 0.5
+            )
+    else:
+        image_resize_factor = 1.0
+        if automatic_suppression:
+            maxima_suppression_size = min_size / 1.5
+
+    footprint = centrosome.cpmorphology.strel_disk(
+        max(1, maxima_suppression_size - 0.5)
+    )
+
+    distance_transformed_image = None
+
+    if unclump_method == UnclumpMethod.INTENSITY:
+        # Remove dim maxima
+        maxima_image = get_maxima(
+            blurred_image, labeled_image, footprint, image_resize_factor
+        )
+    elif unclump_method == UnclumpMethod.SHAPE:
+        if fill_holes_method == FillHolesMethod.NEVER:
+            # For shape, even if the user doesn't want to fill holes,
+            # a point far away from the edge might be near a hole.
+            # So we fill just for this part.
+            foreground = centrosome.cpmorphology.fill_labeled_holes(labeled_image) > 0
+        else:
+            foreground = labeled_image > 0
+        distance_transformed_image = scipy.ndimage.distance_transform_edt(foreground)
+        # randomize the distance slightly to get unique maxima
+        numpy.random.seed(0)
+        distance_transformed_image += numpy.random.uniform(
+            0, 0.001, distance_transformed_image.shape
+        )
+        maxima_image = get_maxima(
+            distance_transformed_image,
+            labeled_image,
+            footprint,
+            image_resize_factor,
+        )
+    else:
+        raise ValueError(f"Unsupported unclump method: {unclump_method}")
+
+    # Create the image for watershed
+    if watershed_method == WatershedMethod.INTENSITY:
+        # use the reverse of the image to get valleys at peaks
+        watershed_image = 1 - image
+    elif watershed_method == WatershedMethod.SHAPE:
+        if distance_transformed_image is None:
+            distance_transformed_image = scipy.ndimage.distance_transform_edt(
+                labeled_image > 0
+            )
+        watershed_image = -distance_transformed_image
+        watershed_image = watershed_image - numpy.min(watershed_image)
+    elif watershed_method == WatershedMethod.PROPAGATE:
+        # No image used
+        pass
+    else:
+        raise ValueError(f"Unsupported watershed method: {watershed_method}")
+    #
+    # Create a marker array where the unlabeled image has a label of
+    # -(nobjects+1)
+    # and every local maximum has a unique label which will become
+    # the object's label. The labels are negative because that
+    # makes the watershed algorithm use FIFO for the pixels which
+    # yields fair boundaries when markers compete for pixels.
+    #
+    labeled_maxima, object_count = scipy.ndimage.label(
+        maxima_image, numpy.ones((3, 3), bool)
+    )
+    if watershed_method == WatershedMethod.PROPAGATE:
+        watershed_boundaries, distance = centrosome.propagate.propagate(
+            numpy.zeros(labeled_maxima.shape),
+            labeled_maxima,
+            labeled_image != 0,
+            1.0,
+        )
+    else:
+        markers_dtype = (
+            numpy.int16 if object_count < numpy.iinfo(numpy.int16).max else numpy.int32
+        )
+        markers = numpy.zeros(watershed_image.shape, markers_dtype)
+        markers[labeled_maxima > 0] = -labeled_maxima[labeled_maxima > 0]
+
+        #
+        # Some labels have only one maker in them, some have multiple and
+        # will be split up.
+        #
+
+        watershed_boundaries = skimage.segmentation.watershed(
+            connectivity=numpy.ones((3, 3), bool),
+            image=watershed_image,
+            markers=markers,
+            mask=labeled_image != 0,
+        )
+
+        watershed_boundaries = -watershed_boundaries
+
+    if return_cp_output:
+        return watershed_boundaries, labeled_maxima, maxima_suppression_size
+    else:
+        return watershed_boundaries
+    
+    
+def filter_labels(
+        labels_out: ObjectSegmentation, 
+        objects: ObjectSegmentation, 
+        mask: Optional[Image2DGrayscaleMask]=None, 
+        discard_edge: bool=False
+    ) -> ObjectSegmentation:
+    """Filter labels out of the output
+
+    Filter labels that are not in the segmented input labels. Optionally
+    filter labels that are touching the edge.
+
+    labels_out - the unfiltered output labels
+    objects    - the objects thing, containing both segmented and
+                    small_removed labels
+    """
+    segmented_labels = objects.copy()
+    max_out = numpy.max(labels_out)
+    if max_out > 0:
+        segmented_labels, m1 = size_similarly(labels_out, segmented_labels)
+        segmented_labels[~m1] = 0
+        lookup = scipy.ndimage.maximum(
+            segmented_labels, labels_out, list(range(max_out + 1))
+        )
+        lookup = numpy.array(lookup, int)
+        lookup[0] = 0
+        segmented_labels_out = lookup[labels_out]
+    else:
+        segmented_labels_out = labels_out.copy()
+    if discard_edge:
+        if mask is not None:
+            mask_border = mask & ~scipy.ndimage.binary_erosion(mask)
+            edge_labels = segmented_labels_out[mask_border]
+        else:
+            edge_labels = numpy.hstack(
+                (
+                    segmented_labels_out[0, :],
+                    segmented_labels_out[-1, :],
+                    segmented_labels_out[:, 0],
+                    segmented_labels_out[:, -1],
+                )
+            )
+        edge_labels = numpy.unique(edge_labels)
+        #
+        # Make a lookup table that translates edge labels to zero
+        # but translates everything else to itself
+        #
+        lookup = numpy.arange(max(max_out, numpy.max(segmented_labels)) + 1)
+        lookup[edge_labels] = 0
+        #
+        # Run the segmented labels through this to filter out edge
+        # labels
+        segmented_labels_out = lookup[segmented_labels_out]
+
+    return segmented_labels_out
+
+
+def size_similarly(labels, secondary):
+    """Size the secondary matrix similarly to the labels matrix
+
+    labels - labels matrix
+    secondary - a secondary image or labels matrix which might be of
+                different size.
+    Return the resized secondary matrix and a mask indicating what portion
+    of the secondary matrix is bogus (manufactured values).
+
+    Either the mask is all ones or the result is a copy, so you can
+    modify the output within the unmasked region w/o destroying the original.
+    """
+    if labels.shape[:2] == secondary.shape[:2]:
+        return secondary, numpy.ones(secondary.shape, bool)
+    if labels.shape[0] <= secondary.shape[0] and labels.shape[1] <= secondary.shape[1]:
+        if secondary.ndim == 2:
+            return (
+                secondary[: labels.shape[0], : labels.shape[1]],
+                numpy.ones(labels.shape, bool),
+            )
+        else:
+            return (
+                secondary[: labels.shape[0], : labels.shape[1], :],
+                numpy.ones(labels.shape, bool),
+            )
+
+    #
+    # Some portion of the secondary matrix does not cover the labels
+    #
+    result = numpy.zeros(
+        list(labels.shape) + list(secondary.shape[2:]), secondary.dtype
+    )
+    i_max = min(secondary.shape[0], labels.shape[0])
+    j_max = min(secondary.shape[1], labels.shape[1])
+    if secondary.ndim == 2:
+        result[:i_max, :j_max] = secondary[:i_max, :j_max]
+    else:
+        result[:i_max, :j_max, :] = secondary[:i_max, :j_max, :]
+    mask = numpy.zeros(labels.shape, bool)
+    mask[:i_max, :j_max] = 1
+    return result, mask
+
+def outline(labels: ObjectSegmentation) -> ObjectSegmentation:
+    """Given a label matrix, return a matrix of the outlines of the labeled objects
+    
+    If a pixel is not zero and has at least one neighbor with a different
+    value, then it is part of the outline.
+    """
+
+    output = numpy.zeros(labels.shape, labels.dtype)
+    lr_different = labels[1:, :] != labels[:-1, :]
+    ud_different = labels[:, 1:] != labels[:, :-1]
+    d1_different = labels[1:, 1:] != labels[:-1, :-1]
+    d2_different = labels[1:, :-1] != labels[:-1, 1:]
+    different = numpy.zeros(labels.shape, bool)
+    different[1:, :][lr_different] = True
+    different[:-1, :][lr_different] = True
+    different[:, 1:][ud_different] = True
+    different[:, :-1][ud_different] = True
+    different[1:, 1:][d1_different] = True
+    different[:-1, :-1][d1_different] = True
+    different[1:, :-1][d2_different] = True
+    different[:-1, 1:][d2_different] = True
+    #
+    # Labels on edges need outlines
+    #
+    different[0, :] = True
+    different[:, 0] = True
+    different[-1, :] = True
+    different[:, -1] = True
+
+    output[different] = labels[different]
+    return output
+        
 #############################################################
 # ConvertObjectsToImage
 #############################################################

{cellprofiler_library_nightly-5.0.0.dev416 → cellprofiler_library_nightly-5.0.0.dev454}/cellprofiler_library/modules/__init__.py

@@ -16,3 +16,6 @@ from ._watershed import watershed
 from ._measureimageoverlap import measureimageoverlap
 from ._gaussianfilter import gaussianfilter
 from ._measureobjectsizeshape import measureobjectsizeshape
+from ._identifyprimaryobjects import identifyprimaryobjects
+from ._identifysecondaryobjects import identifysecondaryobjects
+from ._identifytertiaryobjects import identifytertiaryobjects