ENH: Add optional polar coloring output to MTRSimFilter

* Implement MTRSim::applyPolarColoring using IPFMapper with the MatLab
  HCP colour scheme and Z-axis reference direction
* Call applyPolarColoring from operator() when generatePolarColoring is true;
  short-circuits on error; leaves no array when the flag is false
* Add two unit tests: polar ON verifies array shape (3 components, 10000
  tuples) and non-zero content; polar OFF asserts array is absent

Signed-off-by: Michael Jackson <mike.jackson@bluequartz.net>

Author: imikejackson

src/MTRSim/Filters/Algorithms/MTRSim.cpp

@@ -3,8 +3,10 @@
 #include "simplnx/DataStructure/DataArray.hpp"
 #include "simplnx/DataStructure/Geometry/ImageGeom.hpp"
 
+#include "LibMTRSim/IPFMapper.hpp"
 #include "LibMTRSim/MTRSimDriver.hpp"
 
+#include <Eigen/Dense>
 #include <fmt/format.h>
 
 #include <exception>
@@ -102,7 +104,38 @@ Result<> MTRSim::operator()()
   }
 
   m_MessageHandler(IFilter::Message::Type::Info, "MTR simulation complete.");
-  // Polar coloring (Task 8) is handled in a later task; the optional array (if
-  // requested) is left created-but-unfilled here and populated next task.
+
+  if(m_InputValues->generatePolarColoring)
+  {
+    m_MessageHandler(IFilter::Message::Type::Info, "Computing polar coloring...");
+    auto colorResult = applyPolarColoring(sim, cellAm);
+    if(colorResult.invalid())
+    {
+      return colorResult;
+    }
+  }
+
+  return {};
+}
+
+// -----------------------------------------------------------------------------
+Result<> MTRSim::applyPolarColoring(const mtrsim::MTRSimResult& sim, const DataPath& cellAttrMatPath)
+{
+  const std::size_t N = sim.phi1.size();
+  Eigen::VectorXd phi1 = Eigen::Map<const Eigen::VectorXd>(sim.phi1.data(), static_cast<Eigen::Index>(N));
+  Eigen::VectorXd phi = Eigen::Map<const Eigen::VectorXd>(sim.phi.data(), static_cast<Eigen::Index>(N));
+  Eigen::VectorXd phi2 = Eigen::Map<const Eigen::VectorXd>(sim.phi2.data(), static_cast<Eigen::Index>(N));
+
+  mtrsim::IPFMapper mapper{mtrsim::CrystalSystem::HCP};
+  const std::vector<mtrsim::RGBColor> colors = mapper.eulerToColors(phi1, phi, phi2, {0.0, 0.0, 1.0}, mtrsim::IPFColorScheme::MatLab);
+
+  auto& rgb = m_DataStructure.getDataRefAs<UInt8Array>(cellAttrMatPath.createChildPath(m_InputValues->polarColorsArrayName));
+  auto& store = rgb.getDataStoreRef();
+  for(std::size_t i = 0; i < N; ++i)
+  {
+    store[i * 3 + 0] = colors[i].r;
+    store[i * 3 + 1] = colors[i].g;
+    store[i * 3 + 2] = colors[i].b;
+  }
   return {};
 }

src/MTRSim/Filters/Algorithms/MTRSim.hpp

@@ -6,6 +6,8 @@
 #include "simplnx/DataStructure/DataStructure.hpp"
 #include "simplnx/Filter/IFilter.hpp"
 
+#include "LibMTRSim/MTRSimDriver.hpp"
+
 #include <vector>
 
 namespace nx::core
@@ -48,6 +50,7 @@ class MTRSIM_EXPORT MTRSim
   Result<> operator()();
 
 private:
+  Result<> applyPolarColoring(const mtrsim::MTRSimResult& sim, const DataPath& cellAttrMatPath);
   DataStructure& m_DataStructure;
   const MTRSimInputValues* m_InputValues = nullptr;
   const std::atomic_bool& m_ShouldCancel;

test/MTRSimTest.cpp

@@ -248,6 +248,72 @@ TEST_CASE("MTRSim::MTRSimFilter: Rejects Volume Fraction not summing to 1.0", "[
   SIMPLNX_RESULT_REQUIRE_INVALID(preflightResult.outputActions);
 }
 
+TEST_CASE("MTRSim::MTRSimFilter: Execute with polar coloring ON fills Polar Colors array", "[MTRSim][MTRSimFilter]")
+{
+  UnitTest::LoadPlugins();
+
+  DataStructure dataStructure;
+  const std::vector<DataPath> compPaths = BuildOdfDataStructure(dataStructure, 3);
+  for(const auto& path : compPaths)
+  {
+    auto& arr = dataStructure.getDataRefAs<Float64Array>(path);
+    arr.fill(1.0);
+  }
+
+  MTRSimFilter filter;
+  Arguments args = MakeValidArgs(compPaths);
+  args.insertOrAssign(MTRSimFilter::k_GeneratePolarColoring_Key, true);
+  args.insertOrAssign(MTRSimFilter::k_UseSeed_Key, true);
+  args.insertOrAssign(MTRSimFilter::k_SeedValue_Key, static_cast<uint64>(42));
+
+  auto preflightResult = filter.preflight(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions);
+
+  auto executeResult = filter.execute(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result);
+
+  const DataPath cellAm = DataPath({"MTR Microstructure"}).createChildPath("Cell Data");
+  constexpr usize expectedTuples = 100 * 100;
+
+  auto& rgb = dataStructure.getDataRefAs<UInt8Array>(cellAm.createChildPath("Polar Colors"));
+  REQUIRE(rgb.getNumberOfComponents() == 3);
+  REQUIRE(rgb.getNumberOfTuples() == expectedTuples);
+  uint64 sum = 0;
+  for(usize i = 0; i < rgb.getSize(); ++i)
+  {
+    sum += rgb[i];
+  }
+  REQUIRE(sum > 0);
+}
+
+TEST_CASE("MTRSim::MTRSimFilter: Execute with polar coloring OFF omits Polar Colors array", "[MTRSim][MTRSimFilter]")
+{
+  UnitTest::LoadPlugins();
+
+  DataStructure dataStructure;
+  const std::vector<DataPath> compPaths = BuildOdfDataStructure(dataStructure, 3);
+  for(const auto& path : compPaths)
+  {
+    auto& arr = dataStructure.getDataRefAs<Float64Array>(path);
+    arr.fill(1.0);
+  }
+
+  MTRSimFilter filter;
+  Arguments args = MakeValidArgs(compPaths);
+  // k_GeneratePolarColoring_Key is false by default in MakeValidArgs
+  args.insertOrAssign(MTRSimFilter::k_UseSeed_Key, true);
+  args.insertOrAssign(MTRSimFilter::k_SeedValue_Key, static_cast<uint64>(42));
+
+  auto preflightResult = filter.preflight(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_VALID(preflightResult.outputActions);
+
+  auto executeResult = filter.execute(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_VALID(executeResult.result);
+
+  const DataPath cellAm = DataPath({"MTR Microstructure"}).createChildPath("Cell Data");
+  REQUIRE(dataStructure.getDataAs<UInt8Array>(cellAm.createChildPath("Polar Colors")) == nullptr);
+}
+
 TEST_CASE("MTRSim::MTRSimFilter: Rejects Theta List rows with wrong column count", "[MTRSim][MTRSimFilter][ErrorPath]")
 {
   UnitTest::LoadPlugins();