CellProfiler-nightly 5.0.0.dev738__tar.gz → 5.0.0.dev745__tar.gz

{cellprofiler_nightly-5.0.0.dev738 → cellprofiler_nightly-5.0.0.dev745}/CellProfiler_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev738
+Version: 5.0.0.dev745
 Summary: CellProfiler is a free open-source software designed to enable biologists without training in computer vision or programming to quantitatively measure phenotypes from thousands of images automatically.
 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_nightly-5.0.0.dev745/CellProfiler_nightly.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "5.0.0.dev0",
+  "distance": 745,
+  "node": "gc1d6426989d64f4dc9774aa246c7054a214a7d33",
+  "dirty": true,
+  "branch": "main",
+  "node_date": "2026-09-30"
+}

{cellprofiler_nightly-5.0.0.dev738 → cellprofiler_nightly-5.0.0.dev745}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev738
+Version: 5.0.0.dev745
 Summary: CellProfiler is a free open-source software designed to enable biologists without training in computer vision or programming to quantitatively measure phenotypes from thousands of images automatically.
 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_nightly-5.0.0.dev738 → cellprofiler_nightly-5.0.0.dev745}/cellprofiler/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '5.0.0.dev738'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev738')
+__version__ = version = '5.0.0.dev745'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev745')
 
-__commit_id__ = commit_id = 'g03f79f7e2'
+__commit_id__ = commit_id = 'gc1d642698'

{cellprofiler_nightly-5.0.0.dev738 → cellprofiler_nightly-5.0.0.dev745}/cellprofiler/modules/splitormergeobjects.py

@@ -1,6 +1,5 @@
-import centrosome.cpmorphology
 import numpy
-import scipy.ndimage
+from cellprofiler.modules import _help
 from cellprofiler_core.constants.measurement import (
     C_PARENT,
     FF_CHILDREN_COUNT,
@@ -14,13 +13,11 @@ from cellprofiler_core.setting import ValidationError
 from cellprofiler_core.setting.choice import Choice
 from cellprofiler_core.setting.subscriber import LabelSubscriber, ImageSubscriber
 from cellprofiler_core.setting.text import Integer, Float, LabelName
-from cellprofiler_core.utilities.core.module.identify import (
-    add_object_count_measurements,
-    add_object_location_measurements,
-    get_object_measurement_columns,
-)
+from cellprofiler_core.utilities.core.module.identify import get_object_measurement_columns
+from cellprofiler_core.utilities.core.workspace import add_library_measurements_to_workspace_measurements
+from cellprofiler_library.opts.splitormergeobjects import RelabelOption, MergeOption, MergingMethod, ObjectIntensityMethod
+from cellprofiler_library.modules._splitormergeobjects import split_or_merge_objects
 
-from cellprofiler.modules import _help
 
 __doc__ = """\
 SplitOrMergeObjects
@@ -94,19 +91,6 @@ reassignment.
     **{"HELP_ON_SAVING_OBJECTS": _help.HELP_ON_SAVING_OBJECTS}
 )
 
-OPTION_MERGE = "Merge"
-OPTION_SPLIT = "Split"
-
-UNIFY_DISTANCE = "Distance"
-UNIFY_PARENT = "Per-parent"
-
-CA_CENTROIDS = "Centroids"
-CA_CLOSEST_POINT = "Closest point"
-
-UM_DISCONNECTED = "Disconnected"
-UM_CONVEX_HULL = "Convex hull"
-
-
 class SplitOrMergeObjects(Module):
     module_name = "SplitOrMergeObjects"
     category = "Object Processing"
@@ -134,52 +118,59 @@ You can use this name in subsequent modules that take objects as inputs.""",
 
         self.relabel_option = Choice(
             "Operation",
-            [OPTION_MERGE, OPTION_SPLIT],
+            [RelabelOption.MERGE.value, RelabelOption.SPLIT.value],
             doc="""\
 You can choose one of the following options:
 
--  *%(OPTION_MERGE)s:* Assign adjacent or nearby objects the same label
+-  *{OPTION_MERGE}:* Assign adjacent or nearby objects the same label
    based on certain criteria. It can be useful, for example, to merge
    together touching objects that were incorrectly split into two pieces
    by an **Identify** module.
--  *%(OPTION_SPLIT)s:* Assign a unique number to separate objects that
+-  *{OPTION_SPLIT}:* Assign a unique number to separate objects that
    currently share the same label. This can occur if you applied certain
-   operations in the **Morph** module to objects."""
-            % globals(),
+   operations in the **Morph** module to objects.""".format(
+        **{"OPTION_MERGE": RelabelOption.MERGE.value, "OPTION_SPLIT": RelabelOption.SPLIT.value}
+   ),
         )
 
         self.merge_option = Choice(
             "Merging method",
-            [UNIFY_DISTANCE, UNIFY_PARENT],
+            [MergeOption.UNIFY_DISTANCE.value, MergeOption.UNIFY_PARENT.value],
             doc="""\
-*(Used only with the "%(OPTION_MERGE)s" option)*
+*(Used only with the "{OPTION_MERGE}" option)*
 
 You can merge objects in one of two ways:
 
--  *%(UNIFY_DISTANCE)s:* All objects within a certain pixel radius from
+-  *{UNIFY_DISTANCE}:* All objects within a certain pixel radius from
    each other will be merged.
--  *%(UNIFY_PARENT)s:* All objects which share the same parent
+-  *{UNIFY_PARENT}:* All objects which share the same parent
    relationship to another object will be merged. This is not to be
    confused with using the **RelateObjects** module, in which the
    related objects remain as individual objects. See **RelateObjects**
-   for more details."""
-            % globals(),
+   for more details.""".format(
+       **{
+           "OPTION_MERGE": RelabelOption.MERGE.value,
+           "UNIFY_DISTANCE": MergeOption.UNIFY_DISTANCE.value,
+           "UNIFY_PARENT": MergeOption.UNIFY_PARENT.value
+       }
+   ),
         )
 
         self.merging_method = Choice(
             "Output object type",
-            [UM_DISCONNECTED, UM_CONVEX_HULL],
+            [MergingMethod.DISCONNECTED.value, MergingMethod.CONVEX_HULL.value],
             doc="""\
-*(Used only with the "%(UNIFY_PARENT)s" merging method)*
+*(Used only with the "{UNIFY_PARENT}" merging method)*
 
 **SplitOrMergeObjects** can either merge the child objects and keep them
 disconnected or it can find the smallest convex polygon (the convex
 hull) that encloses all of a parent’s child objects. The convex hull
 will be truncated to include only those pixels in the parent - in that
-case it may not truly be convex. Choose *%(UM_DISCONNECTED)s* to leave
-the children as disconnected pieces. Choose *%(UM_CONVEX_HULL)s* to
-create an output object that is the convex hull around them all."""
-            % globals(),
+case it may not truly be convex. Choose *{UM_DISCONNECTED}* to leave
+the children as disconnected pieces. Choose *{UM_CONVEX_HULL}* to
+create an output object that is the convex hull around them all.""".format(
+    **{"UNIFY_PARENT": MergeOption.UNIFY_PARENT.value, "UM_DISCONNECTED": MergingMethod.DISCONNECTED.value, "UM_CONVEX_HULL": MergingMethod.CONVEX_HULL.value}
+),
         )
 
         self.parent_object = Choice(
@@ -202,32 +193,34 @@ Please note the following:
             0,
             minval=0,
             doc="""\
-*(Used only with the "%(OPTION_MERGE)s" option and the "%(UNIFY_DISTANCE)s"
+*(Used only with the "{OPTION_MERGE}" option and the "{UNIFY_DISTANCE}"
 method)*
 
 Objects that are less than or equal to the distance you enter here, in
 pixels, will be merged. If you choose zero (the default), only objects
-that are touching will be merged. Note that *%(OPTION_MERGE)s* will
+that are touching will be merged. Note that *{OPTION_MERGE}* will
 not actually connect or bridge the two objects by adding any new pixels;
 it simply assigns the same object number to the portions of the object.
 The new, merged object may therefore consist of two or more unconnected
 components. If you want to add pixels around objects, see
-**ExpandOrShrink** or **Morph**."""
-            % globals(),
+**ExpandOrShrink** or **Morph**.""".format(
+    **{"OPTION_MERGE": RelabelOption.MERGE.value, "UNIFY_DISTANCE": MergeOption.UNIFY_DISTANCE.value}
+),
         )
 
         self.wants_image = Binary(
             "Merge using a grayscale image?",
             False,
             doc="""\
-*(Used only with the "%(OPTION_MERGE)s" option)*
+*(Used only with the "{OPTION_MERGE}" option)*
 
 Select *Yes* to use the objects’ intensity features to determine
 whether two objects should be merged. If you choose to use a grayscale
-image, *%(OPTION_MERGE)s* will merge two objects only if they are
+image, *{OPTION_MERGE}* will merge two objects only if they are
 within the distance you have specified *and* certain criteria about the
-objects within the grayscale image are met."""
-            % globals(),
+objects within the grayscale image are met.""".format(
+    **{"OPTION_MERGE": RelabelOption.MERGE.value}
+),
         )
 
         self.image_name = ImageSubscriber(
@@ -255,7 +248,7 @@ described for the method you choose in the next setting.""",
 
         self.where_algorithm = Choice(
             "Method to find object intensity",
-            [CA_CLOSEST_POINT, CA_CENTROIDS],
+            [ObjectIntensityMethod.CLOSEST_POINT.value, ObjectIntensityMethod.CENTROIDS.value],
             doc="""\
 *(Used only if a grayscale image is to be used as a guide for
 merging)*
@@ -264,7 +257,7 @@ You can use one of two methods to determine whether two objects should
 merged, assuming they meet the distance criteria (as specified
 above):
 
--  *%(CA_CENTROIDS)s:* When the module considers merging two objects,
+-  *{CA_CENTROIDS}:* When the module considers merging two objects,
    this method identifies the centroid of each object, records the
    intensity value of the dimmer of the two centroids, multiplies this
    value by the *minimum intensity fraction* to generate a threshold,
@@ -278,7 +271,7 @@ above):
    the center of the cell: a single cell that was incorrectly segmented
    into two objects will typically not have a dim line between the
    centroids of the two halves and will be correctly merged.
--  *%(CA_CLOSEST_POINT)s:* This method is useful for unifying
+-  *{CA_CLOSEST_POINT}:* This method is useful for unifying
    irregularly shaped cells that are connected. It starts by assigning
    background pixels in the vicinity of the objects to the nearest
    object. Objects are then merged if each object has background pixels
@@ -291,8 +284,9 @@ above):
    An example of a feature that satisfies the above constraints is a
    line of pixels that connects two neighboring objects and is roughly
    the same intensity as the boundary pixels of both (such as an axon
-   connecting two neurons' soma)."""
-            % globals(),
+   connecting two neurons' soma).""".format(
+       **{"CA_CENTROIDS": ObjectIntensityMethod.CENTROIDS.value, "CA_CLOSEST_POINT": ObjectIntensityMethod.CLOSEST_POINT.value}
+   ),
         )
 
     def get_parent_choices(self, pipeline):
@@ -306,8 +300,8 @@ above):
 
     def validate_module(self, pipeline):
         if (
-            self.relabel_option == OPTION_MERGE
-            and self.merge_option == UNIFY_PARENT
+            self.relabel_option == RelabelOption.MERGE.value
+            and self.merge_option == MergeOption.UNIFY_PARENT.value
             and self.parent_object.value == "None"
         ):
             raise ValidationError(
@@ -331,9 +325,9 @@ above):
 
     def visible_settings(self):
         result = [self.objects_name, self.output_objects_name, self.relabel_option]
-        if self.relabel_option == OPTION_MERGE:
+        if self.relabel_option == RelabelOption.MERGE.value:
             result += [self.merge_option]
-            if self.merge_option == UNIFY_DISTANCE:
+            if self.merge_option == MergeOption.UNIFY_DISTANCE.value:
                 result += [self.distance_threshold, self.wants_image]
                 if self.wants_image:
                     result += [
@@ -341,105 +335,72 @@ above):
                         self.minimum_intensity_fraction,
                         self.where_algorithm,
                     ]
-            elif self.merge_option == UNIFY_PARENT:
+            elif self.merge_option == MergeOption.UNIFY_PARENT.value:
                 result += [self.merging_method, self.parent_object]
         return result
 
     def run(self, workspace):
+        #
+        # Construct arguments for split_or_merge_objects
+        #
         objects_name = self.objects_name.value
         objects = workspace.object_set.get_objects(objects_name)
         assert isinstance(objects, Objects)
         labels = objects.segmented
-        if self.relabel_option == OPTION_SPLIT:
-            output_labels, count = scipy.ndimage.label(
-                labels > 0, numpy.ones((3, 3), bool)
-            )
-        else:
-            if self.merge_option == UNIFY_DISTANCE:
-                mask = labels > 0
-                if self.distance_threshold.value > 0:
-                    #
-                    # Take the distance transform of the reverse of the mask
-                    # and figure out what points are less than 1/2 of the
-                    # distance from an object.
-                    #
-                    d = scipy.ndimage.distance_transform_edt(~mask)
-                    mask = d < self.distance_threshold.value / 2 + 1
-                output_labels, count = scipy.ndimage.label(
-                    mask, numpy.ones((3, 3), bool)
-                )
-                output_labels[labels == 0] = 0
-                if self.wants_image:
-                    output_labels = self.filter_using_image(workspace, mask)
-            elif self.merge_option == UNIFY_PARENT:
-                parents_name = self.parent_object.value
-                parents_of = workspace.measurements[
-                    objects_name, "_".join((C_PARENT, parents_name))
-                ]
-                output_labels = labels.copy().astype(numpy.uint32)
-                output_labels[labels > 0] = parents_of[labels[labels > 0] - 1]
-                if self.merging_method == UM_CONVEX_HULL:
-                    ch_pts, n_pts = centrosome.cpmorphology.convex_hull(output_labels)
-                    ijv = centrosome.cpmorphology.fill_convex_hulls(ch_pts, n_pts)
-                    output_labels[ijv[:, 0], ijv[:, 1]] = ijv[:, 2]
-
-                #Renumber to be consecutive
-                ## Create an array that maps label indexes to their new values
-                ## All labels to be deleted have a value in this array of zero
-                indexes = numpy.unique(output_labels)[1:]
-                new_object_count = len(indexes)
-                max_label = numpy.max(output_labels)
-                label_indexes = numpy.zeros((max_label + 1,), int)
-                label_indexes[indexes] = numpy.arange(1, new_object_count + 1)
-
-                # Reindex the labels of the old source image
-                output_labels = label_indexes[output_labels]
 
+        parents_of = None
+        if self.merge_option == MergeOption.UNIFY_PARENT.value:
+            feature_name = "_".join((C_PARENT, self.parent_object.value))
+            parents_of = workspace.measurements[objects_name, feature_name]
+
+        image = None
+        if self.relabel_option.value != RelabelOption.SPLIT.value and self.merge_option.value == MergeOption.UNIFY_DISTANCE.value and self.wants_image.value:
+            image = self.get_image(workspace)
+
+        #
+        # Run split_or_merge_objects
+        #
+        output_labels, output_small_removed_segmented, output_unedited_segmented, lib_measurements = split_or_merge_objects(
+            labels=labels,
+            relabel_option=RelabelOption(self.relabel_option.value),
+            objects_name=objects_name,
+            objects_small_removed_segmented=objects.small_removed_segmented if objects.has_small_removed_segmented else None,
+            objects_unedited_segmented=objects.unedited_segmented if objects.has_unedited_segmented else None,
+            parent_name=self.parent_object.value,
+            merge_option=MergeOption(self.merge_option.value),
+            distance_threshold=self.distance_threshold.value,
+            parents_of=parents_of,
+            merging_method=self.merging_method.value,
+            image=image,
+            merge_condition=self.where_algorithm.value,
+            minimum_intensity_fraction=self.minimum_intensity_fraction.value,
+            output_objects_name = self.output_objects_name.value,
+            output_object_volumetric=objects.volumetric,
+            labels_ijv=objects.ijv,
+            return_measurements=True
+        )
+
+        #
+        # Add the outputs of the split_or_merge_objects to the workspace
+        #
         output_objects = Objects()
         output_objects.segmented = output_labels
-        if objects.has_small_removed_segmented:
-            output_objects.small_removed_segmented = copy_labels(
-                objects.small_removed_segmented, output_labels
-            )
-        if objects.has_unedited_segmented:
-            output_objects.unedited_segmented = copy_labels(
-                objects.unedited_segmented, output_labels
-            )
+        if output_small_removed_segmented is not None:
+            output_objects.small_removed_segmented = output_small_removed_segmented
+        if output_unedited_segmented is not None:
+            output_objects.unedited_segmented = output_unedited_segmented
         output_objects.parent_image = objects.parent_image
         workspace.object_set.add_objects(output_objects, self.output_objects_name.value)
 
         measurements = workspace.measurements
-        add_object_count_measurements(
-            measurements,
-            self.output_objects_name.value,
-            numpy.max(output_objects.segmented),
-        )
-        add_object_location_measurements(
-            measurements, self.output_objects_name.value, output_objects.segmented
-        )
-
-        #
-        # Relate the output objects to the input ones and record
-        # the relationship.
-        #
-        children_per_parent, parents_of_children = objects.relate_children(
-            output_objects
-        )
-        measurements.add_measurement(
-            self.objects_name.value,
-            FF_CHILDREN_COUNT % self.output_objects_name.value,
-            children_per_parent,
-        )
-        measurements.add_measurement(
-            self.output_objects_name.value,
-            FF_PARENT % self.objects_name.value,
-            parents_of_children,
-        )
+        add_library_measurements_to_workspace_measurements(measurements, lib_measurements)
 
         if self.show_window:
+            if image is not None:
+                workspace.display_data.image = image
             workspace.display_data.orig_labels = objects.segmented
             workspace.display_data.output_labels = output_objects.segmented
-            if self.merge_option == UNIFY_PARENT:
+            if self.merge_option == MergeOption.UNIFY_PARENT.value:
                 workspace.display_data.parent_labels = workspace.object_set.get_objects(
                     self.parent_object.value
                 ).segmented
@@ -455,11 +416,11 @@ above):
             0, 0, workspace.display_data.orig_labels, title=self.objects_name.value
         )
 
-        if self.relabel_option == OPTION_MERGE and (
-            (self.merge_option == UNIFY_DISTANCE and self.wants_image)
-            or (self.merge_option == UNIFY_PARENT)
+        if self.relabel_option == RelabelOption.MERGE.value and (
+            (self.merge_option == MergeOption.UNIFY_DISTANCE.value and self.wants_image)
+            or (self.merge_option == MergeOption.UNIFY_PARENT.value)
         ):
-            if self.merge_option == UNIFY_DISTANCE and self.wants_image:
+            if self.merge_option == MergeOption.UNIFY_DISTANCE.value and self.wants_image:
                 image = workspace.display_data.image
                 cplabels = [
                     dict(
@@ -472,7 +433,7 @@ above):
                     ),
                 ]
 
-            elif self.merge_option == UNIFY_PARENT:
+            elif self.merge_option == MergeOption.UNIFY_PARENT.value:
                 image = numpy.zeros(workspace.display_data.output_labels.shape)
                 cplabels = [
                     dict(
@@ -516,132 +477,6 @@ above):
                 sharexy=ax,
             )
 
-    def filter_using_image(self, workspace, mask):
-        """Filter out connections using local intensity minima between objects
-
-        workspace - the workspace for the image set
-        mask - mask of background points within the minimum distance
-        """
-        #
-        # NOTE: This is an efficient implementation and an improvement
-        #       in accuracy over the Matlab version. It would be faster and
-        #       more accurate to eliminate the line-connecting and instead
-        #       do the following:
-        #     * Distance transform to get the coordinates of the closest
-        #       point in an object for points in the background that are
-        #       at most 1/2 of the max distance between objects.
-        #     * Take the intensity at this closest point and similarly
-        #       label the background point if the background intensity
-        #       is at least the minimum intensity fraction
-        #     * Assume there is a connection between objects if, after this
-        #       labeling, there are adjacent points in each object.
-        #
-        # As it is, the algorithm duplicates the Matlab version but suffers
-        # for cells whose intensity isn't high in the centroid and clearly
-        # suffers when two cells touch at some point that's off of the line
-        # between the two.
-        #
-        objects = workspace.object_set.get_objects(self.objects_name.value)
-        labels = objects.segmented
-        image = self.get_image(workspace)
-        if self.show_window:
-            # Save the image for display
-            workspace.display_data.image = image
-        #
-        # Do a distance transform into the background to label points
-        # in the background with their closest foreground object
-        #
-        i, j = scipy.ndimage.distance_transform_edt(
-            labels == 0, return_indices=True, return_distances=False
-        )
-        confluent_labels = labels[i, j]
-        confluent_labels[~mask] = 0
-        if self.where_algorithm == CA_CLOSEST_POINT:
-            #
-            # For the closest point method, find the intensity at
-            # the closest point in the object (which will be the point itself
-            # for points in the object).
-            #
-            object_intensity = image[i, j] * self.minimum_intensity_fraction.value
-            confluent_labels[object_intensity > image] = 0
-        count, index, c_j = centrosome.cpmorphology.find_neighbors(confluent_labels)
-        if len(c_j) == 0:
-            # Nobody touches - return the labels matrix
-            return labels
-        #
-        # Make a row of i matching the touching j
-        #
-        c_i = numpy.zeros(len(c_j))
-        #
-        # Eliminate labels without matches
-        #
-        label_numbers = numpy.arange(1, len(count) + 1)[count > 0]
-        index = index[count > 0]
-        count = count[count > 0]
-        #
-        # Get the differences between labels so we can use a cumsum trick
-        # to increment to the next label when they change
-        #
-        label_numbers[1:] = label_numbers[1:] - label_numbers[:-1]
-        c_i[index] = label_numbers
-        c_i = numpy.cumsum(c_i).astype(int)
-        if self.where_algorithm == CA_CENTROIDS:
-            #
-            # Only connect points > minimum intensity fraction
-            #
-            center_i, center_j = centrosome.cpmorphology.centers_of_labels(labels)
-            indexes, counts, i, j = centrosome.cpmorphology.get_line_pts(
-                center_i[c_i - 1],
-                center_j[c_i - 1],
-                center_i[c_j - 1],
-                center_j[c_j - 1],
-            )
-            #
-            # The indexes of the centroids at pt1
-            #
-            last_indexes = indexes + counts - 1
-            #
-            # The minimum of the intensities at pt0 and pt1
-            #
-            centroid_intensities = numpy.minimum(
-                image[i[indexes], j[indexes]], image[i[last_indexes], j[last_indexes]]
-            )
-            #
-            # Assign label numbers to each point so we can use
-            # scipy.ndimage.minimum. The label numbers are indexes into
-            # "connections" above.
-            #
-            pt_labels = numpy.zeros(len(i), int)
-            pt_labels[indexes[1:]] = 1
-            pt_labels = numpy.cumsum(pt_labels)
-            minima = scipy.ndimage.minimum(
-                image[i, j], pt_labels, numpy.arange(len(indexes))
-            )
-            minima = centrosome.cpmorphology.fixup_scipy_ndimage_result(minima)
-            #
-            # Filter the connections using the image
-            #
-            mif = self.minimum_intensity_fraction.value
-            i = c_i[centroid_intensities * mif <= minima]
-            j = c_j[centroid_intensities * mif <= minima]
-        else:
-            i = c_i
-            j = c_j
-        #
-        # Add in connections from self to self
-        #
-        unique_labels = numpy.unique(labels)
-        i = numpy.hstack((i, unique_labels))
-        j = numpy.hstack((j, unique_labels))
-        #
-        # Run "all_connected_components" to get a component # for
-        # objects identified as same.
-        #
-        new_indexes = centrosome.cpmorphology.all_connected_components(i, j)
-        new_labels = numpy.zeros(labels.shape, int)
-        new_labels[labels != 0] = new_indexes[labels[labels != 0]]
-        return new_labels
-
     def upgrade_settings(self, setting_values, variable_revision_number, module_name):
         if variable_revision_number == 1:
             # Added outline options
@@ -650,11 +485,11 @@ above):
 
         if variable_revision_number == 1:
             # Added per-parent unification
-            setting_values += [UNIFY_DISTANCE, "None"]
+            setting_values += [MergeOption.UNIFY_DISTANCE.value, "None"]
             variable_revision_number = 3
 
         if variable_revision_number == 3:
-            setting_values = setting_values + [UM_DISCONNECTED]
+            setting_values = setting_values + [MergingMethod.DISCONNECTED.value]
             variable_revision_number = 4
 
         if variable_revision_number == 4:
@@ -726,15 +561,3 @@ above):
             return ["%s_Count" % self.output_objects_name.value]
         return []
 
-
-def copy_labels(labels, segmented):
-    """Carry differences between orig_segmented and new_segmented into "labels"
-
-    labels - labels matrix similarly segmented to "segmented"
-    segmented - the newly numbered labels matrix (a subset of pixels are labeled)
-    """
-    max_labels = len(numpy.unique(segmented))
-    seglabel = scipy.ndimage.minimum(labels, segmented, numpy.arange(1, max_labels + 1))
-    labels_new = labels.copy()
-    labels_new[segmented != 0] = seglabel[segmented[segmented != 0] - 1]
-    return labels_new

cellprofiler_nightly-5.0.0.dev738/CellProfiler_nightly.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "5.0.0.dev0",
-  "distance": 738,
-  "node": "g03f79f7e2639328723c64ee0a6118a2e00cbc651",
-  "dirty": true,
-  "branch": "main",
-  "node_date": "2026-09-29"
-}