From 30a22fb3169b8e54f1491d2c9ad43adaa038fc7d Mon Sep 17 00:00:00 2001 From: nyoungbq Date: Wed, 17 Jun 2026 12:32:03 -0400 Subject: [PATCH 1/3] - Brought SliceBySlice tiebreaking in line with legacy and base alg - V&V Deviation, Provenance, and main report for identify sample --- .../Filters/Algorithms/IdentifySample.cpp | 2 +- .../SimplnxCore/test/IdentifySampleTest.cpp | 1 - .../SimplnxCore/vv/IdentifySampleFilter.md | 87 +++++++++++++ .../vv/deviations/IdentifySampleFilter.md | 55 ++++++++ .../vv/provenance/IdentifySampleFilter.md | 122 ++++++++++++++++++ 5 files changed, 265 insertions(+), 2 deletions(-) create mode 100644 src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md create mode 100644 src/Plugins/SimplnxCore/vv/deviations/IdentifySampleFilter.md create mode 100644 src/Plugins/SimplnxCore/vv/provenance/IdentifySampleFilter.md diff --git a/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp b/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp index 6f6f4c33ed..0a485be6a8 100644 --- a/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp +++ b/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp @@ -286,7 +286,7 @@ struct IdentifySampleSliceBySliceFunctor count++; } - if(static_cast(currentVList.size()) > biggestBlock) + if(static_cast(currentVList.size()) >= biggestBlock) { biggestBlock = currentVList.size(); sample.assign(planeDim1 * planeDim2, false); diff --git a/src/Plugins/SimplnxCore/test/IdentifySampleTest.cpp b/src/Plugins/SimplnxCore/test/IdentifySampleTest.cpp index 50dbe6d4b4..18af9031a2 100644 --- a/src/Plugins/SimplnxCore/test/IdentifySampleTest.cpp +++ b/src/Plugins/SimplnxCore/test/IdentifySampleTest.cpp @@ -13,7 +13,6 @@ #include #include -#include using namespace nx::core; using namespace nx::core::UnitTest; diff --git a/src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md b/src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md new file mode 100644 index 0000000000..af7eff42fb --- /dev/null +++ b/src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md @@ -0,0 +1,87 @@ +# V&V Report: IdentifySampleFilter + +| | | +|---|---| +| Plugin | `SimplnxCore` | +| SIMPLNX UUID | `94d47495-5a89-4c7f-a0ee-5ff20e6bd273` | +| DREAM3D 6.5.171 equivalent | `IdentifySample` — UUID `0e8c0818-a3fb-57d4-a5c8-7cb8ae54a40a` | +| Verified commit | *pending* | +| Status | DRAFT | +| Sign-off | *pending* | + +## At a glance + +| Aspect | State | +|---|---| +| Algorithm relationship | **Port** (3D mode) + **1 deviation** (dimensionality dispatch) + new features (`SliceBySlice`, cancel checks) | +| Oracle | **Class 1 (Analytical)** for 3 non-square 2D tests; **Validated-circular** for 12 archive tests (not legacy-equivalent) | +| Code paths | **14 of 17** exercised; 3 gaps (1D dispatch, single-voxel, cancel-check) | +| Tests | **5 TEST_CASEs** (16 functional scenarios) — all pass | +| External archive | `identify_sample_v2.tar.gz` (active) + `identify_sample.tar.gz` (v1, orphaned) | +| Deviations | **1 active** (`IdentifySample-D1`): dimensionality dispatch — legacy correctness on degenerate geometries unverified/suspected wrong | +| Confirmed parity | `checked`-reset between BFS phases verified identical and correct in both versions (source-compared against legacy tag `v6.5.171`) | +| Open bugs | None | + +## Summary + +`IdentifySampleFilter` isolates the largest connected component of "good" voxels in an `ImageGeom`, clearing all smaller components. An optional `FillHoles` pass then closes interior holes — bad-voxel components that don't touch the volume boundary are flipped to good. `SliceBySlice` mode (new in SIMPLNX) applies the same two-pass logic independently per 2D slice. The algorithm is purely boolean/integer, so no floating-point precision drift is possible. The genuinely-3D path is a confirmed port of legacy `IdentifySample::execute()`, including an exact-match BFS `checked`-reset behavior between phases. One deviation is open: SIMPLNX's dimensionality-aware dispatch for degenerate (2D/1D/single-voxel) geometries has no verified legacy counterpart — legacy used a single fixed 3D-stride formula whose correctness on such inputs was never established and is suspected wrong. + +## Algorithm Relationship + +**Port** of the 3D BFS two-pass algorithm; **deviation** in dimensionality handling; **new** SliceBySlice mode. + +- **3D mode**: identical two-pass structure (largest-component isolation, then optional hole fill) to legacy. The `checked`-tracker reset between phases — a historically fragile point (see Deviations) — is confirmed correct and identical in both versions. +- **Dimensionality dispatch** (`ProcessVoxels<>`): routes to `Image3D`, `EmptyZ/Y/XImage2D`, `Z/Y/XImage1D`, or `SingleVoxelImage` neighbor templates based on which dims equal 1. Legacy always used the fixed 3D-stride formula regardless of shape. Classified as deviation `IdentifySample-D1` (not a plain new feature) because degenerate inputs were always legal in legacy — its behavior on them just was never validated. See deviations file. +- **New, no legacy path to compare against**: `SliceBySlice` mode (gated behind a parameter absent from DREAM3D 6.5.171 and unmapped by `FromSIMPLJson`); cancel checks (`m_ShouldCancel`); rate-limited progress messages. + +## Oracle + +| Test group | Class | Basis | +|---|---|---| +| 3 non-square 2D tests | **1 (Analytical)** | 12-voxel hand-built mask, expected output hard-coded; one fixture per `EmptyZ/Y/XImage2D` dispatch path | +| 12 archive tests (`identify_sample_v2.tar.gz`) | **Validated-circular** | Exemplars generated by SIMPLNX's own filter (confirmed via `Generate_Exemplars.py`) over a hand-designed, human-reviewed `16×14×12` feature layout. Stronger than bare-circular (documented features, human review) but **not** Class 2 — no legacy parity claim possible. None of the 12 exercise degenerate geometry, so they provide no coverage for `IdentifySample-D1`. | + +Full provenance detail, including the feature-layout table and the resolved "checked-reset" question, in `vv/provenance/IdentifySampleFilter.md`. + +## Code path coverage + +14 of 17 paths exercised. Source: `Algorithms/IdentifySample.cpp`. + +| # | Path | Exercised by | +|---|---|---| +| 1 | Dispatch: `SliceBySlice=false` → `ProcessVoxels` | `whole_*` + 3 non-square 2D tests | +| 2 | Dispatch: `SliceBySlice=true` → slice functor | `sliced_*` | +| 3 | Dim dispatch: `emptyDimCount==0` → `Image3D` | `whole_*` | +| 4–6 | Dim dispatch: `emptyDimCount==1` → `EmptyZ/Y/XImage2D` | 3 non-square 2D tests (one each) | +| 7 | Dim dispatch: `emptyDimCount==2` → 1D variants | *Not tested. Impractical/unused in practice; gap acceptable.* | +| 8 | Dim dispatch: `emptyDimCount==3` → `SingleVoxelImage` | *Not tested. Degenerate case; gap acceptable.* | +| 9–11 | BFS expansion, valid-neighbor add, boundary skip | All BFS tests | +| 12 | Clear non-largest component | `whole_*` + 3 non-square 2D tests | +| 13 | `FillHoles=false` → hole-fill skipped | `*_nofill` | +| 14 | `FillHoles=true`, enclosed → filled | `*_fill` | +| 15 | `FillHoles=true`, touches boundary → stays bad | `*_fill` | +| 16 | Cancel mid-scan → early return | *Not tested. Cancel disregard would hang any test; low-value gap.* | +| 17 | Slice plane selection (XY/XZ/YZ) | `sliced_xy/xz/yz_*` | + +## Test inventory + +| Test case | Notes | +|---|---| +| `IdentifySampleFilter` (12 sections) | Validated-circular; all SliceBySlice × plane × FillHoles combos | +| `SIMPL Backwards Compatibility` | 6.4 + 6.5 fixtures; UUID + arg-key + param decoding | +| `2D Empty Z/Y/X Non-Square` (×3) | Class 1; one per dimensionality dispatch path | + +5 TEST_CASEs, all pass (16 functional scenarios total). + +## Exemplar archive + +- **Active:** `identify_sample_v2.tar.gz` — SHA512 `a7ffac3e...848ac31`. Provenance: `vv/provenance/IdentifySampleFilter.md`. +- **Orphaned:** `identify_sample.tar.gz` (v1) — no active test references it; recommend removing its `download_test_data()` entry from `CMakeLists.txt`. + +## Deviations from DREAM3D 6.5.171 + +**3D mode:** No deviations — confirmed identical two-pass BFS structure, including the `checked`-reset between phases (source-compared against legacy tag `v6.5.171`, line 254; matches SIMPLNX `IdentifySample.cpp:112` and `:325`). + +**`IdentifySample-D1` (active):** Dimensionality dispatch for degenerate geometries. Legacy's fixed 3D-stride neighbor formula was never validated against 2D/1D/single-voxel inputs and is suspected incorrect; SIMPLNX's dispatch is explicit and Class 1 tested. Recommend trusting SIMPLNX. Full entry in `vv/deviations/IdentifySampleFilter.md`. + +**`SliceBySlice` and cancel checks:** Genuinely new, no legacy path to deviate from. diff --git a/src/Plugins/SimplnxCore/vv/deviations/IdentifySampleFilter.md b/src/Plugins/SimplnxCore/vv/deviations/IdentifySampleFilter.md new file mode 100644 index 0000000000..c78812aa47 --- /dev/null +++ b/src/Plugins/SimplnxCore/vv/deviations/IdentifySampleFilter.md @@ -0,0 +1,55 @@ +# Deviations from DREAM3D 6.5.171: IdentifySample + +This file lists every documented behavioral difference between this SIMPLNX filter and its DREAM3D 6.5.171 equivalent. + +Entries are referenced by stable ID (`IdentifySample-D`) from the V&V report and from public migration guidance. The ID is stable across renames; the Filter UUID field is the permanent cross-reference anchor. + +--- + +## 3D mode — no deviations + +Source-inspection comparison of the genuinely-3D path (`IdentifySampleFunctor`) against DREAM3D 6.5.171 `IdentifySample::execute()` confirmed identical algorithmic structure: + +- **Phase 1 (largest-component isolation):** BFS flood-fill over all good voxels; tracks the largest connected component; all good voxels outside that component are set to false/0. +- **Phase 2 (hole fill, optional):** BFS flood-fill over all bad voxels; connected components that do not reach the volume boundary are flipped to good. + +The algorithm is purely boolean/integer — no floating-point arithmetic — so precision drift cannot occur between two correct implementations of the same 3D logic. + +**Confirmed parity — `checked` reset between phases:** `vv/provenance/IdentifySampleFilter.md` documents an "Internal cluster" fixture in `identify_sample_v2.tar.gz`, purpose-built to catch a bug where the `checked` BFS-visited tracker is not reset between Phase 1 and Phase 2 — voxels visited (and marked `checked=true`) while being absorbed into a non-largest component during Phase 1 would then be skipped entirely during Phase 2's hole-fill scan, since `checked` would already be `true` for them, leaving them permanently un-filled even when they qualify as an enclosed hole. + +Direct source comparison confirms **both versions reset correctly and this is not a deviation**: + +- **Legacy** (`DREAM3D/Source/Plugins/Processing/ProcessingFilters/IdentifySample.cpp:254`, checked out at tag `v6.5.171`): `checked.assign(totalPoints, false);` immediately before the `m_FillHoles` block. +- **SIMPLNX 3D mode** (`Algorithms/IdentifySample.cpp:112`): `checked.assign(totalPoints, false);` immediately before the `if(fillHoles)` block. +- **SIMPLNX SliceBySlice mode** (`Algorithms/IdentifySample.cpp:325`): `checked.assign(planeDim1 * planeDim2, false);` immediately before its own `if(fillHoles)` block, scoped per-slice. + +The bug referenced in the test data's `generated_data/ReadMe.md` was a SIMPLNX-only regression at some prior point in development (already fixed in current source, as shown above) — it never existed in DREAM3D 6.5.171. The "Internal cluster" fixture remains in the archive as a guard against reintroducing it, not as evidence of any current or legacy deviation. + +--- + +## IdentifySample-D1 + +| Field | Value | +|---|---| +| **Deviation ID** | `IdentifySample-D1` | +| **Filter UUID** | `94d47495-5a89-4c7f-a0ee-5ff20e6bd273` | +| **Status** | Active — SIMPLNX defines correct behavior; legacy behavior for this input class is unverified and suspected incorrect | + +**Symptom:** For `ImageGeom` inputs with one or more dimensions equal to 1 (2D, 1D, or single-voxel geometries), `IdentifySampleFilter` output may differ from DREAM3D 6.5.171 `IdentifySample`. + +**Root cause:** Legacy `IdentifySample::execute()` always computes face-neighbor offsets from a single fixed 3D-stride formula (`±1`, `±dims[0]`, `±dims[0]·dims[1]`) sized for a true 3D volume. SIMPLNX's `ProcessVoxels<>` dispatch (`Algorithms/IdentifySample.cpp:393-440`) detects degenerate dimensions via `emptyDimCount` and routes to dimensionality-specific neighbor templates (`EmptyZ/Y/XImage2D`, `Z/Y/XImage1D`, `SingleVoxelImage`), each with neighbor-offset and boundary-validity logic sized for the actual number of non-flat axes. + +**Affected users:** Anyone running `IdentifySampleFilter` on a 2D, 1D, or single-voxel `ImageGeom` (e.g., a single-slice EBSD scan, a line scan, a single-point dataset) who expects numeric parity with a DREAM3D 6.5.171 pipeline run on the same degenerate input. + +**Recommendation:** Trust SIMPLNX. The dimensionality-aware dispatch is purpose-built and Class 1 tested (3 non-square 2D fixtures in `IdentifySampleTest.cpp`, one per `EmptyZ/Y/XImage2D` path) to produce correct face connectivity regardless of geometry shape. + +--- + +## New features (no legacy code path to compare against — not deviations) + +These differ from `IdentifySample-D1` in that no input could have triggered the corresponding legacy behavior at all — there is nothing to deviate from. + +- **`SliceBySlice` mode** (`IdentifySampleSliceBySliceFunctor`): gated behind a parameter (`SliceBySlice`) that does not exist in DREAM3D 6.5.171 and is not mapped by `FromSIMPLJson`. No legacy pipeline could have exercised this path. +- **Cancel checks** (`m_ShouldCancel`): UX-only; no algorithmic effect on a run that completes. + +*If a future run against DREAM3D 6.5.171 confirms (or refutes) the suspected incorrectness in `IdentifySample-D1`, update its Status field accordingly.* diff --git a/src/Plugins/SimplnxCore/vv/provenance/IdentifySampleFilter.md b/src/Plugins/SimplnxCore/vv/provenance/IdentifySampleFilter.md new file mode 100644 index 0000000000..e12214130c --- /dev/null +++ b/src/Plugins/SimplnxCore/vv/provenance/IdentifySampleFilter.md @@ -0,0 +1,122 @@ +# Test Data Provenance: IdentifySampleFilter + +This sidecar records how the test data used by `IdentifySampleFilter`'s unit tests was generated and what oracle class each data set represents. + +--- + +## Archive: `identify_sample_v2.tar.gz` (active) + +| Field | Value | +|---|---| +| **Data location** | `${DREAM3D_DATA_DIR}/identify_sample_v2/` — 12 `.dream3d` files named `{whole,sliced}_{xy,xz,yz}_{nofill,fill}.dream3d` | +| **Data format** | `.dream3d` (HDF5); each file contains an untouched input `Mask` array and a filter-mutated `Mask Exemplar` array | +| **Used by tests** | `SimplnxCore::IdentifySampleFilter` — 12 `SECTION` variants in `test/IdentifySampleTest.cpp` | +| **Generated by** | `Generate_Exemplars.py`, using the `simplnx` Python bindings directly (confirmed by source inspection — see below) | +| **Generated on** | Input data hand-validated 2026-02-17 by "MAJ" (per `ReadMe.md`); archive file timestamps 2026-03-06 | + +### Generation mechanism (confirmed circular for all 12 files) + +`Generate_Exemplars.py` (in the data directory) does the following for each of the 12 parameter combinations: +1. Creates a `16×14×12` `ImageGeom`. +2. Reads a pre-built mask text file (`generated_data/{whole|sliced}_{XY|XZ|YZ}_{nofill|fill}.txt`) into **both** `Mask` (left untouched — becomes the test's input) and `Mask Exemplar` (becomes the working copy). +3. Runs `nx.IdentifySampleFilter()` **in place on `Mask Exemplar`** — i.e., the "exemplar" is simply the output of SIMPLNX's own filter. +4. Writes both arrays to one `.dream3d` via `WriteDREAM3DFilter`. + +This means **all 12 files are mechanism-circular** — exemplars are produced by SIMPLNX itself, not an independent run of DREAM3D 6.5.171. + +### Input mask design is Class-1-style (hand-placed, documented features) + +`generated_data/ReadMe.md` documents the `16×14×12` input mask as a set of hand-placed rectangular features with known coordinates and known purpose, not random/procedural data: + +| Feature | Extent (X,Y,Z) | Size | Purpose | +|---|---|---|---| +| Main sample | [3,12]×[2,11]×[2,9] | 800 | Intended largest component — the "sample" | +| 3D Hole | [6,9]×[5,8]×[4,7] | 64 | Fully enclosed hole, exercises fill-holes BFS | +| Internal cluster | [7,8]×[6,7]×[5,6] | 8 | Island of good voxels *inside* the hole — purpose-built regression guard, see below | +| Noise A/B/C | 8 each | 8 | Disconnected clusters smaller than the sample in every relevant slice/3D — verify non-sample clusters are cleared | + +**Internal cluster is a targeted regression test**, not incidental data: per the ReadMe, it catches a known historical bug where the `checked` BFS-visited tracker was not reset between the largest-component pass and the hole-fill pass, which would leave these 8 voxels permanently un-filled. Current source (`IdentifySample.cpp:112`, `checked.assign(totalPoints, false);`) confirms the reset is present, so this fixture currently passes as a guard against reintroducing that regression. + +**"8 variations" reconciliation:** the top-level `ReadMe.md` states the data was hand-validated "for all 8 variations," while 12 files exist. This is consistent: per `generated_data/ReadMe.md`, the `plane` parameter is ignored when `slice_by_slice=OFF`, so the 6 `whole_*` files reduce to 2 functionally distinct scenarios (nofill/fill); combined with 6 functionally distinct `sliced_*` scenarios (3 planes × 2 fill modes), that totals 8 unique behaviors — matching the validation claim exactly. + +### Stale description in top-level `ReadMe.md` + +The top-level `ReadMe.md` opens by describing a `create_voxel_volume.py` script that generates "a 25×25×25 voxel volume with 3 cylinders cut out... centered along each axis" with random noise. **This does not match the actual archive**: the real geometry is `16×14×12` with hand-placed rectangular features (table above), and no `create_voxel_volume.py` file exists anywhere in the data directory. This paragraph appears to describe an earlier or abandoned generation approach and should not be relied on — the accurate description is `Generate_Exemplars.py` + `generated_data/ReadMe.md`. + +### Oracle classification + +**Validated-circular** for all 12 files — stronger than a bare circular oracle (the input design is fully documented and analytically understood, and a human reviewer verified the filter's output against that documented design for all 8 functionally distinct scenarios) but **not equivalent to a Class 2 (DREAM3D 6.5.171 reference) oracle**. No claim of legacy numeric parity can be drawn from these 12 files — they verify non-regression of SIMPLNX's own BFS logic (including the specific `checked`-reset regression), not correctness against an independent implementation. + +**Coverage gap relative to `IdentifySample-D1`:** this archive's geometry is `16×14×12` — no dimension equals 1 — so it never exercises the dimensionality-dispatch path that `IdentifySample-D1` flags as a deviation. That path is covered separately by the 3 inline non-square 2D Class 1 fixtures in `IdentifySampleTest.cpp` (see below), which remain the only oracle for degenerate-geometry behavior. + +### Recommendation + +The validated-circular classification is acceptable for its actual purpose (regression protection on the 3D BFS algorithm, with a deliberate guard against the `checked`-reset bug). It should **not** be cited as evidence of parity with DREAM3D 6.5.171. If genuine Class 2 confidence is later desired, the same hand-placed feature design documented in `generated_data/ReadMe.md` could be re-run through DREAM3D 6.5.171 directly — no new fixture design would be needed, only re-generation through the legacy tool. Lower-priority alternative: since the feature table already specifies expected behavior per-feature, the per-voxel expected output could be hand-derived from that table and encoded as inline `REQUIRE` assertions, which would upgrade this from "validated circular" to genuine Class 1 without any archive dependency. + +--- + +## Archive: `identify_sample.tar.gz` (v1, orphaned) + +| Field | Value | +|---|---| +| **Data location** | `${DREAM3D_DATA_DIR}/identify_sample/` | +| **Status** | **Orphaned.** Listed in `src/Plugins/SimplnxCore/test/CMakeLists.txt` with a `download_test_data()` entry but no active test references it. Superseded by v2. | +| **Action** | Remove the `download_test_data()` entry from `CMakeLists.txt`. | + +--- + +## Inline data: non-square 2D regression tests (Class 1) + +| Field | Value | +|---|---| +| **Data location** | Inline in `src/Plugins/SimplnxCore/test/IdentifySampleTest.cpp` — `CreateNonSquare2DMaskDataStructure()` + `RunIdentifySampleAndCheck()` | +| **Data format** | C++ source (no external file, no SHA512) | +| **Used by tests** | `2D Empty Z Non-Square {3,4,1}`, `2D Empty Y Non-Square {3,1,4}`, `2D Empty X Non-Square {1,3,4}` | +| **Oracle class** | **Class 1 (Analytical)** | +| **Generated by** | Inline test code; expected output is a hard-coded 12-element `bool` array | + +### How it was generated + +The fixture builds a `3 × 4` mask (in the two non-empty axes) with a specific pattern: + +```text +row 0: T T F +row 1: T T F +row 2: F F T +row 3: F F T +``` + +The top-left block (indices 0,1,3,4 in row-major order) is a 4-voxel connected component. The bottom-right block (indices 10,11) is a 2-voxel connected component. After `IdentifySampleFilter` runs (FillHoles=false, SliceBySlice=false), the expected output is the top-left component only: + +```text +row 0: T T F +row 1: T T F +row 2: F F F +row 3: F F F +``` + +The same 12-voxel layout is embedded in three different `SizeVec3` geometries: + +- `{3, 4, 1}` — exercises `EmptyZImage2D` dispatch (z=1) +- `{3, 1, 4}` — exercises `EmptyYImage2D` dispatch (y=1) +- `{1, 3, 4}` — exercises `EmptyXImage2D` dispatch (x=1) + +All three share identical row-major indexing, so the 12-element `values` and `expected` arrays in the test code are identical for all three. Any wrong row-stride in the dimensionality-templated flood-fill (such as using the 3D neighbor offset for a flat 2D geometry) would either merge the two components into one (incorrect outcome: all 12 voxels retained) or access an out-of-bounds index (test crash). Both failure modes produce a detectable test failure. + +These are the only tests that exercise degenerate-dimension behavior and are therefore the sole evidentiary basis for `IdentifySample-D1`'s claim that SIMPLNX's dimensionality dispatch is correct. + +--- + +## Canonical oracle output + +| DataPath | Source of expected values | +|---|---| +| `/Image Geometry/CellData/Mask` (after filter, whole/sliced archive tests) | Validated-circular: produced by SIMPLNX's own filter, human-reviewed against the documented feature table in `generated_data/ReadMe.md`. Not equivalent to a legacy reference. | +| `/Image Geometry/CellData/Mask` (after filter, non-square 2D tests) | Class 1: coded directly in `expected[]` array. | + +## Second-engineer oracle review + +- **Reviewer:** *Pending* + - *Confirm the feature-table-to-output mapping in `generated_data/ReadMe.md` is plausible for at least the `whole_xy_fill` and `sliced_xy_fill` cases (the two that exercise both the hole-fill BFS and the `checked`-reset regression guard).* + - *Review the non-square 2D fixture layout for plausibility — the 12-element pattern is small enough to verify by hand in ~5 minutes.* +- **Date:** *YYYY-MM-DD (pending)* From 1a15df236374c1e4275e0453a72f89ec978ce84f Mon Sep 17 00:00:00 2001 From: nyoungbq Date: Wed, 17 Jun 2026 13:08:24 -0400 Subject: [PATCH 2/3] properly define SingleVoxelImage Fill Holes handling --- .../src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp b/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp index 0a485be6a8..0d8f20c01d 100644 --- a/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp +++ b/src/Plugins/SimplnxCore/src/SimplnxCore/Filters/Algorithms/IdentifySample.cpp @@ -133,7 +133,10 @@ struct IdentifySampleFunctor if(!checked[voxelIndex] && !goodVoxels.getValue(voxelIndex)) { - bool touchesBoundary = false; + // The following is only initialized as true for SingleVoxelImage, + // the intention being to flag the voxel as a boundary for proper handling + // since the loop that would flag it will not execute with empty lists + bool touchesBoundary = k_NeighborCount == 0; currentVList.push_back(voxelIndex); usize count = 0; while(count < currentVList.size()) From 64f52458d07be7a23f9d808778c2746aca37097a Mon Sep 17 00:00:00 2001 From: nyoungbq Date: Wed, 17 Jun 2026 13:17:04 -0400 Subject: [PATCH 3/3] add completion stamp --- src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md b/src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md index af7eff42fb..dde236abeb 100644 --- a/src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md +++ b/src/Plugins/SimplnxCore/vv/IdentifySampleFilter.md @@ -6,8 +6,8 @@ | SIMPLNX UUID | `94d47495-5a89-4c7f-a0ee-5ff20e6bd273` | | DREAM3D 6.5.171 equivalent | `IdentifySample` — UUID `0e8c0818-a3fb-57d4-a5c8-7cb8ae54a40a` | | Verified commit | *pending* | -| Status | DRAFT | -| Sign-off | *pending* | +| Status | COMPLETE | +| Sign-off | Nathan Young, 06-17-2026 | ## At a glance