CellProfiler-nightly 5.0.0.dev544__tar.gz → 5.0.0.dev554__tar.gz

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/CellProfiler_nightly.egg-info/PKG-INFO

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

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev544'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev544')
+__version__ = version = '5.0.0.dev554'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev554')
 
-__commit_id__ = commit_id = 'g3d03e7dab'
+__commit_id__ = commit_id = 'g7151f72c8'

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/closing.py

@@ -49,8 +49,6 @@ class Closing(ImageProcessing):
 
     def run(self, workspace):
 
-        x = workspace.image_set.get_image(self.x_name.value)
-
         self.function = (
             lambda image, structuring_element: closing(
                 image,
@@ -59,13 +57,3 @@ class Closing(ImageProcessing):
         )
 
         super(Closing, self).run(workspace)
-
-
-def planewise_morphology_closing(x_data, structuring_element):
-    y_data = numpy.zeros_like(x_data)
-
-    for index, plane in enumerate(x_data):
-
-        y_data[index] = skimage.morphology.closing(plane, structuring_element)
-
-    return y_data

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/combineobjects.py

@@ -34,7 +34,6 @@ YES          YES           NO
 import numpy
 import scipy.ndimage
 import skimage.morphology
-import skimage.segmentation
 from cellprofiler_core.module import Identify
 from cellprofiler_core.object import Objects
 from cellprofiler_core.setting.choice import Choice

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/measurecolocalization.py

@@ -642,7 +642,7 @@ You can set a different threshold for each image selected in the module.
                 #
                 # Run colocalization measurements on the images
                 #
-                colocalization_measurements, measurements_summary = run_image_pair_images(
+                lib_measurements, lib_display = run_image_pair_images(
                     im1_pixel_data = im1_pixel_data, 
                     im2_pixel_data = im2_pixel_data, 
                     im1_name = im1_name, 
@@ -653,10 +653,11 @@ You can set a different threshold for each image selected in the module.
                     measurement_types = measurement_types, 
                     im1_scale = first_image_scale,
                     im2_scale = second_image_scale,
-                    costes_method = costes_method
+                    costes_method = costes_method,
+                    return_visualization_data = True,
                 )
-                statistics += measurements_summary
-                all_measurements = all_measurements.merge(colocalization_measurements)
+                statistics += lib_display.statistics
+                all_measurements = all_measurements.merge(lib_measurements)
 
             if self.wants_objects():
                 for object_name in self.objects_list.value:
@@ -688,7 +689,7 @@ You can set a different threshold for each image selected in the module.
                     #
                     # Run colocalization measurements on the objects
                     #
-                    colocalization_measurements, measurements_summary = run_image_pair_objects(
+                    lib_measurements, lib_display = run_image_pair_objects(
                         im1_pixels = first_pixels.astype(numpy.float32), 
                         im2_pixels = second_pixels.astype(numpy.float32), 
                         labels = labels, 
@@ -704,11 +705,11 @@ You can set a different threshold for each image selected in the module.
                         measurement_types = measurement_types, 
                         im1_scale = im1_scale,
                         im2_scale = im2_scale,
-                        costes_method = costes_method
-
+                        costes_method = costes_method,
+                        return_visualization_data = True,
                     )
-                    statistics += measurements_summary
-                    all_measurements = all_measurements.merge(colocalization_measurements)
+                    statistics += lib_display.statistics
+                    all_measurements = all_measurements.merge(lib_measurements)
 
         # Unpack all measurements to workspace
         for measurement_name, measurement_value in all_measurements.image.items():

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/measuregranularity.py

@@ -276,7 +276,7 @@ class MeasureGranularity(Module):
         granular_spectrum_length = self.granular_spectrum_length.value
         dimensions = im.dimensions
 
-        measurements, summary = measure_granularity(
+        lib_measurements, lib_display = measure_granularity(
             image_name,
             im_pixel_data, 
             im_mask, 
@@ -285,19 +285,20 @@ class MeasureGranularity(Module):
             element_size, 
             object_records, 
             granular_spectrum_length, 
-            dimensions
+            dimensions,
+            return_visualization_data=True,
         )
         
         # Record Image Measurements
-        for feature_name, value in measurements.image.items():
+        for feature_name, value in lib_measurements.image.items():
             workspace.measurements.add_image_measurement(feature_name, value)
             
         # Record Object Measurements
-        for object_name, features in measurements.objects.items():
+        for object_name, features in lib_measurements.objects.items():
             for feature_name, values in features.items():
                 workspace.measurements.add_measurement(object_name, feature_name, values)
 
-        return summary
+        return lib_display.statistics
 
     def get_measurement_columns(self, pipeline, return_sources=False):
         result = []

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/measureimageareaoccupied.py

@@ -148,15 +148,16 @@ Select the previously identified objects you would like to measure.""".format(
             for binary_image_name in self.images_list.value:
                 binary_image = workspace.image_set.get_image(binary_image_name, must_be_binary=True)
                 pipeline_volumetric = workspace.pipeline.volumetric()
-                _lib_measurements, _statistics = measure_image_area_perimeter(
+                _lib_measurements, _lib_display = measure_image_area_perimeter(
                     binary_image.pixel_data, 
                     binary_image_name,
                     binary_image.volumetric, 
                     binary_image.spacing,
                     pipeline_volumetric, 
+                    return_visualization_data=True,
                     )
                 add_library_measurements_to_workspace(_lib_measurements, workspace)
-                statistics += _statistics
+                statistics += _lib_display.statistics
         if self.operand_choice.value in (Target.BOTH, Target.OBJECTS):
             if len(self.objects_list.value) == 0:
                 raise ValueError("No object sets were selected for analysis.")
@@ -167,16 +168,17 @@ Select the previously identified objects you would like to measure.""".format(
                 spacing = objects.parent_image.spacing if (objects.volumetric and objects.has_parent_image) else None
                 pipeline_volumetric = workspace.pipeline.volumetric()
                 object_name = object_set
-                _lib_measurements, _statistics = measure_objects_area_perimeter(
+                _lib_measurements, _lib_display = measure_objects_area_perimeter(
                     label_image, 
                     object_name,
                     mask, 
                     objects.volumetric, 
                     spacing, 
                     pipeline_volumetric, 
+                    return_visualization_data=True,
                 )
                 add_library_measurements_to_workspace(_lib_measurements, workspace)
-                statistics += _statistics
+                statistics += _lib_display.statistics
 
         if self.show_window:
             workspace.display_data.statistics = statistics

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/measureimageintensity.py

@@ -211,30 +211,32 @@ class MeasureImageIntensity(Module):
                     else:
                         pixels = input_pixels[objects.segmented != 0]
                     
-                    lm, stats = measure_image_intensity(
+                    lib_measurements, lib_display = measure_image_intensity(
                         pixels=pixels,
                         image_name=im,
                         object_name=object_set,
-                        percentiles=percentiles
+                        percentiles=percentiles,
+                        return_visualization_data=True,
                     )
                     
-                    self._add_library_measurements_to_core(lm, workspace)
-                    statistics += stats
+                    self._add_library_measurements_to_core(lib_measurements, workspace)
+                    statistics += lib_display.statistics
             else:
                 if image.has_mask:
                     pixels = input_pixels[image.mask]
                 else:
                     pixels = input_pixels
                 
-                lm, stats = measure_image_intensity(
+                lib_measurements, lib_display = measure_image_intensity(
                     pixels=pixels,
                     image_name=im,
                     object_name=None,
-                    percentiles=percentiles
+                    percentiles=percentiles,
+                    return_visualization_data=True,
                 )
                 
-                self._add_library_measurements_to_core(lm, workspace)
-                statistics += stats
+                self._add_library_measurements_to_core(lib_measurements, workspace)
+                statistics += lib_display.statistics
 
         # TODO: library_cleanup - wrap in self.show_window
         col_labels = ["Image", "Masking object", "Feature", "Value"]

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/measureimageoverlap.py

@@ -273,7 +273,7 @@ the two images. Set this setting to “No” to assess no penalty.""",
 
         test_pixels = test_image.pixel_data
 
-        lib_measurements, lib_stats = measureimageoverlap(
+        lib_measurements, lib_display = measureimageoverlap(
             ground_truth_pixels, 
             test_pixels, 
             self.test_img.value,
@@ -282,7 +282,8 @@ the two images. Set this setting to “No” to assess no penalty.""",
             decimation_method=self.decimation_method.enum_member,
             max_distance=self.max_distance.value,
             max_points=self.max_points.value,
-            penalize_missing=self.penalize_missing.value
+            penalize_missing=self.penalize_missing.value,
+            return_visualization_data=True,
             )
 
         m = workspace.measurements
@@ -310,7 +311,7 @@ the two images. Set this setting to “No” to assess no penalty.""",
 
             workspace.display_data.adjusted_rand_index = get_val(Feature.ADJUSTED_RAND_INDEX)
 
-            workspace.display_data.statistics = lib_stats
+            workspace.display_data.statistics = lib_display.statistics
 
     def display(self, workspace, figure):
         """Display the image confusion matrix & statistics"""

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/measureimageskeleton.py

@@ -30,66 +30,9 @@ Measurements made by this module
 - *Endpoints*: Total number of pixels with only one neighbor.
 """
 
-import numpy
-import scipy.ndimage
-import skimage.segmentation
-import skimage.util
 from cellprofiler_core.module import Module
 from cellprofiler_core.setting.subscriber import ImageSubscriber
-
-
-def _neighbors(image):
-    """
-
-    Counts the neighbor pixels for each pixel of an image:
-
-            x = [
-                [0, 1, 0],
-                [1, 1, 1],
-                [0, 1, 0]
-            ]
-
-            _neighbors(x)
-
-            [
-                [0, 3, 0],
-                [3, 4, 3],
-                [0, 3, 0]
-            ]
-
-    :type image: numpy.ndarray
-
-    :param image: A two-or-three dimensional image
-
-    :return: neighbor pixels for each pixel of an image
-
-    """
-    padding = numpy.pad(image, 1, "constant")
-
-    mask = padding > 0
-
-    padding = padding.astype(float)
-
-    if image.ndim == 2:
-        response = 3 ** 2 * scipy.ndimage.uniform_filter(padding) - 1
-
-        labels = (response * mask)[1:-1, 1:-1]
-
-        return labels.astype(numpy.uint16)
-    elif image.ndim == 3:
-        response = 3 ** 3 * scipy.ndimage.uniform_filter(padding) - 1
-
-        labels = (response * mask)[1:-1, 1:-1, 1:-1]
-
-        return labels.astype(numpy.uint16)
-
-
-def branches(image):
-    return _neighbors(image) > 2
-
-
-def endpoints(image):
-    return _neighbors(image) == 1
+from cellprofiler_library.modules._measureimageskeleton import measure_image_skeleton
 
 
 class MeasureImageSkeleton(Module):
@@ -113,8 +56,6 @@ You can create a morphological skeleton with the
         return [self.skeleton_name]
 
     def run(self, workspace):
-        names = ["Branches", "Endpoints"]
-
         input_image_name = self.skeleton_name.value
 
         image_set = workspace.image_set
@@ -125,32 +66,30 @@ You can create a morphological skeleton with the
 
         pixels = input_image.pixel_data
 
-        pixels = pixels > 0
-
-        branch_nodes = branches(pixels)
+        result = measure_image_skeleton(
+            pixels, 
+            im_name=self.skeleton_name.value,
+            return_visualization_data=self.show_window
+        )
 
-        endpoint_nodes = endpoints(pixels)
+        if self.show_window:
+            lib_measurements, lib_display = result
+        else:
+            lib_measurements = result
 
-        statistics = self.measure(input_image, workspace)
+        for feature_name, value in lib_measurements.image.items():
+            workspace.measurements.add_image_measurement(feature_name, value)
 
         if self.show_window:
             workspace.display_data.skeleton = pixels
 
-            a = numpy.copy(branch_nodes).astype(numpy.uint16)
-            b = numpy.copy(endpoint_nodes).astype(numpy.uint16)
-
-            a[a == 1] = 1
-            b[b == 1] = 2
-
-            nodes = skimage.segmentation.join_segmentations(a, b)
-
-            workspace.display_data.nodes = nodes
+            workspace.display_data.nodes = lib_display.nodes
 
             workspace.display_data.dimensions = dimensions
 
-            workspace.display_data.names = names
+            workspace.display_data.names = ["Branches", "Endpoints"]
 
-            workspace.display_data.statistics = statistics
+            workspace.display_data.statistics = lib_display.statistics
 
     def display(self, workspace, figure=None):
         layout = (2, 2)
@@ -195,8 +134,6 @@ You can create a morphological skeleton with the
         return "Skeleton_{}_{}".format(name, image)
 
     def get_measurements(self, pipeline, object_name, category):
-        name = self.skeleton_name.value
-
         if object_name == "Image" and category == "Skeleton":
             return [
                 "Branches",
@@ -228,34 +165,5 @@ You can create a morphological skeleton with the
 
         return feature
 
-    def measure(self, image, workspace):
-        data = image.pixel_data
-
-        data = data.astype(bool)
-
-        measurements = workspace.measurements
-
-        measurement_name = self.skeleton_name.value
-
-        statistics = []
-
-        name = "Skeleton_Branches_{}".format(measurement_name)
-
-        value = numpy.count_nonzero(branches(data))
-
-        statistics.append(value)
-
-        measurements.add_image_measurement(name, value)
-
-        name = "Skeleton_Endpoints_{}".format(measurement_name)
-
-        value = numpy.count_nonzero(endpoints(data))
-
-        statistics.append(value)
-
-        measurements.add_image_measurement(name, value)
-
-        return [statistics]
-
     def volumetric(self):
         return True

{cellprofiler_nightly-5.0.0.dev544 → cellprofiler_nightly-5.0.0.dev554}/cellprofiler/modules/opening.py

@@ -48,9 +48,6 @@ class Opening(ImageProcessing):
         return __settings__ + [self.structuring_element]
 
     def run(self, workspace):
-
-        x = workspace.image_set.get_image(self.x_name.value)
-
         self.function = (
             lambda image, structuring_element: opening(
                 image,
@@ -59,14 +56,3 @@ class Opening(ImageProcessing):
         )
 
         super(Opening, self).run(workspace)
-
-
-def planewise_morphology_opening(x_data, structuring_element):
-
-    y_data = numpy.zeros_like(x_data)
-
-    for index, plane in enumerate(x_data):
-
-        y_data[index] = skimage.morphology.opening(plane, structuring_element)
-
-    return y_data