CellProfiler-nightly 5.0.0.dev674__tar.gz → 5.0.0.dev686__tar.gz

{cellprofiler_nightly-5.0.0.dev674 → cellprofiler_nightly-5.0.0.dev686}/CellProfiler_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev674
+Version: 5.0.0.dev686
 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.dev686/CellProfiler_nightly.egg-info/scm_version.json

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

{cellprofiler_nightly-5.0.0.dev674 → cellprofiler_nightly-5.0.0.dev686}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CellProfiler-nightly
-Version: 5.0.0.dev674
+Version: 5.0.0.dev686
 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.dev674 → cellprofiler_nightly-5.0.0.dev686}/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.dev674'
-__version_tuple__ = version_tuple = (5, 0, 0, 'dev674')
+__version__ = version = '5.0.0.dev686'
+__version_tuple__ = version_tuple = (5, 0, 0, 'dev686')
 
-__commit_id__ = commit_id = 'g70806405c'
+__commit_id__ = commit_id = 'g0620ff4c4'

{cellprofiler_nightly-5.0.0.dev674 → cellprofiler_nightly-5.0.0.dev686}/cellprofiler/gui/pipelinecontroller.py

@@ -174,6 +174,53 @@ ED_CONTINUE = "Continue"
 ED_SKIP = "Skip"
 
 
+def make_accessible_proxy(button, handler):
+    """Overlay an invisible native wx.Button on top of a wx.lib.buttons.Gen* button
+
+    Gen* buttons (GenBitmapTextButton, etc.) are custom-drawn windows, not native
+    controls, so they don't publish themselves to the OS Accessibility API and
+    are invisible to tools that hint UI elements via that API. A plain
+    wx.Button is backed by a real NSButton and gets picked up automatically, so we
+    stack one behind the Gen* button, mirror its geometry/visibility/enabled state,
+    and route its click to the same handler.
+    """
+    proxy = wx.Button(
+        button.GetParent(), label=button.GetLabel(), style=wx.BORDER_NONE
+    )
+    proxy.Bind(wx.EVT_BUTTON, handler)
+    proxy.Lower()
+    # Keep it out of Tab order: it's a real second control layered behind the
+    # visible one, and without this Tab would stop on it and draw its focus
+    # ring where nothing appears to be.
+    proxy.DisableFocusFromKeyboard()
+
+    def sync_geometry(event=None):
+        proxy.SetSize(button.GetSize())
+        proxy.SetPosition(button.GetPosition())
+        if event is not None:
+            event.Skip()
+
+    def sync_shown(event):
+        proxy.Show(event.IsShown())
+        event.Skip()
+
+    button.Bind(wx.EVT_SIZE, sync_geometry)
+    button.Bind(wx.EVT_MOVE, sync_geometry)
+    button.Bind(wx.EVT_SHOW, sync_shown)
+    sync_geometry()
+    proxy.Show(button.IsShown())
+
+    unproxied_enable = button.Enable
+
+    def enable(enable=True):
+        proxy.Enable(enable)
+        return unproxied_enable(enable)
+
+    button.Enable = enable
+
+    return proxy
+
+
 class PipelineController(object):
     """Controls the pipeline through the UI
 
@@ -695,6 +742,7 @@ class PipelineController(object):
         )
         self.__test_mode_button.Bind(wx.EVT_BUTTON, self.on_debug_toggle)
         self.__test_mode_button.SetToolTip(self.ENTER_TEST_MODE_HELP)
+        make_accessible_proxy(self.__test_mode_button, self.on_debug_toggle)
 
         self.__tcp_launch_sizer.Add(self.__test_mode_button, 1, wx.EXPAND)
 
@@ -704,6 +752,7 @@ class PipelineController(object):
         )
         self.__analyze_images_button.Bind(wx.EVT_BUTTON, self.on_analyze_images)
         self.__analyze_images_button.SetToolTip(self.ANALYZE_IMAGES_HELP)
+        make_accessible_proxy(self.__analyze_images_button, self.on_analyze_images)
 
         self.__tcp_launch_sizer.Add(self.__analyze_images_button, 1, wx.EXPAND)
 
@@ -717,6 +766,7 @@ class PipelineController(object):
         )
         self.__pause_button.Bind(wx.EVT_BUTTON, self.on_pause)
         self.__pause_button.SetToolTip(self.PAUSE_HELP)
+        make_accessible_proxy(self.__pause_button, self.on_pause)
         self.__tcp_analysis_sizer.Add(self.__pause_button, 1, wx.EXPAND)
 
         self.__resume_button = wx.lib.buttons.GenBitmapTextButton(
@@ -724,6 +774,7 @@ class PipelineController(object):
         )
         self.__resume_button.Bind(wx.EVT_BUTTON, self.on_resume)
         self.__resume_button.SetToolTip(self.RESUME_HELP)
+        make_accessible_proxy(self.__resume_button, self.on_resume)
         self.__tcp_analysis_sizer.Add(self.__resume_button, 1, wx.EXPAND)
 
         self.__stop_analysis_button = wx.lib.buttons.GenBitmapTextButton(
@@ -731,6 +782,7 @@ class PipelineController(object):
         )
         self.__stop_analysis_button.Bind(wx.EVT_BUTTON, self.on_stop_running)
         self.__stop_analysis_button.SetToolTip("Cancel the analysis run")
+        make_accessible_proxy(self.__stop_analysis_button, self.on_stop_running)
         self.__tcp_analysis_sizer.Add(self.__stop_analysis_button, 1, wx.EXPAND)
         #
         # Test mode sizer
@@ -745,6 +797,7 @@ class PipelineController(object):
         )
         self.__tcp_continue.SetToolTip(wx.ToolTip("Run to next pause"))
         self.__tcp_continue.Bind(wx.EVT_BUTTON, self.on_debug_continue)
+        make_accessible_proxy(self.__tcp_continue, self.on_debug_continue)
         sub_sizer.Add(self.__tcp_continue, 1, wx.EXPAND)
 
         self.__tcp_step = wx.lib.buttons.GenBitmapTextButton(
@@ -752,6 +805,7 @@ class PipelineController(object):
         )
         self.__tcp_step.SetToolTip(wx.ToolTip("Step to next module"))
         self.__tcp_step.Bind(wx.EVT_BUTTON, self.on_debug_step)
+        make_accessible_proxy(self.__tcp_step, self.on_debug_step)
         sub_sizer.Add(self.__tcp_step, 1, wx.EXPAND)
 
         sub_sizer = wx.BoxSizer(wx.HORIZONTAL)
@@ -762,6 +816,7 @@ class PipelineController(object):
         )
         self.__tcp_stop_testmode.SetToolTip(wx.ToolTip("Exit test mode"))
         self.__tcp_stop_testmode.Bind(wx.EVT_BUTTON, self.on_debug_stop)
+        make_accessible_proxy(self.__tcp_stop_testmode, self.on_debug_stop)
         sub_sizer.Add(self.__tcp_stop_testmode, 1, wx.EXPAND)
 
         next_image_bmp = wx.Bitmap(cellprofiler.icons.get_builtin_image("IMG_IMAGE"))
@@ -770,6 +825,7 @@ class PipelineController(object):
         )
         self.__tcp_next_imageset.SetToolTip(wx.ToolTip("Jump to next image set"))
         self.__tcp_next_imageset.Bind(wx.EVT_BUTTON, self.on_debug_next_image_set)
+        make_accessible_proxy(self.__tcp_next_imageset, self.on_debug_next_image_set)
         sub_sizer.Add(self.__tcp_next_imageset, 1, wx.EXPAND)
 
         self.show_launch_controls()

{cellprofiler_nightly-5.0.0.dev674 → cellprofiler_nightly-5.0.0.dev686}/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.dev674/CellProfiler_nightly.egg-info/scm_version.json

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