FILT: Rename ComputeMisorientations to ComputeFeatureNeighborMisorientations, add ComputeMisorientations (#1239)

* FILT: Rename ComputeMisorientations to ComputeFeatureNeighborMisorientations
* FILT: ComputeMisorientations Filter Added

This filter computes the misorientation between pair of Euler Angles and outputs
the misorientation as an Axis-Angle value. Also computes the Misorientation between a reference orientation
and the Euler Angles.

Signed-off-by: Michael Jackson <[email protected]>

---------

Signed-off-by: Michael Jackson <[email protected]>

Author: imikejackson

src/Plugins/OrientationAnalysis/CMakeLists.txt

@@ -47,6 +47,7 @@ set(FilterList
   ComputeGBPDMetricBasedFilter
   ComputeIPFColorsFilter
   ComputeKernelAvgMisorientationsFilter
+  ComputeFeatureNeighborMisorientationsFilter
   ComputeMisorientationsFilter
   ComputeQuaternionConjugateFilter
   ComputeSchmidsFilter
@@ -86,7 +87,7 @@ set(STUB_FILTERS
   ComputeBoundaryStrengths
   FindDistsToCharactGBs
   ComputeKernelAvgMisorientations
-  ComputeMisorientations
+  ComputeFeatureNeighborMisorientations
   ComputeSchmids
   FindTwinBoundaries
   FindTwinBoundarySchmidFactors
@@ -182,6 +183,7 @@ set(filter_algorithms
   ComputeGBPDMetricBased
   ComputeIPFColors
   ComputeKernelAvgMisorientations
+  ComputeFeatureNeighborMisorientations
   ComputeMisorientations
   ComputeQuaternionConjugate
   ComputeSchmids

src/Plugins/OrientationAnalysis/docs/ComputeFeatureNeighborMisorientationsFilter.md

@@ -0,0 +1,29 @@
+# Compute Feature Neighbor Misorientations
+
+## Group (Subgroup)
+
+Statistics (Crystallographic)
+
+## Description
+
+This **Filter** determines, for each **Feature**, the misorientations with each of the **Features** that are in contact with it.  The misorientations are stored as a list (for each **Feature**) of angles (in degrees).  The axis of the misorientation is not stored by this **Filter**.
+
+The user can also calculate the average misorientation between the feature and all contacting features.
+
+### Notes
+
+**NOTE:** Only features with identical crystal structures will be calculated. If two features have different crystal structures then a value of NaN is set for the misorientation.
+
+% Auto generated parameter table will be inserted here
+
+## Example Pipelines
+
++ (05) SmallIN100 Crystallographic Statistics
+
+## License & Copyright
+
+Please see the description file distributed with this **Plugin**
+
+## DREAM3D-NX Help
+
+If you need help, need to file a bug report or want to request a new feature, please head over to the [DREAM3DNX-Issues](https://github.com/BlueQuartzSoftware/DREAM3DNX-Issues/discussions) GitHub site where the community of DREAM3D-NX users can help answer your questions.

src/Plugins/OrientationAnalysis/docs/ComputeMisorientationsFilter.md

@@ -1,24 +1,32 @@
-# Compute Feature Neighbor Misorientations
+# Compute Misorientations
 
 ## Group (Subgroup)
 
-Statistics (Crystallographic)
+Tools (Orientations)
 
 ## Description
 
-This **Filter** determines, for each **Feature**, the misorientations with each of the **Features** that are in contact with it.  The misorientations are stored as a list (for each **Feature**) of angles (in degrees).  The axis of the misorientation is not stored by this **Filter**.
+This filter will compute the misorientation as an Axis-Angle representation between a pair of
+Euler Angles or an Euler Angle and a Reference Axis-Angle.
 
-The user can also calculate the average misorientation between the feature and all contacting features.
+Use the Orientation Utility to compute an input Axis-Angle if you only have another representation.
 
-### Notes
+## Compute by Arrays
+
+If 2 Euler Arrays are used then the output is an array with the same number of Tuples as the input
+Euler Arrays and represents the misorientation between the each Euler Angle in the same index in each 
+of the input Euler Angle arrays.
+
+## Compute by Reference Orientation
+
+In this mode the user will supply a reference orientation in the form of an Axis-Angle, where the angle portion is in degrees.
+Then, for every Euler Angle in the input array, the misorientation with the reference orientation will be computed.
 
-**NOTE:** Only features with identical crystal structures will be calculated. If two features have different crystal structures then a value of NaN is set for the misorientation.
 
 % Auto generated parameter table will be inserted here
 
 ## Example Pipelines
 
-+ (05) SmallIN100 Crystallographic Statistics
 
 ## License & Copyright
 

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ComputeFeatureNeighborMisorientations.cpp

@@ -0,0 +1,115 @@
+#include "ComputeFeatureNeighborMisorientations.hpp"
+
+#include "simplnx/Common/Constants.hpp"
+#include "simplnx/DataStructure/DataArray.hpp"
+#include "simplnx/DataStructure/DataGroup.hpp"
+#include "simplnx/DataStructure/NeighborList.hpp"
+
+#include "EbsdLib/LaueOps/LaueOps.h"
+
+using namespace nx::core;
+
+// -----------------------------------------------------------------------------
+ComputeFeatureNeighborMisorientations::ComputeFeatureNeighborMisorientations(DataStructure& dataStructure, const IFilter::MessageHandler& mesgHandler, const std::atomic_bool& shouldCancel,
+                                                                             ComputeFeatureNeighborMisorientationsInputValues* inputValues)
+: m_DataStructure(dataStructure)
+, m_InputValues(inputValues)
+, m_ShouldCancel(shouldCancel)
+, m_MessageHandler(mesgHandler)
+{
+}
+
+// -----------------------------------------------------------------------------
+ComputeFeatureNeighborMisorientations::~ComputeFeatureNeighborMisorientations() noexcept = default;
+
+// -----------------------------------------------------------------------------
+const std::atomic_bool& ComputeFeatureNeighborMisorientations::getCancel()
+{
+  return m_ShouldCancel;
+}
+
+// -----------------------------------------------------------------------------
+Result<> ComputeFeatureNeighborMisorientations::operator()()
+{
+
+  std::vector<LaueOps::Pointer> orientationOps = LaueOps::GetAllOrientationOps();
+
+  // Input Arrays
+  const auto& inFeaturePhases = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->FeaturePhasesArrayPath);
+  const auto& inAvgQuats = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->AvgQuatsArrayPath);
+  const auto& inXtalStruct = m_DataStructure.getDataRefAs<UInt32Array>(m_InputValues->CrystalStructuresArrayPath);
+  const auto& inNeighborList = m_DataStructure.getDataRefAs<NeighborList<int32>>(m_InputValues->NeighborListArrayPath);
+
+  // The output misorientations is going to be used as a vector because the output array is optional and might
+  // not exist in the DataStructure. We cannot get it by reference.
+  auto* avgMisorientations = m_DataStructure.getDataAs<Float32Array>(m_InputValues->AvgMisorientationsArrayName);
+
+  size_t tempMisoList = 0;
+
+  size_t totalFeatures = inFeaturePhases.getNumberOfTuples();
+
+  std::vector<std::vector<float>> tempMisorientationLists(totalFeatures);
+  usize quatIndex = 0;
+  for(size_t i = 1; i < totalFeatures; i++)
+  {
+    quatIndex = i * 4;
+
+    QuatF q1(inAvgQuats[quatIndex], inAvgQuats[quatIndex + 1], inAvgQuats[quatIndex + 2], inAvgQuats[quatIndex + 3]);
+    uint32_t xtalType1 = inXtalStruct[inFeaturePhases[i]];
+
+    const NeighborList<int32_t>::VectorType& featureNeighborList = inNeighborList.getListReference(static_cast<int32_t>(i));
+
+    tempMisorientationLists[i].assign(featureNeighborList.size(), -1.0);
+
+    for(size_t j = 0; j < featureNeighborList.size(); j++)
+    {
+      int32_t neighborFeatureId = featureNeighborList[j];
+      quatIndex = neighborFeatureId * 4;
+      QuatF q2(inAvgQuats[quatIndex], inAvgQuats[quatIndex + 1], inAvgQuats[quatIndex + 2], inAvgQuats[quatIndex + 3]);
+      uint32_t xtalType2 = inXtalStruct[inFeaturePhases[neighborFeatureId]];
+      tempMisoList = featureNeighborList.size();
+      if(xtalType1 == xtalType2 && static_cast<int64_t>(xtalType1) < static_cast<int64_t>(orientationOps.size()))
+      {
+        OrientationD axisAngle = orientationOps[xtalType1]->calculateMisorientation(q1, q2);
+
+        tempMisorientationLists[i][j] = static_cast<float>(axisAngle[3] * nx::core::Constants::k_180OverPiF);
+        if(m_InputValues->ComputeAvgMisors)
+        {
+          (*avgMisorientations)[i] += tempMisorientationLists[i][j];
+        }
+      }
+      else
+      {
+        if(m_InputValues->ComputeAvgMisors)
+        {
+          tempMisoList > 0 ? tempMisoList-- : tempMisoList = 0;
+        }
+        tempMisorientationLists[i][j] = NAN;
+      }
+    }
+    if(m_InputValues->ComputeAvgMisors)
+    {
+      if(tempMisoList != 0)
+      {
+        (*avgMisorientations)[i] /= static_cast<float>(tempMisoList);
+      }
+      else
+      {
+        (*avgMisorientations)[i] = NAN;
+      }
+      tempMisoList = 0;
+    }
+  }
+
+  // Output Variables
+  auto& outMisorientationList = m_DataStructure.getDataRefAs<NeighborList<float32>>(m_InputValues->MisorientationListArrayName);
+  // Set the vector for each list into the NeighborList Object
+  for(size_t i = 1; i < totalFeatures; i++)
+  {
+    // Construct a shared vector<float> through the std::vector<> copy constructor.
+    NeighborList<float>::SharedVectorType sharedMisorientationList(new std::vector<float>(tempMisorientationLists[i]));
+    outMisorientationList.setList(static_cast<int32_t>(i), sharedMisorientationList);
+  }
+
+  return {};
+}

src/Plugins/OrientationAnalysis/src/OrientationAnalysis/Filters/Algorithms/ComputeFeatureNeighborMisorientations.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "OrientationAnalysis/OrientationAnalysis_export.hpp"
+
+#include "simplnx/DataStructure/DataPath.hpp"
+#include "simplnx/DataStructure/DataStructure.hpp"
+#include "simplnx/Filter/IFilter.hpp"
+
+namespace nx::core
+{
+
+struct ORIENTATIONANALYSIS_EXPORT ComputeFeatureNeighborMisorientationsInputValues
+{
+  bool ComputeAvgMisors;
+  DataPath NeighborListArrayPath;
+  DataPath AvgQuatsArrayPath;
+  DataPath FeaturePhasesArrayPath;
+  DataPath CrystalStructuresArrayPath;
+  DataPath MisorientationListArrayName;
+  DataPath AvgMisorientationsArrayName;
+};
+
+/**
+ * @class
+ */
+class ORIENTATIONANALYSIS_EXPORT ComputeFeatureNeighborMisorientations
+{
+public:
+  ComputeFeatureNeighborMisorientations(DataStructure& dataStructure, const IFilter::MessageHandler& mesgHandler, const std::atomic_bool& shouldCancel,
+                                        ComputeFeatureNeighborMisorientationsInputValues* inputValues);
+  ~ComputeFeatureNeighborMisorientations() noexcept;
+
+  ComputeFeatureNeighborMisorientations(const ComputeFeatureNeighborMisorientations&) = delete;
+  ComputeFeatureNeighborMisorientations(ComputeFeatureNeighborMisorientations&&) noexcept = delete;
+  ComputeFeatureNeighborMisorientations& operator=(const ComputeFeatureNeighborMisorientations&) = delete;
+  ComputeFeatureNeighborMisorientations& operator=(ComputeFeatureNeighborMisorientations&&) noexcept = delete;
+
+  Result<> operator()();
+
+  const std::atomic_bool& getCancel();
+
+private:
+  DataStructure& m_DataStructure;
+  const ComputeFeatureNeighborMisorientationsInputValues* m_InputValues = nullptr;
+  const std::atomic_bool& m_ShouldCancel;
+  const IFilter::MessageHandler& m_MessageHandler;
+};
+
+} // namespace nx::core