TEST: Add 200x200x200 benchmark for NeighborOrientationCorrelation

Adds a dedicated benchmark test case with programmatic block-based EBSD
data (25^3 grain blocks, low CI at boundaries, cubic crystal structure).
Benchmark results: IC 2.19s→1.74s (1.26x), OOC 67.94s→18.62s (3.65x).

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>

Author: joeykleingers

src/Plugins/OrientationAnalysis/test/NeighborOrientationCorrelationTest.cpp

@@ -3,14 +3,18 @@
 #include "OrientationAnalysisTestUtils.hpp"
 
 #include "simplnx/Core/Application.hpp"
+#include "simplnx/DataStructure/AttributeMatrix.hpp"
+#include "simplnx/DataStructure/Geometry/ImageGeom.hpp"
 #include "simplnx/Parameters/ArraySelectionParameter.hpp"
 #include "simplnx/Parameters/BoolParameter.hpp"
 #include "simplnx/Parameters/Dream3dImportParameter.hpp"
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
+#include "simplnx/Parameters/MultiArraySelectionParameter.hpp"
 #include "simplnx/UnitTest/UnitTestCommon.hpp"
 
 #include <catch2/catch.hpp>
 
+#include <cmath>
 #include <filesystem>
 
 namespace fs = std::filesystem;
@@ -196,3 +200,108 @@ TEST_CASE("OrientationAnalysis::NeighborOrientationCorrelationFilter: Small IN10
 
   UnitTest::CheckArraysInheritTupleDims(dataStructure, SmallIn100::k_TupleCheckIgnoredPaths);
 }
+
+TEST_CASE("OrientationAnalysis::NeighborOrientationCorrelationFilter: Benchmark 200x200x200", "[OrientationAnalysis][NeighborOrientationCorrelationFilter][Benchmark]")
+{
+  UnitTest::LoadPlugins();
+  // 200x200x200, Quats (float32, 4-comp) => 200*200*4*4 = 640,000 bytes/slice
+  const UnitTest::PreferencesSentinel prefsSentinel("Zarr", 640000, true);
+
+  constexpr usize kDimX = 200;
+  constexpr usize kDimY = 200;
+  constexpr usize kDimZ = 200;
+  constexpr usize kTotalVoxels = kDimX * kDimY * kDimZ;
+  const ShapeType cellTupleShape = {kDimZ, kDimY, kDimX};
+  const auto benchmarkFile = fs::path(fmt::format("{}/neighbor_orientation_correlation_benchmark.dream3d", unit_test::k_BinaryTestOutputDir));
+
+  // Stage 1: Build data programmatically and write to .dream3d
+  {
+    DataStructure buildDS;
+    auto* imageGeom = ImageGeom::Create(buildDS, "Image Geometry");
+    imageGeom->setDimensions({kDimX, kDimY, kDimZ});
+    imageGeom->setSpacing({1.0f, 1.0f, 1.0f});
+    imageGeom->setOrigin({0.0f, 0.0f, 0.0f});
+
+    auto* cellAM = AttributeMatrix::Create(buildDS, "Cell Data", cellTupleShape, imageGeom->getId());
+    imageGeom->setCellData(*cellAM);
+
+    // Quaternions: block-based orientations with noise at boundaries
+    auto* quatsArray = UnitTest::CreateTestDataArray<float32>(buildDS, "Quats", cellTupleShape, {4}, cellAM->getId());
+    auto& quatsStore = quatsArray->getDataStoreRef();
+
+    // Phases: all phase 1 (cubic)
+    auto* phasesArray = UnitTest::CreateTestDataArray<int32>(buildDS, "Phases", cellTupleShape, {1}, cellAM->getId());
+    auto& phasesStore = phasesArray->getDataStoreRef();
+
+    // Confidence Index: low at block boundaries, high inside blocks
+    auto* ciArray = UnitTest::CreateTestDataArray<float32>(buildDS, "Confidence Index", cellTupleShape, {1}, cellAM->getId());
+    auto& ciStore = ciArray->getDataStoreRef();
+
+    constexpr usize kBlockSize = 25;
+    constexpr usize kBlocksPerDim = kDimX / kBlockSize;
+    for(usize z = 0; z < kDimZ; z++)
+    {
+      for(usize y = 0; y < kDimY; y++)
+      {
+        for(usize x = 0; x < kDimX; x++)
+        {
+          const usize idx = z * kDimX * kDimY + y * kDimX + x;
+          phasesStore[idx] = 1;
+
+          // Block-based orientation: each 25^3 block gets a distinct quaternion
+          usize bx = x / kBlockSize;
+          usize by = y / kBlockSize;
+          usize bz = z / kBlockSize;
+          float32 angle = static_cast<float32>(bz * kBlocksPerDim * kBlocksPerDim + by * kBlocksPerDim + bx) * 0.1f;
+          float32 sinHalf = std::sin(angle * 0.5f);
+          float32 cosHalf = std::cos(angle * 0.5f);
+
+          const usize qIdx = idx * 4;
+          quatsStore[qIdx] = cosHalf;
+          quatsStore[qIdx + 1] = sinHalf * 0.577350269f; // 1/sqrt(3)
+          quatsStore[qIdx + 2] = sinHalf * 0.577350269f;
+          quatsStore[qIdx + 3] = sinHalf * 0.577350269f;
+
+          // Low CI at block boundaries (~10% of voxels), high CI inside
+          bool isBoundary = (x % kBlockSize == 0) || (y % kBlockSize == 0) || (z % kBlockSize == 0);
+          bool isNoisy = ((x * 7 + y * 13 + z * 29) % 10 == 0);
+          ciStore[idx] = (isBoundary || isNoisy) ? 0.05f : 0.9f;
+        }
+      }
+    }
+
+    // Ensemble data: Crystal Structures (1 entry for phase 0 = unknown, 1 entry for phase 1 = cubic)
+    auto* ensembleAM = AttributeMatrix::Create(buildDS, "Ensemble Data", {2}, imageGeom->getId());
+    auto* crystalStructuresArray = UnitTest::CreateTestDataArray<uint32>(buildDS, "CrystalStructures", {2}, {1}, ensembleAM->getId());
+    auto& crystalStructuresStore = crystalStructuresArray->getDataStoreRef();
+    crystalStructuresStore[0] = 999; // Unknown
+    crystalStructuresStore[1] = 1;   // Cubic-High (m-3m)
+
+    UnitTest::WriteTestDataStructure(buildDS, benchmarkFile);
+  }
+
+  // Stage 2: Reload (arrays become ZarrStore in OOC) and run filter
+  DataStructure dataStructure = UnitTest::LoadDataStructure(benchmarkFile);
+
+  {
+    const NeighborOrientationCorrelationFilter filter;
+    Arguments args;
+
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_ImageGeometryPath_Key, std::make_any<DataPath>(DataPath({"Image Geometry"})));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_MinConfidence_Key, std::make_any<float32>(0.2f));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_MisorientationTolerance_Key, std::make_any<float32>(5.0f));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_Level_Key, std::make_any<int32>(2));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_CorrelationArrayPath_Key, std::make_any<DataPath>(DataPath({"Image Geometry", "Cell Data", "Confidence Index"})));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_CellPhasesArrayPath_Key, std::make_any<DataPath>(DataPath({"Image Geometry", "Cell Data", "Phases"})));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_QuatsArrayPath_Key, std::make_any<DataPath>(DataPath({"Image Geometry", "Cell Data", "Quats"})));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_CrystalStructuresArrayPath_Key, std::make_any<DataPath>(DataPath({"Image Geometry", "Ensemble Data", "CrystalStructures"})));
+    args.insertOrAssign(NeighborOrientationCorrelationFilter::k_IgnoredDataArrayPaths_Key, std::make_any<MultiArraySelectionParameter::ValueType>(MultiArraySelectionParameter::ValueType{}));
+
+    auto preflightResult = filter.preflight(dataStructure, args);
+    SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions);
+    auto executeResult = filter.execute(dataStructure, args, nullptr, IFilter::MessageHandler{[](const IFilter::Message& message) { fmt::print("{}\n", message.message); }});
+    SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result);
+  }
+
+  fs::remove(benchmarkFile);
+}