cellprofiler-library-nightly 5.0.0.dev496__tar.gz → 5.0.0.dev509__tar.gz

{cellprofiler_library_nightly-5.0.0.dev496 → cellprofiler_library_nightly-5.0.0.dev509}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev496
+Version: 5.0.0.dev509
 Summary: cellprofiler-library implements CellProfiler's image processing and mathematical code, and is usable as a standalone library
 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_library_nightly-5.0.0.dev509/cellprofiler_library/__init__.py

@@ -0,0 +1 @@
+from .measurement_model import LibraryMeasurements

{cellprofiler_library_nightly-5.0.0.dev496 → cellprofiler_library_nightly-5.0.0.dev509}/cellprofiler_library/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '5.0.0.dev496'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev496')
+__version__ = version = '5.0.0.dev509'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev509')
 
-__commit_id__ = commit_id = 'g8d098d2ce'
+__commit_id__ = commit_id = 'gc5c07ce88'

{cellprofiler_library_nightly-5.0.0.dev496 → cellprofiler_library_nightly-5.0.0.dev509}/cellprofiler_library/functions/image_processing.py

@@ -15,9 +15,9 @@ import scipy
 import scipy.interpolate
 import matplotlib
 import math
+from numpy.typing import NDArray
 from centrosome.cpmorphology import fixup_scipy_ndimage_result as fix
 from typing import Any, Optional, Tuple, Callable, Union, List, cast, Dict, TypeVar
-from numpy.typing import NDArray
 from skimage.restoration import denoise_bilateral
 from cellprofiler_library.types import (
     ImageGrayscale, ImageGrayscaleMask, 
@@ -262,7 +262,6 @@ def morphology_dilation(image: ImageAny, structuring_element: StructuringElement
     y_data = skimage.morphology.dilation(image, structuring_element)
     return y_data
 
-
 def median_filter(image, window_size, mode):
     return scipy.ndimage.median_filter(image, size=window_size, mode=mode)
 
@@ -2199,3 +2198,118 @@ def apply_threshold_to_objects(
         output_image_arr[mask] = (image >= scaled_image[segmented - 1])        
 
     return output_image_arr
+
+
+################################################################################
+# MeasureGranularity
+################################################################################
+
+def rescale_pixel_data_and_mask(
+    new_shape: Union[Tuple[int, ...], NDArray[numpy.float64]], 
+    subsample_size: float, 
+    im_pixel_data: ImageGrayscale, 
+    im_mask: ImageGrayscaleMask, 
+    dimensions: int
+    ) -> Tuple[ImageGrayscale, ImageGrayscaleMask]:
+    if dimensions == 2:
+        i, j = (
+            numpy.mgrid[0 : new_shape[0], 0 : new_shape[1]].astype(float)
+            / subsample_size
+        )
+        pixels = scipy.ndimage.map_coordinates(im_pixel_data, (i, j), order=1)
+        mask = (
+            scipy.ndimage.map_coordinates(im_mask.astype(float), (i, j)).astype(float) > 0.9
+        )
+    else:
+        k, i, j = (
+            numpy.mgrid[0 : new_shape[0], 0 : new_shape[1], 0 : new_shape[2]].astype(float)
+            / subsample_size
+        )
+        pixels = scipy.ndimage.map_coordinates(im_pixel_data, (k, i, j), order=1)
+        mask = (
+            scipy.ndimage.map_coordinates(im_mask.astype(float), (k, i, j)).astype(float) > 0.9
+            )
+    return pixels, mask
+
+
+def restore_scale(
+    dimensions: int, 
+    orig_shape: NDArray[numpy.float64], 
+    scaled_shape: NDArray[numpy.float64], 
+    scaled_pixels: ImageGrayscale
+    ) -> ImageGrayscale:
+    if dimensions == 2:
+        i, j = numpy.mgrid[0 : orig_shape[0], 0 : orig_shape[1]].astype(float)
+        #
+        # Make sure the mapping only references the index range of
+        # back_pixels.
+        #
+        i *= float(scaled_shape[0] - 1) / float(orig_shape[0] - 1)
+        j *= float(scaled_shape[1] - 1) / float(orig_shape[1] - 1)
+        scaled_pixels = scipy.ndimage.map_coordinates(scaled_pixels, (i, j), order=1).astype(float)
+    else:
+        k, i, j = numpy.mgrid[
+            0 : orig_shape[0], 0 : orig_shape[1], 0 : orig_shape[2]
+        ].astype(float)
+        k *= float(scaled_shape[0] - 1) / float(orig_shape[0] - 1)
+        i *= float(scaled_shape[1] - 1) / float(orig_shape[1] - 1)
+        j *= float(scaled_shape[2] - 1) / float(orig_shape[2] - 1)
+        scaled_pixels = scipy.ndimage.map_coordinates(scaled_pixels, (k, i, j), order=1).astype(float)
+    return scaled_pixels
+
+def downsample_image_and_mask(
+    im_pixel_data: ImageGrayscale, 
+    im_mask: ImageGrayscaleMask, 
+    dimensions: int, 
+    subsample_size: float
+    ) -> Tuple[ImageGrayscale, ImageGrayscaleMask, NDArray[numpy.float64]]:
+    #
+    # Downsample the image and mask
+    #
+    new_shape = numpy.array(im_pixel_data.shape)
+    if subsample_size < 1:
+        new_shape = new_shape * subsample_size
+        pixels, mask = rescale_pixel_data_and_mask(new_shape, subsample_size, im_pixel_data, im_mask, dimensions)
+    else:
+        pixels = im_pixel_data.copy()
+        mask = im_mask.copy()
+    return pixels, mask, new_shape
+
+def apply_grayscale_tophat_filter(
+    pixels: ImageGrayscale, 
+    mask: ImageGrayscaleMask, 
+    dimensions: int, 
+    image_sample_size: float, 
+    radius: int, 
+    new_shape: NDArray[numpy.float64]
+    ) -> ImageGrayscale:
+    back_pixels, back_mask, back_shape = downsample_image_and_mask(pixels, mask, dimensions, image_sample_size)
+    # radius = element_size
+    footprint = get_morphology_footprint(radius, dimensions)
+    back_pixels = masked_erode(back_pixels, back_mask, footprint)
+    back_pixels = masked_dilate(back_pixels, back_mask, footprint)
+    if image_sample_size < 1:
+        back_pixels = restore_scale(dimensions, new_shape, back_shape, back_pixels)
+    pixels -= back_pixels
+    pixels[pixels < 0] = 0
+    return pixels
+
+def masked_dilate(im, mask, footprint):
+    im_mask = numpy.zeros_like(im)
+    im_mask[mask == True] = im[mask == True]
+    im = morphology_dilation(im_mask, footprint)
+    return im
+
+def masked_erode(im, mask, footprint):
+    im_mask = numpy.zeros_like(im)
+    im_mask[mask == True] = im[mask == True]
+    im = morphology_erosion(im_mask, footprint)
+    return im
+
+def get_morphology_footprint(radius, dimensions):
+    if dimensions == 2:
+        footprint = skimage.morphology.disk(radius, dtype=bool)
+    else:
+        footprint = skimage.morphology.ball(radius, dtype=bool)
+    return footprint
+    

{cellprofiler_library_nightly-5.0.0.dev496 → cellprofiler_library_nightly-5.0.0.dev509}/cellprofiler_library/functions/measurement.py

@@ -11,7 +11,7 @@ import centrosome.fastemd
 
 from centrosome.cpmorphology import fixup_scipy_ndimage_result as fix
 from sklearn.cluster import KMeans
-from typing import Tuple, Optional, Dict, Callable
+from typing import Tuple, Optional, Dict, Callable, List
 from scipy.linalg import lstsq
 from numpy.typing import NDArray
 
@@ -21,11 +21,14 @@ from cellprofiler_library.functions.segmentation import indices_from_ijv
 from cellprofiler_library.functions.segmentation import count_from_ijv
 from cellprofiler_library.functions.segmentation import areas_from_ijv
 from cellprofiler_library.functions.segmentation import cast_labels_to_label_set
+from cellprofiler_library.functions.image_processing import masked_erode, restore_scale, get_morphology_footprint
+
 from cellprofiler_library.opts.objectsizeshapefeatures import ObjectSizeShapeFeatures
-from cellprofiler_library.types import Pixel, ObjectLabel
+from cellprofiler_library.types import Pixel, ObjectLabel, ImageGrayscale, ImageGrayscaleMask, ObjectSegmentation
 from cellprofiler_library.opts.measurecolocalization import CostesMethod
 
 
+            
 def measure_image_overlap_statistics(
     ground_truth_image,
     test_image,
@@ -1377,3 +1380,109 @@ def linear_costes(
         except ValueError:
             break
     return thr_fi_c, thr_si_c
+
+
+###############################################################################
+# Measure Granularity
+###############################################################################
+
+class ObjectRecord(object):
+    def __init__(
+            self, 
+            name: str, 
+            segmented: ObjectSegmentation, 
+            im_mask: Optional[ImageGrayscaleMask], 
+            im_pixel_data: Optional[ImageGrayscale]
+            ):
+        self.name = name
+        self.labels = segmented
+        self.nobjects = np.max(self.labels)
+        if self.nobjects != 0:
+            assert im_mask is not None
+            assert im_pixel_data is not None
+            self.range = np.arange(1, np.max(self.labels) + 1)
+            self.labels = self.labels.copy()
+            self.labels[~im_mask] = 0
+            self.current_mean = fix(
+                scipy.ndimage.mean(im_pixel_data, self.labels, self.range)
+            )
+            self.start_mean = np.maximum(
+                self.current_mean, np.finfo(float).eps
+            )
+
+
+def get_granularity_measurements(
+        im_pixel_data: ImageGrayscale,
+        pixels: ImageGrayscale, 
+        mask: ImageGrayscaleMask, 
+        new_shape: NDArray[numpy.float64],
+        granular_spectrum_length: int,
+        dimensions: int,
+        object_records: List[ObjectRecord]
+        ):
+    # TODO: PR #5034 update the return types of this funciton
+    # Transcribed from the Matlab module: granspectr function
+    #
+    # CALCULATES GRANULAR SPECTRUM, ALSO KNOWN AS SIZE DISTRIBUTION,
+    # GRANULOMETRY, AND PATTERN SPECTRUM, SEE REF.:
+    # J.Serra, Image Analysis and Mathematical Morphology, Vol. 1. Academic Press, London, 1989
+    # Maragos,P. "Pattern spectrum and multiscale shape representation", IEEE Transactions on Pattern Analysis and Machine Intelligence, 11, N 7, pp. 701-716, 1989
+    # L.Vincent "Granulometries and Opening Trees", Fundamenta Informaticae, 41, No. 1-2, pp. 57-90, IOS Press, 2000.
+    # L.Vincent "Morphological Area Opening and Closing for Grayscale Images", Proc. NATO Shape in Picture Workshop, Driebergen, The Netherlands, pp. 197-208, 1992.
+    # I.Ravkin, V.Temov "Bit representation techniques and image processing", Applied Informatics, v.14, pp. 41-90, Finances and Statistics, Moskow, 1988 (in Russian)
+    # THIS IMPLEMENTATION INSTEAD OF OPENING USES EROSION FOLLOWED BY RECONSTRUCTION
+    #
+    footprint = get_morphology_footprint(1, dimensions)
+    ng = granular_spectrum_length
+    startmean = np.mean(pixels[mask])
+    ero = pixels.copy()
+    # Mask the test image so that masked pixels will have no effect
+    # during reconstruction
+    #
+    ero[~mask] = 0
+    currentmean = startmean
+    startmean = max(startmean, np.finfo(float).eps)
+    measurements_arr = []
+    image_measurements_arr = []
+
+    statistics = []
+    for i in range(1, ng + 1):
+        prevmean = currentmean
+        ero = masked_erode(ero, mask, footprint)
+        rec = skimage.morphology.reconstruction(ero, pixels, footprint=footprint)
+        currentmean = np.mean(rec[mask])
+        gs = (prevmean - currentmean) * 100 / startmean
+        statistics += ["%.2f" % gs]
+        image_measurements_arr += [gs]
+        # measurements.add_image_measurement(feature, gs)
+        #
+        # Restore the reconstructed image to the shape of the
+        # original image so we can match against object labels
+        #
+        orig_shape = im_pixel_data.shape
+        rec = restore_scale(dimensions, orig_shape, new_shape, rec)
+
+        #
+        # Calculate the means for the objects
+        #
+        obj_measurements=[]
+        for object_record in object_records:
+            assert isinstance(object_record, ObjectRecord)
+            if object_record.nobjects > 0:
+                new_mean = fix(
+                    scipy.ndimage.mean(
+                        rec, object_record.labels, object_record.range
+                    )
+                )
+                gss = (
+                    (object_record.current_mean - new_mean)
+                    * 100
+                    / object_record.start_mean
+                )
+                object_record.current_mean = new_mean
+            else:
+                gss = np.zeros((0,))
+            obj_measurements += [[object_record.name, gss]]
+        measurements_arr += [obj_measurements]
+    return measurements_arr, image_measurements_arr, statistics
+

cellprofiler_library_nightly-5.0.0.dev509/cellprofiler_library/measurement_model.py

@@ -0,0 +1,154 @@
+from typing import Any, Dict, List
+from pydantic import BaseModel, Field, ConfigDict
+
+class LibraryMeasurements(BaseModel):
+    """
+    A Pydantic implementation mirroring CellProfiler's Measurements class functionality.
+    
+    This class represents measurements for a single image set context, designed to be
+    constructed from and serializable to the "Primitive Dictionary" contract.
+    """
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    # Primary data structures matching the MDC contract
+    image: Dict[str, Any] = Field(default_factory=dict)
+    objects: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
+    
+    # Additional storage for full Measurements compatibility (e.g. Experiment metadata)
+    experiment: Dict[str, Any] = Field(default_factory=dict)
+    
+    # Placeholder for relationships if needed in the future
+    relationships: List[Dict[str, Any]] = Field(default_factory=list)
+
+    def add_measurement(self, object_name: str, feature_name: str, data: Any):
+        """
+        Add a measurement. Mirrors Measurements.add_measurement.
+        
+        Args:
+            object_name: Name of the object (e.g., 'Image', 'Nuclei').
+            feature_name: Name of the feature (e.g., 'AreaShape_Area').
+            data: The value to store (float, string, or numpy array).
+        """
+        if object_name == "Experiment":
+            self.experiment[feature_name] = data
+        elif object_name == "Image":
+            self.image[feature_name] = data
+        else:
+            if object_name not in self.objects:
+                self.objects[object_name] = {}
+            self.objects[object_name][feature_name] = data
+
+    def get_measurement(self, object_name: str, feature_name: str) -> Any:
+        """
+        Get a measurement. Mirrors Measurements.get_measurement.
+        """
+        if object_name == "Experiment":
+            return self.experiment.get(feature_name)
+        elif object_name == "Image":
+            return self.image.get(feature_name)
+        else:
+            return self.objects.get(object_name, {}).get(feature_name)
+
+    def add_image_measurement(self, feature_name: str, data: Any):
+        """Helper to add an image measurement."""
+        self.add_measurement("Image", feature_name, data)
+
+    def add_experiment_measurement(self, feature_name: str, data: Any):
+        """Helper to add an experiment measurement."""
+        self.add_measurement("Experiment", feature_name, data)
+
+    def get_experiment_measurement(self, feature_name: str) -> Any:
+        """Helper to get an experiment measurement."""
+        return self.get_measurement("Experiment", feature_name)
+    
+    def get_object_names(self) -> List[str]:
+        """Return a list of all object names (including Image and Experiment if present)."""
+        names = list(self.objects.keys())
+        if self.image:
+            names = ["Image"] + names
+        if self.experiment:
+            names = ["Experiment"] + names
+        return names
+
+    def get_feature_names(self, object_name: str) -> List[str]:
+        """Return feature names for a specific object."""
+        if object_name == "Experiment":
+            return list(self.experiment.keys())
+        elif object_name == "Image":
+            return list(self.image.keys())
+        else:
+            return list(self.objects.get(object_name, {}).keys())
+            
+    def has_feature(self, object_name: str, feature_name: str) -> bool:
+        """Check if a feature exists."""
+        if object_name == "Experiment":
+            return feature_name in self.experiment
+        elif object_name == "Image":
+            return feature_name in self.image
+        else:
+            return feature_name in self.objects.get(object_name, {})
+
+    def __getitem__(self, key):
+        """Support dict-style access: m['Image', 'Count_Cells']"""
+        if isinstance(key, tuple):
+             assert len(key) == 2
+             return self.get_measurement(*key)
+        raise KeyError("Invalid key format. Expected (Object, Feature)")
+        
+    def __setitem__(self, key, value):
+        """Support dict-style assignment: m['Image', 'Count_Cells'] = 5"""
+        if isinstance(key, tuple):
+             assert len(key) == 2
+             self.add_measurement(*key, value)
+        else:
+             raise KeyError("Invalid key format. Expected (Object, Feature)")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serialize to the primitive dictionary format required by the refactoring contract.
+        """
+        return self.model_dump(exclude_none=True)
+
+    def merge(self, other: 'LibraryMeasurements') -> 'LibraryMeasurements':
+        """
+        Merge this LibraryMeasurements object with another one, returning a new instance.
+        
+        Collision resolution:
+        - Image measurements: 'other' overwrites 'self'
+        - Experiment measurements: 'other' overwrites 'self'
+        - Object measurements: Merged by object name. Within an object, 'other' features overwrite 'self'.
+        - Relationships: Concatenated
+        
+        Args:
+            other: Another LibraryMeasurements instance
+            
+        Returns:
+            A new LibraryMeasurements instance containing merged data
+        """
+        # Create deep copies of dictionaries to avoid side effects
+        new_image = self.image.copy()
+        new_image.update(other.image)
+        
+        new_experiment = self.experiment.copy()
+        new_experiment.update(other.experiment)
+        
+        new_objects = {}
+        # Merge objects
+        all_objects = set(self.objects.keys()) | set(other.objects.keys())
+        for obj_name in all_objects:
+            obj_measurements = self.objects.get(obj_name, {}).copy()
+            obj_measurements.update(other.objects.get(obj_name, {}))
+            new_objects[obj_name] = obj_measurements
+            
+        # Concatenate relationships
+        new_relationships = self.relationships + other.relationships
+        
+        return LibraryMeasurements(
+            image=new_image,
+            objects=new_objects,
+            experiment=new_experiment,
+            relationships=new_relationships
+        )

{cellprofiler_library_nightly-5.0.0.dev496 → cellprofiler_library_nightly-5.0.0.dev509}/cellprofiler_library/modules/_measurecolocalization.py

@@ -1,11 +1,12 @@
 import numpy as np
 from numpy.typing import NDArray
-from typing import List, Tuple, Annotated, Optional, Dict, Union
+from typing import List, Tuple, Annotated, Optional, Union
 from pydantic import validate_call, ConfigDict, BeforeValidator, Field
 from cellprofiler_library.functions.measurement import measure_correlation_and_slope_from_objects, measure_manders_coefficient_from_objects, measure_rwc_coefficient_from_objects, measure_overlap_coefficient_from_objects, measure_costes_coefficient_from_objects, get_thresholded_images_and_counts, measure_correlation_and_slope, measure_manders_coefficient, measure_rwc_coefficient, measure_overlap_coefficient, measure_costes_coefficient
 from cellprofiler_library.opts.measurecolocalization import TemplateMeasurementFormat, MeasurementType
 from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, Pixel, ObjectLabel, ObjectSegmentation, ImageAny, ImageAnyMask
 from cellprofiler_library.opts.measurecolocalization import CostesMethod
+from cellprofiler_library.measurement_model import LibraryMeasurements
 from cellprofiler_library.functions.image_processing import crop_image_similarly
 from cellprofiler_library.functions.object_processing import size_similarly, object_crop_image_similarly
 
@@ -121,14 +122,14 @@ def run_image_pair_images(
     costes_method:      Annotated[Optional[CostesMethod], Field(description="")] = CostesMethod.FAST,
     ) -> Annotated[
         Tuple[
-            Dict[str, np.float64],
+            LibraryMeasurements,
             List[Tuple[str, str, str, str, str]]
         ], Field(description="List of measurement results and a dictionary of measurements with precise values")]:
     """Calculate the correlation between the pixels of two images"""
 
 
     summary: List[Tuple[str, str, str, str, str]] = []
-    measurements: Dict[str, np.float64] = {}
+    measurements = LibraryMeasurements()
     corr =      np.float64(np.NaN)
     slope =     np.float64(np.NaN)
     C1 =        np.float64(np.NaN)
@@ -210,22 +211,22 @@ def run_image_pair_images(
     costes_measurement_2 = TemplateMeasurementFormat.COSTES_FORMAT % (im2_name, im1_name)
     
     if MeasurementType.CORRELATION in measurement_types:
-        measurements[corr_measurement] = corr
-        measurements[slope_measurement] = slope
+        measurements.add_image_measurement(corr_measurement, corr)
+        measurements.add_image_measurement(slope_measurement, slope)
     if MeasurementType.OVERLAP in measurement_types:        
-        measurements[overlap_measurement] = overlap
-        measurements[k_measurement_1] = K1
-        measurements[k_measurement_2] = K2
+        measurements.add_image_measurement(overlap_measurement, overlap)
+        measurements.add_image_measurement(k_measurement_1, K1)
+        measurements.add_image_measurement(k_measurement_2, K2)
 
     if MeasurementType.MANDERS in measurement_types:
-        measurements[manders_measurement_1] = M1
-        measurements[manders_measurement_2] = M2
+        measurements.add_image_measurement(manders_measurement_1, M1)
+        measurements.add_image_measurement(manders_measurement_2, M2)
     if MeasurementType.RWC in measurement_types:
-        measurements[rwc_measurement_1] = RWC1
-        measurements[rwc_measurement_2] = RWC2
+        measurements.add_image_measurement(rwc_measurement_1, RWC1)
+        measurements.add_image_measurement(rwc_measurement_2, RWC2)
     if MeasurementType.COSTES in measurement_types:
-        measurements[costes_measurement_1] = C1
-        measurements[costes_measurement_2] = C2
+        measurements.add_image_measurement(costes_measurement_1, C1)
+        measurements.add_image_measurement(costes_measurement_2, C2)
 
     return measurements, summary
 
@@ -259,7 +260,7 @@ def run_image_pair_objects(
     im2_scale:          Annotated[Optional[Union[float, int]], Field(description="Second image scale for costes thresholding")]=None,
     costes_method:      Annotated[Optional[CostesMethod], Field(description="Costes method for costes thresholding")]=CostesMethod.FAST
     ) -> Tuple[
-        Dict[str, NDArray[np.float64]],
+        LibraryMeasurements,
         List[Tuple[str, str, str, str, str]]
         ]:
     if MeasurementType.COSTES in measurement_types:
@@ -346,41 +347,40 @@ def run_image_pair_objects(
             summary += __get_object_result_array((im2_name, im1_name, object_name), "Manders coeff (Costes)", C2)
 
 
-    measurements: Dict[str, NDArray[np.float64]] = {}
+    measurements = LibraryMeasurements()
+    
     if MeasurementType.CORRELATION in measurement_types:
         measurement = TemplateMeasurementFormat.CORRELATION_FORMAT % (im1_name, im2_name)
-        measurements[measurement] = corr
+        measurements.add_measurement(object_name, measurement, corr)
     if MeasurementType.MANDERS in measurement_types:
         manders_measurement_1 = TemplateMeasurementFormat.MANDERS_FORMAT % (im1_name, im2_name)
         manders_measurement_2 = TemplateMeasurementFormat.MANDERS_FORMAT % (im2_name, im1_name)
         
-        measurements[manders_measurement_1] = M1
-        measurements[manders_measurement_2] = M2
+        measurements.add_measurement(object_name, manders_measurement_1, M1)
+        measurements.add_measurement(object_name, manders_measurement_2, M2)
     
     if MeasurementType.RWC in measurement_types:
         rwc_measurement_1 = TemplateMeasurementFormat.RWC_FORMAT % (im1_name, im2_name)
         rwc_measurement_2 = TemplateMeasurementFormat.RWC_FORMAT % (im2_name, im1_name)
 
-        measurements[rwc_measurement_1] = RWC1
-        measurements[rwc_measurement_2] = RWC2
+        measurements.add_measurement(object_name, rwc_measurement_1, RWC1)
+        measurements.add_measurement(object_name, rwc_measurement_2, RWC2)
     
     if MeasurementType.OVERLAP in measurement_types:
         overlap_measurement = TemplateMeasurementFormat.OVERLAP_FORMAT % (im1_name, im2_name)
         k_measurement_1 = TemplateMeasurementFormat.K_FORMAT % (im1_name, im2_name)
         k_measurement_2 = TemplateMeasurementFormat.K_FORMAT % (im2_name, im1_name)
         
-        measurements[overlap_measurement] = overlap
-        measurements[k_measurement_1] = K1
-        measurements[k_measurement_2] = K2
+        measurements.add_measurement(object_name, overlap_measurement, overlap)
+        measurements.add_measurement(object_name, k_measurement_1, K1)
+        measurements.add_measurement(object_name, k_measurement_2, K2)
     
     if MeasurementType.COSTES in measurement_types:
         costes_measurement_1 = TemplateMeasurementFormat.COSTES_FORMAT % (im1_name, im2_name)
         costes_measurement_2 = TemplateMeasurementFormat.COSTES_FORMAT % (im2_name, im1_name)
         
-        measurements[costes_measurement_1] = C1
-        measurements[costes_measurement_2] = C2
-
-    if n_objects == 0:
+        measurements.add_measurement(object_name, costes_measurement_1, C1)
+        measurements.add_measurement(object_name, costes_measurement_2, C2)
         col_order_1 = (im1_name, im2_name, object_name)
         summary +=  [
             (*col_order_1, "Mean correlation", "-"),

cellprofiler_library_nightly-5.0.0.dev509/cellprofiler_library/modules/_measuregranularity.py

@@ -0,0 +1,42 @@
+from pydantic import validate_call, ConfigDict, Field
+from typing import Annotated, List
+from cellprofiler_library.functions.measurement import get_granularity_measurements, ObjectRecord
+from cellprofiler_library.functions.image_processing import apply_grayscale_tophat_filter, downsample_image_and_mask
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def measure_granularity(
+        im_pixel_data:              Annotated[ImageGrayscale, Field(description="Pixel values of the image")],
+        im_mask:                    Annotated[ImageGrayscaleMask, Field(description="Boolean mask of where the measurements should be made")],
+        subsample_size:             Annotated[float, Field(description="Subsampling factor for granularity measurements")],
+        image_sample_size:          Annotated[float, Field(description="Subsampling factor for background reduction")],
+        element_size:               Annotated[int, Field(description="Radius of structuring element")],
+        object_records:             Annotated[List[ObjectRecord], Field(description="Object records")],
+        granular_spectrum_length:   Annotated[int, Field(description="Range of the granular spectrum")],
+        dimensions:                 Annotated[int, Field(description="Dimensionality of the image")] = 2,
+        ):
+    # TODO: PR #5034 update the return types of this funciton
+    #
+    # Downsample the image and mask
+    #
+    pixels, mask, new_shape = downsample_image_and_mask(im_pixel_data, im_mask, dimensions, subsample_size)
+    
+    #
+    # Remove background pixels using a greyscale tophat filter
+    #
+    pixels = apply_grayscale_tophat_filter(pixels, mask, dimensions, image_sample_size, element_size, new_shape)
+    
+    #
+    # Compute measurements
+    #
+    _measurements_arr, _image_measurements_arr, _statistics = get_granularity_measurements(
+        im_pixel_data,
+        pixels, 
+        mask, 
+        new_shape,
+        granular_spectrum_length,
+        dimensions,
+        object_records
+    )
+
+    return _measurements_arr, _image_measurements_arr, _statistics

cellprofiler_library_nightly-5.0.0.dev509/cellprofiler_library/opts/measuregranularity.py

@@ -0,0 +1,2 @@
+class TemplateMeasurementFormat(str):
+    GRANULARITY = "Granularity_%s_%s"

{cellprofiler_library_nightly-5.0.0.dev496 → cellprofiler_library_nightly-5.0.0.dev509}/cellprofiler_library_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev496
+Version: 5.0.0.dev509
 Summary: cellprofiler-library implements CellProfiler's image processing and mathematical code, and is usable as a standalone library
 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_library_nightly-5.0.0.dev496 → cellprofiler_library_nightly-5.0.0.dev509}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ environment.yml
 pyproject.toml
 cellprofiler_library/__init__.py
 cellprofiler_library/_version.py
+cellprofiler_library/measurement_model.py
 cellprofiler_library/py.typed
 cellprofiler_library/types.py
 cellprofiler_library/functions/__init__.py
@@ -36,6 +37,7 @@ cellprofiler_library/modules/_identifysecondaryobjects.py
 cellprofiler_library/modules/_identifytertiaryobjects.py
 cellprofiler_library/modules/_imagemath.py
 cellprofiler_library/modules/_measurecolocalization.py
+cellprofiler_library/modules/_measuregranularity.py
 cellprofiler_library/modules/_measureimageoverlap.py
 cellprofiler_library/modules/_measureobjectsizeshape.py
 cellprofiler_library/modules/_medialaxis.py
@@ -72,6 +74,7 @@ cellprofiler_library/opts/identifysecondaryobjects.py
 cellprofiler_library/opts/identifytertiaryobjects.py
 cellprofiler_library/opts/imagemath.py
 cellprofiler_library/opts/measurecolocalization.py
+cellprofiler_library/opts/measuregranularity.py
 cellprofiler_library/opts/measureimageoverlap.py
 cellprofiler_library/opts/morph.py
 cellprofiler_library/opts/objectsizeshapefeatures.py