cellprofiler-library-nightly 5.0.0.dev592__tar.gz → 5.0.0.dev610__tar.gz

{cellprofiler_library_nightly-5.0.0.dev592 → cellprofiler_library_nightly-5.0.0.dev610}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev592 → cellprofiler_library_nightly-5.0.0.dev610}/cellprofiler_library/functions/measurement.py

@@ -10,6 +10,9 @@ import centrosome.propagate
 import centrosome.fastemd
 import centrosome.index
 import centrosome.cpmorphology
+import centrosome.threshold
+import centrosome.haralick
+import centrosome.radial_power_spectrum
 from centrosome.outline import outline
 from functools import reduce
 from sklearn.cluster import KMeans
@@ -2173,6 +2176,264 @@ def compute_earth_movers_distance_objects(
     return emd
 
 
+###############################################################################
+# MeasureImageQuality
+###############################################################################
+
+def get_focus_score_for_scale_group(
+        scale_groups: Sequence[int],
+        pixel_data: ImageGrayscale,
+        dimensions: int,
+        image_mask: Optional[ImageGrayscaleMask]=None,
+) -> Tuple[
+    NDArray[numpy.float_],
+    int,
+    Sequence[numpy.float_]
+]:
+    if image_mask is not None:
+            masked_pixel_data = pixel_data[image_mask]
+    else:
+        masked_pixel_data = pixel_data
+    shape = pixel_data.shape
+    local_focus_score = []
+    focus_score = 0
+    for scale in scale_groups:
+        focus_score = 0
+        if len(masked_pixel_data):
+            mean_image_value = numpy.mean(masked_pixel_data)
+            squared_normalized_image = (masked_pixel_data - mean_image_value) ** 2
+            if mean_image_value > 0:
+                focus_score = numpy.sum(squared_normalized_image) / (
+                    numpy.product(masked_pixel_data.shape) * mean_image_value
+                )
+        #
+        # Create a labels matrix that grids the image to the dimensions
+        # of the window size
+        #
+        if dimensions == 2:
+            i, j = numpy.mgrid[0 : shape[0], 0 : shape[1]].astype(float)
+            m, n = (numpy.array(shape) + scale - 1) // scale
+            i = (i * float(m) / float(shape[0])).astype(int)
+            j = (j * float(n) / float(shape[1])).astype(int)
+            grid = i * n + j + 1
+            grid_range = numpy.arange(0, m * n + 1, dtype=numpy.int32)
+        elif dimensions == 3:
+            k, i, j = numpy.mgrid[
+                0 : shape[0], 0 : shape[1], 0 : shape[2]
+            ].astype(float)
+            o, m, n = (numpy.array(shape) + scale - 1) // scale
+            k = (k * float(o) / float(shape[0])).astype(int)
+            i = (i * float(m) / float(shape[1])).astype(int)
+            j = (j * float(n) / float(shape[2])).astype(int)
+            grid = k * o + i * n + j + 1  # hmm
+            grid_range = numpy.arange(0, m * n * o + 1, dtype=numpy.int32)
+        else:
+            raise ValueError("Image dimensions must be 2 or 3")
+        if image_mask is not None:
+            grid[numpy.logical_not(image_mask)] = 0
+        
+        #
+        # Do the math per label
+        #
+        local_means = centrosome.cpmorphology.fixup_scipy_ndimage_result(
+            scipy.ndimage.mean(pixel_data, grid, grid_range)
+        )
+        local_squared_normalized_image = (
+            pixel_data - local_means[grid]
+        ) ** 2
+        #
+        # Compute the sum of local_squared_normalized_image values for each
+        # grid for means > 0. Exclude grid label = 0 because that's masked
+        #
+        grid_mask = (local_means != 0) & ~numpy.isnan(local_means)
+        nz_grid_range = grid_range[grid_mask]
+        if len(nz_grid_range) and nz_grid_range[0] == 0:
+            nz_grid_range = nz_grid_range[1:]
+            local_means = local_means[1:]
+            grid_mask = grid_mask[1:]
+        local_focus_score += [
+            0
+        ]  # assume the worst - that we can't calculate it
+        if len(nz_grid_range):
+            sums = centrosome.cpmorphology.fixup_scipy_ndimage_result(
+                scipy.ndimage.sum(
+                    local_squared_normalized_image, grid, nz_grid_range
+                )
+            )
+            pixel_counts = centrosome.cpmorphology.fixup_scipy_ndimage_result(
+                scipy.ndimage.sum(numpy.ones(shape), grid, nz_grid_range)
+            )
+            local_norm_var = sums / (pixel_counts * local_means[grid_mask])
+            local_norm_median = numpy.median(local_norm_var)
+            if numpy.isfinite(local_norm_median) and local_norm_median > 0:
+                local_focus_score[-1] = (
+                    numpy.var(local_norm_var) / local_norm_median
+                )
+    return focus_score, scale, local_focus_score
+
+def get_correlation_for_scale_group(
+        pixel_data: ImageGrayscale, 
+        scale_groups: Sequence[int], 
+        image_mask: Optional[ImageGrayscaleMask]=None
+    ) -> Dict[int, numpy.float_]:
+    # Compute Haralick's correlation texture for the given scales
+    image_labels = numpy.ones(pixel_data.shape, int)
+    if image_mask is not None:
+        image_labels[~image_mask] = 0
+    scale_measurements = {}
+    for scale in scale_groups:
+        scale_measurements[scale] = get_correlation_for_scale(pixel_data, image_labels, scale)
+    return scale_measurements
+
+def get_correlation_for_scale(
+        pixel_data: ImageGrayscale, 
+        image_labels: NDArray[numpy.int_], 
+        scale: int
+    ) -> float:
+    # Compute Haralick's correlation texture for the given scale
+    value = centrosome.haralick.Haralick(pixel_data, image_labels, 0, scale).H3()
+
+    if len(value) != 1 or not numpy.isfinite(value[0]):
+        value = 0.0
+    else:
+        value = float(value)
+    return value
+
+
+def get_saturation_value(
+        pixel_data: ImageGrayscale, 
+        image_mask: Optional[ImageGrayscaleMask]=None
+    ) -> Tuple[
+        float,
+        float
+    ]:
+    if image_mask is not None:
+        pixel_data = pixel_data[image_mask]
+    pixel_count = numpy.product(pixel_data.shape)
+    if pixel_count == 0:
+        percent_maximal = 0
+        percent_minimal = 0
+    else:
+        number_pixels_maximal = numpy.sum(pixel_data == numpy.max(pixel_data))
+        number_pixels_minimal = numpy.sum(pixel_data == numpy.min(pixel_data))
+        percent_maximal = (
+            100.0 * float(number_pixels_maximal) / float(pixel_count)
+        )
+        percent_minimal = (
+            100.0 * float(number_pixels_minimal) / float(pixel_count)
+        )
+    return percent_minimal, percent_maximal
+
+
+def get_intensity_measurement_values(
+        pixels: ImageGrayscale, 
+        image_mask: Optional[ImageGrayscaleMask]=None
+    ) -> Tuple[
+        numpy.int_,
+        numpy.float_,
+        numpy.float_,
+        numpy.float_,
+        numpy.float_,
+        numpy.float_,
+        numpy.float_,
+        numpy.float_
+    ]:
+    if image_mask is not None:
+        pixels = pixels[image_mask]
+    
+    pixel_count = numpy.product(pixels.shape)
+    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
+    else:
+        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)
+    return pixel_count, pixel_sum, pixel_mean, pixel_std, pixel_mad, pixel_median, pixel_min, pixel_max
+
+
+def get_power_spectrum_measurement_values(
+        pixel_data: ImageGrayscale, 
+        image_mask: Optional[ImageGrayscaleMask]=None, 
+        dimensions: int = 2
+    ) -> float:
+    if dimensions == 3:
+        # TODO: cannot calculate "radial power spectrum" for volumes: Not implemented.      
+        pass
+
+    if image_mask is not None:
+        pixel_data = numpy.array(pixel_data)  # make a copy
+        masked_pixels = pixel_data[image_mask]
+        pixel_count = numpy.product(masked_pixels.shape)
+        if pixel_count > 0:
+            pixel_data[~image_mask] = numpy.mean(masked_pixels)
+        else:
+            pixel_data[~image_mask] = 0
+
+    radii, magnitude, power = centrosome.radial_power_spectrum.rps(pixel_data)
+    if sum(magnitude) > 0 and len(numpy.unique(pixel_data)) > 1:
+        valid = magnitude > 0
+        radii = radii[valid].reshape((-1, 1))
+        power = power[valid].reshape((-1, 1))
+        if radii.shape[0] > 1:
+            idx = numpy.isfinite(numpy.log(power))
+            powerslope = scipy.linalg.basic.lstsq(
+                numpy.hstack(
+                    (
+                        numpy.log(radii)[idx][:, numpy.newaxis],
+                        numpy.ones(radii.shape)[idx][:, numpy.newaxis],
+                    )
+                ),
+                numpy.log(power)[idx][:, numpy.newaxis],
+            )[0][0]
+        else:
+            powerslope = 0.
+    else:
+        powerslope = 0.
+    return powerslope
+
+
+def calculate_threshold_for_threshold_group(
+        image_pixel_data: ImageGrayscale = numpy.ones((100, 100)),
+        mask: Optional[ImageGrayscaleMask] = None,
+        algorithm: str = centrosome.threshold.TM_OTSU,
+        object_fraction: float = 0.1,
+        two_class_otsu: bool = True,
+        use_weighted_variance: bool = True,
+        assign_middle_to_foreground: bool = True,
+) -> float:
+    if mask is not None:
+        _, global_threshold = centrosome.threshold.get_threshold(
+            algorithm,
+            centrosome.threshold.TM_GLOBAL,
+            image_pixel_data,
+            mask = mask,
+            object_fraction=object_fraction,
+            two_class_otsu=two_class_otsu,
+            use_weighted_variance=use_weighted_variance,
+            assign_middle_to_foreground=assign_middle_to_foreground,
+        )
+    else:
+        _, global_threshold = centrosome.threshold.get_threshold(
+            algorithm,
+            centrosome.threshold.TM_GLOBAL,
+            image_pixel_data,
+            object_fraction=object_fraction,
+            two_class_otsu=two_class_otsu,
+            use_weighted_variance=use_weighted_variance,
+            assign_middle_to_foreground=assign_middle_to_foreground,
+        )
+    return global_threshold
+
 ###############################################################################
 # Measure Image Skeleton
 ###############################################################################

cellprofiler_library_nightly-5.0.0.dev610/cellprofiler_library/modules/_measureimagequality.py

@@ -0,0 +1,302 @@
+import numpy
+from numpy.typing import NDArray
+from typing import Optional, List, Sequence, Annotated, Union, Tuple, Any
+from pydantic import BaseModel, Field, validate_call, ConfigDict
+from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask
+from cellprofiler_library.measurement_model import LibraryMeasurements
+from cellprofiler_library.opts.measureimagequality import (
+     Feature, ScaledThresholdMethod, TemplateMeasurementFormat
+)
+from cellprofiler_library.functions.measurement import (
+    get_focus_score_for_scale_group,
+    get_correlation_for_scale_group,
+    get_saturation_value,
+    get_intensity_measurement_values,
+    get_power_spectrum_measurement_values,
+    calculate_threshold_for_threshold_group
+)
+
+ImageQualityMesVal = Union[
+    # image scaling, blur powerslope, saturation percent_minimal|percent_maximal, threshold global_threshold
+    float, 
+    # blur focus_score
+    NDArray[numpy.float_],
+    # intensity pixel_count
+    numpy.int_,
+    # blur local_focus_score
+    # intensity
+    #  pixel_sum|pixel_mean|pixel_std|pixel_mad|pixel_median|pixel_min|pixel_max
+    numpy.float_,
+    # converted stat vals
+    str
+]
+ImageQualityStatistics = List[Tuple[str, ImageQualityMesVal]]
+
+class ImageQualityDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        populate_by_name=True
+    )
+
+    statistics: ImageQualityStatistics
+
+class ThresholdConfig(BaseModel):
+    algorithm: str
+    object_fraction: float = 0.1
+    two_class_otsu: bool = True
+    use_weighted_variance: bool = True
+    assign_middle_to_foreground: bool = True
+
+    def get_scale_string(self) -> Optional[str]:
+        if self.algorithm == ScaledThresholdMethod.OTSU.value:
+            scale = "2" if self.two_class_otsu else "3"
+            if not self.two_class_otsu:
+                scale += "F" if self.assign_middle_to_foreground else "B"
+            scale += "W" if self.use_weighted_variance else "S"
+            return scale
+        elif self.algorithm == ScaledThresholdMethod.MOG.value:
+            return str(int(self.object_fraction * 100))
+        return None
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def measure_image_quality(
+    image:                  Annotated[ImageGrayscale, Field(description="The image to measure.")],
+    image_name:             Annotated[str, Field(description="The name of the image.")],
+    image_mask:             Annotated[Optional[ImageGrayscaleMask], Field(description="The mask for the image.")] = None,
+    volumetric:             Annotated[bool, Field(description="Whether the image is volumetric (3D).")] = False,
+    include_image_scalings: Annotated[bool, Field(description="Whether to include image scalings in the measurements.")] = False,
+    image_scale_value:      Annotated[float, Field(description="The scaling value of the image.")] = numpy.nan,
+    check_blur:             Annotated[bool, Field(description="Whether to calculate blur metrics.")] = False,
+    blur_scales:            Annotated[Optional[Sequence[int]], Field(description="List of scales (window sizes) for blur metrics.")] = None,
+    check_saturation:       Annotated[bool, Field(description="Whether to calculate saturation metrics.")] = False,
+    check_intensity:        Annotated[bool, Field(description="Whether to calculate intensity metrics.")] = False,
+    calculate_threshold:    Annotated[bool, Field(description="Whether to calculate threshold metrics.")] = False,
+    threshold_groups:       Annotated[Optional[List[ThresholdConfig]], Field(description="List of threshold configurations.")] = None,
+    return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, ImageQualityDisplayData]]:
+    """
+    Measure image quality metrics.
+
+    Args:
+        image: Input image.
+        image_name: Name of the image.
+        image_mask: Optional mask for the image.
+        volumetric: Whether the image is volumetric (3D).
+        include_image_scalings: Whether to record image scaling.
+        image_scale_value: The scaling value of the image.
+        check_blur: Whether to calculate blur metrics.
+        blur_scales: List of scales (window sizes) for blur metrics.
+        check_saturation: Whether to calculate saturation metrics.
+        check_intensity: Whether to calculate intensity metrics.
+        calculate_threshold: Whether to calculate threshold metrics.
+        threshold_groups: List of threshold configurations.
+
+    Returns:
+        LibraryMeasurements object containing the measurements.
+    """
+    measurements = LibraryMeasurements()
+    statistics: ImageQualityStatistics = []
+
+    dimensions = image.ndim
+
+    feat_stat_name_map = {
+        TemplateMeasurementFormat.IQ_SCALING: f"{image_name} scaling",
+        TemplateMeasurementFormat.IQ_POWER_SPECTRUM_SLOPE: f"{image_name} {Feature.POWER_SPECTRUM_SLOPE.value}",
+        TemplateMeasurementFormat.IQ_PERCENT_MAXIMAL: f"{image_name} maximal",
+        TemplateMeasurementFormat.IQ_PERCENT_MINIMAL: f"{image_name} minimal",
+        TemplateMeasurementFormat.IQ_TOTAL_AREA: f"{image_name} Total Area",
+        TemplateMeasurementFormat.IQ_TOTAL_VOLUME: f"{image_name} Total Volume",
+        TemplateMeasurementFormat.IQ_TOTAL_INTENSITY: f"{image_name} Total intensity",
+        TemplateMeasurementFormat.IQ_MEAN_INTENSITY: f"{image_name} Mean intensity",
+        TemplateMeasurementFormat.IQ_MEDIAN_INTENSITY: f"{image_name} Median intensity",
+        TemplateMeasurementFormat.IQ_STD_INTENSITY: f"{image_name} Std intensity",
+        TemplateMeasurementFormat.IQ_MAD_INTENSITY: f"{image_name} MAD intensity",
+        TemplateMeasurementFormat.IQ_MIN_INTENSITY: f"{image_name} Min intensity",
+        TemplateMeasurementFormat.IQ_MAX_INTENSITY: f"{image_name} Max intensity",
+        # template stat names
+        TemplateMeasurementFormat.IQ_FOCUS_SCORE: f"{image_name} focus score @%d",
+        TemplateMeasurementFormat.IQ_LOCAL_FOCUS_SCORE: f"{image_name} local focus score @%d",
+        TemplateMeasurementFormat.IQ_CORR: f"{image_name} {Feature.CORRELATION.value} @%d",
+        TemplateMeasurementFormat.IQ_THRESHOLD: f"{image_name} %s",
+    }
+    def add_measurement(
+            feature_template: str,
+            template_val: str,
+            feat_val: ImageQualityMesVal,
+            stat_template_val: Optional[Any]=None,
+            feat_val_template: Optional[str]=None
+        ):
+        feature = feature_template % template_val
+        measurements.add_image_measurement(feature, feat_val)
+        if return_visualization_data:
+            stat_name = feat_stat_name_map.get(feature_template, None)
+            if stat_name is None:
+                return # TODO: 5114 - handle this
+            if stat_template_val is not None:
+                stat_name = stat_name % stat_template_val
+            if feat_val_template is not None:
+                feat_val = feat_val_template % feat_val
+            statistics.append((stat_name, feat_val))
+
+    # Image Scalings
+    if include_image_scalings:
+        add_measurement(TemplateMeasurementFormat.IQ_SCALING, image_name, image_scale_value)
+
+    # Blur Measurements
+    if check_blur and blur_scales is not None:
+        # Focus Score
+        focus_score, scale, local_focus_score = get_focus_score_for_scale_group(
+            blur_scales,
+            image,
+            dimensions,
+            image_mask,
+        )
+        # Correlation
+        scale_measurements = get_correlation_for_scale_group(image, blur_scales, image_mask)
+
+        # Focus Score
+        add_measurement(
+            TemplateMeasurementFormat.IQ_FOCUS_SCORE,
+            image_name,
+            focus_score,
+            stat_template_val=blur_scales[-1]
+        )
+
+        for idx, scale in enumerate(blur_scales):
+            # Focus Score
+            add_measurement(
+                TemplateMeasurementFormat.IQ_LOCAL_FOCUS_SCORE,
+                f"{image_name}_{scale}",
+                local_focus_score[idx],
+                stat_template_val=scale,
+            )
+            # Correlation
+            add_measurement(
+                TemplateMeasurementFormat.IQ_CORR,
+                f"{image_name}_{scale}",
+                scale_measurements[scale],
+                stat_template_val=scale,
+                feat_val_template="%.2f",
+            )
+
+        # Power Spectrum
+        if dimensions == 2:
+            powerslope = get_power_spectrum_measurement_values(image, image_mask, dimensions)
+            add_measurement(
+                TemplateMeasurementFormat.IQ_POWER_SPECTRUM_SLOPE,
+                image_name,
+                powerslope,
+                feat_val_template="%.1f",
+            )
+
+    # Saturation Measurements
+    if check_saturation:
+        percent_minimal, percent_maximal = get_saturation_value(image, image_mask)
+
+        add_measurement(
+            TemplateMeasurementFormat.IQ_PERCENT_MAXIMAL,
+            image_name,
+            percent_maximal,
+            feat_val_template="%.1f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_PERCENT_MINIMAL,
+            image_name,
+            percent_minimal,
+            feat_val_template="%.1f",
+        )
+
+    # Intensity Measurements
+    if check_intensity:
+        (
+            pixel_count,
+            pixel_sum,
+            pixel_mean,
+            pixel_std,
+            pixel_mad,
+            pixel_median,
+            pixel_min,
+            pixel_max,
+        ) = get_intensity_measurement_values(image, image_mask)
+
+        add_measurement(
+            TemplateMeasurementFormat.IQ_TOTAL_VOLUME if volumetric else TemplateMeasurementFormat.IQ_TOTAL_AREA,
+            image_name,
+            pixel_count,
+            feat_val_template="%.2f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_TOTAL_INTENSITY,
+            image_name,
+            pixel_sum,
+            feat_val_template="%.2f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_MEAN_INTENSITY,
+            image_name,
+            pixel_mean,
+            feat_val_template="%.2f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_MEDIAN_INTENSITY,
+            image_name,
+            pixel_median,
+            feat_val_template="%.2f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_STD_INTENSITY,
+            image_name,
+            pixel_std,
+            feat_val_template="%.2f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_MAD_INTENSITY,
+            image_name,
+            pixel_mad,
+            feat_val_template="%.2f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_MAX_INTENSITY,
+            image_name,
+            pixel_max,
+            feat_val_template="%.2f",
+        )
+        add_measurement(
+            TemplateMeasurementFormat.IQ_MIN_INTENSITY,
+            image_name,
+            pixel_min,
+            feat_val_template="%.2f",
+        )
+
+    # Threshold Measurements
+    if calculate_threshold and threshold_groups is not None:
+        # We need to cast pixel data to float32 for threshold calculations as in original code
+        # "pixel_data = image.pixel_data.astype(numpy.float32)"
+        pixel_data_float = image.astype(numpy.float32)
+
+        for config in threshold_groups:
+            global_threshold = calculate_threshold_for_threshold_group(
+                image_pixel_data=pixel_data_float,
+                mask=image_mask,
+                algorithm=config.algorithm,
+                object_fraction=config.object_fraction,
+                two_class_otsu=config.two_class_otsu,
+                use_weighted_variance=config.use_weighted_variance,
+                assign_middle_to_foreground=config.assign_middle_to_foreground,
+            )
+
+            scale = config.get_scale_string()
+            algo = config.algorithm
+
+            add_measurement(
+                TemplateMeasurementFormat.IQ_THRESHOLD,
+                f"{algo}_{image_name}_{scale}" if scale else f"{algo}_{image_name}",
+                global_threshold,
+                stat_template_val=f"{algo}" + (f" {scale}" if scale else "")
+            )
+
+    if return_visualization_data:
+        return measurements, ImageQualityDisplayData(
+            statistics=statistics,
+        )
+    return measurements

{cellprofiler_library_nightly-5.0.0.dev592 → cellprofiler_library_nightly-5.0.0.dev610}/cellprofiler_library/modules/_threshold.py

@@ -15,6 +15,8 @@ from ..opts.threshold import (
 )
 from ..types import ImageGrayscale, ImageGrayscaleMask
 
+# TODO: library cleanup - needs standardizing
+# frontend still uses centrosome
 @validate_call(config=ConfigDict(arbitrary_types_allowed=True))
 def threshold(
     image:                      Annotated[ImageGrayscale, Field(description="Image to threshold")],

cellprofiler_library_nightly-5.0.0.dev610/cellprofiler_library/opts/measureimagequality.py

@@ -0,0 +1,89 @@
+from enum import Enum
+from centrosome.threshold import (
+    TM_OTSU,
+    TM_MOG,
+    TM_METHODS,
+)
+from .threshold import OtsuMethod as ThreshOtsuMethod
+
+"""Root module measurement name"""
+C_IMAGE_QUALITY = "ImageQuality"
+
+C_SCALING = "Scaling"
+
+class Feature(str, Enum):
+    FOCUS_SCORE = "FocusScore"
+    LOCAL_FOCUS_SCORE = "LocalFocusScore"
+    CORRELATION = "Correlation"
+    POWER_SPECTRUM_SLOPE = "PowerLogLogSlope"
+    TOTAL_AREA = "TotalArea"
+    TOTAL_VOLUME = "TotalVolume"
+    TOTAL_INTENSITY = "TotalIntensity"
+    MEAN_INTENSITY = "MeanIntensity"
+    MEDIAN_INTENSITY = "MedianIntensity"
+    STD_INTENSITY = "StdIntensity"
+    MAD_INTENSITY = "MADIntensity"
+    MAX_INTENSITY = "MaxIntensity"
+    MIN_INTENSITY = "MinIntensity"
+    PERCENT_MAXIMAL = "PercentMaximal"
+    PERCENT_MINIMAL = "PercentMinimal"
+    THRESHOLD = "Threshold"
+
+class TemplateMeasurementFormat(str):
+    """A string subclass for measurement formatting."""
+    # IQ = Image Quality
+    IQ_SCALING = f"{C_IMAGE_QUALITY}_{C_SCALING}_%s"
+    IQ_FOCUS_SCORE = f"{C_IMAGE_QUALITY}_{Feature.FOCUS_SCORE.value}_%s"
+    IQ_LOCAL_FOCUS_SCORE = f"{C_IMAGE_QUALITY}_{Feature.LOCAL_FOCUS_SCORE.value}_%s"
+    IQ_CORR = f"{C_IMAGE_QUALITY}_{Feature.CORRELATION.value}_%s"
+    IQ_POWER_SPECTRUM_SLOPE = f"{C_IMAGE_QUALITY}_{Feature.POWER_SPECTRUM_SLOPE.value}_%s"
+    IQ_PERCENT_MAXIMAL = f"{C_IMAGE_QUALITY}_{Feature.PERCENT_MAXIMAL.value}_%s"
+    IQ_PERCENT_MINIMAL = f"{C_IMAGE_QUALITY}_{Feature.PERCENT_MINIMAL.value}_%s"
+    IQ_TOTAL_AREA = f"{C_IMAGE_QUALITY}_{Feature.TOTAL_AREA.value}_%s"
+    IQ_TOTAL_VOLUME = f"{C_IMAGE_QUALITY}_{Feature.TOTAL_VOLUME.value}_%s"
+    IQ_TOTAL_INTENSITY = f"{C_IMAGE_QUALITY}_{Feature.TOTAL_INTENSITY.value}_%s"
+    IQ_MEAN_INTENSITY = f"{C_IMAGE_QUALITY}_{Feature.MEAN_INTENSITY.value}_%s"
+    IQ_MEDIAN_INTENSITY = f"{C_IMAGE_QUALITY}_{Feature.MEDIAN_INTENSITY.value}_%s"
+    IQ_STD_INTENSITY = f"{C_IMAGE_QUALITY}_{Feature.STD_INTENSITY.value}_%s"
+    IQ_MAD_INTENSITY = f"{C_IMAGE_QUALITY}_{Feature.MAD_INTENSITY.value}_%s"
+    IQ_MAX_INTENSITY = f"{C_IMAGE_QUALITY}_{Feature.MAX_INTENSITY.value}_%s"
+    IQ_MIN_INTENSITY = f"{C_IMAGE_QUALITY}_{Feature.MIN_INTENSITY.value}_%s"
+    IQ_THRESHOLD = f"{C_IMAGE_QUALITY}_{Feature.THRESHOLD.value}%s"
+
+class Aggregate(str, Enum):
+    MEAN = "Mean"
+    MEDIAN = "Median"
+    STD = "Std" 
+INTENSITY_FEATURES = [
+    Feature.TOTAL_INTENSITY,
+    Feature.MEAN_INTENSITY,
+    Feature.MEDIAN_INTENSITY,
+    Feature.STD_INTENSITY,
+    Feature.MAD_INTENSITY,
+    Feature.MAX_INTENSITY,
+    Feature.MIN_INTENSITY,
+]
+INTENSITY_TEMPLATES = [
+    TemplateMeasurementFormat.IQ_TOTAL_INTENSITY,
+    TemplateMeasurementFormat.IQ_MEAN_INTENSITY,
+    TemplateMeasurementFormat.IQ_MEDIAN_INTENSITY,
+    TemplateMeasurementFormat.IQ_STD_INTENSITY,
+    TemplateMeasurementFormat.IQ_MAD_INTENSITY,
+    TemplateMeasurementFormat.IQ_MAX_INTENSITY,
+    TemplateMeasurementFormat.IQ_MIN_INTENSITY,
+]
+SATURATION_FEATURES = [Feature.PERCENT_MAXIMAL, Feature.PERCENT_MINIMAL]
+SATURATION_TEMPLATES = [TemplateMeasurementFormat.IQ_PERCENT_MAXIMAL, TemplateMeasurementFormat.IQ_PERCENT_MINIMAL]
+AGGREGATES = [Aggregate.MEAN.value, Aggregate.MEDIAN.value, Aggregate.STD.value]
+MEAN_THRESH_ALL_IMAGES = "MeanThresh_AllImages"
+MEDIAN_THRESH_ALL_IMAGES = "MedianThresh_AllImages"
+STD_THRESH_ALL_IMAGES = "StdThresh_AllImages"
+
+class ScaledThresholdMethod(str, Enum):
+    OTSU = TM_OTSU
+    MOG = TM_MOG
+# could just do `from .threshold import OtsuMethod` at the top
+# but we make it explicit here to silence static analysis warnings
+OtsuMethod = ThreshOtsuMethod
+# similar to above
+THRESHOLD_METHODS = TM_METHODS

{cellprofiler_library_nightly-5.0.0.dev592 → cellprofiler_library_nightly-5.0.0.dev610}/cellprofiler_library_nightly.egg-info/PKG-INFO

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

@@ -41,6 +41,7 @@ cellprofiler_library/modules/_measuregranularity.py
 cellprofiler_library/modules/_measureimageareaoccupied.py
 cellprofiler_library/modules/_measureimageintensity.py
 cellprofiler_library/modules/_measureimageoverlap.py
+cellprofiler_library/modules/_measureimagequality.py
 cellprofiler_library/modules/_measureimageskeleton.py
 cellprofiler_library/modules/_measureobjectintensity.py
 cellprofiler_library/modules/_measureobjectneighbors.py
@@ -85,6 +86,7 @@ cellprofiler_library/opts/measuregranularity.py
 cellprofiler_library/opts/measureimageareaoccupied.py
 cellprofiler_library/opts/measureimageintensity.py
 cellprofiler_library/opts/measureimageoverlap.py
+cellprofiler_library/opts/measureimagequality.py
 cellprofiler_library/opts/measureimageskeleton.py
 cellprofiler_library/opts/measureobjectintensity.py
 cellprofiler_library/opts/measureobjectneighbors.py