From 3de221264ae5c2fee2e97768d6c68bb0a303b08c Mon Sep 17 00:00:00 2001
From: Paul Elliott <paul@vizworkshop.com>
Date: Sat, 27 Jun 2026 14:12:02 -0400
Subject: [PATCH 1/3] feat(paint): add fill holes segmentation process

Fill Holes fills enclosed background regions in a segment group on a slice.

Options select current-slice vs whole-volume and all-segments vs the selected segment.

Only background voxels are filled, so existing segments are never overwritten.

Fill Holes is the default process.
---
 src/components/FillHolesParameterControls.vue |  77 +++++++++
 src/components/ProcessControls.vue            |   9 +
 src/components/ProcessTypeSelector.vue        |  14 +-
 src/components/ProcessWorkflow.vue            |  12 +-
 .../tools/paint/__tests__/fillHoles.spec.ts   | 162 ++++++++++++++++++
 src/core/tools/paint/fillHoles.ts             | 159 +++++++++++++++++
 src/store/tools/fillHoles.ts                  |  80 +++++++++
 src/store/tools/paintProcess.ts               |   3 +-
 tests/pageobjects/volview.page.ts             |  67 ++++++++
 tests/specs/paint-fill-holes.e2e.ts           |  55 ++++++
 10 files changed, 626 insertions(+), 12 deletions(-)
 create mode 100644 src/components/FillHolesParameterControls.vue
 create mode 100644 src/core/tools/paint/__tests__/fillHoles.spec.ts
 create mode 100644 src/core/tools/paint/fillHoles.ts
 create mode 100644 src/store/tools/fillHoles.ts
 create mode 100644 tests/specs/paint-fill-holes.e2e.ts

diff --git a/src/components/FillHolesParameterControls.vue b/src/components/FillHolesParameterControls.vue
new file mode 100644
index 000000000..a4b2d21f4
--- /dev/null
+++ b/src/components/FillHolesParameterControls.vue
@@ -0,0 +1,77 @@
+<template>
+  <div class="d-flex align-center">
+    <mini-expansion-panel>
+      <template #title>Fill enclosed holes in the segmentation.</template>
+      <ul>
+        <li>Finds background regions fully enclosed by segments on a slice.</li>
+        <li>
+          Fills holes on the current slice by default, or every slice of the
+          active view's axis.
+        </li>
+        <li>
+          All-segments mode fills each hole with the surrounding segment's
+          label; selected-segment mode fills only the active segment's holes.
+        </li>
+      </ul>
+    </mini-expansion-panel>
+  </div>
+
+  <div class="w-100 px-4 mb-3 d-flex flex-column align-center">
+    <div class="text-caption mb-1">Slices</div>
+    <v-btn-toggle
+      :model-value="sliceScope"
+      density="compact"
+      variant="outlined"
+      divided
+      mandatory
+      :disabled="isDisabled"
+      @update:model-value="setSliceScope"
+    >
+      <v-btn :value="FillHolesSliceScope.CurrentSlice" size="small">
+        Current slice
+      </v-btn>
+      <v-btn :value="FillHolesSliceScope.WholeVolume" size="small">
+        All slices
+      </v-btn>
+    </v-btn-toggle>
+  </div>
+
+  <div class="w-100 px-4 mb-4 d-flex flex-column align-center">
+    <div class="text-caption mb-1">Segments</div>
+    <v-btn-toggle
+      :model-value="segmentScope"
+      density="compact"
+      variant="outlined"
+      divided
+      mandatory
+      :disabled="isDisabled"
+      @update:model-value="setSegmentScope"
+    >
+      <v-btn :value="FillHolesSegmentScope.AllSegments" size="small">
+        All segments
+      </v-btn>
+      <v-btn :value="FillHolesSegmentScope.SelectedSegment" size="small">
+        Selected segment
+      </v-btn>
+    </v-btn-toggle>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { computed } from 'vue';
+import {
+  useFillHolesStore,
+  FillHolesSliceScope,
+  FillHolesSegmentScope,
+} from '@/src/store/tools/fillHoles';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
+import MiniExpansionPanel from './MiniExpansionPanel.vue';
+
+const fillHolesStore = useFillHolesStore();
+const processStore = usePaintProcessStore();
+
+const sliceScope = computed(() => fillHolesStore.sliceScope);
+const segmentScope = computed(() => fillHolesStore.segmentScope);
+const isDisabled = computed(() => processStore.processStep === 'previewing');
+const { setSliceScope, setSegmentScope } = fillHolesStore;
+</script>
diff --git a/src/components/ProcessControls.vue b/src/components/ProcessControls.vue
index a1b40b660..78b22493f 100644
--- a/src/components/ProcessControls.vue
+++ b/src/components/ProcessControls.vue
@@ -2,6 +2,11 @@
   <div class="d-flex flex-column align-center w-100">
     <ProcessTypeSelector />
 
+    <template v-if="activeProcessType === ProcessType.FillHoles">
+      <FillHolesParameterControls />
+      <ProcessWorkflow :algorithm="fillHolesAlgorithm" />
+    </template>
+
     <template v-if="activeProcessType === ProcessType.FillBetween">
       <FillBetweenParameterControls />
       <ProcessWorkflow :algorithm="fillBetweenAlgorithm" />
@@ -24,15 +29,19 @@ import ProcessTypeSelector from './ProcessTypeSelector.vue';
 import ProcessWorkflow from './ProcessWorkflow.vue';
 import FillBetweenParameterControls from './FillBetweenParameterControls.vue';
 import GaussianSmoothParameterControls from './GaussianSmoothParameterControls.vue';
+import FillHolesParameterControls from './FillHolesParameterControls.vue';
 import { useFillBetweenStore } from '../store/tools/fillBetween';
 import { useGaussianSmoothStore } from '../store/tools/gaussianSmooth';
+import { useFillHolesStore } from '../store/tools/fillHoles';
 
 const processStore = usePaintProcessStore();
 const fillBetweenStore = useFillBetweenStore();
 const gaussianSmoothStore = useGaussianSmoothStore();
+const fillHolesStore = useFillHolesStore();
 
 const activeProcessType = computed(() => processStore.activeProcessType);
 
 const fillBetweenAlgorithm = fillBetweenStore.computeAlgorithm;
 const gaussianSmoothAlgorithm = gaussianSmoothStore.computeAlgorithm;
+const fillHolesAlgorithm = fillHolesStore.computeAlgorithm;
 </script>
diff --git a/src/components/ProcessTypeSelector.vue b/src/components/ProcessTypeSelector.vue
index 49cd5ecba..2d863e8aa 100644
--- a/src/components/ProcessTypeSelector.vue
+++ b/src/components/ProcessTypeSelector.vue
@@ -4,8 +4,20 @@
       v-model="activeProcessType"
       mandatory
       selected-class="selected"
-      class="d-flex align-center justify-center"
+      class="d-flex align-center justify-center flex-wrap"
     >
+      <v-item :value="ProcessType.FillHoles" v-slot="{ selectedClass, toggle }">
+        <v-btn
+          variant="tonal"
+          rounded="8"
+          stacked
+          :class="['process-button', 'mx-2', selectedClass]"
+          @click.stop="toggle"
+        >
+          <v-icon>mdi-format-color-fill</v-icon>
+          <span class="text-caption">Fill Holes</span>
+        </v-btn>
+      </v-item>
       <v-item
         :value="ProcessType.FillBetween"
         v-slot="{ selectedClass, toggle }"
diff --git a/src/components/ProcessWorkflow.vue b/src/components/ProcessWorkflow.vue
index 25c802ee7..dd86bcfa4 100644
--- a/src/components/ProcessWorkflow.vue
+++ b/src/components/ProcessWorkflow.vue
@@ -16,17 +16,16 @@
       <v-btn-toggle
         v-if="processStep === 'previewing'"
         :model-value="showingOriginal ? 0 : 1"
-        @update:model-value="handleToggleChange"
         mandatory
         variant="outlined"
         divided
         density="compact"
       >
-        <v-btn :value="0" size="small">
+        <v-btn :value="0" size="small" @click="processStore.togglePreview()">
           <v-icon start size="small">mdi-eye-outline</v-icon>
           Original
         </v-btn>
-        <v-btn :value="1" size="small">
+        <v-btn :value="1" size="small" @click="processStore.togglePreview()">
           <v-icon start size="small">mdi-eye-settings</v-icon>
           Processed
         </v-btn>
@@ -76,13 +75,6 @@ function startCompute() {
   processStore.startProcess(id, props.algorithm);
 }
 
-function handleToggleChange(value: number) {
-  const shouldShowOriginal = value === 0;
-  if (shouldShowOriginal !== showingOriginal.value) {
-    processStore.togglePreview();
-  }
-}
-
 function handleCancel() {
   processStore.cancelProcess();
 }
diff --git a/src/core/tools/paint/__tests__/fillHoles.spec.ts b/src/core/tools/paint/__tests__/fillHoles.spec.ts
new file mode 100644
index 000000000..59ef7e50d
--- /dev/null
+++ b/src/core/tools/paint/__tests__/fillHoles.spec.ts
@@ -0,0 +1,162 @@
+import { describe, it, expect } from 'vitest';
+import { fillHoles } from '../fillHoles';
+
+// Build a flat single-slice label map (axis 2, k=0) from a 2D grid.
+// grid[j][i] maps to flat index i + j*dimI.
+function flatFromGrid(grid: number[][]) {
+  const dimI = grid[0].length;
+  const dimJ = grid.length;
+  const data = new Uint8Array(grid.flat());
+  return { data, dimensions: [dimI, dimJ, 1] as [number, number, number] };
+}
+
+describe('fillHoles', () => {
+  it('fills a background hole enclosed by a single segment', () => {
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1],
+      [1, 0, 1],
+      [1, 1, 1],
+    ]);
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [1, 1, 1],
+          [1, 1, 1],
+          [1, 1, 1],
+        ]).data
+      )
+    );
+  });
+
+  it('leaves border-connected background untouched', () => {
+    const { data, dimensions } = flatFromGrid([
+      [0, 1, 1],
+      [1, 0, 1],
+      [1, 1, 1],
+    ]);
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    // The top-left 0 reaches the border, so it stays 0; the center is enclosed.
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [0, 1, 1],
+          [1, 1, 1],
+          [1, 1, 1],
+        ]).data
+      )
+    );
+  });
+
+  it('does not mutate the input array', () => {
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1],
+      [1, 0, 1],
+      [1, 1, 1],
+    ]);
+    const before = Array.from(data);
+    fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(Array.from(data)).toEqual(before);
+  });
+
+  it('all-segments: fills a hole with the majority bordering label', () => {
+    const { data, dimensions } = flatFromGrid([
+      [5, 5, 5],
+      [7, 0, 5],
+      [5, 5, 5],
+    ]);
+    // The center 0 borders three 5s and one 7, so the majority is 5.
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(out[1 + 1 * 3]).toBe(5);
+  });
+
+  it('selected-segment: fills enclosed background but preserves encircled segments', () => {
+    // 7 wide x 5 tall. Left block is a ring of 1 enclosing 0s and 2s; a stray
+    // 2 sits outside the ring on the right border.
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1, 1, 1, 0, 2],
+      [1, 0, 2, 0, 1, 0, 0],
+      [1, 2, 2, 2, 1, 0, 0],
+      [1, 0, 2, 0, 1, 0, 0],
+      [1, 1, 1, 1, 1, 0, 0],
+    ]);
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      label: 1,
+    });
+    // Enclosed background (0) becomes 1; the enclosed 2s stay 2.
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [1, 1, 1, 1, 1, 0, 2],
+          [1, 1, 2, 1, 1, 0, 0],
+          [1, 2, 2, 2, 1, 0, 0],
+          [1, 1, 2, 1, 1, 0, 0],
+          [1, 1, 1, 1, 1, 0, 0],
+        ]).data
+      )
+    );
+  });
+
+  it('selected-segment: does not override a segment it fully encircles', () => {
+    // Segment 1 forms a ring around segment 2 with a background gap between.
+    const { data, dimensions } = flatFromGrid([
+      [1, 1, 1, 1, 1],
+      [1, 0, 0, 0, 1],
+      [1, 0, 2, 0, 1],
+      [1, 0, 0, 0, 1],
+      [1, 1, 1, 1, 1],
+    ]);
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      label: 1,
+    });
+    // The background gap fills with 1; the encircled 2 is untouched.
+    expect(Array.from(out)).toEqual(
+      Array.from(
+        flatFromGrid([
+          [1, 1, 1, 1, 1],
+          [1, 1, 1, 1, 1],
+          [1, 1, 2, 1, 1],
+          [1, 1, 1, 1, 1],
+          [1, 1, 1, 1, 1],
+        ]).data
+      )
+    );
+  });
+
+  it('whole-volume on a non-default axis fills every slice', () => {
+    // dims [3,3,3], slicing along axis 0: each i-plane is the (j,k) plane.
+    // Every i-plane is a ring of 1 around a 0 at (j=1, k=1).
+    const dimensions: [number, number, number] = [3, 3, 3];
+    const data = new Uint8Array(27).fill(1);
+    const holeOffset = (i: number) => i + 1 * 3 + 1 * 9; // j=1, k=1
+    for (let i = 0; i < 3; i += 1) data[holeOffset(i)] = 0;
+    // A border voxel that must stay 0 (corner of the i=0 plane).
+    data[0] = 0;
+
+    const out = fillHoles({ data, dimensions, axis: 0 });
+    for (let i = 0; i < 3; i += 1) {
+      expect(out[holeOffset(i)]).toBe(1);
+    }
+    expect(out[0]).toBe(0);
+  });
+
+  it('only fills the requested slice when sliceIndex is given', () => {
+    const dimensions: [number, number, number] = [3, 3, 3];
+    const data = new Uint8Array(27).fill(1);
+    const holeOffset = (i: number) => i + 1 * 3 + 1 * 9;
+    for (let i = 0; i < 3; i += 1) data[holeOffset(i)] = 0;
+
+    const out = fillHoles({ data, dimensions, axis: 0, sliceIndex: 1 });
+    expect(out[holeOffset(0)]).toBe(0);
+    expect(out[holeOffset(1)]).toBe(1);
+    expect(out[holeOffset(2)]).toBe(0);
+  });
+});
diff --git a/src/core/tools/paint/fillHoles.ts b/src/core/tools/paint/fillHoles.ts
new file mode 100644
index 000000000..00dc2c809
--- /dev/null
+++ b/src/core/tools/paint/fillHoles.ts
@@ -0,0 +1,159 @@
+import { TypedArray } from '@kitware/vtk.js/types';
+
+// 4-connected neighbor offsets, shared so the flood-fill loops never allocate
+// a neighbor array per visited voxel.
+const NEIGHBOR_DU = [-1, 1, 0, 0];
+const NEIGHBOR_DV = [0, 0, -1, 1];
+
+export type FillHolesOptions = {
+  // Flat label-map scalar array, indexed as i + j*dimI + k*dimI*dimJ.
+  data: TypedArray | number[];
+  // Label-map IJK dimensions [dimI, dimJ, dimK].
+  dimensions: [number, number, number];
+  // IJK axis perpendicular to the fill plane (the slice axis).
+  axis: 0 | 1 | 2;
+  // When set, only this slice index along `axis` is processed.
+  // When omitted, every slice along `axis` is processed.
+  sliceIndex?: number;
+  // When set, only this label is treated as foreground (selected-segment mode)
+  // and enclosed background is filled with it. When omitted, every non-zero
+  // voxel is foreground (all-segments mode) and enclosed background is filled
+  // with the majority bordering label. In both modes only background (0)
+  // voxels are filled, so existing segments are never overwritten.
+  label?: number;
+};
+
+// Fills enclosed background regions ("holes") on 2D slices of a label map.
+// A hole is background that does not connect to the slice border. Only
+// background (0) voxels are filled; other segments are never overwritten, even
+// when enclosed by the foreground. Returns a copy of `data`; the input is left
+// untouched.
+export function fillHoles(opts: FillHolesOptions) {
+  const { data, dimensions, axis, sliceIndex, label } = opts;
+  const out = data.slice();
+
+  const strides = [1, dimensions[0], dimensions[0] * dimensions[1]];
+  const sliceStride = strides[axis];
+  const sliceCount = dimensions[axis];
+
+  // The two in-plane axes (everything that isn't the slice axis).
+  const [uAxis, vAxis] = [0, 1, 2].filter((a) => a !== axis);
+  const uDim = dimensions[uAxis];
+  const vDim = dimensions[vAxis];
+  const uStride = strides[uAxis];
+  const vStride = strides[vAxis];
+  const planeSize = uDim * vDim;
+
+  const isForeground =
+    label === undefined
+      ? (value: number) => value !== 0
+      : (value: number) => value === label;
+
+  // 0 = unvisited, 1 = outside (border-connected non-foreground), 2 = hole.
+  const visited = new Uint8Array(planeSize);
+  const stack: number[] = [];
+
+  const firstSlice = sliceIndex ?? 0;
+  const lastSlice = sliceIndex ?? sliceCount - 1;
+
+  for (let slice = firstSlice; slice <= lastSlice; slice++) {
+    const base = slice * sliceStride;
+    visited.fill(0);
+
+    const planeOffset = (u: number, v: number) =>
+      base + u * uStride + v * vStride;
+
+    // Flood non-foreground cells reachable from the slice border ("outside").
+    const seedOutside = (u: number, v: number) => {
+      const p = u + v * uDim;
+      if (visited[p] === 0 && !isForeground(out[planeOffset(u, v)])) {
+        visited[p] = 1;
+        stack.push(p);
+      }
+    };
+    for (let u = 0; u < uDim; u++) {
+      seedOutside(u, 0);
+      seedOutside(u, vDim - 1);
+    }
+    for (let v = 0; v < vDim; v++) {
+      seedOutside(0, v);
+      seedOutside(uDim - 1, v);
+    }
+    while (stack.length) {
+      const p = stack.pop()!;
+      const u = p % uDim;
+      const v = (p - u) / uDim;
+      for (let n = 0; n < 4; n++) {
+        const nu = u + NEIGHBOR_DU[n];
+        const nv = v + NEIGHBOR_DV[n];
+        if (nu < 0 || nu >= uDim || nv < 0 || nv >= vDim) continue;
+        const np = nu + nv * uDim;
+        if (visited[np] === 0 && !isForeground(out[planeOffset(nu, nv)])) {
+          visited[np] = 1;
+          stack.push(np);
+        }
+      }
+    }
+
+    // Any non-foreground cell not marked "outside" is part of a hole. Group
+    // each hole into a connected component and fill it.
+    for (let v = 0; v < vDim; v++) {
+      for (let u = 0; u < uDim; u++) {
+        const p = u + v * uDim;
+        if (visited[p] !== 0 || isForeground(out[planeOffset(u, v)])) continue;
+
+        const holeCells: number[] = [];
+        const borderLabelCounts = new Map<number, number>();
+        visited[p] = 2;
+        stack.push(p);
+        while (stack.length) {
+          const hp = stack.pop()!;
+          const hu = hp % uDim;
+          const hv = (hp - hu) / uDim;
+          holeCells.push(planeOffset(hu, hv));
+          for (let n = 0; n < 4; n++) {
+            const nu = hu + NEIGHBOR_DU[n];
+            const nv = hv + NEIGHBOR_DV[n];
+            if (nu < 0 || nu >= uDim || nv < 0 || nv >= vDim) continue;
+            const np = nu + nv * uDim;
+            const nValue = out[planeOffset(nu, nv)];
+            if (isForeground(nValue)) {
+              borderLabelCounts.set(
+                nValue,
+                (borderLabelCounts.get(nValue) ?? 0) + 1
+              );
+            } else if (visited[np] === 0) {
+              visited[np] = 2;
+              stack.push(np);
+            }
+          }
+        }
+
+        let fillValue = label;
+        if (fillValue === undefined) {
+          // All-segments mode: fill with the majority bordering label.
+          let best = -1;
+          borderLabelCounts.forEach((count, value) => {
+            if (count > best) {
+              best = count;
+              fillValue = value;
+            }
+          });
+        }
+        // fillValue can only be undefined if the hole had no foreground
+        // border, which cannot happen for an enclosed region.
+        if (fillValue !== undefined) {
+          for (let c = 0; c < holeCells.length; c++) {
+            // Only fill background; never overwrite another segment, even when
+            // it is enclosed by the selected segment.
+            if (out[holeCells[c]] === 0) {
+              out[holeCells[c]] = fillValue;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return out;
+}
diff --git a/src/store/tools/fillHoles.ts b/src/store/tools/fillHoles.ts
new file mode 100644
index 000000000..2a087a91c
--- /dev/null
+++ b/src/store/tools/fillHoles.ts
@@ -0,0 +1,80 @@
+import { defineStore } from 'pinia';
+import { ref } from 'vue';
+import { TypedArray } from '@kitware/vtk.js/types';
+import vtkLabelMap from '@/src/vtk/LabelMap';
+import { LPSAxis } from '@/src/types/lps';
+import { useViewStore } from '@/src/store/views';
+import { useViewSliceStore } from '@/src/store/view-configs/slicing';
+import { useCurrentImage } from '@/src/composables/useCurrentImage';
+import { computeEffectiveView } from '@/src/core/views/effectiveView';
+import { fillHoles } from '@/src/core/tools/paint/fillHoles';
+
+export enum FillHolesSliceScope {
+  CurrentSlice = 'currentSlice',
+  WholeVolume = 'wholeVolume',
+}
+
+export enum FillHolesSegmentScope {
+  AllSegments = 'allSegments',
+  SelectedSegment = 'selectedSegment',
+}
+
+export const useFillHolesStore = defineStore('fillHoles', () => {
+  const sliceScope = ref(FillHolesSliceScope.CurrentSlice);
+  const segmentScope = ref(FillHolesSegmentScope.AllSegments);
+
+  function setSliceScope(value: FillHolesSliceScope) {
+    sliceScope.value = value;
+  }
+
+  function setSegmentScope(value: FillHolesSegmentScope) {
+    segmentScope.value = value;
+  }
+
+  async function computeAlgorithm(
+    segImage: vtkLabelMap,
+    activeSegment: number
+  ): Promise<TypedArray | number[]> {
+    const viewStore = useViewStore();
+    const viewSliceStore = useViewSliceStore();
+    const { currentImageMetadata } = useCurrentImage('global');
+
+    const view = viewStore.getView(viewStore.activeView);
+    const effectiveView = view ? computeEffectiveView(view, view.dataID) : null;
+    // The segment group shares its parent image's geometry, so the active 2D
+    // view's orientation maps directly to the label map's IJK slice axis.
+    const orientation: LPSAxis =
+      effectiveView?.kind === 'volume2D' ? effectiveView.axis : 'Axial';
+    const axis = currentImageMetadata.value.lpsOrientation[orientation];
+
+    const dimensions = segImage.getDimensions() as [number, number, number];
+    const data = segImage.getPointData().getScalars().getData();
+
+    let sliceIndex: number | undefined;
+    if (sliceScope.value === FillHolesSliceScope.CurrentSlice) {
+      const sliceConfig =
+        effectiveView?.kind === 'volume2D'
+          ? viewSliceStore.getConfig(
+              effectiveView.viewInfo.id,
+              effectiveView.renderDataID
+            )
+          : undefined;
+      sliceIndex = sliceConfig?.slice ?? Math.floor(dimensions[axis] / 2);
+    }
+
+    const label =
+      segmentScope.value === FillHolesSegmentScope.SelectedSegment
+        ? activeSegment
+        : undefined;
+
+    return fillHoles({ data, dimensions, axis, sliceIndex, label });
+  }
+
+  return {
+    sliceScope,
+    segmentScope,
+    setSliceScope,
+    setSegmentScope,
+    computeAlgorithm,
+  };
+});
diff --git a/src/store/tools/paintProcess.ts b/src/store/tools/paintProcess.ts
index 66269dae1..ab0e08d64 100644
--- a/src/store/tools/paintProcess.ts
+++ b/src/store/tools/paintProcess.ts
@@ -10,6 +10,7 @@ import { useCurrentImage } from '@/src/composables/useCurrentImage';
 import { useSegmentGroupStore } from '../segmentGroups';
 
 export enum ProcessType {
+  FillHoles = 'fillHoles',
   FillBetween = 'fillBetween',
   GaussianSmooth = 'gaussianSmooth',
 }
@@ -43,7 +44,7 @@ export type ProcessAlgorithm = (
 
 export const usePaintProcessStore = defineStore('paintProcess', () => {
   const processState = ref<ProcessState>({ step: 'start' });
-  const activeProcessType = ref<ProcessType>(ProcessType.FillBetween);
+  const activeProcessType = ref<ProcessType>(ProcessType.FillHoles);
 
   const processStep = computed(() => processState.value.step);
 
diff --git a/tests/pageobjects/volview.page.ts b/tests/pageobjects/volview.page.ts
index 7aebc7984..dc759b6e2 100644
--- a/tests/pageobjects/volview.page.ts
+++ b/tests/pageobjects/volview.page.ts
@@ -114,6 +114,73 @@ class VolViewPage extends Page {
     await button.click();
   }
 
+  // Paint "Process" mode and the Fill Holes process workflow.
+  get processModeButton() {
+    return $('button*=Process');
+  }
+
+  get fillHolesProcessButton() {
+    return $('button*=Fill Holes');
+  }
+
+  get fillHolesWholeVolumeButton() {
+    return $('button*=Whole volume');
+  }
+
+  get fillHolesSelectedSegmentButton() {
+    return $('button*=Selected segment');
+  }
+
+  get processPreviewButton() {
+    return $('button*=Preview');
+  }
+
+  get processApplyButton() {
+    return $('button*=Apply');
+  }
+
+  async paintStrokeOnView(view: ChainablePromiseElement) {
+    const canvas = await view.$('canvas');
+    const location = await canvas.getLocation();
+    const size = await canvas.getSize();
+    const centerX = Math.round(location.x + size.width / 2);
+    const centerY = Math.round(location.y + size.height / 2);
+
+    await browser
+      .action('pointer')
+      .move({ x: centerX, y: centerY })
+      .down()
+      .move({ x: centerX + 40, y: centerY })
+      .move({ x: centerX + 40, y: centerY + 40 })
+      .move({ x: centerX, y: centerY + 40 })
+      .move({ x: centerX, y: centerY })
+      .up()
+      .perform();
+  }
+
+  async runFillHoles() {
+    await this.processModeButton.waitForClickable();
+    await this.processModeButton.click();
+
+    const fillHoles = this.fillHolesProcessButton;
+    await fillHoles.waitForClickable();
+    await fillHoles.click();
+
+    const preview = this.processPreviewButton;
+    await preview.waitForClickable();
+    await preview.click();
+
+    // Reaching the "previewing" state (Apply appears) only happens after the
+    // algorithm runs successfully on the label map.
+    const apply = this.processApplyButton;
+    await apply.waitForDisplayed();
+    await apply.waitForClickable();
+    await apply.click();
+
+    // Applying returns the workflow to its start state (Preview reappears).
+    await this.processPreviewButton.waitForDisplayed();
+  }
+
   get viewTwoContainer() {
     return $('div[data-testid~="two-view-container"]');
   }
diff --git a/tests/specs/paint-fill-holes.e2e.ts b/tests/specs/paint-fill-holes.e2e.ts
new file mode 100644
index 000000000..845c75006
--- /dev/null
+++ b/tests/specs/paint-fill-holes.e2e.ts
@@ -0,0 +1,55 @@
+import AppPage from '../pageobjects/volview.page';
+
+describe('Fill Holes paint process', () => {
+  it('runs the Fill Holes workflow to completion on a painted segment', async () => {
+    await AppPage.open();
+    await AppPage.downloadProstateSample();
+    await AppPage.waitForViews();
+
+    const views2D = await AppPage.getViews2D();
+    const axialView = views2D[0];
+
+    await AppPage.activatePaint();
+    // Paint a shape so the label map has data for the algorithm to process.
+    await AppPage.paintStrokeOnView(axialView);
+
+    // Default options: current slice, all segments.
+    await AppPage.runFillHoles();
+
+    // The Preview button is back, meaning the process applied without error.
+    await expect(AppPage.processPreviewButton).toBeDisplayed();
+  });
+
+  it('runs Fill Holes with whole-volume and selected-segment options', async () => {
+    await AppPage.open();
+    await AppPage.downloadProstateSample();
+    await AppPage.waitForViews();
+
+    const views2D = await AppPage.getViews2D();
+    const axialView = views2D[0];
+
+    await AppPage.activatePaint();
+    await AppPage.paintStrokeOnView(axialView);
+
+    await AppPage.processModeButton.waitForClickable();
+    await AppPage.processModeButton.click();
+    await AppPage.fillHolesProcessButton.waitForClickable();
+    await AppPage.fillHolesProcessButton.click();
+
+    // Switch both option toggles away from their defaults.
+    await AppPage.fillHolesWholeVolumeButton.waitForClickable();
+    await AppPage.fillHolesWholeVolumeButton.click();
+    await AppPage.fillHolesSelectedSegmentButton.waitForClickable();
+    await AppPage.fillHolesSelectedSegmentButton.click();
+
+    await AppPage.processPreviewButton.waitForClickable();
+    await AppPage.processPreviewButton.click();
+
+    const apply = AppPage.processApplyButton;
+    await apply.waitForDisplayed();
+    await apply.waitForClickable();
+    await apply.click();
+
+    await expect(AppPage.processPreviewButton).toBeDisplayed();
+  });
+});

From 22d3288868929f45a4417b32f8d9380793bd2037 Mon Sep 17 00:00:00 2001
From: Paul Elliott <paul@vizworkshop.com>
Date: Sat, 27 Jun 2026 17:11:15 -0400
Subject: [PATCH 2/3] fix(paint): correct slice axis, locked-segment growth,
 and preview data loss

Commit processed scalars on Apply even when the original preview is shown, so
the result is no longer silently discarded (shared by all paint processes).
Make the active-segment requirement opt-out so all-segments Fill Holes runs.
Centralize process wiring (label, icon, controls, algorithm) in a registry.
Fill Holes: require an active 2D view and resolve the slice axis from the
segment group's parent image instead of the global current image.
Fill Holes: skip locked segments in all-segments fill and break majority
ties by lowest label; run the flood fill in a web worker.
Tests: add a preview-toggle e2e, fix the whole-volume selector, share setup.
---
 src/components/FillHolesParameterControls.vue |  80 +++++++-----
 src/components/ProcessControls.vue            |  44 ++-----
 src/components/ProcessTypeSelector.vue        |  41 ++----
 src/components/ProcessWorkflow.vue            |   9 +-
 src/components/processes.ts                   |  56 +++++++++
 .../tools/paint/__tests__/fillHoles.spec.ts   |  47 +++++++
 src/core/tools/paint/fillHoles.ts             | 119 +++++++++++-------
 src/core/tools/paint/fillHoles.worker.ts      |  14 +++
 src/store/tools/fillHoles.ts                  |  96 ++++++++++----
 src/store/tools/paintProcess.ts               |  47 ++++---
 tests/pageobjects/volview.page.ts             |  16 ++-
 tests/specs/paint-fill-holes.e2e.ts           |  43 +++++--
 12 files changed, 413 insertions(+), 199 deletions(-)
 create mode 100644 src/components/processes.ts
 create mode 100644 src/core/tools/paint/fillHoles.worker.ts

diff --git a/src/components/FillHolesParameterControls.vue b/src/components/FillHolesParameterControls.vue
index a4b2d21f4..f3fac8589 100644
--- a/src/components/FillHolesParameterControls.vue
+++ b/src/components/FillHolesParameterControls.vue
@@ -16,42 +16,28 @@
     </mini-expansion-panel>
   </div>
 
-  <div class="w-100 px-4 mb-3 d-flex flex-column align-center">
-    <div class="text-caption mb-1">Slices</div>
+  <div
+    v-for="scope in scopes"
+    :key="scope.label"
+    class="w-100 px-4 mb-4 d-flex flex-column align-center"
+  >
+    <div class="text-caption mb-1">{{ scope.label }}</div>
     <v-btn-toggle
-      :model-value="sliceScope"
+      :model-value="scope.value"
       density="compact"
       variant="outlined"
       divided
       mandatory
       :disabled="isDisabled"
-      @update:model-value="setSliceScope"
+      @update:model-value="scope.onChange"
     >
-      <v-btn :value="FillHolesSliceScope.CurrentSlice" size="small">
-        Current slice
-      </v-btn>
-      <v-btn :value="FillHolesSliceScope.WholeVolume" size="small">
-        All slices
-      </v-btn>
-    </v-btn-toggle>
-  </div>
-
-  <div class="w-100 px-4 mb-4 d-flex flex-column align-center">
-    <div class="text-caption mb-1">Segments</div>
-    <v-btn-toggle
-      :model-value="segmentScope"
-      density="compact"
-      variant="outlined"
-      divided
-      mandatory
-      :disabled="isDisabled"
-      @update:model-value="setSegmentScope"
-    >
-      <v-btn :value="FillHolesSegmentScope.AllSegments" size="small">
-        All segments
-      </v-btn>
-      <v-btn :value="FillHolesSegmentScope.SelectedSegment" size="small">
-        Selected segment
+      <v-btn
+        v-for="option in scope.options"
+        :key="option.value"
+        :value="option.value"
+        size="small"
+      >
+        {{ option.label }}
       </v-btn>
     </v-btn-toggle>
   </div>
@@ -70,8 +56,38 @@ import MiniExpansionPanel from './MiniExpansionPanel.vue';
 const fillHolesStore = useFillHolesStore();
 const processStore = usePaintProcessStore();
 
-const sliceScope = computed(() => fillHolesStore.sliceScope);
-const segmentScope = computed(() => fillHolesStore.segmentScope);
 const isDisabled = computed(() => processStore.processStep === 'previewing');
-const { setSliceScope, setSegmentScope } = fillHolesStore;
+
+type ScopeControl = {
+  label: string;
+  value: string;
+  onChange: (value: string) => void;
+  options: { value: string; label: string }[];
+};
+
+const scopes = computed<ScopeControl[]>(() => [
+  {
+    label: 'Slices',
+    value: fillHolesStore.sliceScope,
+    onChange: (value) =>
+      fillHolesStore.setSliceScope(value as FillHolesSliceScope),
+    options: [
+      { value: FillHolesSliceScope.CurrentSlice, label: 'Current slice' },
+      { value: FillHolesSliceScope.WholeVolume, label: 'All slices' },
+    ],
+  },
+  {
+    label: 'Segments',
+    value: fillHolesStore.segmentScope,
+    onChange: (value) =>
+      fillHolesStore.setSegmentScope(value as FillHolesSegmentScope),
+    options: [
+      { value: FillHolesSegmentScope.AllSegments, label: 'All segments' },
+      {
+        value: FillHolesSegmentScope.SelectedSegment,
+        label: 'Selected segment',
+      },
+    ],
+  },
+]);
 </script>
diff --git a/src/components/ProcessControls.vue b/src/components/ProcessControls.vue
index 78b22493f..7a587a923 100644
--- a/src/components/ProcessControls.vue
+++ b/src/components/ProcessControls.vue
@@ -2,46 +2,28 @@
   <div class="d-flex flex-column align-center w-100">
     <ProcessTypeSelector />
 
-    <template v-if="activeProcessType === ProcessType.FillHoles">
-      <FillHolesParameterControls />
-      <ProcessWorkflow :algorithm="fillHolesAlgorithm" />
-    </template>
-
-    <template v-if="activeProcessType === ProcessType.FillBetween">
-      <FillBetweenParameterControls />
-      <ProcessWorkflow :algorithm="fillBetweenAlgorithm" />
-    </template>
-
-    <template v-if="activeProcessType === ProcessType.GaussianSmooth">
-      <GaussianSmoothParameterControls />
-      <ProcessWorkflow :algorithm="gaussianSmoothAlgorithm" />
+    <template v-if="activeDefinition">
+      <component :is="activeDefinition.controls" />
+      <ProcessWorkflow
+        :algorithm="activeDefinition.getAlgorithm()"
+        :requires-active-segment="
+          activeDefinition.requiresActiveSegment?.() ?? true
+        "
+      />
     </template>
   </div>
 </template>
 
 <script setup lang="ts">
 import { computed } from 'vue';
-import {
-  ProcessType,
-  usePaintProcessStore,
-} from '@/src/store/tools/paintProcess';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
 import ProcessTypeSelector from './ProcessTypeSelector.vue';
 import ProcessWorkflow from './ProcessWorkflow.vue';
-import FillBetweenParameterControls from './FillBetweenParameterControls.vue';
-import GaussianSmoothParameterControls from './GaussianSmoothParameterControls.vue';
-import FillHolesParameterControls from './FillHolesParameterControls.vue';
-import { useFillBetweenStore } from '../store/tools/fillBetween';
-import { useGaussianSmoothStore } from '../store/tools/gaussianSmooth';
-import { useFillHolesStore } from '../store/tools/fillHoles';
+import { PROCESS_DEFINITIONS } from './processes';
 
 const processStore = usePaintProcessStore();
-const fillBetweenStore = useFillBetweenStore();
-const gaussianSmoothStore = useGaussianSmoothStore();
-const fillHolesStore = useFillHolesStore();
-
-const activeProcessType = computed(() => processStore.activeProcessType);
 
-const fillBetweenAlgorithm = fillBetweenStore.computeAlgorithm;
-const gaussianSmoothAlgorithm = gaussianSmoothStore.computeAlgorithm;
-const fillHolesAlgorithm = fillHolesStore.computeAlgorithm;
+const activeDefinition = computed(() =>
+  PROCESS_DEFINITIONS.find((def) => def.type === processStore.activeProcessType)
+);
 </script>
diff --git a/src/components/ProcessTypeSelector.vue b/src/components/ProcessTypeSelector.vue
index 2d863e8aa..8c7837bd4 100644
--- a/src/components/ProcessTypeSelector.vue
+++ b/src/components/ProcessTypeSelector.vue
@@ -6,35 +6,10 @@
       selected-class="selected"
       class="d-flex align-center justify-center flex-wrap"
     >
-      <v-item :value="ProcessType.FillHoles" v-slot="{ selectedClass, toggle }">
-        <v-btn
-          variant="tonal"
-          rounded="8"
-          stacked
-          :class="['process-button', 'mx-2', selectedClass]"
-          @click.stop="toggle"
-        >
-          <v-icon>mdi-format-color-fill</v-icon>
-          <span class="text-caption">Fill Holes</span>
-        </v-btn>
-      </v-item>
-      <v-item
-        :value="ProcessType.FillBetween"
-        v-slot="{ selectedClass, toggle }"
-      >
-        <v-btn
-          variant="tonal"
-          rounded="8"
-          stacked
-          :class="['process-button', 'mx-2', selectedClass]"
-          @click.stop="toggle"
-        >
-          <v-icon>mdi-layers-triple</v-icon>
-          <span class="text-caption">Fill Between</span>
-        </v-btn>
-      </v-item>
       <v-item
-        :value="ProcessType.GaussianSmooth"
+        v-for="definition in PROCESS_DEFINITIONS"
+        :key="definition.type"
+        :value="definition.type"
         v-slot="{ selectedClass, toggle }"
       >
         <v-btn
@@ -44,8 +19,8 @@
           :class="['process-button', 'mx-2', selectedClass]"
           @click.stop="toggle"
         >
-          <v-icon>mdi-blur</v-icon>
-          <span class="text-caption">Smooth</span>
+          <v-icon>{{ definition.icon }}</v-icon>
+          <span class="text-caption">{{ definition.label }}</span>
         </v-btn>
       </v-item>
     </v-item-group>
@@ -54,10 +29,8 @@
 
 <script setup lang="ts">
 import { computed } from 'vue';
-import {
-  ProcessType,
-  usePaintProcessStore,
-} from '@/src/store/tools/paintProcess';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
+import { PROCESS_DEFINITIONS } from './processes';
 
 const processStore = usePaintProcessStore();
 
diff --git a/src/components/ProcessWorkflow.vue b/src/components/ProcessWorkflow.vue
index dd86bcfa4..69bf55d87 100644
--- a/src/components/ProcessWorkflow.vue
+++ b/src/components/ProcessWorkflow.vue
@@ -59,9 +59,12 @@ import {
 
 interface Props {
   algorithm: ProcessAlgorithm;
+  requiresActiveSegment?: boolean;
 }
 
-const props = defineProps<Props>();
+const props = withDefaults(defineProps<Props>(), {
+  requiresActiveSegment: true,
+});
 
 const processStore = usePaintProcessStore();
 const paintStore = usePaintToolStore();
@@ -72,7 +75,9 @@ const showingOriginal = computed(() => processStore.showingOriginal);
 function startCompute() {
   const id = paintStore.activeSegmentGroupID;
   if (!id) return;
-  processStore.startProcess(id, props.algorithm);
+  processStore.startProcess(id, props.algorithm, {
+    requiresActiveSegment: props.requiresActiveSegment,
+  });
 }
 
 function handleCancel() {
diff --git a/src/components/processes.ts b/src/components/processes.ts
new file mode 100644
index 000000000..d16aff121
--- /dev/null
+++ b/src/components/processes.ts
@@ -0,0 +1,56 @@
+import type { Component } from 'vue';
+import {
+  ProcessType,
+  type ProcessAlgorithm,
+} from '@/src/store/tools/paintProcess';
+import {
+  useFillHolesStore,
+  FillHolesSegmentScope,
+} from '@/src/store/tools/fillHoles';
+import { useFillBetweenStore } from '@/src/store/tools/fillBetween';
+import { useGaussianSmoothStore } from '@/src/store/tools/gaussianSmooth';
+import FillHolesParameterControls from './FillHolesParameterControls.vue';
+import FillBetweenParameterControls from './FillBetweenParameterControls.vue';
+import GaussianSmoothParameterControls from './GaussianSmoothParameterControls.vue';
+
+export type ProcessDefinition = {
+  type: ProcessType;
+  label: string;
+  icon: string;
+  controls: Component;
+  // Resolved lazily so each call reads the live store (Pinia singletons).
+  getAlgorithm: () => ProcessAlgorithm;
+  // Whether the process needs the active segment. Defaults to true; processes
+  // that act on every segment opt out. Resolved lazily for reactivity.
+  requiresActiveSegment?: () => boolean;
+};
+
+// Single source of truth for the paint processes. Adding a process is one
+// entry here instead of synchronized edits across the selector, the controls,
+// and the type enum.
+export const PROCESS_DEFINITIONS: ProcessDefinition[] = [
+  {
+    type: ProcessType.FillHoles,
+    label: 'Fill Holes',
+    icon: 'mdi-format-color-fill',
+    controls: FillHolesParameterControls,
+    getAlgorithm: () => useFillHolesStore().computeAlgorithm,
+    requiresActiveSegment: () =>
+      useFillHolesStore().segmentScope ===
+      FillHolesSegmentScope.SelectedSegment,
+  },
+  {
+    type: ProcessType.FillBetween,
+    label: 'Fill Between',
+    icon: 'mdi-layers-triple',
+    controls: FillBetweenParameterControls,
+    getAlgorithm: () => useFillBetweenStore().computeAlgorithm,
+  },
+  {
+    type: ProcessType.GaussianSmooth,
+    label: 'Smooth',
+    icon: 'mdi-blur',
+    controls: GaussianSmoothParameterControls,
+    getAlgorithm: () => useGaussianSmoothStore().computeAlgorithm,
+  },
+];
diff --git a/src/core/tools/paint/__tests__/fillHoles.spec.ts b/src/core/tools/paint/__tests__/fillHoles.spec.ts
index 59ef7e50d..1f77280bd 100644
--- a/src/core/tools/paint/__tests__/fillHoles.spec.ts
+++ b/src/core/tools/paint/__tests__/fillHoles.spec.ts
@@ -159,4 +159,51 @@ describe('fillHoles', () => {
     expect(out[holeOffset(1)]).toBe(1);
     expect(out[holeOffset(2)]).toBe(0);
   });
+
+  it('all-segments: breaks majority ties by the lowest label', () => {
+    // The center borders two 8s (reached first by the flood) and two 3s. The
+    // lower label must win regardless of traversal order, so this fails if ties
+    // fall back to insertion order.
+    const { data, dimensions } = flatFromGrid([
+      [8, 8, 3],
+      [8, 0, 3],
+      [8, 3, 3],
+    ]);
+    const out = fillHoles({ data, dimensions, axis: 2, sliceIndex: 0 });
+    expect(out[1 + 1 * 3]).toBe(3);
+  });
+
+  it('all-segments: does not grow a locked segment into a hole', () => {
+    const { data, dimensions } = flatFromGrid([
+      [5, 5, 5],
+      [5, 0, 5],
+      [5, 5, 5],
+    ]);
+    // 5 is locked, so its enclosed hole is left as background.
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      lockedLabels: [5],
+    });
+    expect(out[1 + 1 * 3]).toBe(0);
+  });
+
+  it('all-segments: fills with the unlocked majority even when a locked label borders', () => {
+    const { data, dimensions } = flatFromGrid([
+      [5, 5, 5],
+      [7, 0, 5],
+      [5, 5, 5],
+    ]);
+    // Majority 5 (unlocked) wins over the single locked 7 neighbor.
+    const out = fillHoles({
+      data,
+      dimensions,
+      axis: 2,
+      sliceIndex: 0,
+      lockedLabels: [7],
+    });
+    expect(out[1 + 1 * 3]).toBe(5);
+  });
 });
diff --git a/src/core/tools/paint/fillHoles.ts b/src/core/tools/paint/fillHoles.ts
index 00dc2c809..5ccb8e8c0 100644
--- a/src/core/tools/paint/fillHoles.ts
+++ b/src/core/tools/paint/fillHoles.ts
@@ -21,6 +21,10 @@ export type FillHolesOptions = {
   // with the majority bordering label. In both modes only background (0)
   // voxels are filled, so existing segments are never overwritten.
   label?: number;
+  // All-segments mode only: labels that must not be grown. A hole whose
+  // majority bordering label is locked is left unfilled rather than expanding a
+  // locked segment.
+  lockedLabels?: number[];
 };
 
 // Fills enclosed background regions ("holes") on 2D slices of a label map.
@@ -29,8 +33,9 @@ export type FillHolesOptions = {
 // when enclosed by the foreground. Returns a copy of `data`; the input is left
 // untouched.
 export function fillHoles(opts: FillHolesOptions) {
-  const { data, dimensions, axis, sliceIndex, label } = opts;
+  const { data, dimensions, axis, sliceIndex, label, lockedLabels } = opts;
   const out = data.slice();
+  const lockedSet = lockedLabels?.length ? new Set(lockedLabels) : null;
 
   const strides = [1, dimensions[0], dimensions[0] * dimensions[1]];
   const sliceStride = strides[axis];
@@ -48,6 +53,8 @@ export function fillHoles(opts: FillHolesOptions) {
     label === undefined
       ? (value: number) => value !== 0
       : (value: number) => value === label;
+  // Only all-segments mode needs to tally each hole's bordering labels.
+  const trackBorders = label === undefined;
 
   // 0 = unvisited, 1 = outside (border-connected non-foreground), 2 = hole.
   const visited = new Uint8Array(planeSize);
@@ -63,6 +70,36 @@ export function fillHoles(opts: FillHolesOptions) {
     const planeOffset = (u: number, v: number) =>
       base + u * uStride + v * vStride;
 
+    // Drain `stack`, expanding the region into unvisited non-foreground
+    // neighbors (each marked with `mark`). `collect`, when given, receives the
+    // flat offset of every region cell; `onBorder`, when given, is called with
+    // each bordering foreground label.
+    const drain = (
+      mark: number,
+      collect?: number[],
+      onBorder?: (value: number) => void
+    ) => {
+      while (stack.length) {
+        const p = stack.pop()!;
+        const u = p % uDim;
+        const v = (p - u) / uDim;
+        if (collect) collect.push(planeOffset(u, v));
+        for (let n = 0; n < 4; n++) {
+          const nu = u + NEIGHBOR_DU[n];
+          const nv = v + NEIGHBOR_DV[n];
+          if (nu < 0 || nu >= uDim || nv < 0 || nv >= vDim) continue;
+          const np = nu + nv * uDim;
+          const nValue = out[planeOffset(nu, nv)];
+          if (isForeground(nValue)) {
+            onBorder?.(nValue);
+          } else if (visited[np] === 0) {
+            visited[np] = mark;
+            stack.push(np);
+          }
+        }
+      }
+    };
+
     // Flood non-foreground cells reachable from the slice border ("outside").
     const seedOutside = (u: number, v: number) => {
       const p = u + v * uDim;
@@ -79,21 +116,7 @@ export function fillHoles(opts: FillHolesOptions) {
       seedOutside(0, v);
       seedOutside(uDim - 1, v);
     }
-    while (stack.length) {
-      const p = stack.pop()!;
-      const u = p % uDim;
-      const v = (p - u) / uDim;
-      for (let n = 0; n < 4; n++) {
-        const nu = u + NEIGHBOR_DU[n];
-        const nv = v + NEIGHBOR_DV[n];
-        if (nu < 0 || nu >= uDim || nv < 0 || nv >= vDim) continue;
-        const np = nu + nv * uDim;
-        if (visited[np] === 0 && !isForeground(out[planeOffset(nu, nv)])) {
-          visited[np] = 1;
-          stack.push(np);
-        }
-      }
-    }
+    drain(1);
 
     // Any non-foreground cell not marked "outside" is part of a hole. Group
     // each hole into a connected component and fill it.
@@ -103,49 +126,49 @@ export function fillHoles(opts: FillHolesOptions) {
         if (visited[p] !== 0 || isForeground(out[planeOffset(u, v)])) continue;
 
         const holeCells: number[] = [];
-        const borderLabelCounts = new Map<number, number>();
+        const borderLabelCounts = trackBorders
+          ? new Map<number, number>()
+          : null;
         visited[p] = 2;
         stack.push(p);
-        while (stack.length) {
-          const hp = stack.pop()!;
-          const hu = hp % uDim;
-          const hv = (hp - hu) / uDim;
-          holeCells.push(planeOffset(hu, hv));
-          for (let n = 0; n < 4; n++) {
-            const nu = hu + NEIGHBOR_DU[n];
-            const nv = hv + NEIGHBOR_DV[n];
-            if (nu < 0 || nu >= uDim || nv < 0 || nv >= vDim) continue;
-            const np = nu + nv * uDim;
-            const nValue = out[planeOffset(nu, nv)];
-            if (isForeground(nValue)) {
-              borderLabelCounts.set(
-                nValue,
-                (borderLabelCounts.get(nValue) ?? 0) + 1
-              );
-            } else if (visited[np] === 0) {
-              visited[np] = 2;
-              stack.push(np);
-            }
-          }
-        }
+        drain(
+          2,
+          holeCells,
+          borderLabelCounts
+            ? (value) =>
+                borderLabelCounts.set(
+                  value,
+                  (borderLabelCounts.get(value) ?? 0) + 1
+                )
+            : undefined
+        );
 
         let fillValue = label;
-        if (fillValue === undefined) {
-          // All-segments mode: fill with the majority bordering label.
-          let best = -1;
+        if (fillValue === undefined && borderLabelCounts) {
+          // All-segments mode: fill with the majority bordering label, breaking
+          // ties by lowest label so the result is deterministic. Never fill
+          // with a locked label, which would grow a locked segment.
+          let bestCount = 0;
+          let bestLabel = -1;
           borderLabelCounts.forEach((count, value) => {
-            if (count > best) {
-              best = count;
-              fillValue = value;
+            if (
+              count > bestCount ||
+              (count === bestCount && value < bestLabel)
+            ) {
+              bestCount = count;
+              bestLabel = value;
             }
           });
+          if (bestLabel !== -1 && !lockedSet?.has(bestLabel)) {
+            fillValue = bestLabel;
+          }
         }
-        // fillValue can only be undefined if the hole had no foreground
-        // border, which cannot happen for an enclosed region.
+        // fillValue stays undefined only when the hole had no fillable border
+        // (no foreground neighbors, or every bordering label is locked).
         if (fillValue !== undefined) {
           for (let c = 0; c < holeCells.length; c++) {
             // Only fill background; never overwrite another segment, even when
-            // it is enclosed by the selected segment.
+            // it is enclosed by the foreground.
             if (out[holeCells[c]] === 0) {
               out[holeCells[c]] = fillValue;
             }
diff --git a/src/core/tools/paint/fillHoles.worker.ts b/src/core/tools/paint/fillHoles.worker.ts
new file mode 100644
index 000000000..6e3f30995
--- /dev/null
+++ b/src/core/tools/paint/fillHoles.worker.ts
@@ -0,0 +1,14 @@
+import * as Comlink from 'comlink';
+import { fillHoles, FillHolesOptions } from '@/src/core/tools/paint/fillHoles';
+
+// Runs the pure flood-fill off the main thread so whole-volume fills do not
+// freeze the UI, mirroring gaussianSmooth.worker.ts.
+export function fillHolesWorker(input: FillHolesOptions) {
+  return fillHoles(input);
+}
+
+const workerApi = {
+  fillHolesWorker,
+};
+
+Comlink.expose(workerApi);
diff --git a/src/store/tools/fillHoles.ts b/src/store/tools/fillHoles.ts
index 2a087a91c..64b674592 100644
--- a/src/store/tools/fillHoles.ts
+++ b/src/store/tools/fillHoles.ts
@@ -1,13 +1,14 @@
 import { defineStore } from 'pinia';
 import { ref } from 'vue';
-import { TypedArray } from '@kitware/vtk.js/types';
+import * as Comlink from 'comlink';
 import vtkLabelMap from '@/src/vtk/LabelMap';
-import { LPSAxis } from '@/src/types/lps';
 import { useViewStore } from '@/src/store/views';
 import { useViewSliceStore } from '@/src/store/view-configs/slicing';
-import { useCurrentImage } from '@/src/composables/useCurrentImage';
-import { computeEffectiveView } from '@/src/core/views/effectiveView';
-import { fillHoles } from '@/src/core/tools/paint/fillHoles';
+import { usePaintToolStore } from '@/src/store/tools/paint';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
+import { getImageMetadata } from '@/src/composables/useCurrentImage';
+import { getEffectiveView } from '@/src/core/views/effectiveView';
+import { fillHolesWorker } from '@/src/core/tools/paint/fillHoles.worker';
 
 export enum FillHolesSliceScope {
   CurrentSlice = 'currentSlice',
@@ -19,6 +20,23 @@ export enum FillHolesSegmentScope {
   SelectedSegment = 'selectedSegment',
 }
 
+type WorkerApi = {
+  fillHolesWorker: typeof fillHolesWorker;
+};
+
+let workerInstance: Comlink.Remote<WorkerApi> | null = null;
+
+async function getWorker() {
+  if (!workerInstance) {
+    const worker = new Worker(
+      new URL('@/src/core/tools/paint/fillHoles.worker.ts', import.meta.url),
+      { type: 'module' }
+    );
+    workerInstance = Comlink.wrap<WorkerApi>(worker);
+  }
+  return workerInstance;
+}
+
 export const useFillHolesStore = defineStore('fillHoles', () => {
   const sliceScope = ref(FillHolesSliceScope.CurrentSlice);
   const segmentScope = ref(FillHolesSegmentScope.AllSegments);
@@ -34,40 +52,66 @@ export const useFillHolesStore = defineStore('fillHoles', () => {
   async function computeAlgorithm(
     segImage: vtkLabelMap,
     activeSegment: number
-  ): Promise<TypedArray | number[]> {
+  ) {
     const viewStore = useViewStore();
     const viewSliceStore = useViewSliceStore();
-    const { currentImageMetadata } = useCurrentImage('global');
+    const paintStore = usePaintToolStore();
+    const segmentGroupStore = useSegmentGroupStore();
+
+    // Fill Holes works on the slice plane of the 2D view the user is on, so a
+    // 2D view must be active to know which axis (and slice) to operate on.
+    const effectiveView = getEffectiveView(viewStore.activeView);
+    if (effectiveView?.kind !== 'volume2D') {
+      throw new Error(
+        'Fill Holes needs an active 2D slice view. Click a 2D view, then try again.'
+      );
+    }
+
+    const groupId = paintStore.activeSegmentGroupID;
+    if (!groupId) {
+      throw new Error('No active segment group');
+    }
+    const metadata = segmentGroupStore.metadataByID[groupId];
 
-    const view = viewStore.getView(viewStore.activeView);
-    const effectiveView = view ? computeEffectiveView(view, view.dataID) : null;
-    // The segment group shares its parent image's geometry, so the active 2D
-    // view's orientation maps directly to the label map's IJK slice axis.
-    const orientation: LPSAxis =
-      effectiveView?.kind === 'volume2D' ? effectiveView.axis : 'Axial';
-    const axis = currentImageMetadata.value.lpsOrientation[orientation];
+    // Resolve the IJK slice axis against the segment group's own parent image
+    // (the label map shares its geometry), not whatever image happens to be
+    // globally current.
+    const { lpsOrientation } = getImageMetadata(metadata.parentImage);
+    const axis = lpsOrientation[effectiveView.axis];
 
     const dimensions = segImage.getDimensions() as [number, number, number];
     const data = segImage.getPointData().getScalars().getData();
 
     let sliceIndex: number | undefined;
     if (sliceScope.value === FillHolesSliceScope.CurrentSlice) {
-      const sliceConfig =
-        effectiveView?.kind === 'volume2D'
-          ? viewSliceStore.getConfig(
-              effectiveView.viewInfo.id,
-              effectiveView.renderDataID
-            )
-          : undefined;
+      const sliceConfig = viewSliceStore.getConfig(
+        effectiveView.viewInfo.id,
+        effectiveView.renderDataID
+      );
       sliceIndex = sliceConfig?.slice ?? Math.floor(dimensions[axis] / 2);
     }
 
-    const label =
-      segmentScope.value === FillHolesSegmentScope.SelectedSegment
-        ? activeSegment
-        : undefined;
+    const selectedSegment =
+      segmentScope.value === FillHolesSegmentScope.SelectedSegment;
+    const label = selectedSegment ? activeSegment : undefined;
+    // All-segments mode can fill a hole with any bordering label, so guard
+    // locked segments from being grown. Selected-segment mode only writes the
+    // active segment, whose lock is already enforced before the process starts.
+    const lockedLabels = selectedSegment
+      ? undefined
+      : Object.values(metadata.segments.byValue)
+          .filter((segment) => segment.locked)
+          .map((segment) => segment.value);
 
-    return fillHoles({ data, dimensions, axis, sliceIndex, label });
+    const worker = await getWorker();
+    return worker.fillHolesWorker({
+      data,
+      dimensions,
+      axis,
+      sliceIndex,
+      label,
+      lockedLabels,
+    });
   }
 
   return {
diff --git a/src/store/tools/paintProcess.ts b/src/store/tools/paintProcess.ts
index ab0e08d64..a9d16effa 100644
--- a/src/store/tools/paintProcess.ts
+++ b/src/store/tools/paintProcess.ts
@@ -58,6 +58,17 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
   }
 
   function confirmProcess() {
+    const state = processState.value;
+    // Apply commits the processed result. When the user is viewing the
+    // original, the image currently holds originalScalars, so restore the
+    // processed scalars before finishing or the result is silently discarded.
+    if (state.step === 'previewing' && state.showingOriginal) {
+      state.segImage
+        .getPointData()
+        .getScalars()
+        .setData(state.processedScalars);
+      state.segImage.modified();
+    }
     resetState();
   }
 
@@ -90,20 +101,28 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
     activeProcessType.value = processType;
   }
 
-  async function startProcess(groupId: string, algorithm: ProcessAlgorithm) {
-    if (!paintStore.activeSegment) {
-      messageStore.addError('No active segment selected');
-      return;
-    }
+  async function startProcess(
+    groupId: string,
+    algorithm: ProcessAlgorithm,
+    options?: { requiresActiveSegment?: boolean }
+  ) {
+    const activeSegment = paintStore.activeSegment;
+    // Most processes operate on the active segment; all-segments processes opt
+    // out so they are not blocked by (or limited to) a single active segment.
+    const requiresActiveSegment = options?.requiresActiveSegment ?? true;
+
+    if (requiresActiveSegment) {
+      if (!activeSegment) {
+        messageStore.addError('No active segment selected');
+        return;
+      }
 
-    // Check if the active segment is locked
-    const segment = segmentGroupStore.getSegment(
-      groupId,
-      paintStore.activeSegment
-    );
-    if (segment?.locked) {
-      messageStore.addError('Cannot process locked segment');
-      return;
+      // Check if the active segment is locked
+      const segment = segmentGroupStore.getSegment(groupId, activeSegment);
+      if (segment?.locked) {
+        messageStore.addError('Cannot process locked segment');
+        return;
+      }
     }
 
     const segImage = segmentGroupStore.dataIndex[groupId];
@@ -121,7 +140,7 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
     };
 
     try {
-      const outputScalars = await algorithm(segImage, paintStore.activeSegment);
+      const outputScalars = await algorithm(segImage, activeSegment ?? 0);
 
       // If the state changed during the async operation, stop processing
       if (processState.value.step !== 'computing') {
diff --git a/tests/pageobjects/volview.page.ts b/tests/pageobjects/volview.page.ts
index dc759b6e2..c69b9e814 100644
--- a/tests/pageobjects/volview.page.ts
+++ b/tests/pageobjects/volview.page.ts
@@ -124,7 +124,7 @@ class VolViewPage extends Page {
   }
 
   get fillHolesWholeVolumeButton() {
-    return $('button*=Whole volume');
+    return $('button*=All slices');
   }
 
   get fillHolesSelectedSegmentButton() {
@@ -139,6 +139,20 @@ class VolViewPage extends Page {
     return $('button*=Apply');
   }
 
+  get processOriginalButton() {
+    return $('button*=Original');
+  }
+
+  get processProcessedButton() {
+    return $('button*=Processed');
+  }
+
+  // The selected button in a Vuetify v-btn-toggle carries v-btn--active.
+  async isPreviewToggleActive(button: ChainablePromiseElement) {
+    const classes = await button.getAttribute('class');
+    return (classes ?? '').includes('v-btn--active');
+  }
+
   async paintStrokeOnView(view: ChainablePromiseElement) {
     const canvas = await view.$('canvas');
     const location = await canvas.getLocation();
diff --git a/tests/specs/paint-fill-holes.e2e.ts b/tests/specs/paint-fill-holes.e2e.ts
index 845c75006..1a1471d8d 100644
--- a/tests/specs/paint-fill-holes.e2e.ts
+++ b/tests/specs/paint-fill-holes.e2e.ts
@@ -1,7 +1,7 @@
 import AppPage from '../pageobjects/volview.page';
 
 describe('Fill Holes paint process', () => {
-  it('runs the Fill Holes workflow to completion on a painted segment', async () => {
+  beforeEach(async () => {
     await AppPage.open();
     await AppPage.downloadProstateSample();
     await AppPage.waitForViews();
@@ -12,7 +12,9 @@ describe('Fill Holes paint process', () => {
     await AppPage.activatePaint();
     // Paint a shape so the label map has data for the algorithm to process.
     await AppPage.paintStrokeOnView(axialView);
+  });
 
+  it('runs the Fill Holes workflow to completion on a painted segment', async () => {
     // Default options: current slice, all segments.
     await AppPage.runFillHoles();
 
@@ -21,16 +23,6 @@ describe('Fill Holes paint process', () => {
   });
 
   it('runs Fill Holes with whole-volume and selected-segment options', async () => {
-    await AppPage.open();
-    await AppPage.downloadProstateSample();
-    await AppPage.waitForViews();
-
-    const views2D = await AppPage.getViews2D();
-    const axialView = views2D[0];
-
-    await AppPage.activatePaint();
-    await AppPage.paintStrokeOnView(axialView);
-
     await AppPage.processModeButton.waitForClickable();
     await AppPage.processModeButton.click();
     await AppPage.fillHolesProcessButton.waitForClickable();
@@ -52,4 +44,33 @@ describe('Fill Holes paint process', () => {
 
     await expect(AppPage.processPreviewButton).toBeDisplayed();
   });
+
+  it('toggles the preview in place between processed and original', async () => {
+    await AppPage.processModeButton.waitForClickable();
+    await AppPage.processModeButton.click();
+    await AppPage.fillHolesProcessButton.waitForClickable();
+    await AppPage.fillHolesProcessButton.click();
+
+    await AppPage.processPreviewButton.waitForClickable();
+    await AppPage.processPreviewButton.click();
+
+    // Previewing starts on the processed result.
+    await AppPage.processProcessedButton.waitForDisplayed();
+    await browser.waitUntil(() =>
+      AppPage.isPreviewToggleActive(AppPage.processProcessedButton)
+    );
+    expect(
+      await AppPage.isPreviewToggleActive(AppPage.processOriginalButton)
+    ).toBe(false);
+
+    // Clicking the already-active button flips the preview in place, without
+    // moving the pointer to the other button.
+    await AppPage.processProcessedButton.click();
+    await browser.waitUntil(() =>
+      AppPage.isPreviewToggleActive(AppPage.processOriginalButton)
+    );
+    expect(
+      await AppPage.isPreviewToggleActive(AppPage.processProcessedButton)
+    ).toBe(false);
+  });
 });

From a7ec8a0c5efee9fa62c361ed71955f16f01ec356 Mon Sep 17 00:00:00 2001
From: Paul Elliott <paul@vizworkshop.com>
Date: Sun, 28 Jun 2026 12:42:59 -0400
Subject: [PATCH 3/3] fix(paint): correct fill holes slice mapping and process
 races

---
 src/components/FillHolesParameterControls.vue |   5 +-
 src/store/__tests__/fillHoles.spec.ts         | 174 ++++++++++++++++++
 src/store/__tests__/paintProcess.spec.ts      |  85 +++++++++
 src/store/tools/fillHoles.ts                  |  24 ++-
 src/store/tools/paintProcess.ts               |  38 ++--
 5 files changed, 305 insertions(+), 21 deletions(-)
 create mode 100644 src/store/__tests__/fillHoles.spec.ts
 create mode 100644 src/store/__tests__/paintProcess.spec.ts

diff --git a/src/components/FillHolesParameterControls.vue b/src/components/FillHolesParameterControls.vue
index f3fac8589..94b6c2c71 100644
--- a/src/components/FillHolesParameterControls.vue
+++ b/src/components/FillHolesParameterControls.vue
@@ -1,7 +1,10 @@
 <template>
   <div class="d-flex align-center">
     <mini-expansion-panel>
-      <template #title>Fill enclosed holes in the segmentation.</template>
+      <template #title
+        >Fill enclosed holes in the segmentation on the axis of the selected
+        view.</template
+      >
       <ul>
         <li>Finds background regions fully enclosed by segments on a slice.</li>
         <li>
diff --git a/src/store/__tests__/fillHoles.spec.ts b/src/store/__tests__/fillHoles.spec.ts
new file mode 100644
index 000000000..4368c5422
--- /dev/null
+++ b/src/store/__tests__/fillHoles.spec.ts
@@ -0,0 +1,174 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { setActivePinia, createPinia } from 'pinia';
+import { nextTick } from 'vue';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+import vtkLabelMap from '@/src/vtk/LabelMap';
+import { useFillHolesStore } from '@/src/store/tools/fillHoles';
+import { useImageCacheStore } from '@/src/store/image-cache';
+import { usePaintToolStore } from '@/src/store/tools/paint';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
+import { useViewSliceStore } from '@/src/store/view-configs/slicing';
+import { useViewStore } from '@/src/store/views';
+
+const fillHolesWorkerMock = vi.hoisted(() => vi.fn(async (input) => input));
+
+vi.mock('comlink', () => ({
+  wrap: () => ({
+    fillHolesWorker: fillHolesWorkerMock,
+  }),
+}));
+
+vi.mock('@/src/store/image-stats', () => ({
+  useImageStatsStore: () => ({ stats: {} }),
+}));
+
+function addScalars(image: vtkImageData, values: Uint8Array) {
+  image.getPointData().setScalars(
+    vtkDataArray.newInstance({
+      numberOfComponents: 1,
+      values,
+    })
+  );
+}
+
+type Vector3 = [number, number, number];
+type Matrix3 = [
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+  number,
+];
+
+function makeImage(dimensions: Vector3, spacing: Vector3, direction: Matrix3) {
+  const image = vtkImageData.newInstance({ spacing, direction });
+  image.setDimensions(dimensions);
+  addScalars(
+    image,
+    new Uint8Array(dimensions[0] * dimensions[1] * dimensions[2])
+  );
+  image.computeTransforms();
+  return image;
+}
+
+function makeLabelMap(
+  dimensions: Vector3,
+  spacing: Vector3,
+  direction: Matrix3
+) {
+  const labelMap = vtkLabelMap.newInstance({ spacing, direction });
+  labelMap.setDimensions(dimensions);
+  addScalars(
+    labelMap,
+    new Uint8Array(dimensions[0] * dimensions[1] * dimensions[2])
+  );
+  labelMap.computeTransforms();
+  return labelMap;
+}
+
+describe('Fill Holes store', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+    fillHolesWorkerMock.mockClear();
+    vi.stubGlobal(
+      'Worker',
+      class {
+        terminate() {}
+      }
+    );
+  });
+
+  async function setupFillHolesRun(labelMap: vtkLabelMap, parentSlice: number) {
+    const imageCacheStore = useImageCacheStore();
+    const segmentGroupStore = useSegmentGroupStore();
+    const viewStore = useViewStore();
+    const viewSliceStore = useViewSliceStore();
+    const paintStore = usePaintToolStore();
+    const fillHolesStore = useFillHolesStore();
+
+    const parentImageID = 'parent-image';
+    const parentImage = makeImage(
+      [10, 10, 10],
+      [1, 1, 1],
+      [1, 0, 0, 0, 1, 0, 0, 0, 1]
+    );
+    imageCacheStore.addVTKImageData(parentImage, 'Parent', {
+      id: parentImageID,
+    });
+    await nextTick();
+
+    const groupId = segmentGroupStore.addLabelmap(labelMap, {
+      name: 'Test group',
+      parentImage: parentImageID,
+      segments: {
+        order: [1],
+        byValue: {
+          1: {
+            value: 1,
+            name: 'Segment 1',
+            color: [255, 0, 0, 255],
+            visible: true,
+            locked: false,
+          },
+        },
+      },
+    });
+
+    const axialView = viewStore.visibleViews.find(
+      (view) => view.type === '2D' && view.options.orientation === 'Axial'
+    );
+    expect(axialView).toBeDefined();
+    viewStore.setDataForView(axialView!.id, parentImageID);
+    viewStore.setActiveView(axialView!.id);
+    viewSliceStore.updateConfig(axialView!.id, parentImageID, {
+      slice: parentSlice,
+    });
+
+    paintStore.activeSegmentGroupID = groupId;
+    paintStore.activeSegment = 1;
+
+    return { fillHolesStore };
+  }
+
+  it('uses the label-map axis for the active parent view axis', async () => {
+    // Label-map I points along parent/world axial, so an active Axial view must
+    // be sent to the worker as axis 0 rather than the parent image's axis 2.
+    const labelMap = makeLabelMap(
+      [5, 10, 10],
+      [1, 1, 1],
+      [0, 0, 1, 0, 1, 0, 1, 0, 0]
+    );
+    const { fillHolesStore } = await setupFillHolesRun(labelMap, 0);
+
+    await fillHolesStore.computeAlgorithm(labelMap, 1);
+
+    expect(fillHolesWorkerMock).toHaveBeenCalledTimes(1);
+    expect(fillHolesWorkerMock.mock.calls[0][0]).toMatchObject({
+      axis: 0,
+    });
+  });
+
+  it('converts the active parent slice into label-map slice space', async () => {
+    // Same orientation, different axial spacing: parent slice 4 is world z=4,
+    // which lands on label-map slice 2 when label-map z spacing is 2.
+    const labelMap = makeLabelMap(
+      [10, 10, 5],
+      [1, 1, 2],
+      [1, 0, 0, 0, 1, 0, 0, 0, 1]
+    );
+    const { fillHolesStore } = await setupFillHolesRun(labelMap, 4);
+
+    await fillHolesStore.computeAlgorithm(labelMap, 1);
+
+    expect(fillHolesWorkerMock).toHaveBeenCalledTimes(1);
+    expect(fillHolesWorkerMock.mock.calls[0][0]).toMatchObject({
+      axis: 2,
+      sliceIndex: 2,
+    });
+  });
+});
diff --git a/src/store/__tests__/paintProcess.spec.ts b/src/store/__tests__/paintProcess.spec.ts
new file mode 100644
index 000000000..899b178a4
--- /dev/null
+++ b/src/store/__tests__/paintProcess.spec.ts
@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { setActivePinia, createPinia } from 'pinia';
+import vtkDataArray from '@kitware/vtk.js/Common/Core/DataArray';
+import vtkLabelMap from '@/src/vtk/LabelMap';
+import { PaintMode } from '@/src/core/tools/paint';
+import { useSegmentGroupStore } from '@/src/store/segmentGroups';
+import { usePaintToolStore } from '@/src/store/tools/paint';
+import { usePaintProcessStore } from '@/src/store/tools/paintProcess';
+
+function makeLabelMap(values: Uint8Array) {
+  const labelMap = vtkLabelMap.newInstance();
+  labelMap.setDimensions([values.length, 1, 1]);
+  labelMap.getPointData().setScalars(
+    vtkDataArray.newInstance({
+      numberOfComponents: 1,
+      values,
+    })
+  );
+  labelMap.computeTransforms();
+  return labelMap;
+}
+
+function getScalars(labelMap: vtkLabelMap) {
+  return Array.from(labelMap.getPointData().getScalars().getData());
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+describe('Paint process store', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  it('ignores stale async results after a newer process starts', async () => {
+    const segmentGroupStore = useSegmentGroupStore();
+    const paintStore = usePaintToolStore();
+    const labelMap = makeLabelMap(new Uint8Array([0, 0]));
+    const groupId = segmentGroupStore.addLabelmap(labelMap, {
+      name: 'Test group',
+      parentImage: 'image-1',
+      segments: {
+        order: [1],
+        byValue: {
+          1: {
+            value: 1,
+            name: 'Segment 1',
+            color: [255, 0, 0, 255],
+            visible: true,
+            locked: false,
+          },
+        },
+      },
+    });
+
+    paintStore.activeSegmentGroupID = groupId;
+    paintStore.activeSegment = 1;
+    paintStore.activeMode = PaintMode.Process;
+    const processStore = usePaintProcessStore();
+
+    const first = deferred<Uint8Array>();
+    const second = deferred<Uint8Array>();
+    const firstRun = processStore.startProcess(groupId, () => first.promise);
+    const secondRun = processStore.startProcess(groupId, () => second.promise);
+
+    first.resolve(new Uint8Array([9, 9]));
+    await firstRun;
+
+    expect(processStore.processState.step).toBe('computing');
+    expect(getScalars(labelMap)).toEqual([0, 0]);
+
+    second.resolve(new Uint8Array([2, 2]));
+    await secondRun;
+
+    expect(processStore.processState.step).toBe('previewing');
+    expect(getScalars(labelMap)).toEqual([2, 2]);
+  });
+});
diff --git a/src/store/tools/fillHoles.ts b/src/store/tools/fillHoles.ts
index 64b674592..d6c123cee 100644
--- a/src/store/tools/fillHoles.ts
+++ b/src/store/tools/fillHoles.ts
@@ -9,6 +9,8 @@ import { useSegmentGroupStore } from '@/src/store/segmentGroups';
 import { getImageMetadata } from '@/src/composables/useCurrentImage';
 import { getEffectiveView } from '@/src/core/views/effectiveView';
 import { fillHolesWorker } from '@/src/core/tools/paint/fillHoles.worker';
+import { convertSliceIndex } from '@/src/utils/imageSpace';
+import { getLPSDirections } from '@/src/utils/lps';
 
 export enum FillHolesSliceScope {
   CurrentSlice = 'currentSlice',
@@ -73,11 +75,9 @@ export const useFillHolesStore = defineStore('fillHoles', () => {
     }
     const metadata = segmentGroupStore.metadataByID[groupId];
 
-    // Resolve the IJK slice axis against the segment group's own parent image
-    // (the label map shares its geometry), not whatever image happens to be
-    // globally current.
-    const { lpsOrientation } = getImageMetadata(metadata.parentImage);
-    const axis = lpsOrientation[effectiveView.axis];
+    const parentMetadata = getImageMetadata(metadata.parentImage);
+    const labelMapLpsOrientation = getLPSDirections(segImage.getDirection());
+    const axis = labelMapLpsOrientation[effectiveView.axis];
 
     const dimensions = segImage.getDimensions() as [number, number, number];
     const data = segImage.getPointData().getScalars().getData();
@@ -86,9 +86,19 @@ export const useFillHolesStore = defineStore('fillHoles', () => {
     if (sliceScope.value === FillHolesSliceScope.CurrentSlice) {
       const sliceConfig = viewSliceStore.getConfig(
         effectiveView.viewInfo.id,
-        effectiveView.renderDataID
+        metadata.parentImage
+      );
+      const parentAxis = parentMetadata.lpsOrientation[effectiveView.axis];
+      const parentSlice =
+        sliceConfig?.slice ??
+        Math.floor(parentMetadata.dimensions[parentAxis] / 2);
+      sliceIndex = convertSliceIndex(
+        parentSlice,
+        parentMetadata.lpsOrientation,
+        parentMetadata.indexToWorld,
+        segImage,
+        effectiveView.axis
       );
-      sliceIndex = sliceConfig?.slice ?? Math.floor(dimensions[axis] / 2);
     }
 
     const selectedSegment =
diff --git a/src/store/tools/paintProcess.ts b/src/store/tools/paintProcess.ts
index a9d16effa..0c5b63b1e 100644
--- a/src/store/tools/paintProcess.ts
+++ b/src/store/tools/paintProcess.ts
@@ -45,6 +45,7 @@ export type ProcessAlgorithm = (
 export const usePaintProcessStore = defineStore('paintProcess', () => {
   const processState = ref<ProcessState>({ step: 'start' });
   const activeProcessType = ref<ProcessType>(ProcessType.FillHoles);
+  let activeProcessRunId = 0;
 
   const processStep = computed(() => processState.value.step);
 
@@ -126,6 +127,10 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
     }
 
     const segImage = segmentGroupStore.dataIndex[groupId];
+    const activeParentImageID =
+      segmentGroupStore.metadataByID[groupId].parentImage;
+    const processType = activeProcessType.value;
+    const processRunId = ++activeProcessRunId;
 
     const originalScalars = segImage
       .getPointData()
@@ -135,16 +140,19 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
 
     processState.value = {
       step: 'computing',
-      activeParentImageID: segmentGroupStore.metadataByID[groupId].parentImage,
-      processType: activeProcessType.value,
+      activeParentImageID,
+      processType,
     };
 
     try {
       const outputScalars = await algorithm(segImage, activeSegment ?? 0);
 
-      // If the state changed during the async operation, stop processing
-      if (processState.value.step !== 'computing') {
-        return; // cancelProcess handled the state change
+      // If the state changed during the async operation, stop processing.
+      if (
+        processRunId !== activeProcessRunId ||
+        processState.value.step !== 'computing'
+      ) {
+        return;
       }
 
       const scalars = segImage.getPointData().getScalars();
@@ -153,22 +161,26 @@ export const usePaintProcessStore = defineStore('paintProcess', () => {
 
       processState.value = {
         step: 'previewing',
-        activeParentImageID:
-          segmentGroupStore.metadataByID[groupId].parentImage,
-        processType: activeProcessType.value,
+        activeParentImageID,
+        processType,
         segImage,
         originalScalars,
         processedScalars: outputScalars,
         showingOriginal: false,
       };
     } catch (error) {
-      messageStore.addError(`${activeProcessType.value} Operation Failed`, {
+      if (
+        processRunId !== activeProcessRunId ||
+        processState.value.step !== 'computing'
+      ) {
+        return;
+      }
+
+      messageStore.addError(`${processType} Operation Failed`, {
         error: error as Error,
       });
-      if (processState.value.step === 'computing') {
-        rollbackPreview(segImage, originalScalars);
-        resetState();
-      }
+      rollbackPreview(segImage, originalScalars);
+      resetState();
     }
   }