cellprofiler-library-nightly 5.0.0.dev634__tar.gz → 5.0.0.dev642__tar.gz

{cellprofiler_library_nightly-5.0.0.dev634/cellprofiler_library_nightly.egg-info → cellprofiler_library_nightly-5.0.0.dev642}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev634 → cellprofiler_library_nightly-5.0.0.dev642}/cellprofiler_library/functions/image_processing.py

@@ -19,6 +19,9 @@ 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 skimage.restoration import denoise_bilateral
+from centrosome.cpmorphology import get_line_pts, all_connected_components
+from scipy.ndimage import binary_erosion, binary_fill_holes
+from scipy.ndimage import mean as mean_of_labels
 from cellprofiler_library.types import (
     ImageGrayscale, ImageGrayscaleMask, 
     Image2DColor, 
@@ -27,6 +30,7 @@ from cellprofiler_library.types import (
     ObjectSegmentation, 
     Image2D, Image2DMask, 
     StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask,
+    Image2DBinary, ObjectLabel
 )
 from cellprofiler_library.opts import threshold as Threshold
 from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
@@ -2312,4 +2316,250 @@ def get_morphology_footprint(radius, dimensions):
     else:
         footprint = skimage.morphology.ball(radius, dtype=bool)
     return footprint
-    
+    
+###############################################################################
+# IdentifyDeadWorms
+###############################################################################
+
+
+def get_3d_adjacent_after_erosion(
+        mask: Image2DBinary,
+        angle_count: int = 32,
+        worm_width: int = 100,
+        worm_length: int = 10,
+    ) -> Tuple[
+        NDArray[numpy.int_],
+        NDArray[numpy.int_],
+        NDArray[numpy.int_],
+    ]:
+    #
+    # We collect the i,j and angle of pairs of points that
+    # are 3-d adjacent after erosion.
+    #
+    # i - the i coordinate of each point found after erosion
+    # j - the j coordinate of each point found after erosion
+    # a - the angle of the structuring element for each point found
+    #
+    i = numpy.zeros(0, int)
+    j = numpy.zeros(0, int)
+    a = numpy.zeros(0, int)
+
+    ig, jg = numpy.mgrid[0 : mask.shape[0], 0 : mask.shape[1]]
+    for angle_number in range(angle_count):
+        angle = float(angle_number) * numpy.pi / float(angle_count)
+        strel = get_diamond(angle, worm_width, worm_length)
+        erosion = binary_erosion(mask, strel)
+        #
+        # Accumulate the count, i, j and angle for all foreground points
+        # in the erosion
+        #
+        this_count = numpy.sum(erosion)
+        i = numpy.hstack((i, ig[erosion]))
+        j = numpy.hstack((j, jg[erosion]))
+        a = numpy.hstack((a, numpy.ones(this_count, float) * angle))
+
+    return i, j, a
+
+def process_all_connected_components(
+        first: NDArray[numpy.int_], 
+        second: NDArray[numpy.int_], 
+        i_center: NDArray[numpy.int_], 
+        j_center: NDArray[numpy.int_], 
+        angular_orientation: NDArray[numpy.int_], 
+        mask: NDArray[numpy.bool_]
+    ) -> Tuple[
+        NDArray[numpy.int_],
+        NDArray[numpy.int_],
+        NDArray[numpy.float_],
+        int,
+        NDArray[numpy.int_],
+        NDArray[ObjectLabel],
+    ]:
+    #
+    # Do all connected components.
+    #
+    if len(first) > 0:
+        ij_labels = all_connected_components(first, second) + 1
+        nlabels = numpy.max(ij_labels)
+        label_indexes = numpy.arange(1, nlabels + 1)
+        #
+        # Compute the measurements
+        #
+        center_x = fix(mean_of_labels(j_center, ij_labels, label_indexes))
+        center_y = fix(mean_of_labels(i_center, ij_labels, label_indexes))
+        #
+        # The angles are wierdly complicated because of the wrap-around.
+        # You can imagine some horrible cases, like a circular patch of
+        # "worm" in which all angles are represented or a gentle "U"
+        # curve.
+        #
+        # For now, I'm going to use the following heuristic:
+        #
+        # Compute two different "angles". The angles of one go
+        # from 0 to 180 and the angles of the other go from -90 to 90.
+        # Take the variance of these from the mean and
+        # choose the representation with the lowest variance.
+        #
+        # An alternative would be to compute the variance at each possible
+        # dividing point. Another alternative would be to actually trace through
+        # the connected components - both overkill for such an inconsequential
+        # measurement I hope.
+        #
+        angles = fix(mean_of_labels(angular_orientation, ij_labels, label_indexes))
+        angular_orientation_variance = (angular_orientation - angles[ij_labels - 1]) ** 2
+
+        vangles = fix(mean_of_labels(angular_orientation_variance, ij_labels, label_indexes))
+        
+        aa = angular_orientation.copy()
+        aa[angular_orientation > numpy.pi / 2] -= numpy.pi
+        
+        aangles = fix(mean_of_labels(aa, ij_labels, label_indexes))
+        aangular_orientation_variance = (aa - aangles[ij_labels - 1]) ** 2
+        
+        vaangles = fix(mean_of_labels(aangular_orientation_variance, ij_labels, label_indexes))
+        
+        aangles[aangles < 0] += numpy.pi
+        angles[vaangles < vangles] = aangles[vaangles < vangles]
+        #
+        # Squish the labels to 2-d. The labels for overlaps are arbitrary.
+        #
+        labels = numpy.zeros(mask.shape, int)
+        labels[i_center, j_center] = ij_labels
+    else:
+        center_x = numpy.zeros(0, int)
+        center_y = numpy.zeros(0, int)
+        angles = numpy.zeros(0)
+        nlabels = 0
+        label_indexes = numpy.zeros(0, int)
+        labels = numpy.zeros(mask.shape, int)
+
+    return center_x, center_y, angles, nlabels, label_indexes, labels
+
+
+def get_diamond(
+        angle: float, 
+        worm_width: int, 
+        worm_length: int
+    ) -> StructuringElement:
+    """Get a diamond-shaped structuring element
+
+    angle - angle at which to tilt the diamond
+
+    returns a binary array that can be used as a footprint for
+    the erosion
+    """
+    #
+    # The shape:
+    #
+    #                   + x1,y1
+    #
+    # x0,y0 +                          + x2, y2
+    #
+    #                   + x3,y3
+    #
+    x0 = int(numpy.sin(angle) * worm_length / 2)
+    x1 = int(numpy.cos(angle) * worm_width / 2)
+    x2 = -x0
+    x3 = -x1
+    y2 = int(numpy.cos(angle) * worm_length / 2)
+    y1 = int(numpy.sin(angle) * worm_width / 2)
+    y0 = -y2
+    y3 = -y1
+    xmax = numpy.max(numpy.abs([x0, x1, x2, x3]))
+    ymax = numpy.max(numpy.abs([y0, y1, y2, y3]))
+    strel = numpy.zeros((ymax * 2 + 1, xmax * 2 + 1), bool)
+    index, count, i, j = get_line_pts(
+        numpy.array([y0, y1, y2, y3]) + ymax,
+        numpy.array([x0, x1, x2, x3]) + xmax,
+        numpy.array([y1, y2, y3, y0]) + ymax,
+        numpy.array([x1, x2, x3, x0]) + xmax,
+    )
+    strel[i, j] = True
+    strel = binary_fill_holes(strel)
+    return strel
+
+
+def find_adjacent_by_distance(
+        i_center: NDArray[numpy.int_], 
+        j_center: NDArray[numpy.int_], 
+        angular_orientation: NDArray[numpy.int_],
+        wants_automatic_distance: bool = True,
+        worm_width: Optional[int] = 100,
+        worm_length: Optional[int] = 10,
+        angle_count: Optional[int] = 32,
+        space_distance: Optional[float] = 5,
+        angular_distance: Optional[float] = 30,
+    ) -> Tuple[
+        NDArray[numpy.int_],
+        NDArray[numpy.int_],
+    ]:
+    """Return pairs of worm centers that are deemed adjacent by distance
+
+    i - i-centers of worms
+    j - j-centers of worms
+    a - angular orientation of worms
+
+    Returns two vectors giving the indices of the first and second
+    centers that are connected.
+    """
+    if len(i_center) < 2:
+        return numpy.zeros(len(i_center), int), numpy.zeros(len(i_center), int)
+    if wants_automatic_distance:
+        assert worm_width is not None and worm_length is not None, "worm_width and worm_length must be provided if wants_automatic_distance is True"
+        space_distance = worm_width
+        angle_distance = numpy.arctan2(
+            worm_width, worm_length
+        )
+        angle_distance += numpy.pi / angle_count
+    else:
+        assert space_distance is not None and angular_distance is not None, "space_distance and angular_distance must be provided if wants_automatic_distance is False"
+        space_distance = space_distance
+        angle_distance = angular_distance * numpy.pi / 180
+    #
+    # Sort by i and break the sorted vector into chunks where
+    # consecutive locations are separated by more than space_distance
+    #
+    order = numpy.lexsort((angular_orientation, j_center, i_center))
+    i_center = i_center[order]
+    j_center = j_center[order]
+    angular_orientation = angular_orientation[order]
+    breakpoint = numpy.hstack(([False], i_center[1:] - i_center[:-1] > space_distance))
+    if numpy.all(~breakpoint):
+        # No easy win - cross all with all
+        first, second = numpy.mgrid[0 : len(i_center), 0 : len(i_center)]
+    else:
+        # The segment that each belongs to
+        segment_number = numpy.cumsum(breakpoint)
+        # The number of elements in each segment
+        member_count = numpy.bincount(segment_number)
+        # The index of the first element in the segment
+        member_idx = numpy.hstack(([0], numpy.cumsum(member_count[:-1])))
+        # The index of the first element, for every element in the segment
+        segment_start = member_idx[segment_number]
+        #
+        # Develop the cross-products for each segment. Each segment has
+        # member_count * member_count crosses.
+        #
+        # # of (first,second) pairs in each segment
+        cross_size = member_count ** 2
+        # Index in final array of first element of each segment
+        segment_idx = numpy.cumsum(cross_size)
+        # relative location of first "first"
+        first_start_idx = numpy.cumsum(member_count[segment_number[:-1]])
+        first = numpy.zeros(segment_idx[-1], int)
+        first[first_start_idx] = 1
+        # The "firsts" array
+        first = numpy.cumsum(first)
+        first_start_idx = numpy.hstack(([0], first_start_idx))
+        second = (
+            numpy.arange(len(first)) - first_start_idx[first] + segment_start[first]
+        )
+    mask = (
+        numpy.abs((i_center[first] - i_center[second]) ** 2 + (j_center[first] - j_center[second]) ** 2)
+        <= space_distance ** 2
+    ) & (
+        (numpy.abs(angular_orientation[first] - angular_orientation[second]) <= angle_distance)
+        | (angular_orientation[first] + numpy.pi - angular_orientation[second] <= angle_distance)
+        | (angular_orientation[second] + numpy.pi - angular_orientation[first] <= angle_distance)
+    )
+    return order[first[mask]], order[second[mask]]

cellprofiler_library_nightly-5.0.0.dev642/cellprofiler_library/modules/_identifydeadworms.py

@@ -0,0 +1,92 @@
+import numpy
+
+from numpy.typing import NDArray
+from typing import Optional, Annotated, Union, Tuple
+from pydantic import Field, validate_call, ConfigDict, BaseModel
+
+from cellprofiler_library.types import Image2DBinary, Image2DBinaryMask, ObjectLabel
+from cellprofiler_library.functions.image_processing import get_3d_adjacent_after_erosion, process_all_connected_components, find_adjacent_by_distance
+from cellprofiler_library.measurement_model import LibraryMeasurements
+
+from cellprofiler_library.opts.identifydeadworms import M_LOCATION_CENTER_X, M_LOCATION_CENTER_Y, M_ANGLE, M_NUMBER_OBJECT_NUMBER, TemplateMeasurementFormat
+
+
+class IdentifyDeadWormsDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    center_x: NDArray[numpy.int_]
+    center_y: NDArray[numpy.int_]
+    angles: NDArray[numpy.float_]
+    mask: Image2DBinaryMask
+    nlabels: int
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def identify_dead_worms(
+        pixel_data:         Annotated[Image2DBinary, Field(description="Input binary image")],
+        image_mask:         Annotated[Optional[Image2DBinaryMask], Field(description="Input binary image mask")],
+        automatic_distance: Annotated[bool, Field(default=True, description="Whether to calculate distance parameters automatically")],
+        worm_width:         Annotated[int, Field(default=100, ge=1, description="This is the width (the short axis), measured in pixels, of the diamond used as a template when matching against the worm. It should be less than the width of a worm.")],
+        worm_length:        Annotated[int, Field(default=10, ge=1, description="This is the length (the long axis), measured in pixels, of the diamond used as a template when matching against the worm. It should be less than the length of a worm")],
+        angle_count:        Annotated[int, Field(description="Number of different angles at which the template will betried", ge=1)] = 32,
+        space_distance:     Annotated[Optional[float], Field(default=5, ge=1, description="Used only if not automatically calculating distance parameters Enter the distance for calculating the worm centers, in units of pixels. The worm centers must be at least many pixels apart for the centers to be considered two separate worms.")]=5,
+        angular_distance:   Annotated[Optional[float], Field(default=30, ge=1, description="Used only if automatically calculating distance parameters IdentifyDeadWorms calculates the worm centers at different angles. Two worm centers are considered to represent different worms if their angular distance is larger than this number. The number is measured in degrees.")]=30,
+        object_name:        Annotated[str, Field(description="Name for the dead worm object")]="dead worm",
+        return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
+) -> Union[
+        Tuple[NDArray[ObjectLabel], LibraryMeasurements],
+        Tuple[NDArray[ObjectLabel], LibraryMeasurements, IdentifyDeadWormsDisplayData]
+    ]:
+
+    mask = pixel_data
+    if image_mask is not None:
+        mask = mask & image_mask
+    #
+    # We collect the i,j and angle of pairs of points that
+    # are 3-d adjacent after erosion.
+    #
+    i_center, j_center, angular_orientation = get_3d_adjacent_after_erosion(mask, angle_count, worm_width, worm_length)
+
+    #
+    # Find connections based on distances, not adjacency
+    #
+    first, second = find_adjacent_by_distance(
+        i_center, 
+        j_center, 
+        angular_orientation, 
+        automatic_distance,
+        worm_width, 
+        worm_length,
+        angle_count,
+        space_distance,
+        angular_distance
+    )
+        
+    #
+    # Do all connected components.
+    #
+    center_x, center_y, angles, nlabels, label_indexes, labels = process_all_connected_components(first, second, i_center, j_center, angular_orientation, mask)
+
+    #
+    # Make measurements
+    #
+    measurements = LibraryMeasurements()
+
+    measurements.add_measurement(object_name, M_LOCATION_CENTER_X, center_x)
+    measurements.add_measurement(object_name, M_LOCATION_CENTER_Y, center_y)
+    measurements.add_measurement(object_name, M_ANGLE, angles * 180 / numpy.pi)
+    measurements.add_measurement(object_name, M_NUMBER_OBJECT_NUMBER, label_indexes)
+    measurements.add_image_measurement(TemplateMeasurementFormat.FF_COUNT % object_name, nlabels)
+
+    if return_visualization_data:
+        return labels, measurements, IdentifyDeadWormsDisplayData(
+            mask=mask,
+            center_x=center_x,
+            center_y=center_y,
+            angles=angles,
+            nlabels=nlabels,
+        )
+    return labels, measurements

{cellprofiler_library_nightly-5.0.0.dev634 → cellprofiler_library_nightly-5.0.0.dev642}/cellprofiler_library/modules/_measuregranularity.py

@@ -33,7 +33,7 @@ def measure_granularity(
         granular_spectrum_length:   Annotated[int, Field(description="Range of the granular spectrum")],
         dimensions:                 Annotated[int, Field(description="Dimensionality of the image")] = 2,
         return_visualization_data: Annotated[bool, Field(description="Return data for display")] = False,
-        ) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, GranularityDisplayData]]:
+) -> Union[LibraryMeasurements, Tuple[LibraryMeasurements, GranularityDisplayData]]:
     #
     # Downsample the image and mask
     #

cellprofiler_library_nightly-5.0.0.dev642/cellprofiler_library/opts/identifydeadworms.py

@@ -0,0 +1,20 @@
+C_LOCATION = "Location"
+
+FTR_CENTER_X = "Center_X"
+M_LOCATION_CENTER_X = f"{C_LOCATION}_{FTR_CENTER_X}"
+
+FTR_CENTER_Y = "Center_Y"
+M_LOCATION_CENTER_Y = f"{C_LOCATION}_{FTR_CENTER_Y}"
+
+C_WORMS = "Worm"
+F_ANGLE = "Angle"
+M_ANGLE = f"{C_WORMS}_{F_ANGLE}"
+
+C_NUMBER = "Number"
+FTR_OBJECT_NUMBER = "Object_Number"
+M_NUMBER_OBJECT_NUMBER = f"{C_NUMBER}_{FTR_OBJECT_NUMBER}"
+
+C_COUNT = "Count"
+
+class TemplateMeasurementFormat(str):
+    FF_COUNT = f"{C_COUNT}_%s"

{cellprofiler_library_nightly-5.0.0.dev634 → cellprofiler_library_nightly-5.0.0.dev642/cellprofiler_library_nightly.egg-info}/PKG-INFO

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

@@ -32,6 +32,7 @@ cellprofiler_library/modules/_fillobjects.py
 cellprofiler_library/modules/_flipandrotate.py
 cellprofiler_library/modules/_gaussianfilter.py
 cellprofiler_library/modules/_graytocolor.py
+cellprofiler_library/modules/_identifydeadworms.py
 cellprofiler_library/modules/_identifyprimaryobjects.py
 cellprofiler_library/modules/_identifysecondaryobjects.py
 cellprofiler_library/modules/_identifytertiaryobjects.py
@@ -79,6 +80,7 @@ cellprofiler_library/opts/erodeimage.py
 cellprofiler_library/opts/erodeobjects.py
 cellprofiler_library/opts/flipandrotate.py
 cellprofiler_library/opts/graytocolor.py
+cellprofiler_library/opts/identifydeadworms.py
 cellprofiler_library/opts/identifyprimaryobjects.py
 cellprofiler_library/opts/identifysecondaryobjects.py
 cellprofiler_library/opts/identifytertiaryobjects.py