CellProfiler-nightly 5.0.0.dev399__tar.gz → 5.0.0.dev409__tar.gz

{cellprofiler_nightly-5.0.0.dev399 → cellprofiler_nightly-5.0.0.dev409}/CellProfiler_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev399
+Version: 5.0.0.dev409
 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.dev399 → cellprofiler_nightly-5.0.0.dev409}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev399
+Version: 5.0.0.dev409
 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.dev399 → cellprofiler_nightly-5.0.0.dev409}/cellprofiler/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev399'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev399')
+__version__ = version = '5.0.0.dev409'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev409')
 
-__commit_id__ = commit_id = 'ge6c545a1c'
+__commit_id__ = commit_id = 'g578baed29'

{cellprofiler_nightly-5.0.0.dev399 → cellprofiler_nightly-5.0.0.dev409}/cellprofiler/modules/overlayoutlines.py

@@ -5,7 +5,7 @@ OverlayOutlines
 **OverlayOutlines** places outlines of objects over a desired image.
 
 This module places outlines of objects on any desired image (grayscale, color, or blank).
-The resulting image can be saved using the **SaveImages** module.
+The resulting image can be saved using the **SaveImages** module. Overlaying multiple objects will overwrite previous outlines.
 
 |
 
@@ -16,10 +16,6 @@ YES          YES          NO
 ============ ============ ===============
 """
 
-import numpy
-import skimage.color
-import skimage.segmentation
-import skimage.util
 from cellprofiler_core.image import Image
 from cellprofiler_core.module import Module
 from cellprofiler_core.setting import Binary, Divider, SettingsGroup, Color
@@ -28,25 +24,9 @@ from cellprofiler_core.setting.do_something import DoSomething, RemoveSettingBut
 from cellprofiler_core.setting.subscriber import ImageSubscriber, LabelSubscriber
 from cellprofiler_core.setting.text import ImageName
 
-WANTS_COLOR = "Color"
-WANTS_GRAYSCALE = "Grayscale"
+from cellprofiler_library.modules._overlayoutlines import overlay_outlines
+from cellprofiler_library.opts.overlayoutlines import BrightnessMode, OutlineMode, COLOR_ORDER, SourceMode
 
-MAX_IMAGE = "Max of image"
-MAX_POSSIBLE = "Max possible"
-
-COLORS = {
-    "White": (1, 1, 1),
-    "Black": (0, 0, 0),
-    "Red": (1, 0, 0),
-    "Green": (0, 1, 0),
-    "Blue": (0, 0, 1),
-    "Yellow": (1, 1, 0),
-}
-
-COLOR_ORDER = ["Red", "Green", "Blue", "Yellow", "White", "Black"]
-
-FROM_IMAGES = "Image"
-FROM_OBJECTS = "Objects"
 
 NUM_FIXED_SETTINGS_V1 = 5
 NUM_FIXED_SETTINGS_V2 = 6
@@ -118,7 +98,7 @@ image can be selected in later modules (for instance, **SaveImages**).
 
         self.wants_color = Choice(
             "Outline display mode",
-            [WANTS_COLOR, WANTS_GRAYSCALE],
+            [OutlineMode.COLOR.value, OutlineMode.GRAYSCALE.value],
             doc="""\
 Specify how to display the outline contours around your objects. Color
 outlines produce a clearer display for images where the cell borders
@@ -132,7 +112,7 @@ same intensity as the brightest pixel in the image.
 
         self.max_type = Choice(
             "Select method to determine brightness of outlines",
-            [MAX_IMAGE, MAX_POSSIBLE],
+            [BrightnessMode.MAX_IMAGE.value, BrightnessMode.MAX_POSSIBLE.value],
             doc="""\
 *(Used only when outline display mode is grayscale)*
 
@@ -148,7 +128,7 @@ If your image is quite dim, then putting bright white lines onto it may
 not be useful. It may be preferable to make the outlines equal to the
 maximal brightness already occurring in the image.
 """.format(
-                **{"MAX_IMAGE": MAX_IMAGE, "MAX_POSSIBLE": MAX_POSSIBLE}
+                **{"MAX_IMAGE": BrightnessMode.MAX_IMAGE.value, "MAX_POSSIBLE": BrightnessMode.MAX_POSSIBLE.value}
             ),
         )
 
@@ -185,7 +165,7 @@ maximal brightness already occurring in the image.
             Color(
                 "Select outline color",
                 default_color,
-                doc="Objects will be outlined in this color.",
+                doc="Objects will be outlined in this color. If overlaying multiple objects, the previous outlines will be overwritten.",
             ),
         )
 
@@ -232,39 +212,82 @@ maximal brightness already occurring in the image.
             self.line_mode,
             self.spacer,
         ]
-        if self.wants_color.value == WANTS_GRAYSCALE and not self.blank_image.value:
+        if self.wants_color.value == OutlineMode.GRAYSCALE and not self.blank_image.value:
             result += [self.max_type]
         for outline in self.outlines:
             result += [outline.objects_name]
-            if self.wants_color.value == WANTS_COLOR:
+            if self.wants_color.value == OutlineMode.COLOR:
                 result += [outline.color]
             if hasattr(outline, "remover"):
                 result += [outline.remover]
         result += [self.add_outline_button]
         return result
 
-    def run(self, workspace):
-        base_image, dimensions = self.base_image(workspace)
-
-        if self.wants_color.value == WANTS_COLOR:
-            pixel_data = self.run_color(workspace, base_image.copy())
+    def run(self, workspace):        
+        # Extract base image parameters
+        if self.blank_image.value:
+            _outline = self.outlines[0]
+            _objects = workspace.object_set.get_objects(_outline.objects_name.value)
+
+            obj_shape = _objects.shape
+            obj_dimensions = _objects.dimensions
+            im_pixel_data = None
+            im_multichannel = False
+            im_dimensions = None
+            
         else:
-            pixel_data = self.run_bw(workspace, base_image)
+            image = workspace.image_set.get_image(self.image_name.value)
 
+            obj_shape = None
+            obj_dimensions = None
+            im_pixel_data = image.pixel_data
+            im_multichannel = image.multichannel
+            im_dimensions = image.dimensions
+        
+        # Extract outline data for both color and BW modes
+        object_labels_list = []
+        colors_list = []
+        is_volumetric = (im_dimensions or obj_dimensions) > 2
+        
+        for outline in self.outlines:
+            objects = workspace.object_set.get_objects(outline.objects_name.value)
+            obj_labels_list = objects.get_labels()
+            
+            # For BW mode
+            object_labels_list.append(obj_labels_list)
+            
+            # For color mode
+            color_rgb = outline.color.to_rgb()
+            colors_list.append(color_rgb)
+
+        if self.wants_color.value == OutlineMode.GRAYSCALE:
+            colors_list = None
+        
+        # Call dispatcher with all extracted parameters
+        pixel_data, base_image, dimensions = overlay_outlines(
+            BrightnessMode.MAX_POSSIBLE if self.blank_image.value else self.max_type.value,
+            self.line_mode.value,
+            obj_shape,
+            obj_dimensions,
+            im_pixel_data,
+            im_multichannel,
+            im_dimensions,
+            object_labels_list,
+            colors_list,
+            is_volumetric
+        )
+        
+        # UI/Framework-specific logic - create output image and update workspace
         output_image = Image(pixel_data, dimensions=dimensions)
-
         workspace.image_set.add(self.output_image_name.value, output_image)
-
+        
         if not self.blank_image.value:
             image = workspace.image_set.get_image(self.image_name.value)
-
             output_image.parent_image = image
-
+        
         if self.show_window:
             workspace.display_data.pixel_data = pixel_data
-
             workspace.display_data.image_pixel_data = base_image
-
             workspace.display_data.dimensions = dimensions
 
     def display(self, workspace, figure):
@@ -273,7 +296,7 @@ maximal brightness already occurring in the image.
         if self.blank_image.value:
             figure.set_subplots((1, 1), dimensions=dimensions)
 
-            if self.wants_color.value == WANTS_COLOR:
+            if self.wants_color.value == OutlineMode.COLOR:
                 figure.subplot_imshow(
                     0,
                     0,
@@ -294,7 +317,7 @@ maximal brightness already occurring in the image.
                 0, 0, workspace.display_data.image_pixel_data, self.image_name.value
             )
 
-            if self.wants_color.value == WANTS_COLOR:
+            if self.wants_color.value == OutlineMode.COLOR:
                 figure.subplot_imshow(
                     1,
                     0,
@@ -311,97 +334,6 @@ maximal brightness already occurring in the image.
                     sharexy=figure.subplot(0, 0),
                 )
 
-    def base_image(self, workspace):
-        if self.blank_image.value:
-            outline = self.outlines[0]
-
-            objects = workspace.object_set.get_objects(outline.objects_name.value)
-
-            return numpy.zeros(objects.shape + (3,)), objects.dimensions
-
-        image = workspace.image_set.get_image(self.image_name.value)
-
-        pixel_data = skimage.img_as_float(image.pixel_data)
-
-        if image.multichannel:
-            return pixel_data, image.dimensions
-
-        return skimage.color.gray2rgb(pixel_data), image.dimensions
-
-    def run_bw(self, workspace, pixel_data):
-        if self.blank_image.value or self.max_type.value == MAX_POSSIBLE:
-            color = 1.0
-        else:
-            color = numpy.max(pixel_data)
-
-        for outline in self.outlines:
-            objects = workspace.object_set.get_objects(outline.objects_name.value)
-
-            pixel_data = self.draw_outlines(pixel_data, objects, color)
-
-        return skimage.color.rgb2gray(pixel_data)
-
-    def run_color(self, workspace, pixel_data):
-        for outline in self.outlines:
-            objects = workspace.object_set.get_objects(outline.objects_name.value)
-
-            color = tuple(c / 255.0 for c in outline.color.to_rgb())
-
-            pixel_data = self.draw_outlines(pixel_data, objects, color)
-
-        return pixel_data
-
-    def draw_outlines(self, pixel_data, objects, color):
-        for labels, _ in objects.get_labels():
-            resized_labels = self.resize(pixel_data, labels)
-
-            if objects.volumetric:
-                for index, plane in enumerate(resized_labels):
-                    pixel_data[index] = skimage.segmentation.mark_boundaries(
-                        pixel_data[index],
-                        plane,
-                        color=color,
-                        mode=self.line_mode.value.lower(),
-                    )
-            else:
-                pixel_data = skimage.segmentation.mark_boundaries(
-                    pixel_data,
-                    resized_labels,
-                    color=color,
-                    mode=self.line_mode.value.lower(),
-                )
-
-        return pixel_data
-
-    def resize(self, pixel_data, labels):
-        initial_shape = labels.shape
-
-        final_shape = pixel_data.shape
-
-        if pixel_data.ndim > labels.ndim:  # multichannel
-            final_shape = final_shape[:-1]
-
-        adjust = numpy.subtract(final_shape, initial_shape)
-
-        cropped = skimage.util.crop(
-            labels,
-            [
-                (0, dim_adjust)
-                for dim_adjust in numpy.abs(
-                    numpy.minimum(adjust, numpy.zeros_like(adjust))
-                )
-            ],
-        )
-
-        return numpy.pad(
-            cropped,
-            [
-                (0, dim_adjust)
-                for dim_adjust in numpy.maximum(adjust, numpy.zeros_like(adjust))
-            ],
-            mode="constant",
-            constant_values=0,
-        )
 
     def upgrade_settings(self, setting_values, variable_revision_number, module_name):
         if variable_revision_number == 1:
@@ -424,7 +356,7 @@ maximal brightness already occurring in the image.
                 NUM_FIXED_SETTINGS_V2, len(setting_values), NUM_OUTLINE_SETTINGS_V2
             ):
                 new_setting_values += setting_values[i : (i + NUM_OUTLINE_SETTINGS_V2)]
-                new_setting_values += [FROM_IMAGES, "None"]
+                new_setting_values += [SourceMode.FROM_IMAGES, "None"]
             setting_values = new_setting_values
             variable_revision_number = 3
 
@@ -448,5 +380,6 @@ maximal brightness already occurring in the image.
 
         return setting_values, variable_revision_number
 
+
     def volumetric(self):
         return True

{cellprofiler_nightly-5.0.0.dev399 → cellprofiler_nightly-5.0.0.dev409}/cellprofiler/modules/removeholes.py

@@ -26,6 +26,7 @@ import numpy
 import skimage.morphology
 from cellprofiler_core.module import ImageProcessing
 from cellprofiler_core.setting.text import Float
+from cellprofiler_library.modules._removeholes import remove_holes
 
 
 class RemoveHoles(ImageProcessing):
@@ -56,22 +57,7 @@ class RemoveHoles(ImageProcessing):
         return __settings__ + [self.size]
 
     def run(self, workspace):
-        self.function = lambda image, diameter: fill_holes(image, diameter)
+        self.function = remove_holes
 
         super(RemoveHoles, self).run(workspace)
 
-
-def fill_holes(image, diameter):
-    radius = diameter / 2.0
-
-    if image.dtype.kind == "f":
-        image = skimage.img_as_bool(image)
-
-    if image.ndim == 2 or image.shape[-1] in (3, 4):
-        factor = radius ** 2
-    else:
-        factor = (4.0 / 3.0) * (radius ** 3)
-
-    size = numpy.pi * factor
-
-    return skimage.morphology.remove_small_holes(image, size)