feat: opt finding most common label on proj, tooltips

Co-authored-by: Copilot <copilot@github.com>

Author: Teranis

cellacdc/docs/source/tooltips.rst

@@ -447,7 +447,7 @@ Edit tools: Segmentation and tracking
     * Note: right-click on a background ROI to remove it.
     * HELP: Use this function if you need to set the background level specific for each object. Cell-ACDC will save the metrics `amount`, `concentration` and `corrected_mean` where the background correction will be performed by subtracting the mean of the signal in the background ROI (for each object).
 * **Delete everything outside segmented areas (** |delObjsOutSegmMaskAction| **):** Select a segmentation file and delete everything outside segmented area.
-* **Hull contour (** |hullContToolButton| **"K"):** Right-click on a cell to replace it with its hull contour. Use it to fill cracks and holes. Shift right click fill holes of the entire 3D object.
+* **Hull contour (** |hullContToolButton| **"K"):** Right-click on a cell to replace it with its hull contour. Use it to fill cracks and holes. Shift right click to apply hull to the entire 3D object.
 * **Fill holes (** |fillHolesToolButton| **"F"):** Right-click on a cell to fill holes. Shift right click fill holes of the entire 3D object.
 * **Move object mask (** |moveLabelToolButton| **"P"):** Right-click drag and drop a labels to move it around.
 * **Expand/Shrink object mask (** |expandLabelToolButton| **"E"):** Leave mouse cursor on the label you want to expand/shrink and press arrow up/down on the keyboard to expand/shrink the mask.

cellacdc/precompiled/precompiled_functions.cp313-win_amd64.pyd

@@ -128,6 +128,115 @@ def find_all_objects_3D(np.uint32_t[:, :, :] label_img):
             idx += 1
     return out_labels, out_bboxes
 
+def most_common_projection_3D(np.uint32_t[:, :, :] lab, int axis):
+    """Most-common-value projection for a 3-D label image along `axis`.
+
+    Tie-break matches np.unique(..., return_counts=True) + np.argmax(counts),
+    i.e. the smallest label wins when counts are equal.
+    """
+    if axis < 0 or axis > 2:
+        raise ValueError(f'axis must be 0, 1, or 2. Got {axis}.')
+
+    cdef Py_ssize_t z = lab.shape[0]
+    cdef Py_ssize_t y = lab.shape[1]
+    cdef Py_ssize_t x = lab.shape[2]
+    cdef Py_ssize_t i, j, a, b, depth
+    cdef unsigned int v, vv
+    cdef unsigned int best_label, best_count, curr_count
+    cdef bint seen
+    cdef np.uint32_t[:, :] out_view
+
+    if axis == 0:
+        depth = z
+        out = np.empty((y, x), dtype=np.uint32)
+        out_view = out
+        for i in range(y):
+            for j in range(x):
+                best_count = 0
+                best_label = UINT_MAX
+                for a in range(depth):
+                    v = lab[a, i, j]
+                    seen = False
+                    for b in range(a):
+                        if lab[b, i, j] == v:
+                            seen = True
+                            break
+                    if seen:
+                        continue
+
+                    curr_count = 1
+                    for b in range(a + 1, depth):
+                        if lab[b, i, j] == v:
+                            curr_count += 1
+
+                    if curr_count > best_count or (curr_count == best_count and v < best_label):
+                        best_count = curr_count
+                        best_label = v
+
+                out_view[i, j] = best_label
+        return out
+
+    if axis == 1:
+        depth = y
+        out = np.empty((z, x), dtype=np.uint32)
+        out_view = out
+        for i in range(z):
+            for j in range(x):
+                best_count = 0
+                best_label = UINT_MAX
+                for a in range(depth):
+                    v = lab[i, a, j]
+                    seen = False
+                    for b in range(a):
+                        if lab[i, b, j] == v:
+                            seen = True
+                            break
+                    if seen:
+                        continue
+
+                    curr_count = 1
+                    for b in range(a + 1, depth):
+                        if lab[i, b, j] == v:
+                            curr_count += 1
+
+                    if curr_count > best_count or (curr_count == best_count and v < best_label):
+                        best_count = curr_count
+                        best_label = v
+
+                out_view[i, j] = best_label
+        return out
+
+    depth = x
+    out = np.empty((z, y), dtype=np.uint32)
+    out_view = out
+    for i in range(z):
+        for j in range(y):
+            best_count = 0
+            best_label = UINT_MAX
+            for a in range(depth):
+                v = lab[i, j, a]
+                seen = False
+                for b in range(a):
+                    vv = lab[i, j, b]
+                    if vv == v:
+                        seen = True
+                        break
+                if seen:
+                    continue
+
+                curr_count = 1
+                for b in range(a + 1, depth):
+                    vv = lab[i, j, b]
+                    if vv == v:
+                        curr_count += 1
+
+                if curr_count > best_count or (curr_count == best_count and v < best_label):
+                    best_count = curr_count
+                    best_label = v
+
+            out_view[i, j] = best_label
+    return out
+
 def calc_IoA_matrix_2D(
         np.uint32_t[:, :] lab,
         np.uint32_t[:, :] prev_lab,

cellacdc/precompiled_functions.pyx

@@ -1,5 +1,6 @@
 import numpy as np
 from scipy import ndimage as ndi
+from scipy import stats as scipy_stats
 import skimage.measure
 import cv2
 from . import printl, debugutils
@@ -9,10 +10,19 @@
 import traceback as traceback
 
 try:
-    from cellacdc.precompiled.precompiled_functions import find_all_objects_2D, find_all_objects_3D
+    from cellacdc.precompiled.precompiled_functions import (
+        find_all_objects_2D,
+        find_all_objects_3D,
+    )
     _CYTHON_FIND_OBJECTS = True
 except Exception:
     _CYTHON_FIND_OBJECTS = False
+
+try:
+    from cellacdc.precompiled.precompiled_functions import most_common_projection_3D
+    _CYTHON_MOST_COMMON_PROJECTION = True
+except Exception:
+    _CYTHON_MOST_COMMON_PROJECTION = False
 # WARNING: Developers have already used
 #     14 hrs
 # to optimize this.
@@ -475,13 +485,7 @@ def _get_lab_projection(self, lab, slicing='z', kind='max'):
             return np.max(lab, axis=axis)
 
         if kind == 'most_common':
-            moved = np.moveaxis(lab, axis, 0)
-            flat = moved.reshape(moved.shape[0], -1)
-            projected_flat = np.empty(flat.shape[1], dtype=lab.dtype)
-            for i in range(flat.shape[1]):
-                values, counts = np.unique(flat[:, i], return_counts=True)
-                projected_flat[i] = values[np.argmax(counts)]
-            return projected_flat.reshape(moved.shape[1:])
+            return self._compute_most_common_projection(lab, axis=axis)
 
         if kind == 'mean':
             projected = np.mean(lab, axis=axis)
@@ -491,6 +495,47 @@ def _get_lab_projection(self, lab, slicing='z', kind='max'):
         # Regionprops requires integer labels.
         return np.rint(projected).astype(lab.dtype, copy=False)
 
+    def _compute_most_common_projection(self, lab, axis):
+        if _CYTHON_MOST_COMMON_PROJECTION:
+            lab_uint32 = lab.astype(np.uint32, copy=False)
+            projected = most_common_projection_3D(lab_uint32, int(axis))
+            return projected.astype(lab.dtype, copy=False)
+
+        moved = np.moveaxis(lab, axis, 0)
+        projected = scipy_stats.mode(moved, axis=0, keepdims=False).mode
+        return projected.astype(lab.dtype, copy=False)
+
+    def _get_projection_patch_slices(self, slicing, cutout_bbox):
+        z0, y0, x0, z1, y1, x1 = [int(v) for v in cutout_bbox]
+        if slicing == 'z':
+            return (slice(y0, y1), slice(x0, x1))
+        if slicing == 'y':
+            return (slice(z0, z1), slice(x0, x1))
+        return (slice(z0, z1), slice(y0, y1))
+
+    def _compute_most_common_projection_patch(self, slicing, cutout_bbox):
+        z0, y0, x0, z1, y1, x1 = [int(v) for v in cutout_bbox]
+        if slicing == 'z':
+            patch_lab = self.lab[:, y0:y1, x0:x1]
+        elif slicing == 'y':
+            patch_lab = self.lab[z0:z1, :, x0:x1]
+        else:
+            patch_lab = self.lab[z0:z1, y0:y1, :]
+
+        axis = self._slice_axis_index(slicing)
+        return self._compute_most_common_projection(patch_lab, axis=axis)
+
+    def _update_cached_most_common_projection_locally(self, slicing, cutout_bbox):
+        lab_proj = self._get_cached_or_new_lab_projection(slicing, 'most_common')
+        patch_slices = self._get_projection_patch_slices(slicing, cutout_bbox)
+        if any(slc.start >= slc.stop for slc in patch_slices):
+            return lab_proj
+
+        patch = self._compute_most_common_projection_patch(slicing, cutout_bbox)
+        lab_proj[patch_slices] = patch
+        self._proj_labs[slicing]['most_common'] = lab_proj
+        return lab_proj
+
     def _get_cached_or_new_lab_projection(self, slicing, kind):
         lab_proj = self._proj_labs[slicing].get(kind)
         if lab_proj is None:
@@ -581,12 +626,21 @@ def _sync_initialized_slice_rps_via_update(self, specific_IDs_update_centroids=N
                 specific_IDs_update_centroids=specific_IDs_update_centroids,
             )
 
-    def _sync_initialized_proj_rps_via_update(self, specific_IDs_update_centroids=None):
+    def _sync_initialized_proj_rps_via_update(
+            self,
+            specific_IDs_update_centroids=None,
+            cutout_bbox=None,
+        ):
         if not self._has_initialized_proj_rps():
             return
 
         for slicing, kind, rp in self._iter_initialized_proj_rps():
-            lab_proj = self._replace_cached_lab_projection(slicing, kind)
+            if cutout_bbox is not None and kind == 'most_common':
+                lab_proj = self._update_cached_most_common_projection_locally(
+                    slicing, cutout_bbox
+                )
+            else:
+                lab_proj = self._replace_cached_lab_projection(slicing, kind)
             rp.update_regionprops(
                 lab_proj,
                 specific_IDs_update_centroids=specific_IDs_update_centroids,
@@ -1083,7 +1137,8 @@ def update_regionprops_via_cutout(
             specific_IDs_update_centroids=target_IDs
         )
         self._sync_initialized_proj_rps_via_update(
-            specific_IDs_update_centroids=target_IDs
+            specific_IDs_update_centroids=target_IDs,
+            cutout_bbox=cutout_bbox,
         )
 
     def get_centroid(self, ID, exact=False):

cellacdc/regionprops.py

@@ -153,6 +153,36 @@ def test_projection_regionprops_support_most_common_kind():
     assert rp.get_obj_from_proj_rp(3, kind='most common z-projection', warn=False) is not None
 
 
+def test_most_common_projection_uses_local_cutout_update(monkeypatch):
+    old_lab = np.zeros((3, 6, 6), dtype=np.uint16)
+    old_lab[:, 1:4, 1:4] = 1
+
+    rp = acdcRegionprops(old_lab)
+    proj_before = rp.get_proj_rp(kind='most_common', slicing='z')
+    expected_before = rp._get_lab_projection(old_lab, slicing='z', kind='most_common')
+    np.testing.assert_array_equal(proj_before.lab, expected_before)
+
+    new_lab = old_lab.copy()
+    new_lab[0:2, 2:5, 2:5] = 2
+
+    original_replace_cached = rp._replace_cached_lab_projection
+
+    def _replace_cached_should_not_run_for_most_common(slicing, kind):
+        if kind == 'most_common':
+            raise AssertionError(
+                'most_common projection should be updated locally for cutout updates.'
+            )
+        return original_replace_cached(slicing, kind)
+
+    monkeypatch.setattr(rp, '_replace_cached_lab_projection', _replace_cached_should_not_run_for_most_common)
+
+    rp.update_regionprops_via_cutout(new_lab, cutout_bbox=(2, 2, 5, 5))
+
+    proj_after = rp.get_proj_rp(kind='most_common', slicing='z')
+    expected_after = rp._get_lab_projection(new_lab, slicing='z', kind='most_common')
+    np.testing.assert_array_equal(proj_after.lab, expected_after)
+
+
 def test_get_obj_from_id_for_stored_slice_and_projection_rps():
     lab = np.zeros((4, 8, 8), dtype=np.uint16)
     lab[1:3, 2:5, 3:6] = 2