CellProfiler-nightly 5.0.0.dev520__tar.gz → 5.0.0.dev534__tar.gz

{cellprofiler_nightly-5.0.0.dev520 → cellprofiler_nightly-5.0.0.dev534}/CellProfiler_nightly.egg-info/PKG-INFO

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

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

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev520'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev520')
+__version__ = version = '5.0.0.dev534'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev534')
 
-__commit_id__ = commit_id = 'g6a15833a1'
+__commit_id__ = commit_id = 'gb1ea41570'

{cellprofiler_nightly-5.0.0.dev520 → cellprofiler_nightly-5.0.0.dev534}/cellprofiler/modules/measureimageintensity.py

@@ -1,7 +1,7 @@
 import logging
 
 import numpy
-from cellprofiler_core.constants.measurement import COLTYPE_FLOAT
+from cellprofiler_core.constants.measurement import COLTYPE_FLOAT, COLTYPE_INTEGER
 from cellprofiler_core.module import Module
 from cellprofiler_core.setting import Binary, ValidationError, Divider
 from cellprofiler_core.setting.text import Text
@@ -11,7 +11,8 @@ from cellprofiler_core.setting.subscriber import (
 )
 
 from cellprofiler.modules import _help
-
+from cellprofiler_library.opts.measureimageintensity import TemplateMeasurementFormat, TemplateFeature, ALL_MEASUREMENTS
+from cellprofiler_library.modules._measureimageintensity import measure_image_intensity
 LOGGER = logging.getLogger(__name__)
 
 __doc__ = """
@@ -72,52 +73,6 @@ Measurements made by this module
     **{"HELP_ON_MEASURING_INTENSITIES": _help.HELP_ON_MEASURING_INTENSITIES}
 )
 
-"""Measurement feature name format for the TotalIntensity measurement"""
-F_TOTAL_INTENSITY = "Intensity_TotalIntensity_%s"
-
-"""Measurement feature name format for the MeanIntensity measurement"""
-F_MEAN_INTENSITY = "Intensity_MeanIntensity_%s"
-
-"""Measurement feature name format for the MeanIntensity measurement"""
-F_MEDIAN_INTENSITY = "Intensity_MedianIntensity_%s"
-
-"""Measurement feature name format for the StdIntensity measurement"""
-F_STD_INTENSITY = "Intensity_StdIntensity_%s"
-
-"""Measurement feature name format for the MedAbsDevIntensity measurement"""
-F_MAD_INTENSITY = "Intensity_MADIntensity_%s"
-
-"""Measurement feature name format for the MaxIntensity measurement"""
-F_MAX_INTENSITY = "Intensity_MaxIntensity_%s"
-
-"""Measurement feature name format for the MinIntensity measurement"""
-F_MIN_INTENSITY = "Intensity_MinIntensity_%s"
-
-"""Measurement feature name format for the TotalArea measurement"""
-F_TOTAL_AREA = "Intensity_TotalArea_%s"
-
-"""Measurement feature name format for the PercentMaximal measurement"""
-F_PERCENT_MAXIMAL = "Intensity_PercentMaximal_%s"
-
-"""Measurement feature name format for the Quartile measurements"""
-F_UPPER_QUARTILE = "Intensity_UpperQuartileIntensity_%s"
-F_LOWER_QUARTILE = "Intensity_LowerQuartileIntensity_%s"
-
-ALL_MEASUREMENTS = [
-    "TotalIntensity",
-    "MeanIntensity",
-    "StdIntensity",
-    "MADIntensity",
-    "MedianIntensity",
-    "MinIntensity",
-    "MaxIntensity",
-    "TotalArea",
-    "PercentMaximal",
-    "LowerQuartileIntensity",
-    "UpperQuartileIntensity",
-]
-
-
 class MeasureImageIntensity(Module):
     module_name = "MeasureImageIntensity"
     category = "Measurement"
@@ -224,20 +179,22 @@ class MeasureImageIntensity(Module):
 
     def run(self, workspace):
         """Perform the measurements on the image sets"""
-        col_labels = ["Image", "Masking object", "Feature", "Value"]
+        percentiles_to_measure = self.percentiles.value
+        wants_object = self.wants_objects.value
+        objects_list = self.objects_list.value
+            
         statistics = []
         if self.wants_percentiles:
-            percentiles = self.get_percentiles(self.percentiles.value, stop=True)
+            percentiles = self.get_percentiles(percentiles_to_measure, stop=True)
         else:
             percentiles = None
+        
         for im in self.images_list.value:
             image = workspace.image_set.get_image(im, must_be_grayscale=True)
             input_pixels = image.pixel_data
 
-            measurement_name = im
-            if self.wants_objects.value:
-                for object_set in self.objects_list.value:
-                    measurement_name += "_" + object_set
+            if wants_object:
+                for object_set in objects_list:
                     objects = workspace.get_objects(object_set)
                     if objects.shape != input_pixels.shape:
                         raise ValueError(
@@ -253,17 +210,33 @@ class MeasureImageIntensity(Module):
                         ]
                     else:
                         pixels = input_pixels[objects.segmented != 0]
-                    statistics += self.measure(
-                        pixels, im, object_set, measurement_name, workspace, percentiles=percentiles
+                    
+                    lm, stats = measure_image_intensity(
+                        pixels=pixels,
+                        image_name=im,
+                        object_name=object_set,
+                        percentiles=percentiles
                     )
+                    
+                    self._add_library_measurements_to_core(lm, workspace)
+                    statistics += stats
             else:
                 if image.has_mask:
                     pixels = input_pixels[image.mask]
                 else:
                     pixels = input_pixels
-                statistics += self.measure(
-                    pixels, im, None, measurement_name, workspace, percentiles=percentiles
+                
+                lm, stats = measure_image_intensity(
+                    pixels=pixels,
+                    image_name=im,
+                    object_name=None,
+                    percentiles=percentiles
                 )
+                
+                self._add_library_measurements_to_core(lm, workspace)
+                statistics += stats
+
+        col_labels = ["Image", "Masking object", "Feature", "Value"]
         workspace.display_data.statistics = statistics
         workspace.display_data.col_labels = col_labels
 
@@ -276,115 +249,31 @@ class MeasureImageIntensity(Module):
             col_labels=workspace.display_data.col_labels,
         )
 
-    def measure(self, pixels, image_name, object_name, measurement_name, workspace, percentiles=None):
-        """Perform measurements on an array of pixels
-        pixels - image pixel data, masked to objects if applicable
-        image_name - name of the current input image
-        object_name - name of the current object set pixels are masked to
-        measurement_name - group title to be used in data tables
-        workspace - has all the details for current image set
-        """
-        pixel_count = numpy.product(pixels.shape)
-        percentile_measures = {}
-        if pixel_count == 0:
-            pixel_sum = 0
-            pixel_mean = 0
-            pixel_std = 0
-            pixel_mad = 0
-            pixel_median = 0
-            pixel_min = 0
-            pixel_max = 0
-            pixel_pct_max = 0
-            pixel_lower_qrt = 0
-            pixel_upper_qrt = 0
-            if percentiles:
-                for percentile in percentiles:
-                    percentile_measures[percentile] = 0
-        else:
-            pixels = pixels.flatten()
-            pixels = pixels[
-                numpy.nonzero(numpy.isfinite(pixels))[0]
-            ]  # Ignore NaNs, Infs
-            pixel_count = numpy.product(pixels.shape)
-
-            pixel_sum = numpy.sum(pixels)
-            pixel_mean = pixel_sum / float(pixel_count)
-            pixel_std = numpy.std(pixels)
-            pixel_median = numpy.median(pixels)
-            pixel_mad = numpy.median(numpy.abs(pixels - pixel_median))
-            pixel_min = numpy.min(pixels)
-            pixel_max = numpy.max(pixels)
-            pixel_pct_max = (
-                100.0 * float(numpy.sum(pixels == pixel_max)) / float(pixel_count)
-            )
-            pixel_lower_qrt, pixel_upper_qrt = numpy.percentile(pixels, [25, 75])
-
-            if percentiles:
-                percentile_results = numpy.percentile(pixels, percentiles)
-                for percentile, res in zip(percentiles, percentile_results):
-                    percentile_measures[percentile] = res
-
-
-        m = workspace.measurements
-        m.add_image_measurement(F_TOTAL_INTENSITY % measurement_name, pixel_sum)
-        m.add_image_measurement(F_MEAN_INTENSITY % measurement_name, pixel_mean)
-        m.add_image_measurement(F_MEDIAN_INTENSITY % measurement_name, pixel_median)
-        m.add_image_measurement(F_STD_INTENSITY % measurement_name, pixel_std)
-        m.add_image_measurement(F_MAD_INTENSITY % measurement_name, pixel_mad)
-        m.add_image_measurement(F_MAX_INTENSITY % measurement_name, pixel_max)
-        m.add_image_measurement(F_MIN_INTENSITY % measurement_name, pixel_min)
-        m.add_image_measurement(F_TOTAL_AREA % measurement_name, pixel_count)
-        m.add_image_measurement(F_PERCENT_MAXIMAL % measurement_name, pixel_pct_max)
-        m.add_image_measurement(F_LOWER_QUARTILE % measurement_name, pixel_lower_qrt)
-        m.add_image_measurement(F_UPPER_QUARTILE % measurement_name, pixel_upper_qrt)
-
-        all_features = [
-                ("Total intensity", pixel_sum),
-                ("Mean intensity", pixel_mean),
-                ("Median intensity", pixel_median),
-                ("Std intensity", pixel_std),
-                ("MAD intensity", pixel_mad),
-                ("Min intensity", pixel_min),
-                ("Max intensity", pixel_max),
-                ("Pct maximal", pixel_pct_max),
-                ("Lower quartile", pixel_lower_qrt),
-                ("Upper quartile", pixel_upper_qrt),
-                ("Total area", pixel_count),
-        ]
-        for percentile, value in percentile_measures.items():
-            m.add_image_measurement(f"Intensity_Percentile_{percentile}_{measurement_name}", value)
-            all_features.append((f"Percentile {percentile}", value))
-
-        return [
-            [
-                image_name,
-                object_name if self.wants_objects.value else "",
-                feature_name,
-                str(value),
-            ]
-            for feature_name, value in all_features
-        ]
-
+    def _add_library_measurements_to_core(self, lib_measurements, workspace):
+        for feature_name, value in lib_measurements.image.items():
+            workspace.measurements.add_image_measurement(feature_name, value)
+            
     def get_measurement_columns(self, pipeline):
         """Return column definitions for measurements made by this module"""
         columns = []
         col_defs = [
-            (F_TOTAL_INTENSITY, COLTYPE_FLOAT),
-            (F_MEAN_INTENSITY, COLTYPE_FLOAT),
-            (F_MEDIAN_INTENSITY, COLTYPE_FLOAT),
-            (F_STD_INTENSITY, COLTYPE_FLOAT),
-            (F_MAD_INTENSITY, COLTYPE_FLOAT),
-            (F_MIN_INTENSITY, COLTYPE_FLOAT),
-            (F_MAX_INTENSITY, COLTYPE_FLOAT),
-            (F_TOTAL_AREA, "integer"),
-            (F_PERCENT_MAXIMAL, COLTYPE_FLOAT),
-            (F_LOWER_QUARTILE, COLTYPE_FLOAT),
-            (F_UPPER_QUARTILE, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.TOTAL_INTENSITY, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.MEAN_INTENSITY, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.MEDIAN_INTENSITY, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.STD_INTENSITY, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.MAD_INTENSITY, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.MIN_INTENSITY, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.MAX_INTENSITY, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.TOTAL_AREA, COLTYPE_INTEGER),
+            (TemplateMeasurementFormat.PERCENT_MAXIMAL, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.LOWER_QUARTILE, COLTYPE_FLOAT),
+            (TemplateMeasurementFormat.UPPER_QUARTILE, COLTYPE_FLOAT),
         ]
         if self.wants_percentiles:
             percentiles = self.get_percentiles(self.percentiles.value, stop=False)
             for percentile in percentiles:
-                col_defs.append((f"Intensity_Percentile_{percentile}_%s", COLTYPE_FLOAT))
+                # partial application of template
+                col_defs.append((TemplateMeasurementFormat.PERCENTILE % (percentile, '%s'), COLTYPE_FLOAT))
 
         for im in self.images_list.value:
             for feature, coltype in col_defs:
@@ -409,7 +298,7 @@ class MeasureImageIntensity(Module):
             if self.wants_percentiles:
                 percentiles = self.get_percentiles(self.percentiles.value, stop=False)
                 for i in percentiles:
-                    measures.append(f"Percentile_{i}")
+                    measures.append(TemplateFeature.PERCENTILE.value)
             return measures
         return []
 
@@ -418,7 +307,7 @@ class MeasureImageIntensity(Module):
         if self.wants_percentiles:
             percentiles = self.get_percentiles(self.percentiles.value, stop=False)
             for i in percentiles:
-                measures.append(f"Percentile_{i}")
+                measures.append(TemplateFeature.PERCENTILE.value)
         if (
             object_name == "Image"
             and category == "Intensity"

cellprofiler_nightly-5.0.0.dev534/cellprofiler/modules/measureobjectintensity.py

@@ -0,0 +1,282 @@
+from cellprofiler_core.constants.measurement import C_LOCATION, COLTYPE_FLOAT
+from cellprofiler_core.module import Module
+from cellprofiler_core.setting import Divider, ValidationError
+from cellprofiler_core.setting.subscriber import (
+    ImageListSubscriber,
+    LabelListSubscriber,
+)
+from cellprofiler.modules import _help
+from cellprofiler_library.modules._measureobjectintensity import measure_object_intensity
+from cellprofiler_library.opts.measureobjectintensity import ALL_MEASUREMENTS, ALL_LOCATION_MEASUREMENTS, C_INTENSITY, TemplateMeasurementFormat, IntensityFeature
+
+__doc__ = """
+MeasureObjectIntensity
+======================
+
+**MeasureObjectIntensity** measures several intensity features for
+identified objects.
+
+Given an image with objects identified (e.g., nuclei or cells), this
+module extracts intensity features for each object based on one or more
+corresponding grayscale images. Measurements are recorded for each
+object.
+
+Intensity measurements are made for all combinations of the images and
+objects entered. If you want only specific image/object measurements,
+you can use multiple MeasureObjectIntensity modules for each group of
+measurements desired.
+
+{HELP_ON_MEASURING_INTENSITIES}
+
+|
+
+============ ============ ===============
+Supports 2D? Supports 3D? Respects masks?
+============ ============ ===============
+YES          YES          YES
+============ ============ ===============
+
+See also
+^^^^^^^^
+
+See also **NamesAndTypes**, **MeasureImageIntensity**.
+
+Measurements made by this module
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+-  *IntegratedIntensity:* The sum of the pixel intensities within an
+   object.
+-  *MeanIntensity:* The average pixel intensity within an object.
+-  *StdIntensity:* The standard deviation of the pixel intensities
+   within an object.
+-  *MaxIntensity:* The maximal pixel intensity within an object.
+-  *MinIntensity:* The minimal pixel intensity within an object.
+-  *IntegratedIntensityEdge:* The sum of the edge pixel intensities of
+   an object.
+-  *MeanIntensityEdge:* The average edge pixel intensity of an object.
+-  *StdIntensityEdge:* The standard deviation of the edge pixel
+   intensities of an object.
+-  *MaxIntensityEdge:* The maximal edge pixel intensity of an object.
+-  *MinIntensityEdge:* The minimal edge pixel intensity of an object.
+-  *MassDisplacement:* The distance between the centers of gravity in
+   the gray-level representation of the object and the binary
+   representation of the object.
+-  *LowerQuartileIntensity:* The intensity value of the pixel for which
+   25% of the pixels in the object have lower values.
+-  *MedianIntensity:* The median intensity value within the object.
+-  *MADIntensity:* The median absolute deviation (MAD) value of the
+   intensities within the object. The MAD is defined as the
+   median(\|x\ :sub:`i` - median(x)\|).
+-  *UpperQuartileIntensity:* The intensity value of the pixel for which
+   75% of the pixels in the object have lower values.
+-  *Location\_CenterMassIntensity\_X, Location\_CenterMassIntensity\_Y:*
+   The (X,Y) coordinates of the intensity weighted centroid (=
+   center of mass = first moment) of all pixels within the object.
+-  *Location\_MaxIntensity\_X, Location\_MaxIntensity\_Y:* The
+   (X,Y) coordinates of the pixel with the maximum intensity within the
+   object.
+
+""".format(
+    **{"HELP_ON_MEASURING_INTENSITIES": _help.HELP_ON_MEASURING_INTENSITIES}
+)
+
+class MeasureObjectIntensity(Module):
+    module_name = "MeasureObjectIntensity"
+    variable_revision_number = 4
+    category = "Measurement"
+
+    def create_settings(self):
+        self.images_list = ImageListSubscriber(
+            "Select images to measure",
+            [],
+            doc="""Select the grayscale images whose intensity you want to measure.""",
+        )
+        self.divider = Divider()
+        self.objects_list = LabelListSubscriber(
+            "Select objects to measure",
+            [],
+            doc="""Select the object sets whose intensity you want to measure.""",
+        )
+
+    def settings(self):
+        result = [self.images_list, self.objects_list]
+        return result
+
+    def visible_settings(self):
+        result = [self.images_list, self.divider, self.objects_list]
+        return result
+
+    def upgrade_settings(self, setting_values, variable_revision_number, module_name):
+        if variable_revision_number == 2:
+            num_imgs = setting_values.index("Do not use")
+            setting_values = (
+                [str(num_imgs)]
+                + setting_values[:num_imgs]
+                + setting_values[num_imgs + 1 :]
+            )
+            variable_revision_number = 3
+        if variable_revision_number == 3:
+            num_imgs = int(setting_values[0])
+            images_list = setting_values[1 : num_imgs + 1]
+            objects_list = setting_values[num_imgs + 1 :]
+            setting_values = [
+                ", ".join(map(str, images_list)),
+                ", ".join(map(str, objects_list)),
+            ]
+            variable_revision_number = 4
+        return setting_values, variable_revision_number
+
+    def validate_module(self, pipeline):
+        """Make sure chosen objects and images are selected only once"""
+        images = set()
+        if len(self.images_list.value) == 0:
+            raise ValidationError("No images selected", self.images_list)
+        elif len(self.objects_list.value) == 0:
+            raise ValidationError("No objects selected", self.objects_list)
+        for image_name in self.images_list.value:
+            if image_name in images:
+                raise ValidationError(
+                    "%s has already been selected" % image_name, image_name
+                )
+            images.add(image_name)
+
+        objects = set()
+        for object_name in self.objects_list.value:
+            if object_name in objects:
+                raise ValidationError(
+                    "%s has already been selected" % object_name, object_name
+                )
+            objects.add(object_name)
+
+    def get_measurement_columns(self, pipeline):
+        """Return the column definitions for measurements made by this module"""
+        columns = []
+        for image_name in self.images_list.value:
+            for object_name in self.objects_list.value:
+                for category, features in (
+                    (C_INTENSITY, ALL_MEASUREMENTS),
+                    (C_LOCATION, ALL_LOCATION_MEASUREMENTS,),
+                ):
+                    for feature in features:
+                        columns.append(
+                            (
+                                object_name,
+                                "%s_%s_%s" % (category, feature, image_name),
+                                COLTYPE_FLOAT,
+                            )
+                        )
+
+        return columns
+
+    def get_categories(self, pipeline, object_name):
+        """Get the categories of measurements supplied for the given object name
+
+        pipeline - pipeline being run
+        object_name - name of labels in question (or 'Images')
+        returns a list of category names
+        """
+        for object_set in self.objects_list.value:
+            if object_set == object_name:
+                return [C_INTENSITY, C_LOCATION]
+        return []
+
+    def get_measurements(self, pipeline, object_name, category):
+        """Get the measurements made on the given object in the given category"""
+        if category == C_LOCATION:
+            all_measurements = ALL_LOCATION_MEASUREMENTS
+        elif category == C_INTENSITY:
+            all_measurements = ALL_MEASUREMENTS
+        else:
+            return []
+        for object_set in self.objects_list.value:
+            if object_set == object_name:
+                return all_measurements
+        return []
+
+    def get_measurement_images(self, pipeline, object_name, category, measurement):
+        """Get the images used to make the given measurement in the given category on the given object"""
+        if category == C_INTENSITY:
+            if measurement not in ALL_MEASUREMENTS:
+                return []
+        elif category == C_LOCATION:
+            if measurement not in ALL_LOCATION_MEASUREMENTS:
+                return []
+        else:
+            return []
+        for object_set in self.objects_list.value:
+            if object_set == object_name:
+                return self.images_list.value
+        return []
+    
+    def run(self, workspace):
+        if self.show_window:
+            workspace.display_data.col_labels = (
+                "Image",
+                "Object",
+                "Feature",
+                "Mean",
+                "Median",
+                "STD",
+            )
+            workspace.display_data.statistics = []
+        if len(self.images_list.value) == 0 or len(self.objects_list.value) == 0:
+            raise ValueError(
+                "This module needs at least 1 image and object set selected"
+            )
+        for image_name in self.images_list.value:
+            image = workspace.image_set.get_image(image_name, must_be_grayscale=True)
+            for object_name in self.objects_list.value:
+                if object_name not in workspace.object_set.object_names:
+                    raise ValueError(
+                        "The %s objects are missing from the pipeline." % object_name
+                    )
+                # Need to refresh image after each iteration...
+                img = image.pixel_data
+                image_mask = image.mask if image.has_mask else None
+
+                objects = workspace.object_set.get_objects(object_name)
+                nobjects = objects.count
+                
+                lib_measurements, lib_stats = measure_object_intensity(
+                    img=img,
+                    image_name=image_name,
+                    object_name=object_name,
+                    image_mask=image_mask,
+                    object_labels=objects.get_labels(),
+                    nobjects=nobjects,
+                    image_dimensions=image.dimensions,
+                )
+
+                m = workspace.measurements
+
+                # Feature Name -> Template String
+                feature_template_map = {
+                    val[:-len('_%s')].split('_', 1)[1]: val
+                    for val in (getattr(TemplateMeasurementFormat, x.name) for x in IntensityFeature)
+                }
+
+                for stat in lib_stats:
+                    image_name = stat[0]
+                    object_name = stat[1]
+                    feature_name = stat[2]
+                    measurement_name = feature_template_map[feature_name] % image_name
+                    # Retrieve measurement from LibraryMeasurements
+                    # Note: measure_object_intensity adds them with the same key format
+                    if lib_measurements.has_feature(object_name, measurement_name):
+                        measurement = lib_measurements.get_measurement(object_name, measurement_name)
+                        m.add_measurement(object_name, measurement_name, measurement)
+                        if self.show_window and len(measurement) > 0:
+                            workspace.display_data.statistics.append(stat)
+
+    def display(self, workspace, figure):
+        figure.set_subplots((1, 1))
+        figure.subplot_table(
+            0,
+            0,
+            workspace.display_data.statistics,
+            col_labels=workspace.display_data.col_labels,
+            title="default",
+        )
+
+    def volumetric(self):
+        return True