cellprofiler-library-nightly 5.0.0.dev643__tar.gz → 5.0.0.dev649__tar.gz

{cellprofiler_library_nightly-5.0.0.dev643/cellprofiler_library_nightly.egg-info → cellprofiler_library_nightly-5.0.0.dev649}/PKG-INFO

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

{cellprofiler_library_nightly-5.0.0.dev643 → cellprofiler_library_nightly-5.0.0.dev649}/cellprofiler_library/functions/image_processing.py

@@ -13,6 +13,7 @@ import centrosome.threshold
 import centrosome.filter
 import scipy
 import scipy.interpolate
+import scipy.sparse
 import matplotlib
 import math
 from numpy.typing import NDArray
@@ -22,6 +23,7 @@ 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 scipy.fftpack import fft2, ifft2
 from cellprofiler_library.types import (
     ImageGrayscale, ImageGrayscaleMask, 
     Image2DColor, 
@@ -29,8 +31,7 @@ from cellprofiler_library.types import (
     ImageAny, ImageAnyMask, 
     ObjectSegmentation, 
     Image2D, Image2DMask, 
-    StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask,
-    Image2DBinary, ObjectLabel
+    StructuringElement, ObjectLabelSet, ImageColor, ImageBinaryMask, Image2DBinary, ObjectLabel, ImageBinary, Pixel
 )
 from cellprofiler_library.opts import threshold as Threshold
 from cellprofiler_library.opts.enhanceorsuppressfeatures import SpeckleAccuracy, NeuriteMethod
@@ -2563,3 +2564,309 @@ def find_adjacent_by_distance(
         | (angular_orientation[second] + numpy.pi - angular_orientation[first] <= angle_distance)
     )
     return order[first[mask]], order[second[mask]]
+
+################################################################################
+# Align
+################################################################################
+
+
+def align_cross_correlation(
+        pixels1: Image2D, 
+        pixels2: Image2D
+    ) -> Tuple[
+        int,
+        int
+    ]:
+    """Align the second image with the first using max cross-correlation
+
+    returns the x,y offsets to add to image1's indexes to align it with
+    image2
+
+    Many of the ideas here are based on the paper, "Fast Normalized
+    Cross-Correlation" by J.P. Lewis
+    (http://www.idiom.com/~zilla/Papers/nvisionInterface/nip.html)
+    which is frequently cited when addressing this problem.
+    """
+    #
+    # TODO: Possibly use all 3 dimensions for color some day
+    #
+    if pixels1.ndim == 3:
+        pixels1 = numpy.mean(pixels1, 2)
+    if pixels2.ndim == 3:
+        pixels2 = numpy.mean(pixels2, 2)
+    #
+    # We double the size of the image to get a field of zeros
+    # for the parts of one image that don't overlap the displaced
+    # second image.
+    #
+    # Since we're going into the frequency domain, if the images are of
+    # different sizes, we can make the FFT shape large enough to capture
+    # the period of the largest image - the smaller just will have zero
+    # amplitude at that frequency.
+    #
+    s = numpy.maximum(pixels1.shape, pixels2.shape)
+    fshape = s * 2
+    #
+    # Calculate the # of pixels at a particular point
+    #
+    i, j = numpy.mgrid[-s[0]: s[0], -s[1]: s[1]]
+    unit = numpy.abs(i * j).astype(float)
+    unit[unit < 1] = 1  # keeps from dividing by zero in some places
+    #
+    # Normalize the pixel values around zero which does not affect the
+    # correlation, keeps some of the sums of multiplications from
+    # losing precision and precomputes t(x-u,y-v) - t_mean
+    #
+    pixels1 = pixels1 - numpy.mean(pixels1)
+    pixels2 = pixels2 - numpy.mean(pixels2)
+    #
+    # Lewis uses an image, f and a template t. He derives a normalized
+    # cross correlation, ncc(u,v) =
+    # sum((f(x,y)-f_mean(u,v))*(t(x-u,y-v)-t_mean),x,y) /
+    # sqrt(sum((f(x,y)-f_mean(u,v))**2,x,y) * (sum((t(x-u,y-v)-t_mean)**2,x,y)
+    #
+    # From here, he finds that the numerator term, f_mean(u,v)*(t...) is zero
+    # leaving f(x,y)*(t(x-u,y-v)-t_mean) which is a convolution of f
+    # by t-t_mean.
+    #
+    fp1 = fft2(pixels1, fshape.tolist())
+    fp2 = fft2(pixels2, fshape.tolist())
+    corr12 = ifft2(fp1 * fp2.conj()).real
+
+    #
+    # Use the trick of Lewis here - compute the cumulative sums
+    # in a fashion that accounts for the parts that are off the
+    # edge of the template.
+    #
+    # We do this in quadrants:
+    # q0 q1
+    # q2 q3
+    # For the first,
+    # q0 is the sum over pixels1[i:,j:] - sum i,j backwards
+    # q1 is the sum over pixels1[i:,:j] - sum i backwards, j forwards
+    # q2 is the sum over pixels1[:i,j:] - sum i forwards, j backwards
+    # q3 is the sum over pixels1[:i,:j] - sum i,j forwards
+    #
+    # The second is done as above but reflected lr and ud
+    #
+    p1_si = pixels1.shape[0]
+    p1_sj = pixels1.shape[1]
+    p1_sum = numpy.zeros(fshape)
+    p1_sum[:p1_si, :p1_sj] = cumsum_quadrant(pixels1, False, False)
+    p1_sum[:p1_si, -p1_sj:] = cumsum_quadrant(pixels1, False, True)
+    p1_sum[-p1_si:, :p1_sj] = cumsum_quadrant(pixels1, True, False)
+    p1_sum[-p1_si:, -p1_sj:] = cumsum_quadrant(pixels1, True, True)
+    #
+    # Divide the sum over the # of elements summed-over
+    #
+    p1_mean = p1_sum / unit
+
+    p2_si = pixels2.shape[0]
+    p2_sj = pixels2.shape[1]
+    p2_sum = numpy.zeros(fshape)
+    p2_sum[:p2_si, :p2_sj] = cumsum_quadrant(pixels2, False, False)
+    p2_sum[:p2_si, -p2_sj:] = cumsum_quadrant(pixels2, False, True)
+    p2_sum[-p2_si:, :p2_sj] = cumsum_quadrant(pixels2, True, False)
+    p2_sum[-p2_si:, -p2_sj:] = cumsum_quadrant(pixels2, True, True)
+    p2_sum = numpy.fliplr(numpy.flipud(p2_sum))
+    p2_mean = p2_sum / unit
+    #
+    # Once we have the means for u,v, we can calculate the
+    # variance-like parts of the equation. We have to multiply
+    # the mean^2 by the # of elements being summed-over
+    # to account for the mean being summed that many times.
+    #
+    p1sd = numpy.sum(pixels1 ** 2) - p1_mean ** 2 * numpy.product(s)
+    p2sd = numpy.sum(pixels2 ** 2) - p2_mean ** 2 * numpy.product(s)
+    #
+    # There's always chance of roundoff error for a zero value
+    # resulting in a negative sd, so limit the sds here
+    #
+    sd = numpy.sqrt(numpy.maximum(p1sd * p2sd, 0))
+    corrnorm = corr12 / sd
+    #
+    # There's not much information for points where the standard
+    # deviation is less than 1/100 of the maximum. We exclude these
+    # from consideration.
+    #
+    corrnorm[(unit < numpy.product(s) / 2) & (sd < numpy.mean(sd) / 100)] = 0
+    i, j = numpy.unravel_index(numpy.argmax(corrnorm), fshape)
+    #
+    # Reflect values that fall into the second half
+    #
+    if i > pixels1.shape[0]:
+        i = i - fshape[0]
+    if j > pixels1.shape[1]:
+        j = j - fshape[1]
+    return int(j), int(i)
+
+def align_mutual_information(
+        pixels1: Image2D,
+        pixels2: Image2D,
+        mask1: Image2DMask,
+        mask2: Image2DMask
+    ) -> Tuple[
+        int,
+        int
+    ]:
+    """Align the second image with the first using mutual information
+
+    returns the x,y offsets to add to image1's indexes to align it with
+    image2
+
+    The algorithm computes the mutual information content of the two
+    images, offset by one in each direction (including diagonal) and
+    then picks the direction in which there is the most mutual information.
+    From there, it tries all offsets again and so on until it reaches
+    a local maximum.
+    """
+    #
+    # TODO: Possibly use all 3 dimensions for color some day
+    #
+    if pixels1.ndim == 3:
+        _pixels1: Image2DGrayscale = numpy.mean(pixels1, 2)
+    else:
+        _pixels1: Image2DGrayscale = pixels1
+    if pixels2.ndim == 3:
+        _pixels2: Image2DGrayscale = numpy.mean(pixels2, 2)
+    else:
+        _pixels2: Image2DGrayscale = pixels2
+
+    def mutualinf(x: Image2DGrayscale, y: Image2DGrayscale, maskx: Image2DMask, masky: Image2DMask) -> float:
+        _x = x[maskx & masky]
+        _y = y[maskx & masky]
+        return entropy(_x) + entropy(_y) - entropy2(_x, _y)
+    maxshape = tuple(numpy.maximum(_pixels1.shape, _pixels2.shape))
+    _pixels1 = reshape_image(_pixels1, maxshape)
+    _pixels2 = reshape_image(_pixels2, maxshape)
+    mask1 = reshape_image(mask1, maxshape)
+    mask2 = reshape_image(mask2, maxshape)
+
+    best = mutualinf(_pixels1, _pixels2, mask1, mask2)
+    i = 0
+    j = 0
+    while True:
+        last_i = i
+        last_j = j
+        for new_i in range(last_i - 1, last_i + 2):
+            for new_j in range(last_j - 1, last_j + 2):
+                if new_i == 0 and new_j == 0:
+                    continue
+                p2, p1 = offset_slice(_pixels2, _pixels1, new_i, new_j)
+                m2, m1 = offset_slice(mask2, mask1, new_i, new_j)
+                info = mutualinf(p1, p2, m1, m2)
+                if info > best:
+                    best = info
+                    i = new_i
+                    j = new_j
+        if i == last_i and j == last_j:
+            return j, i
+        
+def offset_slice(
+        pixels1: Union[Image2D, ImageBinary], # Union to support crop_mask (3 channel binary NDArray)
+        pixels2: Image2D, 
+        i: int, 
+        j: int
+    ) -> Tuple[
+        Union[Image2D, ImageBinary],
+        Image2D
+    ]:
+    """Return two sliced arrays where the first slice is offset by i,j
+    relative to the second slice.
+
+    """
+    if i < 0:
+        height = min(pixels1.shape[0] + i, pixels2.shape[0])
+        p1_imin = -i
+        p2_imin = 0
+    else:
+        height = min(pixels1.shape[0], pixels2.shape[0] - i)
+        p1_imin = 0
+        p2_imin = i
+    p1_imax = p1_imin + height
+    p2_imax = p2_imin + height
+    if j < 0:
+        width = min(pixels1.shape[1] + j, pixels2.shape[1])
+        p1_jmin = -j
+        p2_jmin = 0
+    else:
+        width = min(pixels1.shape[1], pixels2.shape[1] - j)
+        p1_jmin = 0
+        p2_jmin = j
+    p1_jmax = p1_jmin + width
+    p2_jmax = p2_jmin + width
+
+    p1 = pixels1[p1_imin:p1_imax, p1_jmin:p1_jmax]
+    p2 = pixels2[p2_imin:p2_imax, p2_jmin:p2_jmax]
+    return p1, p2
+
+
+def cumsum_quadrant(
+        x: Image2D, 
+        i_forwards: bool, 
+        j_forwards: bool
+    ) -> NDArray[numpy.float64]:
+    """Return the cumulative sum going in the i, then j direction
+
+    x - the matrix to be summed
+    i_forwards - sum from 0 to end in the i direction if true
+    j_forwards - sum from 0 to end in the j direction if true
+    """
+    if i_forwards:
+        x = x.cumsum(0)
+    else:
+        x = numpy.flipud(numpy.flipud(x).cumsum(0))
+    if j_forwards:
+        return x.cumsum(1)
+    else:
+        return numpy.fliplr(numpy.fliplr(x).cumsum(1))
+
+
+def entropy(x: NDArray[Pixel]) -> float:
+    """The entropy of x as if x is a probability distribution"""
+    histogram = scipy.ndimage.histogram(x.astype(float), numpy.min(x), numpy.max(x), 256)
+    n = numpy.sum(histogram)
+    if n > 0 and numpy.max(histogram) > 0:
+        histogram = histogram[histogram != 0]
+        return numpy.log2(n) - numpy.sum(histogram * numpy.log2(histogram)) / n
+    else:
+        return 0
+
+
+def entropy2(x: NDArray[Pixel], y: NDArray[Pixel]) -> float:
+    """Joint entropy of paired samples X and Y"""
+    #
+    # Bin each image into 256 gray levels
+    #
+    x = (centrosome.filter.stretch(x) * 255).astype(int)
+    y = (centrosome.filter.stretch(y) * 255).astype(int)
+    #
+    # create an image where each pixel with the same X & Y gets
+    # the same value
+    #
+    xy = 256 * x + y
+    xy = xy.flatten()
+    sparse = scipy.sparse.coo_matrix(
+        (numpy.ones(xy.shape, dtype=numpy.int32), (xy, numpy.zeros(xy.shape, dtype=numpy.int32)))
+    )
+    histogram = sparse.toarray()
+    n = numpy.sum(histogram)
+    if n > 0 and numpy.max(histogram) > 0:
+        histogram = histogram[histogram > 0]
+        return numpy.log2(n) - numpy.sum(histogram * numpy.log2(histogram)) / n
+    else:
+        return 0
+
+ReshapeImageInput = TypeVar("ReshapeImageInput", bound=Union[Image2D, Image2DMask])
+def reshape_image(
+        source: ReshapeImageInput,  # Union to support crop_mask (3 channel binary NDArray)
+        new_shape: Tuple[int, int]
+    ) -> ReshapeImageInput:
+    """Reshape an image to a larger shape, padding with zeros"""
+    if tuple(source.shape) == tuple(new_shape):
+        return source
+
+    result = numpy.zeros(new_shape, source.dtype)
+    result[: source.shape[0], : source.shape[1]] = source
+    return result
+

{cellprofiler_library_nightly-5.0.0.dev643 → cellprofiler_library_nightly-5.0.0.dev649}/cellprofiler_library/functions/measurement.py

@@ -1692,6 +1692,33 @@ def measure_quartile_intensity(indices:NDArray[numpy.int_], areas: NDArray[numpy
     dest_no_upper = limg[order[qindex[qmask_no_upper]]]
     return qmask, _dest, qmask_no_upper, dest_no_upper
 
+def measure_mad_intensity(
+        limg: NDArray[Pixel],
+        llabels: NDArray[ObjectLabel],
+        lindexes: NDArray[numpy.int_],
+        median_intensity: NDArray[numpy.float_],
+        ) -> NDArray[numpy.float64]:
+    """Compute the median absolute deviation (MAD) of intensity per object.
+
+    MAD is defined as median(|x_i - median(x)|). Unlike the quartile measurements,
+    this is computed as a true per-object median of the absolute deviations rather
+    than via interpolated quartile indexing, which would otherwise interpolate
+    across value boundaries for odd-sized objects and yield an incorrect result.
+
+    Args:
+        limg: 1D array of object pixel intensities
+        llabels: 1D array of object labels, aligned with ``limg``
+        lindexes: object label indices to compute over
+        median_intensity: per-object median intensity, indexed by label - 1
+
+    Returns:
+        Array of MAD values, one per entry in ``lindexes``.
+    """
+    madimg = numpy.abs(limg - median_intensity[llabels - 1])
+    return centrosome.cpmorphology.fixup_scipy_ndimage_result(
+        scipy.ndimage.median(madimg, llabels, lindexes)
+    )
+
 ###############################################################################
 # MeasureObjectOverlap
 ###############################################################################

cellprofiler_library_nightly-5.0.0.dev649/cellprofiler_library/modules/_align.py

@@ -0,0 +1,266 @@
+import numpy as np
+
+from typing import Tuple, Optional, List, Union, Annotated
+from pydantic import Field, validate_call, ConfigDict, BaseModel
+
+from cellprofiler_library.opts.align import CropMode, AlignmentMethod, AdditionalAlignmentChoice, MEASUREMENT_FORMAT
+from cellprofiler_library.types import Image2D, Image2DMask, ImageBinary
+from cellprofiler_library.measurement_model import LibraryMeasurements
+from cellprofiler_library.functions.image_processing import (
+    align_cross_correlation,
+    align_mutual_information,
+    offset_slice,
+)
+
+ImageInfo = List[Tuple[
+    str, # input image name
+    Image2D, # input image pixels
+    str, # output image name
+    Image2D, # output image pixels
+    int, # offset X
+    int, # offset Y
+    Tuple[int, int], # image shape
+]]
+
+class AlignDisplayData(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    image_info: ImageInfo
+
+AlignReturnData = Tuple[
+    List[Image2D],
+    List[Image2DMask],
+    List[Optional[Union[Image2DMask, ImageBinary]]],
+    LibraryMeasurements
+]
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def align_images(
+        primary_image: Annotated[Image2D, Field(description="Primary image")],
+        primary_image_mask: Annotated[Image2DMask, Field(description="Primary image mask")],
+        secondary_image: Annotated[Image2D, Field(description="Secondary image")],
+        secondary_image_mask: Annotated[Image2DMask, Field(description="Secondary image mask")],
+        alignment_method: Annotated[AlignmentMethod, Field(description="Alignment method")],
+        crop_mode: Annotated[CropMode, Field(description="Crop mode")],
+        additional_images: Annotated[List[Image2D], Field(description="List of additonal images to align")] = [],
+        additional_image_masks: Annotated[List[Image2DMask], Field(description="List of image masks for additonal images")] = [],
+        additional_image_alignments: Annotated[List[AdditionalAlignmentChoice], Field(description="List of alignment types for additonal images")] = [],
+        input_image_names: Annotated[Optional[List[str]], Field(description="List of input image names for visualization (if None name will be generated)")] = None,
+        output_image_names: Annotated[Optional[List[str]], Field(description="List of output image names for visualization (if None name will be generated)")] = None,
+        return_visualization_data: Annotated[bool, Field(description="Return GT_pixels and ID_pixels for visualization")] = False,
+) -> Union[
+        Tuple[AlignReturnData, AlignDisplayData],
+        AlignReturnData
+    ]:
+        assert len(additional_images) == len(additional_image_masks), "Must have same number of image masks as images"
+        assert len(additional_images) == len(additional_image_alignments), "Must have same number of image alignments as images"
+        assert input_image_names is None or len(input_image_names) == (len(additional_images) + 2), "Must have same number of input image names as images"
+        assert output_image_names is None or len(output_image_names) == (len(additional_images) + 2), "Must have same number of output image names as images"
+
+        off_x, off_y = align_pair(
+            primary_image,
+            secondary_image,
+            primary_image_mask,
+            secondary_image_mask,
+            alignment_method
+        )
+        offsets = [(0,0), (off_y, off_x)]
+
+        for i in range(len(additional_images)):
+            if additional_image_alignments[i] == AdditionalAlignmentChoice.SIMILARLY.value:
+                offsets.append((off_y, off_x))
+            elif additional_image_alignments[i] == AdditionalAlignmentChoice.SEPARATELY.value:
+                a_off_x, a_off_y = align_pair(
+                    primary_image,
+                    additional_images[i],
+                    primary_image_mask,
+                    additional_image_masks[i],
+                    alignment_method
+                )
+                offsets.append((a_off_y, a_off_x))
+
+        shapes = [primary_image.shape[:2], secondary_image.shape[:2]] + [img.shape[:2] for img in additional_images]
+        offsets, shapes = adjust_offsets(offsets, shapes, crop_mode)
+
+        output_images: List[Image2D] = []
+        output_image_masks: List[Image2DMask] = []
+        crop_masks: List[Optional[Union[Image2DMask, ImageBinary]]] = []
+
+        measurements = LibraryMeasurements()
+        image_info: ImageInfo = []
+
+        for i in range(len(offsets)):
+            if i  == 0:
+                input_image = primary_image
+                input_image_mask = primary_image_mask
+                if return_visualization_data:
+                    input_image_name = input_image_names[i] if input_image_names else "Primary Image"
+                    output_image_name = output_image_names[i] if output_image_names else "Primary Image Aligned"
+            elif i  == 1:
+                input_image = secondary_image
+                input_image_mask = secondary_image_mask
+                if return_visualization_data:
+                    input_image_name = input_image_names[i] if input_image_names else "Secondary Image"
+                    output_image_name = output_image_names[i] if output_image_names else "Secondary Image Aligned"
+            else:
+                input_image = additional_images[i-2]
+                input_image_mask = additional_image_masks[i-2]
+                if return_visualization_data:
+                    input_image_name = input_image_names[i] if input_image_names else f"Additional Image {i+1}"
+                    output_image_name = output_image_names[i] if output_image_names else f"Additional Image {i+1} Aligned"
+
+            output_image, output_mask, crop_mask = apply_alignment(
+                input_image,
+                input_image_mask,
+                offsets[i][1],
+                offsets[i][0],
+                shapes[i],
+            )
+
+            output_images.append(output_image)
+            output_image_masks.append(output_mask)
+            crop_masks.append(crop_mask)
+            output_image_name = output_image_names[i] if output_image_names is not None else f"Image{i+1}"
+
+            for axis, value in (("X", -offsets[i][1]), ("Y", -offsets[i][0])):
+                measurements.add_image_measurement(MEASUREMENT_FORMAT % (axis, output_image_name), value)
+
+            if return_visualization_data:
+                image_info.append((
+                    input_image_name,
+                    input_image,
+                    output_image_name,
+                    output_image,
+                    offsets[i][1],
+                    offsets[i][0],
+                    shapes[i]
+                ))
+
+        if return_visualization_data:
+            return (output_images, output_image_masks, crop_masks, measurements), AlignDisplayData(image_info=image_info)
+        return output_images, output_image_masks, crop_masks, measurements
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def align_pair(
+        image1_pixels: Image2D, 
+        image2_pixels: Image2D, 
+        image1_mask: Image2DMask, 
+        image2_mask: Image2DMask, 
+        alignment_method: AlignmentMethod
+    ) -> Tuple[
+        int,
+        int
+    ]:
+    """Align the second image with the first
+    Calculate the alignment offset that must be added to indexes in the
+    first image to arrive at indexes in the second image.
+
+    Returns the x,y (not i,j) offsets.
+    """
+    if alignment_method == AlignmentMethod.CROSS_CORRELATION.value:
+        return align_cross_correlation(image1_pixels, image2_pixels)
+    else: # alignment_method == AlignmentMethod.MUTUAL_INFORMATION.value:
+        return align_mutual_information(
+            image1_pixels, image2_pixels, image1_mask, image2_mask
+        )
+    
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def adjust_offsets(
+        offsets: Annotated[List[Tuple[int, int]], Field(description="Offsets to be adjusted")],
+        shapes: Annotated[List[Tuple[int, int]], Field(description="Shapes of images")],
+        crop_mode: Annotated[CropMode, Field(description="The crop mode determines how the output images are either cropped or padded after alignment")]
+    ) -> Tuple[
+        List[Tuple[int, int]],
+        List[Tuple[int, int]]
+    ]:
+    """Adjust the offsets and shapes for output
+
+    workspace - workspace passed to "run"
+
+    offsets - i,j offsets for each image
+
+    shapes - shapes of the input images
+
+    names - pairs of input / output names
+
+    Based on the crop mode, adjust the offsets and shapes to optimize
+    the cropping.
+    """
+    offsets = np.array(offsets)
+    shapes = np.array(shapes)
+    if crop_mode == CropMode.CROP.value:
+        # modify the offsets so that all are negative
+        max_offset = np.max(offsets, 0)
+        offsets = offsets - max_offset[np.newaxis, :]
+        #
+        # Reduce each shape by the amount chopped off
+        #
+        shapes += offsets
+        #
+        # Pick the smallest in each of the dimensions and repeat for all
+        #
+        shape = np.min(shapes, 0)
+        shapes = np.tile(shape, len(shapes))
+        shapes.shape = offsets.shape
+    elif crop_mode == CropMode.PAD.value:
+        #
+        # modify the offsets so that they are all positive
+        #
+        min_offset = np.min(offsets, 0)
+        offsets = offsets - min_offset[np.newaxis, :]
+        #
+        # Expand each shape by the top-left padding
+        #
+        shapes += offsets
+        #
+        # Pick the largest in each of the dimensions and repeat for all
+        #
+        shape = np.max(shapes, 0)
+        shapes = np.tile(shape, len(shapes))
+        shapes.shape = offsets.shape
+    return offsets.tolist(), shapes.tolist()
+
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def apply_alignment(
+        pixel_data: Annotated[Image2D, Field(description="Pixel data to be aligned")],
+        image_mask: Annotated[Image2DMask, Field(description="Mask of the image to be aligned")],
+        off_x: Annotated[int, Field(description="Offset of the resultant image relative to the original")],
+        off_y: Annotated[int, Field(description="Offset of the resultant image relative to the original")],
+        shape: Annotated[Tuple[int, int], Field(description="Shape of the resultant image")],
+    ) -> Tuple[
+        Image2D, 
+        Image2DMask, 
+        Optional[Union[Image2DMask, ImageBinary]],
+    ]:
+    if pixel_data.ndim == 2:
+        output_shape = (shape[0], shape[1], 1)
+        planes = [pixel_data]
+    else:
+        output_shape = (shape[0], shape[1], pixel_data.shape[2])
+        planes = [pixel_data[:, :, i] for i in range(pixel_data.shape[2])]
+    output_pixels = np.zeros(output_shape, pixel_data.dtype)
+    for i, plane in enumerate(planes):
+        #
+        # Copy the input to the output
+        #
+        p1, p2 = offset_slice(plane, output_pixels[:, :, i], off_y, off_x)
+        p2[:, :] = p1[:, :]
+    if pixel_data.ndim == 2:
+        output_pixels.shape = output_pixels.shape[:2]
+    output_mask = np.zeros(shape, bool)
+    p1, p2 = offset_slice(image_mask, output_mask, off_y, off_x)
+    p2[:, :] = p1[:, :]
+    if np.all(output_mask):
+        output_mask = None
+    crop_mask = np.zeros(pixel_data.shape, bool)
+    p1, p2 = offset_slice(crop_mask, output_pixels, off_y, off_x)
+    p1[:, :] = True
+    if np.all(crop_mask):
+        crop_mask = None
+    return output_pixels, output_mask, crop_mask

{cellprofiler_library_nightly-5.0.0.dev643 → cellprofiler_library_nightly-5.0.0.dev649}/cellprofiler_library/modules/_measureobjectintensity.py

@@ -7,7 +7,7 @@ from pydantic import Field, validate_call, ConfigDict, BaseModel
 from cellprofiler_core.utilities.core.object import crop_labels_and_image
 from cellprofiler_library.types import ImageGrayscale, ImageGrayscaleMask, ObjectLabelSet, Pixel, ObjectLabel
 from cellprofiler_library.measurement_model import LibraryMeasurements
-from cellprofiler_library.functions.measurement import measure_object_area_occupied, measure_integrated_intensity, measure_mean_intensity, measure_std_intensity, measure_min_intensity, measure_max_intensity, measure_max_position, measure_center_of_mass_binary, measure_center_of_mass_intensity, measure_mass_displacement, measure_quartile_intensity
+from cellprofiler_library.functions.measurement import measure_object_area_occupied, measure_integrated_intensity, measure_mean_intensity, measure_std_intensity, measure_min_intensity, measure_max_intensity, measure_max_position, measure_center_of_mass_binary, measure_center_of_mass_intensity, measure_mass_displacement, measure_quartile_intensity, measure_mad_intensity
 from cellprofiler_library.opts.measureobjectintensity import TemplateMeasurementFormat, IntensityFeature
 
 
@@ -216,15 +216,14 @@ def measure_object_intensity(
                 dest[lindexes[qmask_no_upper] - 1] = _dest_no_upper
 
             #
-            # Once again, for the MAD
+            # The MAD = median(|x_i - median(x)|). Compute it as a true
+            # per-object median of the absolute deviations. Reusing the
+            # quartile machinery here would interpolate across value
+            # boundaries for odd-sized objects and give a wrong result.
             #
-            fraction = 1.0/ image_dimensions
-            madimg = numpy.abs(limg - median_intensity[llabels - 1])
-            order = numpy.lexsort((madimg, llabels))
-
-            qmask, _mad_intensity, qmask_no_upper, _mad_intensity_no_upper = measure_quartile_intensity(indices, areas, fraction, madimg, order)
-            mad_intensity[lindexes[qmask] - 1] = _mad_intensity
-            mad_intensity[lindexes[qmask_no_upper] - 1] = _mad_intensity_no_upper
+            mad_intensity[lindexes - 1] = measure_mad_intensity(
+                limg, llabels, lindexes, median_intensity
+            )
 
         emask = masked_outlines > 0
         eimg = img[emask]

cellprofiler_library_nightly-5.0.0.dev649/cellprofiler_library/opts/align.py

@@ -0,0 +1,20 @@
+from enum import Enum
+
+class AlignmentMethod(str, Enum):
+    MUTUAL_INFORMATION = "Mutual Information"
+    CROSS_CORRELATION = "Normalized Cross Correlation"
+
+class CropMode(str, Enum):
+    SAME_SIZE = "Keep size"
+    CROP = "Crop to aligned region"
+    PAD = "Pad images"
+
+class AdditionalAlignmentChoice(str, Enum):
+    SIMILARLY = "Similarly"
+    SEPARATELY = "Separately"
+
+M_ALL = (AlignmentMethod.MUTUAL_INFORMATION, AlignmentMethod.CROSS_CORRELATION)
+
+C_ALIGN = "Align"
+
+MEASUREMENT_FORMAT = C_ALIGN + "_%sshift_%s"

{cellprofiler_library_nightly-5.0.0.dev643 → cellprofiler_library_nightly-5.0.0.dev649/cellprofiler_library_nightly.egg-info}/PKG-INFO

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

@@ -14,6 +14,7 @@ cellprofiler_library/functions/measurement.py
 cellprofiler_library/functions/object_processing.py
 cellprofiler_library/functions/segmentation.py
 cellprofiler_library/modules/__init__.py
+cellprofiler_library/modules/_align.py
 cellprofiler_library/modules/_closing.py
 cellprofiler_library/modules/_colortogray.py
 cellprofiler_library/modules/_combineobjects.py
@@ -67,6 +68,7 @@ cellprofiler_library/modules/_smooth.py
 cellprofiler_library/modules/_threshold.py
 cellprofiler_library/modules/_watershed.py
 cellprofiler_library/opts/__init__.py
+cellprofiler_library/opts/align.py
 cellprofiler_library/opts/colortogray.py
 cellprofiler_library/opts/convertimagetoobjects.py
 cellprofiler_library/opts/convertobjectstoimage.py