CellProfiler-nightly 5.0.0.dev514__tar.gz → 5.0.0.dev527__tar.gz

{cellprofiler_nightly-5.0.0.dev514 → cellprofiler_nightly-5.0.0.dev527}/CellProfiler_nightly.egg-info/PKG-INFO

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

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev514'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev514')
+__version__ = version = '5.0.0.dev527'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev527')
 
-__commit_id__ = commit_id = 'g5b9c361fc'
+__commit_id__ = commit_id = 'g00c6dde9d'

{cellprofiler_nightly-5.0.0.dev514 → cellprofiler_nightly-5.0.0.dev527}/cellprofiler/modules/measureimageareaoccupied.py

@@ -44,7 +44,6 @@ Measurements made by this module
 """
 
 import numpy
-import skimage.measure
 from cellprofiler_core.constants.measurement import COLTYPE_FLOAT
 from cellprofiler_core.module import Module
 from cellprofiler_core.setting import Divider, ValidationError
@@ -53,25 +52,9 @@ from cellprofiler_core.setting.subscriber import (
     ImageListSubscriber,
     LabelListSubscriber,
 )
-
-C_AREA_OCCUPIED = "AreaOccupied"
-
-# Measurement feature name format for the AreaOccupied/VolumeOccupied measurement
-F_AREA_OCCUPIED = "AreaOccupied"
-F_VOLUME_OCCUPIED = "VolumeOccupied"
-
-# Measure feature name format for the Perimeter/SurfaceArea measurement
-F_PERIMETER = "Perimeter"
-F_SURFACE_AREA = "SurfaceArea"
-
-# Measure feature name format for the TotalArea/TotalVolume measurement
-F_TOTAL_AREA = "TotalArea"
-F_TOTAL_VOLUME = "TotalVolume"
-
-O_BINARY_IMAGE = "Binary Image"
-O_OBJECTS = "Objects"
-O_BOTH = "Both"
-
+from cellprofiler_library.modules._measureimageareaoccupied import measure_image_area_perimeter, measure_objects_area_perimeter
+from cellprofiler_library.opts.measureimageareaoccupied import MeasurementType, Target, C_AREA_OCCUPIED
+from cellprofiler_library.measurement_model import LibraryMeasurements
 # The number of settings per image or object group
 IMAGE_SETTING_COUNT = 1
 
@@ -86,14 +69,14 @@ class MeasureImageAreaOccupied(Module):
     def create_settings(self):
         self.operand_choice = Choice(
             "Measure the area occupied by",
-            [O_BINARY_IMAGE, O_OBJECTS, O_BOTH],
+            [Target.BINARY_IMAGE.value, Target.OBJECTS.value, Target.BOTH.value],
             doc="""\
 Area occupied can be measured in two ways:
 
 -  *{O_BINARY_IMAGE}:* The area occupied by the foreground in a binary (black and white) image.
 -  *{O_OBJECTS}:* The area occupied by previously-identified objects.
                     """.format(
-                **{"O_BINARY_IMAGE": O_BINARY_IMAGE, "O_OBJECTS": O_OBJECTS}
+                **{"O_BINARY_IMAGE": Target.BINARY_IMAGE.value, "O_OBJECTS": Target.OBJECTS.value}
             ),
         )
 
@@ -107,7 +90,7 @@ Area occupied can be measured in two ways:
 These should be binary images created earlier in the pipeline, where you would
 like to measure the area occupied by the foreground in the image.
                     """.format(
-                **{"O_BINARY_IMAGE": O_BINARY_IMAGE}
+                **{"O_BINARY_IMAGE": Target.BINARY_IMAGE.value}
             ),
         )
 
@@ -117,13 +100,13 @@ like to measure the area occupied by the foreground in the image.
             doc="""*(Used only if ‘{O_OBJECTS}’ are to be measured)*
 
 Select the previously identified objects you would like to measure.""".format(
-                **{"O_OBJECTS": O_OBJECTS}
+                **{"O_OBJECTS": Target.OBJECTS.value}
             ),
         )
 
     def validate_module(self, pipeline):
         """Make sure chosen objects and images are selected only once"""
-        if self.operand_choice in (O_BINARY_IMAGE, O_BOTH):
+        if self.operand_choice in (Target.BINARY_IMAGE.value, Target.BOTH.value):
             images = set()
             if len(self.images_list.value) == 0:
                 raise ValidationError("No images selected", self.images_list)
@@ -133,7 +116,7 @@ Select the previously identified objects you would like to measure.""".format(
                         "%s has already been selected" % image_name, image_name
                     )
                 images.add(image_name)
-        if self.operand_choice in (O_OBJECTS, O_BOTH):
+        if self.operand_choice in (Target.OBJECTS, Target.BOTH):
             objects = set()
             if len(self.objects_list.value) == 0:
                 raise ValidationError("No objects selected", self.objects_list)
@@ -150,27 +133,50 @@ Select the previously identified objects you would like to measure.""".format(
 
     def visible_settings(self):
         result = [self.operand_choice, self.divider]
-        if self.operand_choice in (O_BOTH, O_BINARY_IMAGE):
+        if self.operand_choice.value in (Target.BOTH, Target.BINARY_IMAGE):
             result.append(self.images_list)
-        if self.operand_choice in (O_BOTH, O_OBJECTS):
+        if self.operand_choice.value in (Target.BOTH, Target.OBJECTS):
             result.append(self.objects_list)
         return result
 
     def run(self, workspace):
-        m = workspace.measurements
-
         statistics = []
 
-        if self.operand_choice in (O_BOTH, O_BINARY_IMAGE):
+        if self.operand_choice.value in (Target.BOTH, Target.BINARY_IMAGE):
             if len(self.images_list.value) == 0:
                 raise ValueError("No images were selected for analysis.")
-            for binary_image in self.images_list.value:
-                statistics += self.measure_images(binary_image, workspace)
-        if self.operand_choice in (O_BOTH, O_OBJECTS):
+            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(
+                    binary_image.pixel_data, 
+                    binary_image_name,
+                    binary_image.volumetric, 
+                    binary_image.spacing,
+                    pipeline_volumetric, 
+                    )
+                add_library_measurements_to_workspace(_lib_measurements, workspace)
+                statistics += _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.")
             for object_set in self.objects_list.value:
-                statistics += self.measure_objects(object_set, workspace)
+                objects = workspace.get_objects(object_set)
+                label_image = objects.segmented
+                mask = objects.parent_image.mask if objects.has_parent_image else None
+                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(
+                    label_image, 
+                    object_name,
+                    mask, 
+                    objects.volumetric, 
+                    spacing, 
+                    pipeline_volumetric, 
+                )
+                add_library_measurements_to_workspace(_lib_measurements, workspace)
+                statistics += _statistics
 
         if self.show_window:
             workspace.display_data.statistics = statistics
@@ -198,122 +204,19 @@ Select the previously identified objects you would like to measure.""".format(
             numpy.array([features], dtype=float),
         )
 
-    def measure_objects(self, object_set, workspace):
-        objects = workspace.get_objects(object_set)
-
-        label_image = objects.segmented
-
-        if objects.has_parent_image:
-            mask = objects.parent_image.mask
-
-            label_image[~mask] = 0
-
-            total_area = numpy.sum(mask)
-        else:
-            total_area = numpy.product(label_image.shape)
-
-        region_properties = skimage.measure.regionprops(label_image)
-
-        area_occupied = numpy.sum([region["area"] for region in region_properties])
-        
-        if area_occupied > 0:
-            if objects.volumetric:
-                spacing = None
-
-                if objects.has_parent_image:
-                    spacing = objects.parent_image.spacing
-
-                labels = numpy.unique(label_image)
-
-                if labels[0] == 0:
-                    labels = labels[1:]
-
-                perimeter = surface_area(label_image, spacing=spacing, index=labels)
-            else:
-                perimeter = numpy.sum(
-                    [numpy.round(region["perimeter"]) for region in region_properties]
-                )
-        else:
-            perimeter = 0
-
-        measurements = workspace.measurements
-        pipeline = workspace.pipeline
-
-        self._add_image_measurement(
-            object_set,
-            F_VOLUME_OCCUPIED if pipeline.volumetric() else F_AREA_OCCUPIED,
-            area_occupied,
-            measurements,
-        )
-
-        self._add_image_measurement(
-            object_set,
-            F_SURFACE_AREA if pipeline.volumetric() else F_PERIMETER,
-            perimeter,
-            measurements,
-        )
-
-        self._add_image_measurement(
-            object_set,
-            F_TOTAL_VOLUME if pipeline.volumetric() else F_TOTAL_AREA,
-            total_area,
-            measurements,
-        )
-
-        return [[object_set, str(area_occupied), str(perimeter), str(total_area),]]
-
-    def measure_images(self, image_set, workspace):
-        image = workspace.image_set.get_image(image_set, must_be_binary=True)
-
-        area_occupied = numpy.sum(image.pixel_data > 0)
-
-        if area_occupied > 0:
-            if image.volumetric:
-                perimeter = surface_area(image.pixel_data > 0, spacing=image.spacing)
-            else:
-                perimeter = skimage.measure.perimeter(image.pixel_data > 0)
-        else:
-            perimeter = 0
-            
-        total_area = numpy.prod(numpy.shape(image.pixel_data))
-
-        measurements = workspace.measurements
-        pipeline = workspace.pipeline
-
-        self._add_image_measurement(
-            image_set,
-            F_VOLUME_OCCUPIED if pipeline.volumetric() else F_AREA_OCCUPIED,
-            area_occupied,
-            measurements,
-        )
-
-        self._add_image_measurement(
-            image_set,
-            F_SURFACE_AREA if pipeline.volumetric() else F_PERIMETER,
-            perimeter,
-            measurements,
-        )
-
-        self._add_image_measurement(
-            image_set,
-            F_TOTAL_VOLUME if pipeline.volumetric() else F_TOTAL_AREA,
-            total_area,
-            measurements,
-        )
 
-        return [[image_set, str(area_occupied), str(perimeter), str(total_area),]]
 
     def _get_feature_names(self, pipeline):
         if pipeline.volumetric():
-            return [F_VOLUME_OCCUPIED, F_SURFACE_AREA, F_TOTAL_VOLUME]
+            return [MeasurementType.VOLUME_OCCUPIED.value, MeasurementType.SURFACE_AREA.value, MeasurementType.TOTAL_VOLUME.value]
 
-        return [F_AREA_OCCUPIED, F_PERIMETER, F_TOTAL_AREA]
+        return [MeasurementType.AREA_OCCUPIED.value, MeasurementType.PERIMETER.value, MeasurementType.TOTAL_AREA.value]
 
     def get_measurement_columns(self, pipeline):
         """Return column definitions for measurements made by this module"""
         columns = []
 
-        if self.operand_choice in (O_BOTH, O_OBJECTS):
+        if self.operand_choice.value in (Target.BOTH, Target.OBJECTS):
             for object_set in self.objects_list.value:
                 for feature in self._get_feature_names(pipeline):
                     columns.append(
@@ -325,7 +228,7 @@ Select the previously identified objects you would like to measure.""".format(
                             COLTYPE_FLOAT,
                         )
                     )
-        if self.operand_choice in (O_BOTH, O_BINARY_IMAGE):
+        if self.operand_choice.value in (Target.BOTH, Target.BINARY_IMAGE):
             for image_set in self.images_list.value:
                 for feature in self._get_feature_names(pipeline):
                     columns.append(
@@ -359,7 +262,7 @@ Select the previously identified objects you would like to measure.""".format(
             return [
                 object_name
                 for object_name in self.objects_list.value
-                if self.operand_choice in (O_OBJECTS, O_BOTH)
+                if self.operand_choice.value in (Target.OBJECTS, Target.BOTH)
             ]
         return []
 
@@ -372,7 +275,7 @@ Select the previously identified objects you would like to measure.""".format(
             return [
                 image_name
                 for image_name in self.images_list.value
-                if self.operand_choice in (O_BINARY_IMAGE, O_BOTH)
+                if self.operand_choice.value in (Target.BINARY_IMAGE, Target.BOTH)
             ]
         return []
 
@@ -426,20 +329,20 @@ Select the previously identified objects you would like to measure.""".format(
             objects_set = set()
             conditions, names1, names2 = [(setting_values[i::3]) for i in range(3)]
             for condition, name1, name2 in zip(conditions, names1, names2):
-                if condition == O_BINARY_IMAGE:
+                if condition == Target.BINARY_IMAGE.value:
                     images_set.add(name2)
-                elif condition == O_OBJECTS:
+                elif condition == Target.OBJECTS.value:
                     objects_set.add(name1)
             if "None" in images_set:
                 images_set.remove("None")
             if "None" in objects_set:
                 objects_set.remove("None")
             if len(images_set) > 0 and len(objects_set) > 0:
-                mode = O_BOTH
+                mode = Target.BOTH.value
             elif len(images_set) == 0:
-                mode = O_OBJECTS
+                mode = Target.OBJECTS.value
             else:
-                mode = O_BINARY_IMAGE
+                mode = Target.BINARY_IMAGE.value
             images_string = ", ".join(map(str, images_set))
             objects_string = ", ".join(map(str, objects_set))
             setting_values = [mode, images_string, objects_string]
@@ -450,28 +353,25 @@ Select the previously identified objects you would like to measure.""".format(
         return True
 
 
-def surface_area(label_image, spacing=None, index=None):
-    if spacing is None:
-        spacing = (1.0,) * label_image.ndim
-
-    if index is None:
-        verts, faces, _normals, _values = skimage.measure.marching_cubes(
-            label_image, spacing=spacing, level=0, method="lorensen"
-        )
-
-        return skimage.measure.mesh_surface_area(verts, faces)
-
-    return numpy.sum(
-        [
-            numpy.round(_label_surface_area(label_image, label, spacing))
-            for label in index
-        ]
-    )
-
-
-def _label_surface_area(label_image, label, spacing):
-    verts, faces, _normals, _values = skimage.measure.marching_cubes(
-        label_image == label, spacing=spacing, level=0, method="lorensen"
-    )
+def add_library_measurements_to_workspace(library_measurements: LibraryMeasurements, workspace):
+    """Add the library measurements to the workspace
+
+    library_measurements - the library measurements to be added
+    workspace - the workspace to which the measurements will be added
+    """
+    #
+    # Record the measurements
+    #
+    # assume isinstance(workspace, Workspace)
+    m = workspace.measurements
+    # assume isinstance(m, Measurements)
+    
+    # Record Image Measurements
+    for feature_name, value in library_measurements.image.items():
+        m.add_image_measurement(feature_name, value)
+    
+    # Record Object Measurements
+    for object_name, features in library_measurements.objects.items():
+        for feature_name, data in features.items():
+            m.add_measurement(object_name, feature_name, data)
 
-    return skimage.measure.mesh_surface_area(verts, faces)