cellprofiler-library-nightly 5.0.0.dev548__tar.gz → 5.0.0.dev554__tar.gz

{cellprofiler_library_nightly-5.0.0.dev548/cellprofiler_library_nightly.egg-info → cellprofiler_library_nightly-5.0.0.dev554}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev548 → cellprofiler_library_nightly-5.0.0.dev554}/cellprofiler_library/modules/_measurecolocalization.py

@@ -1,7 +1,7 @@
 import numpy as np
 from numpy.typing import NDArray
 from typing import List, Tuple, Annotated, Optional, Union
-from pydantic import validate_call, ConfigDict, BeforeValidator, Field
+from pydantic import validate_call, ConfigDict, BeforeValidator, Field, BaseModel
 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
@@ -10,6 +10,7 @@ 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
 
+
 def crop_image_pair_similarly(
         im1_pixel_data:     Annotated[ImageGrayscale, Field(description="First image pixel data")],
         im2_pixel_data:     Annotated[ImageGrayscale, Field(description="Second image pixel data")],
@@ -107,6 +108,16 @@ def crop_image_pair_and_object_similarly(
 
     return im1_pixels, im2_pixels, obj_segmented, mask, im1_costes_pixels, im2_costes_pixels
 
+ColocalizationStatistics = List[Tuple[str, str, str, str, str]]
+
+class ColocalizationDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    statistics: ColocalizationStatistics
+
 @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
 def run_image_pair_images(
     im1_pixel_data:     Annotated[ImageGrayscale, Field(description="First image pixel data")],
@@ -120,16 +131,12 @@ def run_image_pair_images(
     im1_scale:          Annotated[Optional[float], Field(description="")] = None,
     im2_scale:          Annotated[Optional[float], Field(description="")] = None,
     costes_method:      Annotated[Optional[CostesMethod], Field(description="")] = CostesMethod.FAST,
-    ) -> Annotated[
-        Tuple[
-            LibraryMeasurements,
-            List[Tuple[str, str, str, str, str]]
-        ], Field(description="List of measurement results and a dictionary of measurements with precise values")]:
+    return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+    ) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, ColocalizationDisplayData]]:
     """Calculate the correlation between the pixels of two images"""
-
-
-    summary: List[Tuple[str, str, str, str, str]] = []
     measurements = LibraryMeasurements()
+    summary: ColocalizationStatistics = []
+
     corr =      np.float64(np.NaN)
     slope =     np.float64(np.NaN)
     C1 =        np.float64(np.NaN)
@@ -141,6 +148,7 @@ def run_image_pair_images(
     overlap =   np.float64(np.NaN)
     K1 =        np.float64(np.NaN)
     K2 =        np.float64(np.NaN)
+
     if mask is not None and np.any(mask):
         im1_pixels = im1_pixel_data[mask]
         im2_pixels = im2_pixel_data[mask]
@@ -228,11 +236,13 @@ def run_image_pair_images(
         measurements.add_image_measurement(costes_measurement_1, C1)
         measurements.add_image_measurement(costes_measurement_2, C2)
 
-    return measurements, summary
+    if return_visualization_data:
+        return measurements, ColocalizationDisplayData(statistics=summary)
+    return measurements
 
 
-def __get_object_result_array(col_order_list: Tuple[str, str, str], measurement_name: str, measurement_array: NDArray[np.float64]) -> List[Tuple[str, str, str, str, str]]:
-    summary: List[Tuple[str, str, str, str, str]] = []
+def __get_object_result_array(col_order_list: Tuple[str, str, str], measurement_name: str, measurement_array: NDArray[np.float64]) -> ColocalizationStatistics:
+    summary: ColocalizationStatistics = []
     summary += [
         (*col_order_list, f"Mean {measurement_name}", "%.3f" % np.mean(measurement_array)),
         (*col_order_list, f"Median {measurement_name}", "%.3f" % np.median(measurement_array)),
@@ -258,15 +268,13 @@ def run_image_pair_objects(
     measurement_types:  Annotated[List[MeasurementType], Field(description="List of measurement types to be calculated")]=[MeasurementType.CORRELATION, MeasurementType.MANDERS, MeasurementType.RWC, MeasurementType.OVERLAP, MeasurementType.COSTES],
     im1_scale:          Annotated[Optional[Union[float, int]], Field(description="First image scale for costes thresholding")]=None,
     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[
-        LibraryMeasurements,
-        List[Tuple[str, str, str, str, str]]
-        ]:
+    costes_method:      Annotated[Optional[CostesMethod], Field(description="Costes method for costes thresholding")]=CostesMethod.FAST,
+    return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+    ) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, ColocalizationDisplayData]]:
     if MeasurementType.COSTES in measurement_types:
         assert costes_method is not None, "Costes requires a costes method"
     """Calculate per-object correlations between intensities in two images"""
-    summary = []
+    summary: ColocalizationStatistics = []
 
     n_objects = object_count
     # Handle case when both images for the correlation are completely masked out
@@ -389,4 +397,6 @@ def run_image_pair_objects(
             (*col_order_1, "Max correlation", "-"),
         ]
         
-    return measurements, summary
+    if return_visualization_data:
+        return measurements, ColocalizationDisplayData(statistics=summary)
+    return measurements

{cellprofiler_library_nightly-5.0.0.dev548 → cellprofiler_library_nightly-5.0.0.dev554}/cellprofiler_library/modules/_measuregranularity.py

@@ -1,5 +1,5 @@
-from pydantic import validate_call, ConfigDict, Field
-from typing import Annotated, List, Dict, Any, Tuple
+from pydantic import validate_call, ConfigDict, Field, BaseModel
+from typing import Annotated, List, Tuple, Union
 from enum import Enum
 import numpy as np
 
@@ -11,6 +11,16 @@ from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask
 class GranularityMeasurementFormat(str, Enum):
     GRANULARITY = "Granularity_%d_%s"
 
+GranularityStatistics = List[str]
+
+class GranularityDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    statistics: GranularityStatistics
+
 @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
 def measure_granularity(
         image_name:                 Annotated[str, Field(description="Name of the image")],
@@ -22,7 +32,8 @@ def measure_granularity(
         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]]:
+        return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+        ) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, GranularityDisplayData]]:
     #
     # Downsample the image and mask
     #
@@ -75,6 +86,8 @@ def measure_granularity(
             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
+    summary: GranularityStatistics = [image_name] + stats_strings
     
-    return measurements, summary
+    if return_visualization_data:
+        return measurements, GranularityDisplayData(statistics=summary)
+    return measurements

{cellprofiler_library_nightly-5.0.0.dev548 → cellprofiler_library_nightly-5.0.0.dev554}/cellprofiler_library/modules/_measureimageareaoccupied.py

@@ -1,12 +1,22 @@
 import skimage.measure
 import numpy as np
-from typing import Annotated, Optional, Tuple, List
-from pydantic import Field, validate_call, ConfigDict
+from typing import Annotated, Optional, Tuple, List, Union
+from pydantic import Field, validate_call, ConfigDict, BaseModel
 from cellprofiler_library.types import ImageBinary, ObjectSegmentation, ImageAnyMask
 from cellprofiler_library.functions.measurement import measure_area_occupied, measure_total_area, measure_perimeter, measure_object_perimeter, measure_objects_area_occupied, measure_objects_total_area
 from cellprofiler_library.measurement_model import LibraryMeasurements
 from cellprofiler_library.opts.measureimageareaoccupied import TemplateMeasurementFormat
 
+ImageAreaOccupiedStatistics = List[List[str]]
+
+class ImageAreaOccupiedDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    statistics: ImageAreaOccupiedStatistics
+
 
 @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
 def measure_image_area_perimeter(
@@ -14,12 +24,9 @@ def measure_image_area_perimeter(
     image_name:     Annotated[str, Field(description="Name of the image")],
     im_volumetric:  Annotated[bool, Field(description="Image is volumetric")],
     im_spacing:     Annotated[Optional[Tuple[float, ...]], Field(description="Image spacing")] = None,
-    pipeline_volumetric: Annotated[bool, Field(description="Pipeline is volumetric")] = False
-    ) -> Tuple[
-        LibraryMeasurements,
-        List[List[str]]
-    ]:
-
+    pipeline_volumetric: Annotated[bool, Field(description="Pipeline is volumetric")] = False,
+    return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+    ) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, ImageAreaOccupiedDisplayData]]:
     area_occupied = measure_area_occupied(im_pixel_data)
     perimeter = measure_perimeter(im_pixel_data, im_volumetric, im_spacing)  if area_occupied > 0 else np.float64(0.0)
     total_area = measure_total_area(im_pixel_data)
@@ -34,7 +41,10 @@ def measure_image_area_perimeter(
     measurements.add_image_measurement(perimeter_format % image_name, perimeter)
     measurements.add_image_measurement(total_area_format % image_name, total_area)
 
-    return measurements, [[image_name, str(area_occupied), str(perimeter), str(total_area),]]
+    if return_visualization_data:
+        summary: ImageAreaOccupiedStatistics = [[image_name, str(area_occupied), str(perimeter), str(total_area),]]
+        return measurements, ImageAreaOccupiedDisplayData(statistics=summary)
+    return measurements
 
 
 @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
@@ -44,11 +54,9 @@ def measure_objects_area_perimeter(
     mask:           Annotated[Optional[ImageAnyMask], Field(description="Mask of the image")] = None,
     volumetric:     Annotated[bool, Field(description="True if the objects are volumetric")] = False,
     spacing:        Annotated[Optional[Tuple[float, ...]], Field(description="Image spacing")] = None,
-    pipeline_volumetric: Annotated[bool, Field(description="Pipeline is volumetric")] = False
-    ) -> Tuple[
-        LibraryMeasurements,
-        List[List[str]]
-    ]:
+    pipeline_volumetric: Annotated[bool, Field(description="Pipeline is volumetric")] = False,
+    return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+    ) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, ImageAreaOccupiedDisplayData]]:
     if mask is not None:
         label_image[~mask] = 0
     regionprops = skimage.measure.regionprops(label_image)
@@ -67,4 +75,7 @@ def measure_objects_area_perimeter(
     measurements.add_image_measurement(perimeter_format % object_name, perimeter)
     measurements.add_image_measurement(total_area_format % object_name,total_area)
 
-    return measurements, [[object_name, str(area_occupied), str(perimeter), str(total_area),]]
+    if return_visualization_data:
+        summary: ImageAreaOccupiedStatistics = [[object_name, str(area_occupied), str(perimeter), str(total_area),]]
+        return measurements, ImageAreaOccupiedDisplayData(statistics=summary)
+    return measurements

{cellprofiler_library_nightly-5.0.0.dev548 → cellprofiler_library_nightly-5.0.0.dev554}/cellprofiler_library/modules/_measureimageintensity.py

@@ -1,12 +1,20 @@
 import numpy as np
 from numpy.typing import NDArray
 from typing import List, Annotated, Optional, Tuple, Union
-from pydantic import Field, validate_call, ConfigDict
+from pydantic import Field, validate_call, ConfigDict, BaseModel
 from cellprofiler_library.functions.measurement import measure_image_intensities
 from cellprofiler_library.opts.measureimageintensity import TemplateMeasurementFormat, Feature, FORMATED_FEATURE_NAMES, FORMATED_PERCENTILE_TEMPLATE 
 from cellprofiler_library.measurement_model import LibraryMeasurements
 
-IntensityStatistics = List[Union[List[str], Tuple[str,float]]]
+ImageIntensityStatistics = List[Union[List[str], Tuple[str,float]]]
+
+class ImageIntensityDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    statistics: ImageIntensityStatistics
 
 @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
 def measure_image_intensity(
@@ -14,7 +22,8 @@ def measure_image_intensity(
         image_name:     Annotated[str, Field(description="Name of the image")],
         object_name:    Annotated[Optional[str], Field(description="Name of the object set (if any)")] = None,
         percentiles:    Annotated[Optional[List[int]], Field(description="Percentiles to measure")]=[],
-        ) -> Tuple[LibraryMeasurements, IntensityStatistics]:
+        return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+        ) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, ImageIntensityDisplayData]]:
     
     if percentiles is None:
         percentiles = []
@@ -39,17 +48,18 @@ def measure_image_intensity(
     ), percentile_measures = measure_image_intensities(pixels, percentiles)
 
     measurements = LibraryMeasurements()
-    statistics: IntensityStatistics = []
+    statistics: ImageIntensityStatistics = []
 
     def add_measurement(feature_name: str, fmt_template: str, feature_value: Union[int, float]):
         measurements.add_image_measurement(fmt_template % measurement_name, feature_value)
 
-        statistics.append([
-            image_name,
-            object_name if object_name else "",
-            feature_name,
-            str(feature_value),
-        ])
+        if return_visualization_data:
+            statistics.append([
+                image_name,
+                object_name if object_name else "",
+                feature_name,
+                str(feature_value),
+            ])
 
     # Add measurements
     add_measurement(FORMATED_FEATURE_NAMES[Feature.TOTAL_INTENSITY.value], TemplateMeasurementFormat.TOTAL_INTENSITY, pixel_sum)
@@ -73,4 +83,6 @@ def measure_image_intensity(
     percentile_stats.sort(key = lambda p: p[0])
     statistics += [(FORMATED_PERCENTILE_TEMPLATE % p[0], p[1]) for p in percentile_stats]
 
-    return measurements, statistics
+    if return_visualization_data:
+        return measurements, ImageIntensityDisplayData(statistics=statistics)
+    return measurements

{cellprofiler_library_nightly-5.0.0.dev548 → cellprofiler_library_nightly-5.0.0.dev554}/cellprofiler_library/modules/_measureimageoverlap.py

@@ -1,6 +1,6 @@
 import numpy
 from typing import Annotated, Optional, List, Tuple, Union
-from pydantic import Field, validate_call, ConfigDict
+from pydantic import Field, validate_call, ConfigDict, BaseModel
 from cellprofiler_library.opts.measureimageoverlap import ALL_FEATURES, DM, C_IMAGE_OVERLAP, Feature
 from cellprofiler_library.functions.measurement import (
     measure_image_overlap_statistics,
@@ -11,6 +11,14 @@ from cellprofiler_library.measurement_model import LibraryMeasurements
 
 ImageOverlapStatistics = List[Tuple[str, Union[int, float, numpy.float_, numpy.int_]]]
 
+class ImageOverlapDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    statistics: ImageOverlapStatistics
+
 @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
 def measureimageoverlap(
     ground_truth_image: Annotated[ImageBinary, Field(description="Ground truth binary image")],
@@ -22,7 +30,8 @@ def measureimageoverlap(
     penalize_missing:   Annotated[bool, Field(description="Penalize missing points")] = False,
     decimation_method:  Annotated[DM, Field(description="Decimation method")] = DM.KMEANS,
     max_points:         Annotated[int, Field(description="Maximum number of points")] = 250,
-) -> Tuple[LibraryMeasurements, ImageOverlapStatistics]:
+    return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, ImageOverlapDisplayData]]:
 
     all_features = list(ALL_FEATURES)
 
@@ -57,4 +66,6 @@ def measureimageoverlap(
             # Display data (arrays)
             measurements.image[key] = value
 
-    return measurements, stats
+    if return_visualization_data:
+        return measurements, ImageOverlapDisplayData(statistics=stats)
+    return measurements

{cellprofiler_library_nightly-5.0.0.dev548 → cellprofiler_library_nightly-5.0.0.dev554/cellprofiler_library_nightly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev548
+Version: 5.0.0.dev554
 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>