BUG: Enforce component shapes and types that filters read

src/Plugins/OrientationAnalysis/docs/ComputeGBCDPoleFigureFilter.md

@@ -14,6 +14,8 @@ The GBCD is a 5-dimensional histogram that captures the statistical distribution
 
 ![Using ParaView's Threshold filter + Cells to Points + Delaunay2D Filters](Images/Small_IN100_GBCD_Delaunay2D.png)
 
+The GBCD DataArray must have the 6-dimension component shape that Compute GBCD creates (5 positive bin dimensions followed by a final dimension of 2 hemispheres).
+
 ## Algorithm
 
 The image spans the stereographic projection square [-1,1] x [-1,1]. The coordinates are projection values, not lengths, so the geometry length unit is "Unspecified".

src/Plugins/OrientationAnalysis/docs/ComputeShapesFilter.md

@@ -36,6 +36,8 @@ For shape analysis on triangle geometry meshes rather than voxelized image geome
 
 % Auto generated parameter table will be inserted here
 
+**Cell Feature Ids** must have 1 component.
+
 ## References
 
 [1] Representation and Reconstruction of Three-dimensional Microstructures in Ni-based Superalloys, AFOSR FA9550-07-1-0179 Final Report, 20 Dec 2010.

src/Plugins/OrientationAnalysis/docs/ComputeShapesTriangleGeomFilter.md

@@ -47,6 +47,8 @@ but any shape with clear sharp corners may be affected.
 
 % Auto generated parameter table will be inserted here
 
+**Face Feature Centroids** must have 3 components.
+
 ## References
 
 [1] Representation and Reconstruction of Three-dimensional Microstructures in Ni-based Superalloys, AFOSR

src/Plugins/OrientationAnalysis/docs/WriteGBCDGMTFileFilter.md

@@ -37,6 +37,8 @@ It samples the GBCD for the selected phase and misorientation and writes the res
 
 % Auto generated parameter table will be inserted here
 
+The GBCD DataArray must have the 6-dimension component shape that Compute GBCD creates (5 positive bin dimensions followed by a final dimension of 2 hemispheres).
+
 ## Example Pipelines
 
 + (08) Small IN100 GBCD

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/ComputeGBCDPoleFigureFilter.cpp

@@ -17,6 +17,9 @@
 
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
+#include <fmt/ranges.h>
+
+#include <algorithm>
 #include <filesystem>
 
 using namespace nx::core;
@@ -109,6 +112,14 @@ IFilter::PreflightResult ComputeGBCDPoleFigureFilter::preflightImpl(const DataSt
 
   const auto& gbcd = dataStructure.getDataRefAs<Float64Array>(pGBCDArrayPathValue);
 
+  const auto componentShape = gbcd.getComponentShape();
+  if(componentShape.size() != 6 || componentShape[5] != 2 || std::any_of(componentShape.begin(), componentShape.end(), [](usize dimension) { return dimension == 0; }))
+  {
+    return {MakeErrorResult<OutputActions>(-34645, fmt::format("The DataArray '{}' selected for **Input GBCD** has component shape [{}]. The GBCD DataArray must have 6 component dimensions: 5 "
+                                                               "positive bin dimensions followed by a final dimension of 2 (hemispheres).",
+                                                               pGBCDArrayPathValue.toString(), fmt::join(componentShape, ", ")))};
+  }
+
   auto numEnsembles = gbcd.getNumberOfTuples();
   if(pPhaseOfInterestValue >= numEnsembles)
   {

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/ComputeShapesFilter.cpp

@@ -57,7 +57,7 @@ Parameters ComputeShapesFilter::parameters() const
                                                              GeometrySelectionParameter::AllowedTypes{IGeometry::Type::Image}));
   params.insertSeparator(Parameters::Separator{"Input Cell Data"});
   params.insert(std::make_unique<ArraySelectionParameter>(k_CellFeatureIdsArrayPath_Key, "Cell Feature Ids", "Specifies to which feature each cell belongs.", DataPath({"Cell Data", "FeatureIds"}),
-                                                          ArraySelectionParameter::AllowedTypes{DataType::int32}));
+                                                          ArraySelectionParameter::AllowedTypes{DataType::int32}, ArraySelectionParameter::AllowedComponentShapes{{1}}));
 
   params.insertSeparator(Parameters::Separator{"Input Feature Data"});
   params.insert(std::make_unique<ArraySelectionParameter>(k_CentroidsArrayPath_Key, "Feature Centroids", "X, Y, Z coordinates of Feature center of mass", DataPath({"Centroids"}),

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/ComputeShapesTriangleGeomFilter.cpp

@@ -60,7 +60,8 @@ Parameters ComputeShapesTriangleGeomFilter::parameters() const
                                                                     "The DataPath to the AttributeMatrix that holds feature data for the faces",
                                                                     DataPath({"TriangleDataContainer", "Face Feature Data"})));
   params.insert(std::make_unique<ArraySelectionParameter>(k_CentroidsArrayPath_Key, "Face Feature Centroids", "Input DataPath to the **Feature Centroids** for the face data",
-                                                          DataPath({"Face Feature Data", "Centroids"}), ArraySelectionParameter::AllowedTypes{DataType::float32}));
+                                                          DataPath({"Face Feature Data", "Centroids"}), ArraySelectionParameter::AllowedTypes{DataType::float32},
+                                                          ArraySelectionParameter::AllowedComponentShapes{{3}}));
 
   params.insertSeparator(Parameters::Separator{"Output Face Feature Data"});
   params.insert(std::make_unique<DataObjectNameParameter>(k_Omega3sArrayName_Key, "Omega3s", "The name of the DataArray that holds the calculated Omega3 values", "Omega3s"));

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/WriteGBCDGMTFileFilter.cpp

@@ -12,6 +12,9 @@
 
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
+#include <fmt/ranges.h>
+
+#include <algorithm>
 #include <filesystem>
 
 namespace fs = std::filesystem;
@@ -108,6 +111,14 @@ IFilter::PreflightResult WriteGBCDGMTFileFilter::preflightImpl(const DataStructu
 
   const auto& gbcd = dataStructure.getDataRefAs<Float64Array>(pGBCDArrayPathValue);
 
+  const auto componentShape = gbcd.getComponentShape();
+  if(componentShape.size() != 6 || componentShape[5] != 2 || std::any_of(componentShape.begin(), componentShape.end(), [](usize dimension) { return dimension == 0; }))
+  {
+    return {MakeErrorResult<OutputActions>(-96713, fmt::format("The DataArray '{}' selected for **GBCD** has component shape [{}]. The GBCD DataArray must have 6 component dimensions: 5 positive bin "
+                                                               "dimensions followed by a final dimension of 2 (hemispheres).",
+                                                               pGBCDArrayPathValue.toString(), fmt::join(componentShape, ", ")))};
+  }
+
   auto numEnsembles = gbcd.getNumberOfTuples();
   if(pPhaseOfInterestValue >= numEnsembles)
   {

src/Plugins/OrientationAnalysis/test/ComputeGBCDPoleFigureTest.cpp

@@ -270,3 +270,29 @@ TEST_CASE("OrientationAnalysis::ComputeGBCDPoleFigureFilter: Phase and Laue Inde
 
   UnitTest::CheckArraysInheritTupleDims(dataStructure);
 }
+
+TEST_CASE("OrientationAnalysis::ComputeGBCDPoleFigureFilter: Invalid GBCD Component Shape", "[OrientationAnalysis][ComputeGBCDPoleFigureFilter][ComponentShape]")
+{
+  const auto componentShape = GENERATE(ShapeType{1}, ShapeType{2, 2, 2, 2, 2, 1}, ShapeType{0, 2, 2, 2, 2, 2}, ShapeType{2, 0, 2, 2, 2, 2}, ShapeType{2, 2, 0, 2, 2, 2}, ShapeType{2, 2, 2, 0, 2, 2},
+                                       ShapeType{2, 2, 2, 2, 0, 2});
+  CAPTURE(componentShape);
+
+  DataStructure dataStructure;
+  const DataPath gbcdPath({"Malformed GBCD"});
+  const DataPath crystalStructuresPath({"Crystal Structures"});
+  auto* gbcd = UnitTest::CreateTestDataArray<float64>(dataStructure, gbcdPath.getTargetName(), {2}, componentShape);
+  REQUIRE(gbcd != nullptr);
+  auto* crystalStructures = UnitTest::CreateTestDataArray<uint32>(dataStructure, crystalStructuresPath.getTargetName(), {2}, {1});
+  REQUIRE(crystalStructures != nullptr);
+
+  ComputeGBCDPoleFigureFilter filter;
+  Arguments args = filter.getDefaultArguments();
+  args.insertOrAssign(ComputeGBCDPoleFigureFilter::k_PhaseOfInterest_Key, std::make_any<int32>(1));
+  args.insertOrAssign(ComputeGBCDPoleFigureFilter::k_GBCDArrayPath_Key, std::make_any<DataPath>(gbcdPath));
+  args.insertOrAssign(ComputeGBCDPoleFigureFilter::k_CrystalStructuresArrayPath_Key, std::make_any<DataPath>(crystalStructuresPath));
+
+  auto preflightResult = filter.preflight(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_INVALID(preflightResult.outputActions);
+  REQUIRE(preflightResult.outputActions.errors().size() == 1);
+  REQUIRE(preflightResult.outputActions.errors()[0].code == -34645);
+}

src/Plugins/OrientationAnalysis/test/ComputeShapesFilterTest.cpp

@@ -11,6 +11,7 @@
 #include "simplnx/Pipeline/PipelineFilter.hpp"
 #include "simplnx/UnitTest/UnitTestCommon.hpp"
 
+#include <algorithm>
 #include <catch2/catch.hpp>
 
 #include <filesystem>
@@ -186,3 +187,41 @@ TEST_CASE("OrientationAnalysis::ComputeShapesFilter: Geometry cell tuple count",
     REQUIRE(errorRef.message.find("'Grid' has 12 cells") != std::string::npos);
   }
 }
+
+TEST_CASE("OrientationAnalysis::ComputeShapesFilter: Cell Feature Ids requires 1 component", "[OrientationAnalysis][ComputeShapesFilter][ComponentShape]")
+{
+  DataStructure dataStructure;
+  auto* imageGeom = ImageGeom::Create(dataStructure, "Image");
+  REQUIRE(imageGeom != nullptr);
+  imageGeom->setDimensions({2, 1, 1});
+  imageGeom->setSpacing({1.0F, 1.0F, 1.0F});
+  imageGeom->setOrigin({0.0F, 0.0F, 0.0F});
+  auto* cellData = AttributeMatrix::Create(dataStructure, "Cell Data", {1, 1, 2}, imageGeom->getId());
+  REQUIRE(cellData != nullptr);
+  imageGeom->setCellData(*cellData);
+  auto* featureIds = UnitTest::CreateTestDataArray<int32>(dataStructure, "Feature Ids", {1, 1, 2}, {2}, cellData->getId());
+  (*featureIds)[0] = 1;
+  (*featureIds)[1] = 0;
+  (*featureIds)[2] = 2;
+  (*featureIds)[3] = 0;
+  auto* featureData = AttributeMatrix::Create(dataStructure, "Feature Data", {3}, imageGeom->getId());
+  REQUIRE(featureData != nullptr);
+  auto* centroids = UnitTest::CreateTestDataArray<float32>(dataStructure, "Centroids", {3}, {3}, featureData->getId());
+  (*centroids)[3] = 0.5F;
+  (*centroids)[4] = 0.5F;
+  (*centroids)[5] = 0.5F;
+  (*centroids)[6] = 1.5F;
+  (*centroids)[7] = 0.5F;
+  (*centroids)[8] = 0.5F;
+
+  ComputeShapesFilter filter;
+  auto args = filter.getDefaultArguments();
+  args.insertOrAssign(ComputeShapesFilter::k_SelectedImageGeometryPath_Key, std::make_any<DataPath>(DataPath({"Image"})));
+  args.insertOrAssign(ComputeShapesFilter::k_CellFeatureIdsArrayPath_Key, std::make_any<DataPath>(DataPath({"Image", "Cell Data", "Feature Ids"})));
+  args.insertOrAssign(ComputeShapesFilter::k_CentroidsArrayPath_Key, std::make_any<DataPath>(DataPath({"Image", "Feature Data", "Centroids"})));
+
+  auto preflightResult = filter.preflight(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_INVALID(preflightResult.outputActions);
+  REQUIRE(std::any_of(preflightResult.outputActions.errors().begin(), preflightResult.outputActions.errors().end(), [](const Error& error) { return error.code == -208; }));
+  UnitTest::CheckArraysInheritTupleDims(dataStructure);
+}

src/Plugins/OrientationAnalysis/test/ComputeShapesTriangleGeomTest.cpp

@@ -1,11 +1,13 @@
 #include "OrientationAnalysis/Filters/ComputeShapesTriangleGeomFilter.hpp"
 #include "OrientationAnalysis/OrientationAnalysis_test_dirs.hpp"
 
+#include "simplnx/DataStructure/Geometry/TriangleGeom.hpp"
 #include "simplnx/Parameters/ArrayCreationParameter.hpp"
 #include "simplnx/Parameters/DataObjectNameParameter.hpp"
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
 #include "simplnx/UnitTest/UnitTestCommon.hpp"
 
+#include <algorithm>
 #include <catch2/catch.hpp>
 
 #include <filesystem>
@@ -94,3 +96,41 @@ TEST_CASE("OrientationAnalysis::ComputeShapesTriangleGeom", "[OrientationAnalysi
 
   UnitTest::CheckArraysInheritTupleDims(exemplarDataStructure);
 }
+
+TEST_CASE("OrientationAnalysis::ComputeShapesTriangleGeom: Face Feature Centroids requires 3 components", "[OrientationAnalysis][ComputeShapesTriangleGeom][ComponentShape]")
+{
+  DataStructure dataStructure;
+  auto* triangleGeom = TriangleGeom::Create(dataStructure, "Triangles");
+  REQUIRE(triangleGeom != nullptr);
+  auto* vertices = UnitTest::CreateTestDataArray<float32>(dataStructure, "Vertices", {3}, {3}, triangleGeom->getId());
+  triangleGeom->setVertices(*vertices);
+  triangleGeom->setVertexCoordinate(0, {0.0F, 0.0F, 0.0F});
+  triangleGeom->setVertexCoordinate(1, {1.0F, 0.0F, 0.0F});
+  triangleGeom->setVertexCoordinate(2, {0.0F, 1.0F, 0.0F});
+  auto* faces = UnitTest::CreateTestDataArray<IGeometry::MeshIndexType>(dataStructure, "Faces", {1}, {3}, triangleGeom->getId());
+  (*faces)[0] = 0;
+  (*faces)[1] = 1;
+  (*faces)[2] = 2;
+  triangleGeom->setFaceList(*faces);
+  auto* faceData = AttributeMatrix::Create(dataStructure, "Face Data", {1}, triangleGeom->getId());
+  REQUIRE(faceData != nullptr);
+  triangleGeom->setFaceAttributeMatrix(*faceData);
+  auto* labels = UnitTest::CreateTestDataArray<int32>(dataStructure, "Face Labels", {1}, {2}, faceData->getId());
+  (*labels)[0] = 1;
+  (*labels)[1] = 0;
+  auto* featureData = AttributeMatrix::Create(dataStructure, "Feature Data", {2}, triangleGeom->getId());
+  REQUIRE(featureData != nullptr);
+  UnitTest::CreateTestDataArray<float32>(dataStructure, "Centroids", {2}, {1}, featureData->getId());
+
+  ComputeShapesTriangleGeomFilter filter;
+  auto args = filter.getDefaultArguments();
+  args.insertOrAssign(ComputeShapesTriangleGeomFilter::k_TriGeometryDataPath_Key, std::make_any<DataPath>(DataPath({"Triangles"})));
+  args.insertOrAssign(ComputeShapesTriangleGeomFilter::k_FaceLabelsArrayPath_Key, std::make_any<DataPath>(DataPath({"Triangles", "Face Data", "Face Labels"})));
+  args.insertOrAssign(ComputeShapesTriangleGeomFilter::k_FeatureAttributeMatrixPath_Key, std::make_any<DataPath>(DataPath({"Triangles", "Feature Data"})));
+  args.insertOrAssign(ComputeShapesTriangleGeomFilter::k_CentroidsArrayPath_Key, std::make_any<DataPath>(DataPath({"Triangles", "Feature Data", "Centroids"})));
+
+  auto preflightResult = filter.preflight(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_INVALID(preflightResult.outputActions);
+  REQUIRE(std::any_of(preflightResult.outputActions.errors().begin(), preflightResult.outputActions.errors().end(), [](const Error& error) { return error.code == -208; }));
+  UnitTest::CheckArraysInheritTupleDims(dataStructure);
+}

src/Plugins/OrientationAnalysis/test/WriteGBCDGMTFileTest.cpp

@@ -479,3 +479,30 @@ TEST_CASE("OrientationAnalysis::WriteGBCDGMTFileFilter: SIMPL Backwards Compatib
     }
   }
 }
+
+TEST_CASE("OrientationAnalysis::WriteGBCDGMTFileFilter: Invalid GBCD Component Shape", "[OrientationAnalysis][WriteGBCDGMTFile][ComponentShape]")
+{
+  const auto componentShape = GENERATE(ShapeType{1}, ShapeType{2, 2, 2, 2, 2, 1}, ShapeType{0, 2, 2, 2, 2, 2}, ShapeType{2, 0, 2, 2, 2, 2}, ShapeType{2, 2, 0, 2, 2, 2}, ShapeType{2, 2, 2, 0, 2, 2},
+                                       ShapeType{2, 2, 2, 2, 0, 2});
+  CAPTURE(componentShape);
+
+  DataStructure dataStructure;
+  const DataPath gbcdPath({"Malformed GBCD"});
+  const DataPath crystalStructuresPath({"Crystal Structures"});
+  auto* gbcd = UnitTest::CreateTestDataArray<float64>(dataStructure, gbcdPath.getTargetName(), {2}, componentShape);
+  REQUIRE(gbcd != nullptr);
+  auto* crystalStructures = UnitTest::CreateTestDataArray<uint32>(dataStructure, crystalStructuresPath.getTargetName(), {2}, {1});
+  REQUIRE(crystalStructures != nullptr);
+
+  WriteGBCDGMTFileFilter filter;
+  Arguments args = filter.getDefaultArguments();
+  args.insertOrAssign(WriteGBCDGMTFileFilter::k_PhaseOfInterest_Key, std::make_any<int32>(1));
+  args.insertOrAssign(WriteGBCDGMTFileFilter::k_GBCDArrayPath_Key, std::make_any<DataPath>(gbcdPath));
+  args.insertOrAssign(WriteGBCDGMTFileFilter::k_CrystalStructuresArrayPath_Key, std::make_any<DataPath>(crystalStructuresPath));
+  args.insertOrAssign(WriteGBCDGMTFileFilter::k_OutputFile_Key, std::make_any<fs::path>(fs::path(unit_test::k_BinaryTestOutputDir.view()) / "invalid_gbcd_shape.dat"));
+
+  auto preflightResult = filter.preflight(dataStructure, args);
+  SIMPLNX_RESULT_REQUIRE_INVALID(preflightResult.outputActions);
+  REQUIRE(preflightResult.outputActions.errors().size() == 1);
+  REQUIRE(preflightResult.outputActions.errors()[0].code == -96713);
+}

src/Plugins/SimplnxCore/docs/ComputeFeaturePhasesBinaryFilter.md

@@ -16,6 +16,8 @@ This **Filter** is generally useful any time data has already been reduced to a
 
 % Auto generated parameter table will be inserted here
 
+**Cell Feature Ids** must have 1 component.
+
 ## License & Copyright
 
 Please see the description file distributed with this **Plugin**

src/Plugins/SimplnxCore/docs/ComputeKMeansFilter.md

@@ -12,6 +12,8 @@ This **Filter** applies the k means algorithm to an **Attribute Array**.  K mean
 
 Each cluster is summarized by its **centroid**, which is the arithmetic mean (the average position) of all the points assigned to that cluster.  A k means partitioning is a *Voronoi tessellation*: every point is assigned to the cluster whose centroid is closest to it, so the data space is carved into regions where each region contains all the points nearer to one centroid than to any other.  An optimal solution to the k means problem is one in which each point is associated with the cluster that has the closest mean.  This partitioning minimizes the **within-cluster variance**, that is, the sum over all clusters of the squared distances from each point to its cluster centroid; minimizing it makes the points within each cluster as tightly grouped as possible.  The user may select from several distance metrics: *Euclidean*, *Squared Euclidean*, *Manhattan*, *Cosine*, *Pearson*, and *Squared Pearson*.
 
+When **Use Mask Array** is enabled, **Cell Mask Array** must have 1 component and the same number of tuples as **Attribute Array to Cluster**.
+
 ## Algorithm
 
 Initial centroids are drawn uniformly, with replacement, from all selected tuples. A seed gives different initial centroids than in earlier DREAM3D-NX versions.

src/Plugins/SimplnxCore/docs/ComputeKMedoidsFilter.md

@@ -64,6 +64,8 @@ The filter creates a *cluster Ids* array (one dimensionless integer cluster labe
 
 - **Clustered Attribute Array** -- any **Attribute Array** (cell-level, feature-level, or generic) whose tuples are to be partitioned into clusters. This is typically an output of an earlier computation or import step.
 
+When **Use Mask Array** is enabled, **Mask Array** must have 1 component and the same number of tuples as **Attribute Array to Cluster**.
+
 ## Algorithm
 
 This filter has two algorithm implementations that are automatically selected at runtime based on how the input data is stored. The user does not need to choose between them.

src/Plugins/SimplnxCore/docs/ComputeNumFeaturesFilter.md

@@ -16,6 +16,8 @@ The output is a single-component count array indexed by **Ensemble** (phase) Id:
 
 % Auto generated parameter table will be inserted here
 
+**Feature Phases** must be a 1-component int32 DataArray; each value from feature index 1 onward must be a valid index into the **Ensemble Attribute Matrix**.
+
 ## Example Pipelines
 
 + INL Export

src/Plugins/SimplnxCore/docs/ComputeVertexToTriangleDistancesFilter.md

@@ -20,6 +20,8 @@ The sign of each distance depends on the **Triangle Normals**. For the sign to b
 
 % Auto generated parameter table will be inserted here
 
+**Triangle Normals** must have 3 components.
+
 ## License & Copyright
 
 Please see the description file distributed with this plugin.

src/Plugins/SimplnxCore/docs/DBSCANFilter.md

@@ -188,6 +188,8 @@ The *Distance Metric* parameter provides the following choices:
 - **Pearson [4]**: Uses the Pearson correlation distance, measuring linear correlation dissimilarity.
 - **Squared Pearson [5]**: Uses the squared Pearson correlation distance.
 
+When **Use Mask Array** is enabled, **Cell Mask Array** must have 1 component and the same number of tuples as **Attribute Array to Cluster**.
+
 ## Note on Randomness
 
 The inclusion of randomness in this algorithm is solely to attempt to reduce bias from starting cluster. Three parse order options are available: *Low Density First* (deterministic, no seed needed), *Random* (non-deterministic, uses a time-based seed), and *Seeded Random* (deterministic, uses a user-supplied seed value for reproducibility). Low Density First produced identical results faster in our test cases, but the random initialization is truest to the well known DBSCAN algorithm.