cellprofiler-library-nightly 5.0.0.dev611__tar.gz → 5.0.0.dev627__tar.gz

{cellprofiler_library_nightly-5.0.0.dev611/cellprofiler_library_nightly.egg-info → cellprofiler_library_nightly-5.0.0.dev627}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev611 → cellprofiler_library_nightly-5.0.0.dev627}/cellprofiler_library/functions/measurement.py

@@ -13,6 +13,7 @@ import centrosome.cpmorphology
 import centrosome.threshold
 import centrosome.haralick
 import centrosome.radial_power_spectrum
+import centrosome.zernike
 from centrosome.outline import outline
 from functools import reduce
 from sklearn.cluster import KMeans
@@ -27,9 +28,10 @@ from cellprofiler_library.functions.segmentation import areas_from_ijv
 from cellprofiler_library.functions.segmentation import cast_labels_to_label_set
 from cellprofiler_library.functions.segmentation import convert_label_set_to_ijv
 from cellprofiler_library.functions.image_processing import masked_erode, restore_scale, get_morphology_footprint
+from cellprofiler_library.functions.object_processing import size_similarly
 from cellprofiler_library.functions.segmentation import relate_labels
 
-from cellprofiler_library.types import Pixel, ObjectLabel, ImageGrayscale, ImageGrayscaleMask, ImageAny, ImageBinary, ImageBinaryMask, ObjectSegmentation, ObjectLabelsDense, ObjectLabelSet, ObjectSegmentationIJV, Image2DBinary, Image2DColor, Image2DGrayscale
+from cellprofiler_library.types import Pixel, ObjectLabel, ImageGrayscale, ImageGrayscaleMask, ImageAny, ImageBinary, ImageBinaryMask, ObjectSegmentation, ObjectLabelsDense, ObjectLabelSet, ObjectSegmentationIJV, Image2DBinary, Image2DColor, Image2DGrayscale, ObjectLabelMask
 from cellprofiler_library.opts.objectsizeshapefeatures import get_zernike_indexes
 from cellprofiler_library.opts.measurecolocalization import CostesMethod
 from cellprofiler_library.opts.measureobjectoverlap import DecimationMethod as ObjectDecimationMethod
@@ -3437,3 +3439,463 @@ def measure_object_neighbors(
         second_objects,
         expanded_labels,
     )
+
+
+###############################################################################
+# MeasureObjectIntensityDistribution
+###############################################################################
+
+
+def compute_center_distances(
+    labels: ObjectSegmentation,
+    objects_indices: NDArray[numpy.int_],
+    center_objects_segmented: Optional[ObjectSegmentation],
+    use_centers_of_other: bool,
+    use_edges_of_other: bool,
+    wants_scaled: bool,
+    maximum_radius: int,
+) -> Tuple[
+        NDArray[numpy.float_],
+        NDArray[numpy.float_],
+        NDArray[numpy.float_],
+        NDArray[numpy.bool_]
+    ]:
+    """Compute per-pixel normalized distances from each object's center.
+
+    When ``center_objects_segmented`` is None, the center of each object is
+    the point farthest from its edge. Otherwise, the supplied label matrix
+    provides centering objects:
+      - ``use_centers_of_other=True`` collapses each centering object to its
+        centroid before propagating distances.
+      - ``use_edges_of_other=True`` keeps the centering objects extended and
+        excludes their pixels from the result.
+
+    Returns ``(normalized_distance, i_center, j_center, good_mask)``.
+    """
+    # Distance from every labeled pixel to the nearest object edge. Combined
+    # with the distance-from-center below, this defines the normalized radius.
+    distance_to_edge = centrosome.cpmorphology.distance_to_edge(labels)
+
+    if center_objects_segmented is not None:
+        #
+        # Use the center of the centering objects to assign a center
+        # to each labeled pixel using propagation.
+        #
+        # Resize the centering-object labels to match the object label matrix
+        # so the two can be indexed together.
+        center_labels, center_resized_mask = size_similarly(
+            labels, center_objects_segmented
+        )
+
+        # Count the pixels belonging to each centering object so we can ignore
+        # any centering object that ended up empty after resizing.
+        center_pixel_counts = centrosome.cpmorphology.fixup_scipy_ndimage_result(
+            scipy.ndimage.sum(
+                numpy.ones(center_labels.shape),
+                center_labels,
+                numpy.arange(
+                    1, numpy.max(center_labels) + 1, dtype=numpy.int32
+                ),
+            )
+        )
+
+        centers_with_pixels = center_pixel_counts > 0
+
+        # Integer (row, col) centroid of each centering object. The +0.5 rounds
+        # to the nearest pixel before truncation to int.
+        center_i, center_j = (
+            centrosome.cpmorphology.centers_of_labels(center_labels) + 0.5
+        ).astype(int)
+
+        # Keep only the centroids (and labels) of the non-empty centering objects.
+        good_center_i = center_i[centers_with_pixels]
+
+        good_center_j = center_j[centers_with_pixels]
+
+        good_center_labels = numpy.arange(1, len(center_i) + 1)[centers_with_pixels]
+
+        if use_centers_of_other:
+            #
+            # Reduce the propagation seeds to the single-pixel centroids of
+            # the centering objects (rather than their full extent).
+            #
+            center_labels = numpy.zeros(center_labels.shape, int)
+
+            center_labels[good_center_i, good_center_j] = good_center_labels
+
+        # Propagate the centering-object labels outward across the objects,
+        # recording per pixel the assigned center label and the geodesic
+        # distance from that center.
+        assigned_center_label, distance_from_center = centrosome.propagate.propagate(
+            numpy.zeros(center_labels.shape), center_labels, labels != 0, 1
+        )
+
+        # Erase the centers that fall outside of labels.
+        assigned_center_label[labels == 0] = 0
+
+        #
+        # If objects are hollow or crescent-shaped, there may be objects
+        # without center labels. As a backup, assign each such object the
+        # centering object whose centroid is closest to its center of mass.
+        #
+        missing_center_mask = (labels != 0) & (assigned_center_label == 0)
+
+        missing_labels = numpy.unique(labels[missing_center_mask])
+
+        if len(missing_labels):
+            all_centers = centrosome.cpmorphology.centers_of_labels(labels)
+
+            missing_i_centers, missing_j_centers = all_centers[
+                :, missing_labels - 1
+            ]
+
+            # Squared distance from each missing object's centroid to every
+            # candidate centering-object centroid; argsort picks the nearest.
+            delta_i = missing_i_centers[:, numpy.newaxis] - good_center_i[numpy.newaxis, :]
+
+            delta_j = missing_j_centers[:, numpy.newaxis] - good_center_j[numpy.newaxis, :]
+
+            nearest_center_label = good_center_labels[
+                numpy.argsort(delta_i * delta_i + delta_j * delta_j)[:, 0]
+            ]
+
+            # Map every object label to its chosen center, then stamp the
+            # assigned center onto the missing pixels.
+            nearest_center_by_label = numpy.zeros(numpy.max(labels) + 1, int)
+
+            nearest_center_by_label[missing_labels] = nearest_center_label
+
+            assigned_center_label[missing_center_mask] = nearest_center_by_label[
+                labels[missing_center_mask]
+            ]
+
+            #
+            # Now compute the crow-flies (Euclidean) distance to the centers
+            # of these pixels from whatever center was assigned to the object.
+            #
+            pixel_grid_i, pixel_grid_j = numpy.mgrid[
+                0 : labels.shape[0], 0 : labels.shape[1]
+            ]
+
+            delta_i = (
+                pixel_grid_i[missing_center_mask]
+                - center_i[assigned_center_label[missing_center_mask] - 1]
+            )
+
+            delta_j = (
+                pixel_grid_j[missing_center_mask]
+                - center_j[assigned_center_label[missing_center_mask] - 1]
+            )
+
+            distance_from_center[missing_center_mask] = numpy.sqrt(
+                delta_i * delta_i + delta_j * delta_j
+            )
+    else:
+        #
+        # Find the point in each object farthest away from the edge.
+        # This does better than the centroid:
+        # * The center is within the object
+        # * The center tends to be an interesting point, like the center of
+        #   the nucleus or the center of one or the other of two touching cells.
+        #
+        center_i, center_j = centrosome.cpmorphology.maximum_position_of_labels(
+            distance_to_edge, labels, objects_indices
+        )
+
+        center_labels = numpy.zeros(labels.shape, int)
+
+        center_labels[center_i, center_j] = labels[center_i, center_j]
+
+        #
+        # Use the coloring trick here to process touching objects in separate
+        # operations: objects sharing a color never touch, so propagation
+        # within one color cannot bleed across object boundaries.
+        #
+        colors = centrosome.cpmorphology.color_labels(labels)
+
+        n_colors = numpy.max(colors)
+
+        distance_from_center = numpy.zeros(labels.shape)
+
+        assigned_center_label = numpy.zeros(labels.shape, int)
+
+        for color in range(1, n_colors + 1):
+            color_mask = colors == color
+
+            propagated_labels, propagated_distance = centrosome.propagate.propagate(
+                numpy.zeros(center_labels.shape), center_labels, color_mask, 1
+            )
+
+            distance_from_center[color_mask] = propagated_distance[color_mask]
+
+            assigned_center_label[color_mask] = propagated_labels[color_mask]
+
+    # A pixel is "good" if it was assigned to some center.
+    good_mask = assigned_center_label > 0
+
+    if use_edges_of_other:
+        # Exclude pixels within the centering objects when measuring distance
+        # from their edges.
+        good_mask = good_mask & (center_labels == 0)
+
+    # Per-pixel center coordinates, looked up by the assigned center label
+    # (labels are 1-based, hence the -1).
+    i_center = numpy.zeros(assigned_center_label.shape)
+
+    i_center[good_mask] = center_i[assigned_center_label[good_mask] - 1]
+
+    j_center = numpy.zeros(assigned_center_label.shape)
+
+    j_center[good_mask] = center_j[assigned_center_label[good_mask] - 1]
+
+    normalized_distance = numpy.zeros(labels.shape)
+
+    if wants_scaled:
+        # Normalize so the object center is ~0 and the edge is ~1. The 0.001
+        # guards against division by zero when a pixel is both center and edge.
+        total_distance = distance_from_center + distance_to_edge
+
+        normalized_distance[good_mask] = distance_from_center[good_mask] / (
+            total_distance[good_mask] + 0.001
+        )
+    else:
+        # Fixed-scale binning: express distance as a fraction of the user's
+        # maximum radius rather than the per-object radius.
+        normalized_distance[good_mask] = (
+            distance_from_center[good_mask] / maximum_radius
+        )
+
+    return normalized_distance, i_center, j_center, good_mask
+
+
+def compute_per_bin_distributions(
+    labels: ObjectSegmentation,
+    pixel_data: ImageGrayscale,
+    good_mask: ObjectLabelMask,
+    normalized_distance: NDArray[numpy.float_],
+    bin_count: int,
+    nobjects: int,
+) -> Tuple[
+        NDArray[numpy.int_],
+        NDArray[Union[numpy.float32, numpy.float64]],
+        NDArray[Union[numpy.float32, numpy.float64]],
+        NDArray[Union[numpy.float32, numpy.float64]],
+        NDArray[Union[numpy.float32, numpy.float64]],
+    ]:
+    """Compute per-(object, bin) intensity-fraction matrices.
+
+    Returns ``(bin_indexes, fraction_at_distance, mean_pixel_fraction,
+    masked_fraction_at_distance, masked_mean_pixel_fraction)``.
+    """
+    ngood_pixels: numpy.int_ = numpy.sum(good_mask)
+
+    good_labels = labels[good_mask]
+
+    bin_indexes: NDArray[numpy.int_] = (normalized_distance * bin_count).astype(int)
+
+    bin_indexes[bin_indexes > bin_count] = bin_count
+
+    labels_and_bins = (good_labels - 1, bin_indexes[good_mask])
+
+    histogram: NDArray[Union[numpy.float32, numpy.float64]] = scipy.sparse.coo_matrix(
+        (pixel_data[good_mask], labels_and_bins), (nobjects, bin_count + 1)
+    ).toarray()
+
+    sum_by_object: NDArray[Union[numpy.float32, numpy.float64]] = numpy.sum(histogram, 1)
+
+    sum_by_object_per_bin: NDArray[Union[numpy.float32, numpy.float64]] = numpy.dstack([sum_by_object] * (bin_count + 1))[0]
+
+    fraction_at_distance: NDArray[Union[numpy.float32, numpy.float64]] = histogram / sum_by_object_per_bin
+
+    number_at_distance: NDArray[Union[numpy.float32, numpy.float64]] = scipy.sparse.coo_matrix(
+        (numpy.ones(ngood_pixels), labels_and_bins), (nobjects, bin_count + 1)
+    ).toarray()
+
+    object_mask: NDArray[Union[numpy.float32, numpy.float64]] = number_at_distance > 0
+
+    sum_by_object = numpy.sum(number_at_distance, 1)
+
+    sum_by_object_per_bin = numpy.dstack([sum_by_object] * (bin_count + 1))[0]
+
+    fraction_at_bin = number_at_distance / sum_by_object_per_bin
+
+    mean_pixel_fraction = fraction_at_distance / (
+        fraction_at_bin + numpy.finfo(float).eps
+    )
+
+    masked_fraction_at_distance = numpy.ma.masked_array(
+        fraction_at_distance, ~object_mask
+    )
+
+    masked_mean_pixel_fraction = numpy.ma.masked_array(
+        mean_pixel_fraction, ~object_mask
+    )
+
+    return (
+        bin_indexes,
+        fraction_at_distance,
+        mean_pixel_fraction,
+        masked_fraction_at_distance,
+        masked_mean_pixel_fraction,
+    )
+
+
+def compute_radial_indexes(
+    labels: ObjectSegmentation,
+    i_center: NDArray[numpy.float_],
+    j_center: NDArray[numpy.float_],
+    good_mask: ObjectLabelMask,
+) -> NDArray[numpy.int_]:
+    """Assign each good-mask pixel to one of 8 angular wedges around its center.
+
+    Used by the radial CV computation.
+    """
+    i, j = numpy.mgrid[0 : labels.shape[0], 0 : labels.shape[1]]
+
+    imask = i[good_mask] > i_center[good_mask]
+
+    jmask = j[good_mask] > j_center[good_mask]
+
+    absmask = abs(i[good_mask] - i_center[good_mask]) > abs(
+        j[good_mask] - j_center[good_mask]
+    )
+
+    radial_index = (
+        imask.astype(int) + jmask.astype(int) * 2 + absmask.astype(int) * 4
+    )
+
+    return radial_index
+
+
+def compute_minimum_enclosing_circles(
+    label_indexes_pairs: ObjectLabelSet,
+    n_objects: int,
+) -> Tuple[
+        NDArray[numpy.float64],
+        NDArray[numpy.float64],
+    ]:
+    """For each object, compute (i, j) center and radius of the minimum enclosing circle.
+
+    ``label_indexes_pairs`` is a list of ``(labels_array, indexes_array)``
+    tuples (matching the iteration shape of ``Objects.get_labels()``).
+    Returns ``(ij, r)`` arrays sized ``n_objects + 1`` (slot 0 is unused
+    so callers can index by 1-based label).
+    """
+    ij = numpy.zeros((n_objects + 1, 2))
+
+    r = numpy.zeros(n_objects + 1)
+
+    for labels, indexes in label_indexes_pairs:
+        ij_, r_ = centrosome.cpmorphology.minimum_enclosing_circle(
+            labels, indexes
+        )
+
+        ij[indexes] = ij_
+
+        r[indexes] = r_
+
+    return ij, r
+
+
+def prepare_object_zernike_polynomials(
+    label_indexes_pairs: ObjectLabelSet,
+    n_objects: int,
+    ijv: ObjectSegmentationIJV,
+    zernike_degree: int,
+) -> Tuple[
+        NDArray[ObjectLabel],
+        NDArray[numpy.complex128],
+        NDArray[numpy.int32],
+    ]:
+    """Build per-pixel Zernike polynomial values for one object set.
+
+    For each labeled pixel in ``ijv``, computes its normalized position
+    inside its object's minimum enclosing circle, then evaluates all
+    Zernike polynomials up to ``zernike_degree`` at that position.
+
+    Returns ``(l, z, zernike_indexes)`` where ``l`` is the per-pixel
+    label vector (= ``ijv[:, 2]``), ``z`` is the
+    ``(n_pixels, n_zernikes)`` complex matrix of polynomial values, and
+    ``zernike_indexes`` is the list of ``(n, m)`` pairs identifying each
+    column of ``z``.
+    """
+    ij, r = compute_minimum_enclosing_circles(label_indexes_pairs, n_objects)
+
+    label_vec = ijv[:, 2]
+
+    yx = (ijv[:, :2] - ij[label_vec, :]) / r[label_vec, numpy.newaxis]
+
+    zernike_indexes = centrosome.zernike.get_zernike_indexes(zernike_degree + 1)
+
+    zernike_polynomials = centrosome.zernike.construct_zernike_polynomials(
+        yx[:, 1], yx[:, 0], zernike_indexes
+    )
+
+    return label_vec, zernike_polynomials, zernike_indexes
+
+
+def compute_radial_cv_for_bin(
+    nbin: int,
+    labels: ObjectSegmentation,
+    pixel_data: ImageGrayscale,
+    good_mask: ObjectLabelMask,
+    bin_indexes: NDArray[numpy.int_],
+    radial_index: NDArray[numpy.int_],
+    nobjects: int,
+) -> Tuple[
+        NDArray[numpy.bool_],
+        NDArray[numpy.int_],
+        NDArray[Union[numpy.float32, numpy.float64]],
+        NDArray[numpy.bool_],
+    ]:
+    """Compute the per-object radial coefficient of variation for one bin.
+
+    Anisotropy: split each cell into 8 angular wedges, compute the mean
+    intensity per wedge, then the CV across wedges within this radial bin.
+
+    Returns ``(bin_mask, bin_labels, radial_cv, empty_object_mask)``:
+      - ``bin_mask``: pixels in ``good_mask`` that fall in this radial bin.
+      - ``bin_labels``: object label at each pixel in ``bin_mask``.
+      - ``radial_cv``: length-``nobjects`` array of per-object CV values
+        (0 for objects with no pixels in this bin).
+      - ``empty_object_mask``: length-``nobjects`` boolean, True for objects
+        that contributed no wedge to this bin. The caller can apply this
+        as a numpy.ma mask when aggregating ``radial_cv``.
+    """
+    # Pixels of `good_mask` that fall in this radial bin.
+    bin_mask = good_mask & (bin_indexes == nbin)
+
+    bin_pixels = numpy.sum(bin_mask)
+
+    bin_labels = labels[bin_mask]
+
+    # Slice the per-pixel wedge index to just this bin's pixels. radial_index
+    # is dense over good_mask, so filter via the same predicate.
+    bin_radial_index = radial_index[bin_indexes[good_mask] == nbin]
+
+    labels_and_radii = (bin_labels - 1, bin_radial_index)
+
+    # Sum of pixel intensities and pixel counts per (object, wedge), as
+    # dense (nobjects, 8) matrices via sparse construction.
+    radial_values = scipy.sparse.coo_matrix(
+        (pixel_data[bin_mask], labels_and_radii), (nobjects, 8)
+    ).toarray()
+
+    pixel_count = scipy.sparse.coo_matrix(
+        (numpy.ones(bin_pixels), labels_and_radii), (nobjects, 8)
+    ).toarray()
+
+    # A wedge is "empty" if it has zero pixels in this bin. Mask those
+    # cells so the per-object mean/std isn't biased by NaNs.
+    wedge_empty = pixel_count == 0
+
+    radial_means = numpy.ma.masked_array(radial_values / pixel_count, wedge_empty)
+
+    radial_cv = numpy.std(radial_means, 1) / numpy.mean(radial_means, 1)
+
+    # Objects with no contributing wedge get CV = 0.
+    empty_object_mask = numpy.sum(~wedge_empty, 1) == 0
+
+    radial_cv[empty_object_mask] = 0
+
+    return bin_mask, bin_labels, radial_cv, empty_object_mask

{cellprofiler_library_nightly-5.0.0.dev611 → cellprofiler_library_nightly-5.0.0.dev627}/cellprofiler_library/functions/object_processing.py

@@ -875,6 +875,39 @@ def filter_labels(
     return segmented_labels_out
 
 
+def crop_labels_and_image(
+        labels: ObjectSegmentation,
+        image: ImageAny,
+    ):
+    """Crop a labels matrix and an image to the lowest common size
+
+    labels - a n x m labels matrix
+    image - a 2-d or 3-d image
+
+    Assumes that points outside of the common boundary should be masked.
+    """
+    min_dim1 = min(labels.shape[0], image.shape[0])
+    min_dim2 = min(labels.shape[1], image.shape[1])
+
+    if labels.ndim == 3:  # volume
+        min_dim3 = min(labels.shape[2], image.shape[2])
+
+        if image.ndim == 4:  # multichannel volume
+            return (
+                labels[:min_dim1, :min_dim2, :min_dim3],
+                image[:min_dim1, :min_dim2, :min_dim3, :],
+            )
+
+        return (
+            labels[:min_dim1, :min_dim2, :min_dim3],
+            image[:min_dim1, :min_dim2, :min_dim3],
+        )
+
+    if image.ndim == 3:  # multichannel image
+        return labels[:min_dim1, :min_dim2], image[:min_dim1, :min_dim2, :]
+
+    return labels[:min_dim1, :min_dim2], image[:min_dim1, :min_dim2]
+
 def size_similarly(
         labels: ObjectSegmentation, 
         secondary: Union[ObjectSegmentation, ImageAny],