CellProfiler-nightly 5.0.0.dev669__tar.gz → 5.0.0.dev684__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev669
+Version: 5.0.0.dev684
 Summary: CellProfiler is a free open-source software designed to enable biologists without training in computer vision or programming to quantitatively measure phenotypes from thousands of images automatically.
 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_nightly-5.0.0.dev684/CellProfiler_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_nightly-5.0.0.dev669 → cellprofiler_nightly-5.0.0.dev684}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev669
+Version: 5.0.0.dev684
 Summary: CellProfiler is a free open-source software designed to enable biologists without training in computer vision or programming to quantitatively measure phenotypes from thousands of images automatically.
 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_nightly-5.0.0.dev669 → cellprofiler_nightly-5.0.0.dev684}/cellprofiler/_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_nightly-5.0.0.dev669 → cellprofiler_nightly-5.0.0.dev684}/cellprofiler/modules/findmaxima.py

@@ -1,3 +1,4 @@
+
 """
 FindMaxima
 ==========
@@ -20,10 +21,7 @@ YES          YES          NO
 ============ ============ ===============
 """
 
-import numpy
-from skimage.feature import peak_local_max
 from skimage.morphology import disk, ball, dilation
-import scipy.ndimage
 
 from cellprofiler_core.image import Image
 from cellprofiler_core.module import ImageProcessing
@@ -31,12 +29,9 @@ from cellprofiler_core.setting import Color, Binary
 from cellprofiler_core.setting.choice import Choice
 from cellprofiler_core.setting.subscriber import ImageSubscriber, LabelSubscriber
 from cellprofiler_core.setting.text import Integer, Float
-from cellprofiler_core.utilities.core.object import overlay_labels
-
-MODE_THRESHOLD = "Threshold"
-MODE_MASK = "Mask"
-MODE_OBJECTS = "Within Objects"
 
+from cellprofiler_library.opts.findmaxima import BackgroundExclusionMode
+from cellprofiler_library.modules._findmaxima import find_maxima
 
 class FindMaxima(ImageProcessing):
     category = "Advanced"
@@ -57,21 +52,21 @@ class FindMaxima(ImageProcessing):
 
         self.exclude_mode = Choice(
             "Method for excluding background",
-            [MODE_THRESHOLD, MODE_MASK, MODE_OBJECTS],
+            [BackgroundExclusionMode.THRESHOLD.value, BackgroundExclusionMode.MASK.value, BackgroundExclusionMode.OBJECTS.value],
             value="Threshold",
             doc=f"""\
 By default, local maxima will be searched for across the whole image. This means
 that maxima will be found in areas that consist entirely of background. To
 resolve this we have several methods to exclude background.
 
-**{MODE_THRESHOLD}** allows you to specify a minimum pixel intensity to be
+**{BackgroundExclusionMode.THRESHOLD.value}** allows you to specify a minimum pixel intensity to be
 considered as a peak. Setting this to 0 effectively uses no threshold.
 
-**{MODE_MASK}** will restrict peaks to areas which are within a provided mask
+**{BackgroundExclusionMode.MASK.value}** will restrict peaks to areas which are within a provided mask
 image. This mask will typically come from the threshold module or another means
 of finding background.
 
-**{MODE_OBJECTS}** will restrict peaks to areas within an existing set of
+**{BackgroundExclusionMode.OBJECTS.value}** will restrict peaks to areas within an existing set of
 objects.
 """,
         )
@@ -143,11 +138,11 @@ images.
             self.exclude_mode,
         ]
 
-        if self.exclude_mode == MODE_THRESHOLD:
+        if self.exclude_mode == BackgroundExclusionMode.THRESHOLD.value:
             result.append(self.min_intensity)
-        elif self.exclude_mode == MODE_MASK:
+        elif self.exclude_mode == BackgroundExclusionMode.MASK.value:
             result.append(self.mask_image)
-        elif self.exclude_mode == MODE_OBJECTS:
+        elif self.exclude_mode == BackgroundExclusionMode.OBJECTS.value:
             result.append(self.mask_objects)
 
         result.append(self.maxima_size)
@@ -173,30 +168,26 @@ images.
 
         x_data = x_data_orig.copy()
 
-        th_abs = None
-
-        if self.exclude_mode.value == MODE_THRESHOLD:
-            th_abs = self.min_intensity.value
-        elif self.exclude_mode.value == MODE_MASK:
-            mask = images.get_image(self.mask_image.value).pixel_data.astype(bool)
-            x_data[~mask] = 0
-        elif self.exclude_mode.value == MODE_OBJECTS:
-            mask_objects = workspace.object_set.get_objects(self.mask_objects.value)
-            mask = mask_objects.segmented.astype(bool)
-            x_data[~mask] = 0
-        else:
-            raise NotImplementedError("Invalid background method choice")
+        min_intensity_value = None
+        target_mask = None
 
-        maxima_coords = peak_local_max(
-            x_data,
-            min_distance=self.min_distance.value,
-            threshold_abs=th_abs,
+        if self.exclude_mode.value == BackgroundExclusionMode.THRESHOLD.value:
+            min_intensity_value = self.min_intensity.value
+        elif self.exclude_mode.value == BackgroundExclusionMode.MASK.value:
+            target_mask = images.get_image(self.mask_image.value).pixel_data
+        elif self.exclude_mode.value == BackgroundExclusionMode.OBJECTS.value:
+            target_mask = workspace.object_set.get_objects(self.mask_objects.value).segmented
+        else:
+            raise NotImplementedError(f"Invalid background method choice: {self.exclude_mode.value}")
+     
+        y_data = find_maxima(
+            x_data, 
+            self.exclude_mode.value, 
+            self.min_distance.value, 
+            self.label_maxima.value,
+            min_intensity_value, 
+            target_mask,
         )
-        y_data = numpy.zeros(x_data.shape, dtype=bool)
-        y_data[tuple(maxima_coords.T)] = True
-
-        if self.label_maxima:
-            y_data = scipy.ndimage.label(y_data)[0]
 
         y = Image(dimensions=dimensions, image=y_data, parent_image=x, convert=False)
 

{cellprofiler_nightly-5.0.0.dev669 → cellprofiler_nightly-5.0.0.dev684}/cellprofiler/modules/makeprojection.py

@@ -62,24 +62,8 @@ from cellprofiler_core.setting.subscriber import ImageSubscriber
 from cellprofiler_core.setting.text import ImageName
 from cellprofiler_core.setting.text.number import Float
 
-P_AVERAGE = "Average"
-P_MAXIMUM = "Maximum"
-P_MINIMUM = "Minimum"
-P_SUM = "Sum"
-P_VARIANCE = "Variance"
-P_POWER = "Power"
-P_BRIGHTFIELD = "Brightfield"
-P_MASK = "Mask"
-P_ALL = [
-    P_AVERAGE,
-    P_MAXIMUM,
-    P_MINIMUM,
-    P_SUM,
-    P_VARIANCE,
-    P_POWER,
-    P_BRIGHTFIELD,
-    P_MASK,
-]
+from cellprofiler_library.modules._makeprojection import makeprojection
+from cellprofiler_library.opts.makeprojection import ProjectionType, P_ALL
 
 K_PROVIDER = "Provider"
 
@@ -102,18 +86,18 @@ class MakeProjection(Module):
             doc="""\
 The final projection image can be created by the following methods:
 
--  *%(P_AVERAGE)s:* Use the average pixel intensity at each pixel
+-  *{P_AVERAGE}:* Use the average pixel intensity at each pixel
    position.
--  *%(P_MAXIMUM)s:* Use the maximum pixel value at each pixel position.
--  *%(P_MINIMUM)s:* Use the minimum pixel value at each pixel position.
--  *%(P_SUM)s:* Add the pixel values at each pixel position.
--  *%(P_VARIANCE)s:* Compute the variance at each pixel position.
+-  *{P_MAXIMUM}:* Use the maximum pixel value at each pixel position.
+-  *{P_MINIMUM}:* Use the minimum pixel value at each pixel position.
+-  *{P_SUM}:* Add the pixel values at each pixel position.
+-  *{P_VARIANCE}:* Compute the variance at each pixel position.
    The variance method is described in Selinummi et al (2009). The
    method is designed to operate on a Z-stack of brightfield images
    taken at different focus planes. Background pixels will have
    relatively uniform illumination whereas cytoplasm pixels will have
    higher variance across the Z-stack.
--  *%(P_POWER)s:* Compute the power at a given frequency at each pixel
+-  *{P_POWER}:* Compute the power at a given frequency at each pixel
    position.
    The power method is experimental. The method computes the power at a
    given frequency through the Z-stack. It might be used with a phase
@@ -122,7 +106,7 @@ The final projection image can be created by the following methods:
    and pixels that vary with the given frequency will have a higher
    score than other pixels with similar variance, but different
    frequencies.
--  *%(P_BRIGHTFIELD)s:* Perform the brightfield projection at each
+-  *{P_BRIGHTFIELD}:* Perform the brightfield projection at each
    pixel position.
    Artifacts such as dust appear as black spots that are most strongly
    resolved at their focal plane with gradually increasing signals
@@ -130,7 +114,7 @@ The final projection image can be created by the following methods:
    appears in the early Z-stacks. These pixels have a high score for the
    variance method but have a reduced score when using the brightfield
    method.
--  *%(P_MASK)s:* Compute a binary image of the pixels that are masked
+-  *{P_MASK}:* Compute a binary image of the pixels that are masked
    in any of the input images.
    The mask method operates on any masks that might have been applied to
    the images in a group. The output is a binary image where the “1”
@@ -151,8 +135,17 @@ References
    4(10): e7497 `(link)`_.
 
 .. _(link): https://doi.org/10.1371/journal.pone.0007497
-"""
-            % globals(),
+""".format(
+            **{
+                "P_AVERAGE": ProjectionType.AVERAGE.value,
+                "P_MAXIMUM": ProjectionType.MAXIMUM.value,
+                "P_MINIMUM": ProjectionType.MINIMUM.value,
+                "P_SUM": ProjectionType.SUM.value,
+                "P_VARIANCE": ProjectionType.VARIANCE.value,
+                "P_POWER": ProjectionType.POWER.value,
+                "P_BRIGHTFIELD": ProjectionType.BRIGHTFIELD.value,
+                "P_MASK": ProjectionType.MASK.value,
+            })
         )
 
         self.projection_image_name = ImageName(
@@ -166,14 +159,16 @@ References
             6.0,
             minval=1.0,
             doc="""\
-*(Used only if "%(P_POWER)s" is selected as the projection method)*
+*(Used only if "{P_PROJECTION}" is selected as the projection method)*
 
 This setting controls the frequency at which the power is measured. A
 frequency of 2 will respond most strongly to pixels that alternate
 between dark and light in successive z-stack slices. A frequency of N
 will respond most strongly to pixels whose brightness cycles every N
-slices."""
-            % globals(),
+slices.""".format(**
+        {
+           "P_PROJECTION": ProjectionType.POWER.value,
+        })
         )
 
     def settings(self):
@@ -186,14 +181,14 @@ slices."""
 
     def visible_settings(self):
         result = [self.image_name, self.projection_type, self.projection_image_name]
-        if self.projection_type == P_POWER:
+        if self.projection_type == ProjectionType.POWER.value:
             result += [self.frequency]
         return result
 
     def prepare_group(self, workspace, grouping, image_numbers):
         """Reset the aggregate image at the start of group processing"""
         if len(image_numbers) > 0:
-            provider = ImageProvider(
+            provider = ImageProvider.create(
                 self.projection_image_name.value,
                 self.projection_type.value,
                 self.frequency.value,
@@ -266,69 +261,37 @@ slices."""
 class ImageProvider(AbstractImage):
     """Provide the image after averaging but before dilation and smoothing"""
 
-    def __init__(self, name, how_to_accumulate, frequency=6):
+    D_NAME = "name"
+    D_FREQUENCY = "frequency"
+    D_METHOD = "method"
+    D_LIBRARY_STATE = "library_accumulator"
+
+    def __init__(self, name, method, frequency=6.0):
         """Construct using a parent provider that does the real work
 
         name - name of the image provided
         """
         super(ImageProvider, self).__init__()
-        self.__name = name
+        self._name = name
+        self.method = ProjectionType(method)
         self.frequency = frequency
-        self.__image = None
-        self.__how_to_accumulate = how_to_accumulate
-        self.__image_count = None
-        self.__cached_image = None
-        #
-        # Variance needs image squared as float64, image sum and count
-        #
-        self.__vsquared = None
-        self.__vsum = None
-        #
-        # Power needs a running sum (reuse vsum), a power image of the mask
-        # and a complex-values image
-        #
-        self.__power_image = None
-        self.__power_mask = None
-        self.__stack_number = 0
-        #
-        # Brightfield needs a maximum and minimum image
-        #
-        self.__bright_max = None
-        self.__bright_min = None
-        self.__norm0 = None
+        self.library_accumulator = None
+        self._cached_image = None
 
-    D_NAME = "name"
-    D_FREQUENCY = "frequency"
-    D_IMAGE = "image"
-    D_HOW_TO_ACCUMULATE = "howtoaccumulate"
-    D_IMAGE_COUNT = "imagecount"
-    D_VSQUARED = "vsquared"
-    D_VSUM = "vsum"
-    D_POWER_IMAGE = "powerimage"
-    D_POWER_MASK = "powermask"
-    D_STACK_NUMBER = "stacknumber"
-    D_BRIGHT_MAX = "brightmax"
-    D_BRIGHT_MIN = "brightmin"
-    D_NORM0 = "norm0"
+    @staticmethod
+    def create(name, how_to_accumulate, frequency=6.0):
+        """Factory method to create the appropriate ImageProvider."""
+        return ImageProvider(name, how_to_accumulate, frequency)
 
     def save_state(self, d):
         """Save the provider state to a dictionary
 
         d - store state in this dictionary
         """
-        d[self.D_NAME] = self.__name
-        d[self.D_FREQUENCY] = self.frequency
-        d[self.D_IMAGE] = self.__image
-        d[self.D_HOW_TO_ACCUMULATE] = self.__how_to_accumulate
-        d[self.D_IMAGE_COUNT] = self.__image_count
-        d[self.D_VSQUARED] = self.__vsquared
-        d[self.D_VSUM] = self.__vsum
-        d[self.D_POWER_IMAGE] = self.__power_image
-        d[self.D_POWER_MASK] = self.__power_mask
-        d[self.D_STACK_NUMBER] = self.__stack_number
-        d[self.D_BRIGHT_MIN] = self.__bright_min
-        d[self.D_BRIGHT_MAX] = self.__bright_max
-        d[self.D_NORM0] = self.__norm0
+        d[ImageProvider.D_NAME] = self._name
+        d[ImageProvider.D_FREQUENCY] = self.frequency
+        d[ImageProvider.D_METHOD] = self.method.value
+        d[ImageProvider.D_LIBRARY_STATE] = self.library_accumulator
 
     @staticmethod
     def restore_from_state(d):
@@ -340,183 +303,56 @@ class ImageProvider(AbstractImage):
         """
         name = d[ImageProvider.D_NAME]
         frequency = d[ImageProvider.D_FREQUENCY]
-        how_to_accumulate = d[ImageProvider.D_HOW_TO_ACCUMULATE]
-        image_provider = ImageProvider(name, how_to_accumulate, frequency)
-        image_provider.__image = d[ImageProvider.D_IMAGE]
-        image_provider.__image_count = d[ImageProvider.D_IMAGE_COUNT]
-        image_provider.__vsquared = d[ImageProvider.D_VSQUARED]
-        image_provider.__vsum = d[ImageProvider.D_VSUM]
-        image_provider.__power_image = d[ImageProvider.D_POWER_IMAGE]
-        image_provider.__power_mask = d[ImageProvider.D_POWER_MASK]
-        image_provider.__stack_number = d[ImageProvider.D_STACK_NUMBER]
-        image_provider.__bright_min = d[ImageProvider.D_BRIGHT_MIN]
-        image_provider.__bright_max = d[ImageProvider.D_BRIGHT_MAX]
-        image_provider.__norm0 = d[ImageProvider.D_NORM0]
-        return image_provider
+        method = d[ImageProvider.D_METHOD]
+        library_accumulator = d.get(ImageProvider.D_LIBRARY_STATE, None)
+        
+        provider = ImageProvider.create(name, method, frequency)
+        provider.library_accumulator = library_accumulator
+        return provider
 
     def reset(self):
         """Reset accumulator at start of groups"""
-        self.__image_count = None
-        self.__image = None
-        self.__cached_image = None
-        self.__vsquared = None
-        self.__vsum = None
-        self.__power_image = None
-        self.__power_mask = None
-        self.__stack_number = 0
-        self.__bright_max = None
-        self.__bright_min = None
+        self.library_accumulator = None
+        self._cached_image = None
 
     @property
     def has_image(self):
-        return self.__image_count is not None
-
-    @property
-    def count(self):
-        return self.__image_count
+        return self.library_accumulator is not None
 
     def set_image(self, image):
-        self.__cached_image = None
-        if image.has_mask:
-            self.__image_count = image.mask.astype(int)
-        else:
-            self.__image_count = numpy.ones(image.pixel_data.shape[:2], int)
-
-        if self.__how_to_accumulate == P_VARIANCE:
-            self.__vsum = image.pixel_data.copy()
-            self.__vsum[~image.mask] = 0
-            self.__image_count = image.mask.astype(int)
-            self.__vsquared = self.__vsum.astype(numpy.float64) ** 2.0
-            return
-
-        if self.__how_to_accumulate == P_POWER:
-            self.__vsum = image.pixel_data.copy()
-            self.__vsum[~image.mask] = 0
-            self.__image_count = image.mask.astype(int)
-            #
-            # e**0 = 1, so the first image is always in the real plane
-            #
-            self.__power_mask = self.__image_count.astype(numpy.complex128).copy()
-            self.__power_image = image.pixel_data.astype(numpy.complex128).copy()
-            self.__stack_number = 1
-            return
-        if self.__how_to_accumulate == P_BRIGHTFIELD:
-            self.__bright_max = image.pixel_data.copy()
-            self.__bright_min = image.pixel_data.copy()
-            self.__norm0 = numpy.mean(image.pixel_data)
-            return
-
-        if self.__how_to_accumulate == P_MASK:
-            self.__image = image.mask
-            return
-
-        self.__image = image.pixel_data.copy()
-        if image.has_mask:
-            nan_value = 1 if self.__how_to_accumulate == P_MINIMUM else 0
-            self.__image[~image.mask] = nan_value
+        self._cached_image = None
+        self.library_accumulator = makeprojection(
+            self.method,
+            image.pixel_data, 
+            image.mask,
+            self.frequency,
+        )
 
     def accumulate_image(self, image):
-        self.__cached_image = None
-        if image.has_mask:
-            self.__image_count += image.mask.astype(int)
-        else:
-            self.__image_count += 1
-        if self.__how_to_accumulate in [P_AVERAGE, P_SUM]:
-            if image.has_mask:
-                self.__image[image.mask] += image.pixel_data[image.mask]
-            else:
-                self.__image += image.pixel_data
-        elif self.__how_to_accumulate == P_MAXIMUM:
-            if image.has_mask:
-                self.__image[image.mask] = numpy.maximum(
-                    self.__image[image.mask], image.pixel_data[image.mask]
-                )
-            else:
-                self.__image = numpy.maximum(image.pixel_data, self.__image)
-        elif self.__how_to_accumulate == P_MINIMUM:
-            if image.has_mask:
-                self.__image[image.mask] = numpy.minimum(
-                    self.__image[image.mask], image.pixel_data[image.mask]
-                )
-            else:
-                self.__image = numpy.minimum(image.pixel_data, self.__image)
-        elif self.__how_to_accumulate == P_VARIANCE:
-            mask = image.mask
-            self.__vsum[mask] += image.pixel_data[mask]
-            self.__vsquared[mask] += image.pixel_data[mask].astype(numpy.float64) ** 2
-        elif self.__how_to_accumulate == P_POWER:
-            multiplier = numpy.exp(
-                2j * numpy.pi * float(self.__stack_number) / self.frequency
-            )
-            self.__stack_number += 1
-            mask = image.mask
-            self.__vsum[mask] += image.pixel_data[mask]
-            self.__power_image[mask] += multiplier * image.pixel_data[mask]
-            self.__power_mask[mask] += multiplier
-        elif self.__how_to_accumulate == P_BRIGHTFIELD:
-            mask = image.mask
-            norm = numpy.mean(image.pixel_data)
-            pixel_data = image.pixel_data * self.__norm0 / norm
-            max_mask = (self.__bright_max < pixel_data) & mask
-            min_mask = (self.__bright_min > pixel_data) & mask
-            self.__bright_min[min_mask] = pixel_data[min_mask]
-            self.__bright_max[max_mask] = pixel_data[max_mask]
-            self.__bright_min[max_mask] = self.__bright_max[max_mask]
-        elif self.__how_to_accumulate == P_MASK:
-            self.__image = self.__image & image.mask
-        else:
-            raise NotImplementedError(
-                "No such accumulation method: %s" % self.__how_to_accumulate
-            )
+        self._cached_image = None
+        
+        pixels = image.pixel_data
+        mask = image.mask if image.has_mask else None
+        
+        self.library_accumulator = self.library_accumulator.accumulate(pixels, mask)
 
     def provide_image(self, image_set):
-        image_count = self.__image_count
-        mask_2d = image_count > 0
-        if self.__how_to_accumulate == P_VARIANCE:
-            ndim_image = self.__vsquared
-        elif self.__how_to_accumulate == P_POWER:
-            ndim_image = self.__power_image
-        elif self.__how_to_accumulate == P_BRIGHTFIELD:
-            ndim_image = self.__bright_max
-        else:
-            ndim_image = self.__image
-        if ndim_image.ndim == 3:
-            image_count = numpy.dstack([image_count] * ndim_image.shape[2])
-        mask = image_count > 0
-        if self.__cached_image is not None:
-            return self.__cached_image
-        if self.__how_to_accumulate == P_AVERAGE:
-            cached_image = self.__image / image_count
-        elif self.__how_to_accumulate == P_VARIANCE:
-            cached_image = numpy.zeros(self.__vsquared.shape, numpy.float32)
-            cached_image[mask] = self.__vsquared[mask] / image_count[mask]
-            cached_image[mask] -= self.__vsum[mask] ** 2 / (image_count[mask] ** 2)
-        elif self.__how_to_accumulate == P_POWER:
-            cached_image = numpy.zeros(image_count.shape, numpy.complex128)
-            cached_image[mask] = self.__power_image[mask]
-            cached_image[mask] -= (
-                self.__vsum[mask] * self.__power_mask[mask] / image_count[mask]
-            )
-            cached_image = (cached_image * numpy.conj(cached_image)).real.astype(
-                numpy.float32
-            )
-        elif self.__how_to_accumulate == P_BRIGHTFIELD:
-            cached_image = numpy.zeros(image_count.shape, numpy.float32)
-            cached_image[mask] = self.__bright_max[mask] - self.__bright_min[mask]
-        elif self.__how_to_accumulate == P_MINIMUM and numpy.any(~mask):
-            cached_image = self.__image.copy()
-            cached_image[~mask] = 0
-        else:
-            cached_image = self.__image
-        cached_image[~mask] = 0
-        if numpy.all(mask) or self.__how_to_accumulate == P_MASK:
-            self.__cached_image = Image(cached_image)
+        """Return the final projected image."""
+        if self._cached_image is not None:
+            return self._cached_image
+            
+        pixels, mask = self.library_accumulator.finalize()
+        
+        if numpy.all(mask):
+            self._cached_image = Image(pixels)
         else:
-            self.__cached_image = Image(cached_image, mask=mask_2d)
-        return self.__cached_image
+            self._cached_image = Image(pixels, mask=mask)
+            
+        return self._cached_image
 
     def get_name(self):
-        return self.__name
+        """Return the name of the output image."""
+        return self._name
 
     def release_memory(self):
         """Don't discard the image at end of image set"""

cellprofiler_nightly-5.0.0.dev669/CellProfiler_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"
-}