BUG: Check that grid-geometry cell inputs have one tuple per cell

src/Plugins/OrientationAnalysis/docs/AlignSectionsMisorientationFilter.md

@@ -65,6 +65,8 @@ In previous versions a file would have been produced instead. If you wish to rec
 - **Crystal Structures** -- ensemble-level array read from EBSD data or created by [Create Ensemble Info](CreateEnsembleInfoFilter.md).
 - **Mask** (optional) -- a boolean array marking valid cells, typically produced by a threshold operation such as [Multi-Threshold Objects](../SimplnxCore/MultiThresholdObjectsFilter.md).
 
+**Cell Quaternions** and **Cell Phases** must each have one tuple per cell of the selected geometry. When **Use Mask Array** is enabled, **Cell Mask Array** must also have one tuple per cell. They can be in any Attribute Matrix.
+
 ## Algorithm
 
 ### In-Core Path

src/Plugins/OrientationAnalysis/docs/AlignSectionsMutualInformationFilter.md

@@ -66,6 +66,8 @@ In previous versions a file would have been produced instead. If you wish to rec
 - **Crystal Structures** -- ensemble-level array read from EBSD data or created by [Create Ensemble Info](CreateEnsembleInfoFilter.md).
 - **Mask** (optional) -- a boolean array marking valid cells, typically produced by a threshold operation such as [Multi-Threshold Objects](../SimplnxCore/MultiThresholdObjectsFilter.md).
 
+**Cell Quaternions** and **Cell Phases** must each have one tuple per cell of the selected geometry. When **Use Mask Array** is enabled, **Cell Mask Array** must also have one tuple per cell. They can be in any Attribute Matrix.
+
 % Auto generated parameter table will be inserted here
 
 ## References

src/Plugins/OrientationAnalysis/docs/BadDataNeighborOrientationCheckFilter.md

@@ -55,6 +55,8 @@ The cells that flipped from false (black) to true (IPF-colored) had Confidence I
 - **Cell Phases** -- typically read from EBSD data alongside the quaternions.
 - **Crystal Structures** -- ensemble-level array read from EBSD data or created by [Create Ensemble Info](CreateEnsembleInfoFilter.md).
 
+**Cell Quaternions**, **Cell Phases** and **Cell Mask Array** must each have one tuple per cell of the selected geometry. They can be in any Attribute Matrix.
+
 % Auto generated parameter table will be inserted here
 
 ## Example Pipelines

src/Plugins/OrientationAnalysis/docs/ComputeFeatureReferenceCAxisMisorientationsFilter.md

@@ -35,6 +35,8 @@ Results may differ from the DREAM3D 6.6 version by approximately 0.0001 degrees
 - **Average C-Axes** -- produced by [Compute Average C-Axis Orientations](ComputeAvgCAxesFilter.md).
 - **Crystal Structures** -- ensemble-level array read from EBSD data or created by [Create Ensemble Info](CreateEnsembleInfoFilter.md).
 
+**Cell Feature Ids**, **Cell Phases** and **Cell Quaternions** must each have one tuple per cell of the selected geometry. They can be in any Attribute Matrix.
+
 ## Algorithm
 
 For each cell, the quaternion is converted to an active rotation matrix (transpose of the passive orientation matrix) and applied to the <001> c-axis to find the c-axis direction in the sample reference frame. The angle between this cell-level c-axis and the feature's average c-axis is computed. Angles exceeding 90 degrees are folded to (180 - angle) to account for the antipodal symmetry of hexagonal c-axes. The per-cell misorientation values are then used to compute the average and population standard deviation per feature.

src/Plugins/OrientationAnalysis/docs/ComputeKernelAvgMisorientationsFilter.md

@@ -65,6 +65,8 @@ In 3D, the Z Radius works the same way, extending into adjacent slices above and
 
 For related per-feature misorientation metrics, see the **Compute Feature Reference Misorientations** and **Compute Misorientation** filters.
 
+**Cell Feature Ids**, **Cell Phases** and **Cell Quaternions** must each have one tuple per cell of the selected geometry. They can be in any Attribute Matrix.
+
 ## Algorithm
 
 For each valid cell in the Image Geometry, the algorithm examines all cells within the user-specified kernel radius in X, Y, and Z. In per-grain mode, only neighbors with the same feature ID as the center cell are included. In per-voxel mode, any neighbor with a positive feature ID and the same phase as the center cell is included. The crystallographic misorientation angle between the center cell's quaternion and each qualifying neighbor's quaternion is computed using the appropriate LaueOps symmetry operators. The average of these misorientation angles is stored as the KAM value for the center cell.

src/Plugins/OrientationAnalysis/docs/ComputeShapesFilter.md

@@ -32,6 +32,8 @@ For shape analysis on triangle geometry meshes rather than voxelized image geome
 - **Cell Feature Ids** -- produced by a segmentation filter such as [Segment Features (Misorientation)](EBSDSegmentFeaturesFilter.md) or [Segment Features (Scalar)](../SimplnxCore/ScalarSegmentFeaturesFilter.md).
 - **Feature Centroids** -- produced by [Compute Feature Centroids](../SimplnxCore/ComputeFeatureCentroidsFilter.md).
 
+**Cell Feature Ids** must have one tuple per cell of the selected geometry. It can be in any Attribute Matrix.
+
 % Auto generated parameter table will be inserted here
 
 ## References

src/Plugins/OrientationAnalysis/docs/NeighborOrientationCorrelationFilter.md

@@ -26,6 +26,8 @@ Cell (1,1) has CI = 0.05, which is below a 0.1 minimum, so it is flagged. Its 4
 
 In this example, cell (1,1) has a confidence index < 0.1. Its four neighbors are compared pairwise with each other: (13.0), (14.0), (12.0) and (15.0) are all within a few degrees of each other, so every neighbor participates in several similar pairs. The central cell (1,1) has all of its attributes replaced with those of the neighbor holding the highest similar-pair count. Note that the central cell's own orientation and phase play no role in choosing the replacement — only the mutual similarity of its neighbors matters.
 
+**Confidence Index**, **Cell Phases** and **Cell Quaternions** must each have one tuple per cell of the selected geometry. Replacement copies affect arrays in the Attribute Matrix that contains **Confidence Index**, except the arrays in **Attribute Arrays to Ignore**. Keep **Cell Phases** and **Cell Quaternions** in that matrix when they must also be repaired.
+
 ## Example Data
 
 |    Example Input/Output Images |
@@ -43,13 +45,7 @@ This filter will copy all attribute data from neighboring cells into the target
 
 ### Differences from legacy DREAM.3D 6.5.171
 
-DREAM3D-NX's implementation fixes three defects present in DREAM.3D 6.5.171, so results will differ on most datasets:
-
-1. 6.5.171 could count a mixed-phase (or unindexed, phase-0) neighbor pair as "similar" by reusing the previous pair's misorientation, occasionally replacing a cell with data from a **different phase**.
-2. 6.5.171 ran only half the cleanup passes of the original design (`ceil((6 − Level)/2)` instead of `6 − Level`), leaving deep bad regions partially unfilled.
-3. 6.5.171 copied from the *last* neighbor having any similar pair rather than the neighbor with the *highest* similarity count. (When all counts tie — the common case in grain interiors — both versions pick the same neighbor.)
-
-See `NeighborOrientationCorrelationFilter-D1` through `-D4` in `src/Plugins/OrientationAnalysis/vv/deviations/NeighborOrientationCorrelationFilter.md` for the full analysis and migration guidance.
+DREAM3D-NX's implementation fixes three defects present in DREAM.3D 6.5.171.
 
 ## Algorithm
 

src/Plugins/OrientationAnalysis/docs/WriteINLFileFilter.md

@@ -73,6 +73,8 @@ Some information about the phase is included in the header section of the file i
 - **Crystal Structures** -- the **Ensemble**-level array read alongside the phases from the same EBSD reader.
 - **Cell Feature Ids** -- produced by a segmentation filter such as [Segment Features (Misorientation)](EBSDSegmentFeaturesFilter.md) or [Segment Features (Scalar)](../SimplnxCore/ScalarSegmentFeaturesFilter.md).
 
+**Cell Feature Ids**, **Cell Phases** and **Cell Euler Angles** must each have one tuple per cell of the selected geometry. They can be in any Attribute Matrix.
+
 % Auto generated parameter table will be inserted here
 
 ## Example Pipelines

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/AlignSectionsMisorientationFilter.cpp

@@ -185,6 +185,16 @@ IFilter::PreflightResult AlignSectionsMisorientationFilter::preflightImpl(const
     return MakePreflightErrorResult(k_InconsistentTupleCount, fmt::format("The following DataArrays all must have equal number of tuples but this was not satisfied.\n{}", tupleValidityCheck.error()));
   }
 
+  std::vector<DataPath> cellArrayPaths = {pQuatsArrayPath, pCellPhasesArrayPath};
+  if(pUseGoodVoxels)
+  {
+    cellArrayPaths.emplace_back(pGoodVoxelsArrayPath);
+  }
+  if(auto tupleResult = ValidateCellTupleCount(dataStructure, inputImageGeometry, cellArrayPaths, -68072); tupleResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleResult), {})};
+  }
+
   const auto* inputGeom = dataStructure.getDataAs<ImageGeom>(inputImageGeometry);
   if(inputGeom == nullptr)
   {

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/AlignSectionsMutualInformationFilter.cpp

@@ -13,6 +13,7 @@
 #include "simplnx/Parameters/DataObjectNameParameter.hpp"
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
 #include "simplnx/Parameters/NumberParameter.hpp"
+#include "simplnx/Utilities/DataArrayUtilities.hpp"
 #include "simplnx/Utilities/FilterUtilities.hpp"
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 #include "simplnx/Utilities/StringUtilities.hpp"
@@ -143,6 +144,7 @@ IFilter::PreflightResult AlignSectionsMutualInformationFilter::preflightImpl(con
   auto pGoodVoxelsArrayPathValue = filterArgs.value<DataPath>(k_MaskArrayPath_Key);
   auto pCrystalStructuresArrayPathValue = filterArgs.value<DataPath>(k_CrystalStructuresArrayPath_Key);
 
+  auto useMask = filterArgs.value<bool>(k_UseMask_Key);
   auto pStoreAlignmentShifts = filterArgs.value<bool>(k_StoreAlignmentShifts_Key);
 
   nx::core::Result<OutputActions> resultOutputActions;
@@ -159,13 +161,27 @@ IFilter::PreflightResult AlignSectionsMutualInformationFilter::preflightImpl(con
         -3541, fmt::format("The Image Geometry is not 3D and cannot be run through this filter. The dimensions are ({})", StringUtilities::formatDimensions3D(imageGeom.getDimensions())));
   }
 
-  std::vector<DataPath> dataArrayPaths = {pQuatsArrayPathValue, pCellPhasesArrayPathValue, pGoodVoxelsArrayPathValue};
+  std::vector<DataPath> dataArrayPaths = {pQuatsArrayPathValue, pCellPhasesArrayPathValue};
+  if(useMask)
+  {
+    dataArrayPaths.push_back(pGoodVoxelsArrayPathValue);
+  }
   auto tupleValidityCheck = dataStructure.validateNumberOfTuples(dataArrayPaths);
   if(!tupleValidityCheck)
   {
     return MakePreflightErrorResult(-3542, fmt::format("The following DataArrays all must have equal number of tuples but this was not satisfied.\n{}", tupleValidityCheck.error()));
   }
 
+  std::vector<DataPath> cellArrayPaths = {pQuatsArrayPathValue, pCellPhasesArrayPathValue};
+  if(useMask)
+  {
+    cellArrayPaths.emplace_back(pGoodVoxelsArrayPathValue);
+  }
+  if(auto tupleResult = ValidateCellTupleCount(dataStructure, imageGeometryPath, cellArrayPaths, -3543); tupleResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleResult), {})};
+  }
+
   // Handle Array Creation
   if(pStoreAlignmentShifts)
   {

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/BadDataNeighborOrientationCheckFilter.cpp

@@ -7,6 +7,7 @@
 #include "simplnx/Parameters/DataGroupSelectionParameter.hpp"
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
 #include "simplnx/Parameters/NumberParameter.hpp"
+#include "simplnx/Utilities/DataArrayUtilities.hpp"
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
 using namespace nx::core;
@@ -97,6 +98,7 @@ IFilter::UniquePointer BadDataNeighborOrientationCheckFilter::clone() const
 IFilter::PreflightResult BadDataNeighborOrientationCheckFilter::preflightImpl(const DataStructure& dataStructure, const Arguments& filterArgs, const MessageHandler& messageHandler,
                                                                               const std::atomic_bool& shouldCancel, const ExecutionContext& executionContext) const
 {
+  auto imageGeometryPath = filterArgs.value<DataPath>(k_ImageGeometryPath_Key);
   auto pQuatsArrayPathValue = filterArgs.value<DataPath>(k_QuatsArrayPath_Key);
   auto pMaskArrayPathValue = filterArgs.value<DataPath>(k_MaskArrayPath_Key);
   auto pCellPhasesArrayPathValue = filterArgs.value<DataPath>(k_CellPhasesArrayPath_Key);
@@ -121,6 +123,11 @@ IFilter::PreflightResult BadDataNeighborOrientationCheckFilter::preflightImpl(co
     return MakePreflightErrorResult(k_InconsistentTupleCount, fmt::format("The following DataArrays all must have equal number of tuples but this was not satisfied.\n{}", tupleValidityCheck.error()));
   }
 
+  if(auto tupleResult = ValidateCellTupleCount(dataStructure, imageGeometryPath, {pQuatsArrayPathValue, pCellPhasesArrayPathValue, pMaskArrayPathValue}, -6810); tupleResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleResult), {})};
+  }
+
   resultOutputActions.value().modifiedActions.emplace_back(
       DataObjectModification{pMaskArrayPathValue, DataObjectModification::ModifiedType::Modified, dataStructure.getData(pMaskArrayPathValue)->getDataObjectType()});
 

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/ComputeFeatureReferenceCAxisMisorientationsFilter.cpp

@@ -8,6 +8,7 @@
 #include "simplnx/Parameters/DataGroupSelectionParameter.hpp"
 #include "simplnx/Parameters/DataObjectNameParameter.hpp"
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
+#include "simplnx/Utilities/DataArrayUtilities.hpp"
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
 using namespace nx::core;
@@ -96,6 +97,7 @@ IFilter::UniquePointer ComputeFeatureReferenceCAxisMisorientationsFilter::clone(
 IFilter::PreflightResult ComputeFeatureReferenceCAxisMisorientationsFilter::preflightImpl(const DataStructure& dataStructure, const Arguments& filterArgs, const MessageHandler& messageHandler,
                                                                                           const std::atomic_bool& shouldCancel, const ExecutionContext& executionContext) const
 {
+  auto imageGeometryPath = filterArgs.value<DataPath>(k_ImageGeometryPath_Key);
   auto pFeatureIdsArrayPathValue = filterArgs.value<DataPath>(k_FeatureIdsArrayPath_Key);
   auto pCellPhasesArrayPathValue = filterArgs.value<DataPath>(k_CellPhasesArrayPath_Key);
   auto pQuatsArrayPathValue = filterArgs.value<DataPath>(k_QuatsArrayPath_Key);
@@ -114,6 +116,11 @@ IFilter::PreflightResult ComputeFeatureReferenceCAxisMisorientationsFilter::pref
     return {MakeErrorResult<OutputActions>(-9800, fmt::format("The following DataArrays all must have equal number of tuples but this was not satisfied.\n{}", tupleValidityCheck.error()))};
   }
 
+  if(auto tupleResult = ValidateCellTupleCount(dataStructure, imageGeometryPath, {pFeatureIdsArrayPathValue, pCellPhasesArrayPathValue, pQuatsArrayPathValue}, -9805); tupleResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleResult), {})};
+  }
+
   ShapeType tupleShape = dataStructure.getDataRefAs<Int32Array>(pFeatureIdsArrayPathValue).getTupleShape();
   {
     auto createArrayAction =

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/ComputeKernelAvgMisorientationsFilter.cpp

@@ -10,6 +10,7 @@
 #include "simplnx/Parameters/DataObjectNameParameter.hpp"
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
 
+#include "simplnx/Utilities/DataArrayUtilities.hpp"
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
 #include "simplnx/Parameters/VectorParameter.hpp"
@@ -103,6 +104,11 @@ IFilter::PreflightResult ComputeKernelAvgMisorientationsFilter::preflightImpl(co
   auto pKernelAverageMisorientationsArrayNameValue = pCellPhasesArrayPathValue.replaceName(filterArgs.value<std::string>(k_KernelAverageMisorientationsArrayName_Key));
   auto inputImageGeometry = filterArgs.value<DataPath>(k_SelectedImageGeometryPath_Key);
 
+  if(auto tupleResult = ValidateCellTupleCount(dataStructure, inputImageGeometry, {pFeatureIdsArrayPathValue, pCellPhasesArrayPathValue, pQuatsArrayPathValue}, -67205); tupleResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleResult), {})};
+  }
+
   PreflightResult preflightResult;
 
   nx::core::Result<OutputActions> resultOutputActions;

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

@@ -8,6 +8,7 @@
 #include "simplnx/Parameters/ArraySelectionParameter.hpp"
 #include "simplnx/Parameters/DataObjectNameParameter.hpp"
 
+#include "simplnx/Utilities/DataArrayUtilities.hpp"
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
@@ -99,6 +100,12 @@ IFilter::PreflightResult ComputeShapesFilter::preflightImpl(const DataStructure&
   auto pAxisEulerAnglesArrayName = filterArgs.value<std::string>(k_AxisEulerAnglesArrayName_Key);
   auto pAspectRatiosArrayName = filterArgs.value<std::string>(k_AspectRatiosArrayName_Key);
   auto pVolumesArrayName = filterArgs.value<std::string>(k_VolumesArrayName_Key);
+  auto tupleCountResult = ValidateCellTupleCount(dataStructure, filterArgs.value<DataPath>(k_SelectedImageGeometryPath_Key), {pFeatureIdsArrayPath}, -12806);
+  if(tupleCountResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleCountResult), {})};
+  }
+
   auto featureAttrMatrixPath = pCentroidsArrayPath.getParent();
   auto pOmega3sArrayPath = featureAttrMatrixPath.createChildPath(pOmega3sArrayName);
   auto pAxisLengthsArrayPath = featureAttrMatrixPath.createChildPath(pAxisLengthsArrayName);

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/NeighborOrientationCorrelationFilter.cpp

@@ -8,6 +8,7 @@
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
 #include "simplnx/Parameters/MultiArraySelectionParameter.hpp"
 
+#include "simplnx/Utilities/DataArrayUtilities.hpp"
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
 #include "simplnx/Parameters/NumberParameter.hpp"
@@ -174,6 +175,11 @@ IFilter::PreflightResult NeighborOrientationCorrelationFilter::preflightImpl(con
         MakeErrorResult<OutputActions>(k_InvalidNumTuples, fmt::format("The following DataArrays all must have equal number of tuples but this was not satisfied.\n{}", tupleValidityCheck.error()))};
   }
 
+  if(auto tupleResult = ValidateCellTupleCount(dataStructure, pImageGeomPathValue, {pConfidenceIndexArrayPathValue, pCellPhasesArrayPathValue, pQuatsArrayPathValue}, -580098); tupleResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleResult), {})};
+  }
+
   // Inform users that the following arrays are going to be modified in place
   // Cell Data is going to be modified
   nx::core::AppendDataObjectModifications(dataStructure, resultOutputActions.value().modifiedActions, imageGeom.getCellDataPath(), {});

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/WriteINLFileFilter.cpp

@@ -11,6 +11,7 @@
 #include "simplnx/Parameters/FileSystemPathParameter.hpp"
 #include "simplnx/Parameters/GeometrySelectionParameter.hpp"
 
+#include "simplnx/Utilities/DataArrayUtilities.hpp"
 #include "simplnx/Utilities/SIMPLConversion.hpp"
 
 #include <filesystem>
@@ -98,8 +99,17 @@ IFilter::UniquePointer WriteINLFileFilter::clone() const
 IFilter::PreflightResult WriteINLFileFilter::preflightImpl(const DataStructure& dataStructure, const Arguments& filterArgs, const MessageHandler& messageHandler, const std::atomic_bool& shouldCancel,
                                                            const ExecutionContext& executionContext) const
 {
+  auto imageGeometryPath = filterArgs.value<DataPath>(k_ImageGeomPath_Key);
+  auto featureIdsPath = filterArgs.value<DataPath>(k_FeatureIdsArrayPath_Key);
+  auto cellPhasesPath = filterArgs.value<DataPath>(k_CellPhasesArrayPath_Key);
+  auto eulerAnglesPath = filterArgs.value<DataPath>(k_CellEulerAnglesArrayPath_Key);
   auto pMaterialNameArrayPathValue = filterArgs.value<DataPath>(k_MaterialNameArrayPath_Key);
 
+  if(auto tupleResult = ValidateCellTupleCount(dataStructure, imageGeometryPath, {featureIdsPath, cellPhasesPath, eulerAnglesPath}, -78431); tupleResult.invalid())
+  {
+    return {ConvertResultTo<OutputActions>(std::move(tupleResult), {})};
+  }
+
   PreflightResult preflightResult;
   nx::core::Result<OutputActions> resultOutputActions;
   std::vector<PreflightValue> preflightUpdatedValues;