cellprofiler-library-nightly 5.0.0.dev501__tar.gz → 5.0.0.dev512__tar.gz

{cellprofiler_library_nightly-5.0.0.dev501 → cellprofiler_library_nightly-5.0.0.dev512}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev501
+Version: 5.0.0.dev512
 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.dev501 → cellprofiler_library_nightly-5.0.0.dev512}/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.dev501'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev501')
+__version__ = version = '5.0.0.dev512'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev512')
 
-__commit_id__ = commit_id = 'gb8fc0acf1'
+__commit_id__ = commit_id = 'g36bc7931b'

{cellprofiler_library_nightly-5.0.0.dev501 → cellprofiler_library_nightly-5.0.0.dev512}/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.dev501 → cellprofiler_library_nightly-5.0.0.dev512}/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, Union
 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,107 @@ 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]
+        ) -> Tuple[List[List[List[Union[str, NDArray[numpy.float64]]]]], List[float]]:
+    # 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 = []
+
+    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
+        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
+
+            

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

@@ -0,0 +1,80 @@
+from pydantic import validate_call, ConfigDict, Field
+from typing import Annotated, List, Dict, Any, Tuple
+from enum import Enum
+import numpy as np
+
+from cellprofiler_library.measurement_model import LibraryMeasurements
+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
+
+class GranularityMeasurementFormat(str, Enum):
+    GRANULARITY = "Granularity_%d_%s"
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def measure_granularity(
+        image_name:                 Annotated[str, Field(description="Name of the image")],
+        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,
+        ) -> Tuple[LibraryMeasurements, List[str]]:
+    #
+    # 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 = get_granularity_measurements(
+        im_pixel_data,
+        pixels, 
+        mask, 
+        new_shape,
+        granular_spectrum_length,
+        dimensions,
+        object_records
+    )
+
+    measurements = LibraryMeasurements()
+    stats_strings = []
+
+    # Process Image Measurements
+    for i, gs_value in enumerate(image_measurements_arr):
+        spectrum_index = i + 1
+        feature_name = GranularityMeasurementFormat.GRANULARITY % (spectrum_index, image_name)
+        measurements.add_image_measurement(feature_name, gs_value)
+        stats_strings.append("%.2f" % gs_value)
+
+    # Process Object Measurements
+    # measurements_arr is list of lists. Outer list index i corresponds to spectrum_index i+1.
+    for i, obj_measurements_list in enumerate(measurements_arr):
+        spectrum_index = i + 1
+        feature_name = GranularityMeasurementFormat.GRANULARITY % (spectrum_index, image_name)
+        
+        for obj_name, obj_gss in obj_measurements_list:
+            measurements.add_measurement(obj_name, feature_name, obj_gss)
+            
+            # Calculate stats for this object measurement and add to Image measurements
+            stat_name_base = f"{feature_name}_{obj_name}"
+            
+            measurements.add_image_measurement(f"Mean_{stat_name_base}", np.mean(obj_gss) if len(obj_gss) > 0 else 0.0)
+            measurements.add_image_measurement(f"Median_{stat_name_base}", np.median(obj_gss) if len(obj_gss) > 0 else 0.0)
+            measurements.add_image_measurement(f"Max_{stat_name_base}", np.max(obj_gss) if len(obj_gss) > 0 else 0.0)
+            measurements.add_image_measurement(f"Min_{stat_name_base}", np.min(obj_gss) if len(obj_gss) > 0 else 0.0)
+            measurements.add_image_measurement(f"StDev_{stat_name_base}", np.std(obj_gss) if len(obj_gss) > 0 else 0.0)
+
+    # Summary for UI display
+    summary = [image_name] + stats_strings
+    
+    return measurements, summary

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

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

{cellprofiler_library_nightly-5.0.0.dev501 → cellprofiler_library_nightly-5.0.0.dev512}/cellprofiler_library_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev501
+Version: 5.0.0.dev512
 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.dev501 → cellprofiler_library_nightly-5.0.0.dev512}/cellprofiler_library_nightly.egg-info/SOURCES.txt

@@ -37,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
@@ -73,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