cellprofiler-library-nightly 5.0.0.dev669__tar.gz → 5.0.0.dev684__tar.gz

{cellprofiler_library_nightly-5.0.0.dev669/cellprofiler_library_nightly.egg-info → cellprofiler_library_nightly-5.0.0.dev684}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellprofiler-library-nightly
-Version: 5.0.0.dev669
+Version: 5.0.0.dev684
 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.dev669 → cellprofiler_library_nightly-5.0.0.dev684}/cellprofiler_library/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '5.0.0.dev669'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev669')
+__version__ = version = '5.0.0.dev684'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev684')
 
-__commit_id__ = commit_id = 'g51250caf3'
+__commit_id__ = commit_id = 'gf422c7454'

{cellprofiler_library_nightly-5.0.0.dev669 → cellprofiler_library_nightly-5.0.0.dev684}/cellprofiler_library/functions/image_processing.py

@@ -24,6 +24,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 skimage.feature import peak_local_max
 from scipy.fftpack import fft2, ifft2
 from cellprofiler_library.types import (
     ImageGrayscale, ImageGrayscaleMask, 
@@ -3073,3 +3074,34 @@ def get_source_range(
         src_max = source_high
         
     return src_min, src_max
+
+################################################################################
+# FindMaxima
+################################################################################
+
+def find_maxima_in_data(
+        x_data: ImageAny, 
+        min_distance_value: int, 
+        label_maxima: bool, 
+        th_abs: Optional[float]=None
+    ) -> Union[ImageBinary, ObjectSegmentation]:
+    maxima_coords = peak_local_max(
+        x_data,
+        min_distance=min_distance_value,
+        threshold_abs=th_abs,
+    )
+    y_data = numpy.zeros(x_data.shape, dtype=bool)
+    y_data[tuple(maxima_coords.T)] = True
+
+    if label_maxima:
+        y_data = scipy.ndimage.label(y_data)[0]
+    return y_data
+
+def find_maxima_threshold(x_data: ImageAny) -> ImageAny:
+    """Identity function, just returns the input"""
+    return x_data
+
+def apply_target_mask(x_data: ImageAny, masking_image: Union[ImageAny,ObjectSegmentation]) -> ImageAny:
+    mask = masking_image.astype(bool)
+    x_data[~mask] = 0
+    return x_data

cellprofiler_library_nightly-5.0.0.dev684/cellprofiler_library/modules/_findmaxima.py

@@ -0,0 +1,31 @@
+import scipy.ndimage
+from typing import Optional, Annotated, Union
+from pydantic import validate_call, ConfigDict, Field
+from cellprofiler_library.types import ImageAny, ObjectSegmentation, ImageBinary
+from cellprofiler_library.opts.findmaxima import BackgroundExclusionMode
+from cellprofiler_library.functions.image_processing import find_maxima_in_data, find_maxima_threshold, apply_target_mask
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def find_maxima(
+        x_data:              Annotated[ImageAny, Field(description="Input image to search for maxima")],
+        exclude_mode:        Annotated[BackgroundExclusionMode, Field(description="Method for excluding background")],
+        min_distance_value:  Annotated[int, Field(description="Minimum distance between maxima")], #Minimum distance between maxima
+        label_maxima:        Annotated[bool, Field(description="Individually label maxima?")],
+        min_intensity_value: Annotated[Optional[float], Field(description="Specify the minimum intensity of a peak")],
+        target_mask:         Annotated[Optional[Union[ImageAny,ObjectSegmentation]], Field(description="The image or objects to search within")], 
+    ) -> Union[ImageBinary, ObjectSegmentation]:
+    th_abs = min_intensity_value
+
+    if exclude_mode.value == BackgroundExclusionMode.THRESHOLD.value:
+        x_data = find_maxima_threshold(x_data)
+    elif exclude_mode.value == BackgroundExclusionMode.MASK.value:
+        assert target_mask is not None, "Mask image is required for mask mode"
+        x_data = apply_target_mask(x_data, target_mask)
+    elif exclude_mode.value == BackgroundExclusionMode.OBJECTS.value:
+        assert target_mask is not None, "Objects are required for within objects mode"
+        x_data = apply_target_mask(x_data, target_mask)
+    else:
+        raise NotImplementedError("Invalid background method choice")
+    
+    return find_maxima_in_data(x_data, min_distance_value, label_maxima, th_abs)
+

cellprofiler_library_nightly-5.0.0.dev684/cellprofiler_library/modules/_makeprojection.py

@@ -0,0 +1,424 @@
+from functools import partial
+from collections.abc import Callable
+from typing import Any, Tuple, Optional, Annotated, Union, cast
+from typing_extensions import TypeAlias
+from numpy.typing import NDArray
+from pydantic import validate_call, ConfigDict, Field, BaseModel
+import numpy as np
+from cellprofiler_library.types import Image2D, Image2DMask
+from ..opts.makeprojection import ProjectionType
+
+STATE_NOT_INITIALIZED = "Invalid state key. Please initialize the state dictionary with a call to set_projection before calling this function"
+NORM_IS_ZERO = "Norm is zero. Please check your input images"
+REQ_IMG = "Image is required"
+AGG_IMG_MISSING = "Aggregate image missing"
+AGG_VSUM_MISSING = "Aggregate vsum missing"
+AGG_VSQUARED_MISSING = "Aggregate vsquared missing"
+AGG_POWER_MASK_MISSING = "Aggregate power mask missing"
+AGG_POWER_IMAGE_MISSING = "Aggregate power image missing"
+AGG_STACK_NUMBER_MISSING = "Aggregate stack number missing"
+AGG_BRIGHT_MAX_MISSING = "Aggregate bright max mssing"
+AGG_BRIGHT_MIN_MISSING = "Aggregate bright min mssing"
+NORM0_MISSING = "Aggregate norm0 missing"
+POWER_FREQUENCY_NOT_PROVIDED = "Frequency must be provided for Power projection"
+AGG_IMG_MISTYPE = "Aggregate image must be bool mask"
+
+T_PROJECTION_METHOD_INVALID = "Unknown projection method: %s"
+
+
+ProjectionAccumulator: TypeAlias = Callable[
+    [
+        Image2D, # image
+        Optional[Image2DMask], # mask
+    ],
+    "MakeProjectionAccumulator"
+]
+ProjectionFinalizer: TypeAlias = Callable[
+    [],
+    Tuple[Image2D, Image2DMask]
+]
+class MakeProjectionAccumulator(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, 
+        populate_by_name=True
+    )
+
+    accumulate: ProjectionAccumulator
+    finalize: ProjectionFinalizer
+
+@validate_call(config=ConfigDict(arbitrary_types_allowed=True))
+def makeprojection(
+        # set_projection
+        method:     Annotated[ProjectionType, Field(description="The projection method")],
+        # set_projection, accumulate_projection
+        image:      Annotated[Image2D, Field(description="The pixel data of the image to accumulate")],
+        mask:       Annotated[Optional[Image2DMask], Field(description="The mask of the image (True = valid). If None, all pixels are valid")] = None,
+        frequency:  Annotated[float, Field(description="Frequency parameter for Power projection")] = 6.0,
+    ) -> MakeProjectionAccumulator:
+    has_mask = mask is not None
+    if not has_mask:
+        mask = np.ones(image.shape[:2], dtype=bool)
+    agg_image_count = mask.astype(int)
+
+    agg_vsum, agg_vsquared, agg_power_mask, agg_power_image, agg_stack_number, agg_bright_max, agg_bright_min, norm0, agg_image = (None,)*9
+    if method == ProjectionType.VARIANCE:
+        agg_vsum = image.copy()
+        agg_vsum[~mask] = 0
+        agg_vsquared = agg_vsum.astype(np.float64) ** 2.0
+
+    elif method == ProjectionType.POWER:
+        agg_vsum = image.copy()
+        agg_vsum[~mask] = 0
+        #
+        # e**0 = 1 so the first image is always in the real plane
+        #
+        agg_power_mask = agg_image_count.astype(np.complex128).copy()
+        agg_power_image = image.astype(np.complex128).copy()
+        agg_stack_number = np.array(1.)
+
+    elif method == ProjectionType.BRIGHTFIELD:
+        agg_bright_max = image.copy()
+        agg_bright_min = image.copy()
+        norm0 = np.mean(image)
+
+    elif method == ProjectionType.MASK:
+        agg_image = mask
+
+    elif method in (ProjectionType.AVERAGE, ProjectionType.SUM, ProjectionType.MAXIMUM, ProjectionType.MINIMUM):
+        agg_image = image.copy()
+        if has_mask:
+            nan_value = 1 if method == ProjectionType.MINIMUM else 0
+            agg_image[~mask] = nan_value
+
+    else:
+        raise ValueError(T_PROJECTION_METHOD_INVALID % method)
+
+    return MakeProjectionAccumulator(
+        accumulate = partial(
+            accumulate_projection,
+            method=method,
+            agg_image_count=agg_image_count,
+            agg_vsum=agg_vsum,
+            agg_vsquared=agg_vsquared,
+            agg_power_mask=agg_power_mask,
+            agg_power_image=agg_power_image,
+            frequency=frequency,
+            agg_stack_number=agg_stack_number,
+            agg_bright_max=agg_bright_max,
+            agg_bright_min=agg_bright_min,
+            norm0=norm0,
+            agg_image=agg_image,
+        ),
+        finalize = partial(
+            calculate_final_projection,
+            method=method,
+            agg_image_count=agg_image_count,
+            agg_vsum=agg_vsum,
+            agg_vsquared=agg_vsquared,
+            agg_power_image=agg_power_image,
+            agg_power_mask=agg_power_mask,
+            agg_bright_max=agg_bright_max,
+            agg_bright_min=agg_bright_min,
+            agg_image=agg_image,
+        )
+    )
+
+def accumulate_projection(
+        image:      Annotated[Image2D, Field(description="The pixel data of the image to accumulate")],
+        mask:       Annotated[Optional[Image2DMask], Field(description="The mask of the image (True = valid). If None, all pixels are valid")],
+        *,
+        method:           Annotated[ProjectionType, Field(description="The projection method")],
+        agg_image_count:  Annotated[NDArray[np.int_], Field(description="Aggregation of image count")],
+        agg_vsum:         Annotated[Optional[Image2D], Field(description="Aggregation of variance (for methods variance, power)")],
+        agg_vsquared:     Annotated[Optional[NDArray[np.float64]], Field(description="Aggregation of squared variance (for method variance)")],
+        agg_power_mask:   Annotated[Optional[NDArray[np.complex128]], Field(description="Aggregation of power mask (for method power)")],
+        agg_power_image:  Annotated[Optional[NDArray[np.complex128]], Field(description="Aggregation of power image (for method power)")],
+        frequency:        Annotated[float, Field(description="Frequency parameter for Power projection")],
+        agg_stack_number: Annotated[Optional[NDArray[np.float64]], Field(description="Aggregation of stack number (for method power; zero dimensional)")],
+        agg_bright_max:   Annotated[Optional[Image2D], Field(description="Aggregation of max brightfield vals (for method brightfield)")],
+        agg_bright_min:   Annotated[Optional[Image2D], Field(description="Aggregation of min brightfield vals (for method brightfield)")],
+        norm0:            Annotated[Optional[np.floating[Any]], Field(description="Normalization val (for method brightfield)")],
+        agg_image:        Annotated[Optional[Union[Image2DMask, Image2D]], Field(description="Aggregation of image or mask (for methods mask, average, sum, maximum, minimum)")],
+    ) -> MakeProjectionAccumulator:
+    """
+    Accumulate an image into the projection state.
+
+    Args:
+        image: The pixel data of the image to accumulate.
+        mask: The mask of the image (True = valid). If None, all pixels are valid.
+        state: The current accumulation state. Empty dict for first image.
+        method: The projection method.
+        frequency: Frequency parameter for Power projection.
+
+    Returns:
+        Updated state dictionary.
+    """
+    has_mask = mask is not None
+    if has_mask:
+        agg_image_count += mask.astype(int)
+    else:
+        agg_image_count += 1
+    # Ensure mask exists
+    if mask is None:
+        mask = np.ones(image.shape[:2], dtype=bool)
+
+    # Initialize if empty
+
+    if method == ProjectionType.AVERAGE or method == ProjectionType.SUM:
+        assert agg_image is not None, AGG_IMG_MISSING
+        _mut_accumulate_sum(image, mask, agg_image)
+    elif method == ProjectionType.MAXIMUM:
+        assert agg_image is not None, AGG_IMG_MISSING
+        _mut_accumulate_maximum(image, mask, agg_image)
+    elif method == ProjectionType.MINIMUM:
+        assert agg_image is not None, AGG_IMG_MISSING
+        _mut_accumulate_minimum(image, mask, agg_image)
+    elif method == ProjectionType.VARIANCE:
+        assert agg_vsum is not None, AGG_VSUM_MISSING
+        assert agg_vsquared is not None, AGG_VSQUARED_MISSING
+        _mut_accumulate_variance(image, mask, agg_vsum, agg_vsquared)
+    elif method == ProjectionType.POWER:
+        assert frequency is not None, POWER_FREQUENCY_NOT_PROVIDED
+        assert agg_vsum is not None, AGG_VSUM_MISSING
+        assert agg_power_mask is not None, AGG_POWER_MASK_MISSING
+        assert agg_power_image is not None, AGG_POWER_IMAGE_MISSING
+        assert agg_stack_number is not None, AGG_STACK_NUMBER_MISSING
+        _mut_accumulate_power(image, mask, frequency, agg_vsum, agg_power_mask, agg_power_image, agg_stack_number)
+    elif method == ProjectionType.BRIGHTFIELD:
+        assert agg_bright_max is not None, AGG_BRIGHT_MAX_MISSING
+        assert agg_bright_min is not None, AGG_BRIGHT_MIN_MISSING
+        assert norm0 is not None, NORM0_MISSING
+        _mut_accumulate_brightfield(image, mask, norm0, agg_bright_max, agg_bright_min)
+    elif method == ProjectionType.MASK:
+        assert agg_image is not None, AGG_IMG_MISSING
+        assert agg_image.dtype == np.bool_, AGG_IMG_MISTYPE
+        _mut_accumulate_mask(mask, cast(Image2DMask, agg_image))
+    else:
+        raise ValueError(T_PROJECTION_METHOD_INVALID % method)
+
+    return MakeProjectionAccumulator(
+        accumulate = partial(
+            accumulate_projection,
+            method=method,
+            agg_image_count=agg_image_count,
+            agg_vsum=agg_vsum,
+            agg_vsquared=agg_vsquared,
+            agg_power_mask=agg_power_mask,
+            agg_power_image=agg_power_image,
+            frequency=frequency,
+            agg_stack_number=agg_stack_number,
+            agg_bright_max=agg_bright_max,
+            agg_bright_min=agg_bright_min,
+            norm0=norm0,
+            agg_image=agg_image,
+        ),
+        finalize = partial(
+            calculate_final_projection,
+            method=method,
+            agg_image_count=agg_image_count,
+            agg_vsum=agg_vsum,
+            agg_vsquared=agg_vsquared,
+            agg_power_image=agg_power_image,
+            agg_power_mask=agg_power_mask,
+            agg_bright_max=agg_bright_max,
+            agg_bright_min=agg_bright_min,
+            agg_image=agg_image,
+        )
+    )
+
+def calculate_final_projection(
+        *,
+        method:           Annotated[ProjectionType, Field(description="The projection method.")],
+        agg_image_count:  Annotated[NDArray[np.int_], Field(description="Aggregation of image count")],
+        agg_vsum:         Annotated[Optional[Image2D], Field(description="Aggregation of variance (for methods variance, power)")],
+        agg_vsquared:     Annotated[Optional[NDArray[np.float64]], Field(description="Aggregation of squared variance (for method variance)")],
+        agg_power_image:  Annotated[Optional[NDArray[np.complex128]], Field(description="Aggregation of power image (for method power)")],
+        agg_power_mask:   Annotated[Optional[NDArray[np.complex128]], Field(description="Aggregation of power mask (for method power)")],
+        agg_bright_max:   Annotated[Optional[Image2D], Field(description="Aggregation of max brightfield vals (for method brightfield)")],
+        agg_bright_min:   Annotated[Optional[Image2D], Field(description="Aggregation of min brightfield vals (for method brightfield)")],
+        agg_image:        Annotated[Optional[Union[Image2DMask, Image2D]], Field(description="Aggregation of image or mask (for methods mask, average, sum, maximum, minimum)")],
+    ) -> Tuple[Image2D, Image2DMask]:
+    """
+    Calculate the final projection image from the state.
+
+    Args:
+        state: The accumulation state.
+        method: The projection method.
+
+    Returns:
+        Tuple of (pixel_data, mask).
+    """
+    mask_2d = agg_image_count > 0
+    final_projection = None
+    if method == ProjectionType.AVERAGE:
+        assert agg_image is not None, AGG_IMG_MISSING
+        final_projection = _finalize_average(agg_image, agg_image_count)
+    elif method == ProjectionType.SUM:
+        assert agg_image is not None, AGG_IMG_MISSING
+        final_projection = _finalize_sum(agg_image, agg_image_count)
+    elif method == ProjectionType.MAXIMUM:
+        assert agg_image is not None, AGG_IMG_MISSING
+        final_projection = _finalize_maximum(agg_image, agg_image_count)
+    elif method == ProjectionType.MINIMUM:
+        assert agg_image is not None, AGG_IMG_MISSING
+        final_projection = _finalize_minimum(agg_image, agg_image_count)
+    elif method == ProjectionType.VARIANCE:
+        assert agg_vsum is not None, AGG_VSUM_MISSING
+        assert agg_vsquared is not None, AGG_VSQUARED_MISSING
+        final_projection = _finalize_variance(agg_vsum, agg_vsquared, agg_image_count)
+    elif method == ProjectionType.POWER:
+        assert agg_vsum is not None, AGG_VSUM_MISSING
+        assert agg_power_mask is not None, AGG_POWER_MASK_MISSING
+        assert agg_power_image is not None, AGG_POWER_IMAGE_MISSING
+        final_projection = _finalize_power(agg_image_count, agg_power_image, agg_power_mask, agg_vsum)
+    elif method == ProjectionType.BRIGHTFIELD:
+        assert agg_bright_max is not None, AGG_BRIGHT_MAX_MISSING
+        assert agg_bright_min is not None, AGG_BRIGHT_MIN_MISSING
+        final_projection = _finalize_brightfield(agg_image_count, agg_bright_max, agg_bright_min)
+    elif method == ProjectionType.MASK:
+        assert agg_image is not None, AGG_IMG_MISSING
+        final_projection = _finalize_mask(agg_image)
+    else:
+        raise ValueError(T_PROJECTION_METHOD_INVALID % method)
+
+    return final_projection, mask_2d
+
+# --- Helper functions ---
+
+# NOTE: _mut prefix means the function mutates input numpy arrays, rather than returning new arrays
+
+def _mut_accumulate_sum(image: Image2D, mask: Image2DMask, agg_image: Union[Image2DMask, Image2D]):
+    """This function is called by both sum and average projection methods"""
+    agg_image[mask] += image[mask]
+
+def _finalize_sum(agg_image: Union[Image2DMask, Image2D], agg_image_count: NDArray[np.int_]) -> Image2D:
+    mask = agg_image_count > 0
+
+    if np.any(~mask):
+        cached_image = agg_image.copy()
+        cached_image[~mask] = 0
+    else:
+        cached_image = agg_image
+
+    return cached_image
+
+def _finalize_average(agg_image: Union[Image2DMask, Image2D], agg_image_count: NDArray[np.int_]) -> Image2D:
+    # Handle multi-channel image count broadcasting
+    if agg_image.ndim == 3 and agg_image_count.ndim == 2:
+        agg_image_count = np.dstack([agg_image_count] * agg_image.shape[2])
+
+    mask = agg_image_count > 0
+
+    # Avoid divide by zero
+    cached_image = np.zeros_like(agg_image)
+    valid = agg_image_count > 0
+    cached_image[valid] = agg_image[valid] / agg_image_count[valid]
+
+    if cached_image.ndim == 3 and mask.ndim == 2:
+        cached_image[~mask, :] = 0
+    else:
+        cached_image[~mask] = 0
+
+    return cached_image
+
+def _mut_accumulate_maximum(image: Image2D, mask: Image2DMask, agg_image: Union[Image2DMask, Image2D]):
+    agg_image[mask] = np.maximum(agg_image[mask], image[mask])
+
+def _finalize_maximum(agg_image: Union[Image2DMask, Image2D], agg_image_count: NDArray[np.int_]) -> Image2D:
+    # Same finalization logic as SumProvider except it uses the max accumulated image
+    return _finalize_sum(agg_image, agg_image_count)
+
+def _mut_accumulate_minimum(image: Image2D, mask: Image2DMask, agg_image: Union[Image2DMask, Image2D]):
+    agg_image[mask] = np.minimum(agg_image[mask], image[mask])
+
+def _finalize_minimum(agg_image: Union[Image2DMask, Image2D], agg_image_count: NDArray[np.int_]) -> Image2D:
+    return _finalize_sum(agg_image, agg_image_count)
+
+def _mut_accumulate_variance(image: Image2D, mask: Image2DMask, agg_vsum: Image2D, agg_vsquared: NDArray[np.float64]):
+    agg_vsum[mask] += image[mask]
+    agg_vsquared[mask] += image[mask].astype(np.float64) ** 2
+
+def _finalize_variance(agg_vsum: Image2D, agg_vsquared: NDArray[np.float64], agg_image_count: NDArray[np.int_]) -> Image2D:
+    if agg_vsquared.ndim == 3 and agg_image_count.ndim == 2:
+        agg_image_count = np.dstack([agg_image_count] * agg_vsquared.shape[2])
+
+    mask = agg_image_count > 0
+
+    cached_image = np.zeros(agg_vsquared.shape, np.float32)
+
+    # Calculate variance: E[x^2] - (E[x])^2
+
+    valid = mask # logic alias
+    cached_image[valid] = agg_vsquared[valid] / agg_image_count[valid]
+    cached_image[valid] -= (agg_vsum[valid] ** 2) / (agg_image_count[valid] ** 2)
+
+    cached_image[~mask] = 0
+
+    return cached_image
+
+def _mut_accumulate_power(
+        image: Image2D,
+        mask: Image2DMask,
+        frequency: float,
+        agg_vsum: Image2D,
+        agg_power_mask: NDArray[np.complex128],
+        agg_power_image: NDArray[np.complex128],
+        agg_stack_number: NDArray[np.float64],
+    ):
+    multiplier = np.exp(2j * np.pi * agg_stack_number / frequency)
+    agg_stack_number += 1
+
+    agg_vsum[mask] += image[mask]
+    agg_power_image[mask] += multiplier * image[mask]
+    agg_power_mask[mask] += multiplier
+
+def _finalize_power(
+        agg_image_count: NDArray[np.int_],
+        agg_power_image: NDArray[np.complex128],
+        agg_power_mask: NDArray[np.complex128],
+        agg_vsum: Image2D,
+    ) -> Image2D:
+    if agg_power_image.ndim == 3 and agg_image_count.ndim == 2:
+        agg_image_count = np.dstack([agg_image_count] * agg_power_image.shape[2])
+
+    mask = agg_image_count > 0
+
+    cached_image = np.zeros(agg_image_count.shape, np.complex128)
+    cached_image[mask] = agg_power_image[mask]
+    cached_image[mask] -= (agg_vsum[mask] * agg_power_mask[mask] / agg_image_count[mask])
+
+    # |z|^2 = z * conj(z)
+    cached_image = (cached_image * np.conj(cached_image)).real.astype(np.float32)
+    cached_image[~mask] = 0
+
+    return cached_image
+
+def _mut_accumulate_brightfield(image: Image2D, mask: Image2DMask, norm0: np.floating[Any], agg_bright_max: Image2D, agg_bright_min: Image2D):
+    norm = np.mean(image)
+    assert norm != 0, NORM_IS_ZERO
+    pixel_data = image * norm0 / norm
+
+    max_mask = (agg_bright_max < pixel_data) & mask
+    min_mask = (agg_bright_min > pixel_data) & mask
+
+    agg_bright_min[min_mask] = pixel_data[min_mask]
+    agg_bright_max[max_mask] = pixel_data[max_mask]
+    agg_bright_min[max_mask] = agg_bright_max[max_mask]
+
+def _finalize_brightfield(agg_image_count: NDArray[np.int_], agg_bright_max: Image2D, agg_bright_min: Image2D) -> Image2D:
+    if agg_bright_max.ndim == 3 and agg_image_count.ndim == 2:
+        agg_image_count = np.dstack([agg_image_count] * agg_bright_max.shape[2])
+
+    mask = agg_image_count > 0
+
+    cached_image = np.zeros(agg_image_count.shape, np.float32)
+    cached_image[mask] = agg_bright_max[mask] - agg_bright_min[mask]
+    cached_image[~mask] = 0
+
+    return cached_image
+
+def _mut_accumulate_mask(mask: Image2DMask, agg_image: Image2DMask):
+    agg_image &= mask
+
+def _finalize_mask(agg_image: Union[Image2DMask, Image2D]) -> Image2D:
+    return agg_image

cellprofiler_library_nightly-5.0.0.dev684/cellprofiler_library/opts/findmaxima.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class BackgroundExclusionMode(str, Enum):
+    """Background exclusion method"""
+    THRESHOLD = "Threshold"
+    MASK = "Mask"
+    OBJECTS = "Within Objects"

cellprofiler_library_nightly-5.0.0.dev684/cellprofiler_library/opts/makeprojection.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+class ProjectionType(str, Enum):
+    AVERAGE = "Average"
+    MAXIMUM = "Maximum"
+    MINIMUM = "Minimum"
+    SUM = "Sum"
+    VARIANCE = "Variance"
+    POWER = "Power"
+    BRIGHTFIELD = "Brightfield"
+    MASK = "Mask"
+
+P_ALL = [
+    ProjectionType.AVERAGE.value,
+    ProjectionType.MAXIMUM.value,
+    ProjectionType.MINIMUM.value,
+    ProjectionType.SUM.value,
+    ProjectionType.VARIANCE.value,
+    ProjectionType.POWER.value,
+    ProjectionType.BRIGHTFIELD.value,
+    ProjectionType.MASK.value,
+]

{cellprofiler_library_nightly-5.0.0.dev669 → cellprofiler_library_nightly-5.0.0.dev684/cellprofiler_library_nightly.egg-info}/PKG-INFO

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

@@ -31,6 +31,7 @@ cellprofiler_library/modules/_erodeobjects.py
 cellprofiler_library/modules/_expandorshrinkobjects.py
 cellprofiler_library/modules/_fillobjects.py
 cellprofiler_library/modules/_filterobjects.py
+cellprofiler_library/modules/_findmaxima.py
 cellprofiler_library/modules/_flipandrotate.py
 cellprofiler_library/modules/_gaussianfilter.py
 cellprofiler_library/modules/_graytocolor.py
@@ -39,6 +40,7 @@ cellprofiler_library/modules/_identifyprimaryobjects.py
 cellprofiler_library/modules/_identifysecondaryobjects.py
 cellprofiler_library/modules/_identifytertiaryobjects.py
 cellprofiler_library/modules/_imagemath.py
+cellprofiler_library/modules/_makeprojection.py
 cellprofiler_library/modules/_measurecolocalization.py
 cellprofiler_library/modules/_measuregranularity.py
 cellprofiler_library/modules/_measureimageareaoccupied.py
@@ -83,6 +85,7 @@ cellprofiler_library/opts/enhanceorsuppressfeatures.py
 cellprofiler_library/opts/erodeimage.py
 cellprofiler_library/opts/erodeobjects.py
 cellprofiler_library/opts/filterobjects.py
+cellprofiler_library/opts/findmaxima.py
 cellprofiler_library/opts/flipandrotate.py
 cellprofiler_library/opts/graytocolor.py
 cellprofiler_library/opts/identifydeadworms.py
@@ -90,6 +93,7 @@ cellprofiler_library/opts/identifyprimaryobjects.py
 cellprofiler_library/opts/identifysecondaryobjects.py
 cellprofiler_library/opts/identifytertiaryobjects.py
 cellprofiler_library/opts/imagemath.py
+cellprofiler_library/opts/makeprojection.py
 cellprofiler_library/opts/measurecolocalization.py
 cellprofiler_library/opts/measuregranularity.py
 cellprofiler_library/opts/measureimageareaoccupied.py

{cellprofiler_library_nightly-5.0.0.dev669 → cellprofiler_library_nightly-5.0.0.dev684}/cellprofiler_library_nightly.egg-info/scm_file_list.json

@@ -28,6 +28,7 @@
     "cellprofiler_library/modules/_expandorshrinkobjects.py",
     "cellprofiler_library/modules/_fillobjects.py",
     "cellprofiler_library/modules/_filterobjects.py",
+    "cellprofiler_library/modules/_findmaxima.py",
     "cellprofiler_library/modules/_flipandrotate.py",
     "cellprofiler_library/modules/_gaussianfilter.py",
     "cellprofiler_library/modules/_graytocolor.py",
@@ -36,6 +37,7 @@
     "cellprofiler_library/modules/_identifysecondaryobjects.py",
     "cellprofiler_library/modules/_identifytertiaryobjects.py",
     "cellprofiler_library/modules/_imagemath.py",
+    "cellprofiler_library/modules/_makeprojection.py",
     "cellprofiler_library/modules/_measurecolocalization.py",
     "cellprofiler_library/modules/_measuregranularity.py",
     "cellprofiler_library/modules/_measureimageareaoccupied.py",
@@ -80,6 +82,7 @@
     "cellprofiler_library/opts/erodeimage.py",
     "cellprofiler_library/opts/erodeobjects.py",
     "cellprofiler_library/opts/filterobjects.py",
+    "cellprofiler_library/opts/findmaxima.py",
     "cellprofiler_library/opts/flipandrotate.py",
     "cellprofiler_library/opts/graytocolor.py",
     "cellprofiler_library/opts/identifydeadworms.py",
@@ -87,6 +90,7 @@
     "cellprofiler_library/opts/identifysecondaryobjects.py",
     "cellprofiler_library/opts/identifytertiaryobjects.py",
     "cellprofiler_library/opts/imagemath.py",
+    "cellprofiler_library/opts/makeprojection.py",
     "cellprofiler_library/opts/measurecolocalization.py",
     "cellprofiler_library/opts/measuregranularity.py",
     "cellprofiler_library/opts/measureimageareaoccupied.py",

cellprofiler_library_nightly-5.0.0.dev684/cellprofiler_library_nightly.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "5.0.0.dev0",
+  "distance": 684,
+  "node": "gf422c7454d49d65553b3b1e14d292b4b64b3b70c",
+  "dirty": true,
+  "branch": "main",
+  "node_date": "2026-08-28"
+}

cellprofiler_library_nightly-5.0.0.dev669/cellprofiler_library_nightly.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "5.0.0.dev0",
-  "distance": 669,
-  "node": "g51250caf343cdf434f15b90b277ba794c7510c79",
-  "dirty": true,
-  "branch": "main",
-  "node_date": "2026-08-21"
-}