BUG: output same as 6.6.381

imikejackson · imikejackson · commit 3ecdcb8fa3e5 · 2025-09-30T09:02:20.000-04:00
* Forced random seed to `std::mt19937::default_seed`
* Randomized ParentIds is disabled
* Ensure Use Running Average is enabled
diff --git a/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.cpp b/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.cpp
@@ -2,10 +2,10 @@
 
 #include "simplnx/Common/Constants.hpp"
 #include "simplnx/DataStructure/DataArray.hpp"
-#include "simplnx/DataStructure/DataGroup.hpp"
 #include "simplnx/DataStructure/NeighborList.hpp"
 #include "simplnx/Utilities/Math/GeometryMath.hpp"
 #include "simplnx/Utilities/Math/MatrixMath.hpp"
+#include "simplnx/Utilities/MessageHelper.hpp"
 
 #include "EbsdLib/LaueOps/LaueOps.h"
 
@@ -81,35 +81,38 @@ bool GroupMicroTextureRegions::growGrouping(int32_t referenceFeature, int32_t ne
 // -----------------------------------------------------------------------------
 void GroupMicroTextureRegions::execute()
 {
-  NeighborList<int32>& neighborlist = m_DataStructure.getDataRefAs<NeighborList<int32>>(m_InputValues->ContiguousNeighborListArrayPath);
+  MessageHelper messageHelper(m_MessageHandler);
+  ThrottledMessenger throttledMessenger = messageHelper.createThrottledMessenger();
+
+  NeighborList<int32>& featureNeighborListRef = m_DataStructure.getDataRefAs<NeighborList<int32>>(m_InputValues->ContiguousNeighborListArrayPath);
   NeighborList<int32>* nonContigNeighList = nullptr;
   if(m_InputValues->UseNonContiguousNeighbors)
   {
     nonContigNeighList = m_DataStructure.getDataAs<NeighborList<int32>>(m_InputValues->NonContiguousNeighborListArrayPath);
   }
 
-  std::vector<int32> grouplist;
+  std::vector<int32> groupList;
 
-  int32 parentcount = 0;
-  int32 seed = 0;
-  int32 list1size = 0, list2size = 0, listsize = 0;
+  int32 parentCount = 0;
+  int32 featureSeed = 0;
+  int32 list1size = 0, list2size = 0, listSize = 0;
   int32 neigh = 0;
   bool patchGrouping = false;
 
-  while(seed >= 0)
+  while(featureSeed >= 0)
   {
-    parentcount++;
-    seed = getSeed(parentcount);
-    if(seed >= 0)
+    parentCount++;
+    featureSeed = getSeed(parentCount);
+    if(featureSeed >= 0)
     {
-      grouplist.push_back(seed);
-      for(std::vector<int32>::size_type j = 0; j < grouplist.size(); j++)
+      groupList.push_back(featureSeed);
+      for(std::vector<int32>::size_type j = 0; j < groupList.size(); j++)
       {
-        int32 firstfeature = grouplist[j];
-        list1size = int32(neighborlist[firstfeature].size());
+        int32 firstFeature = groupList[j];
+        list1size = static_cast<int32>(featureNeighborListRef[firstFeature].size());
         if(m_InputValues->UseNonContiguousNeighbors)
         {
-          list2size = nonContigNeighList->getListSize(firstfeature);
+          list2size = nonContigNeighList->getListSize(firstFeature);
         }
         for(int32 k = 0; k < 2; k++)
         {
@@ -119,30 +122,30 @@ void GroupMicroTextureRegions::execute()
           }
           if(k == 0)
           {
-            listsize = list1size;
+            listSize = list1size;
           }
           else if(k == 1)
           {
-            listsize = list2size;
+            listSize = list2size;
           }
-          for(int32 l = 0; l < listsize; l++)
+          for(int32 l = 0; l < listSize; l++)
           {
             if(k == 0)
             {
-              neigh = neighborlist[firstfeature][l];
+              neigh = featureNeighborListRef[firstFeature][l];
             }
             else if(k == 1)
             {
               bool ok = false;
-              neigh = nonContigNeighList->getValue(firstfeature, l, ok);
+              neigh = nonContigNeighList->getValue(firstFeature, l, ok);
             }
-            if(neigh != firstfeature)
+            if(neigh != firstFeature)
             {
-              if(determineGrouping(firstfeature, neigh, parentcount))
+              if(determineGrouping(firstFeature, neigh, parentCount))
               {
                 if(!patchGrouping)
                 {
-                  grouplist.push_back(neigh);
+                  groupList.push_back(neigh);
                 }
               }
             }
@@ -151,35 +154,39 @@ void GroupMicroTextureRegions::execute()
       }
       if(patchGrouping)
       {
-        if(growPatch(parentcount))
+        if(growPatch(parentCount))
         {
-          for(std::vector<int32_t>::size_type j = 0; j < grouplist.size(); j++)
+          for(std::vector<int32_t>::size_type j = 0; j < groupList.size(); j++)
           {
-            int32_t firstfeature = grouplist[j];
-            listsize = int32_t(neighborlist[firstfeature].size());
-            for(int32_t l = 0; l < listsize; l++)
+            int32_t firstFeature = groupList[j];
+            listSize = static_cast<int32_t>(featureNeighborListRef[firstFeature].size());
+            for(int32_t l = 0; l < listSize; l++)
             {
-              neigh = neighborlist[firstfeature][l];
-              if(neigh != firstfeature)
+              neigh = featureNeighborListRef[firstFeature][l];
+              if(neigh != firstFeature)
               {
-                if(growGrouping(firstfeature, neigh, parentcount))
+                if(growGrouping(firstFeature, neigh, parentCount))
                 {
-                  grouplist.push_back(neigh);
+                  groupList.push_back(neigh);
                 }
               }
             }
           }
         }
       }
+
+      throttledMessenger.sendThrottledMessage([&]() { return fmt::format("Parent Count: {}", parentCount); });
     }
-    grouplist.clear();
+    groupList.clear();
   }
 }
 
 // -----------------------------------------------------------------------------
 Result<> GroupMicroTextureRegions::operator()()
 {
-  m_Generator = std::mt19937_64(m_InputValues->SeedValue);
+  MessageHelper messageHelper(m_MessageHandler);
+
+  m_Generator = std::mt19937_64(std::mt19937::default_seed);
   m_Distribution = std::uniform_real_distribution<float32>(0.0f, 1.0f);
 
   m_AvgCAxes[0] = 0.0f;
@@ -188,6 +195,9 @@ Result<> GroupMicroTextureRegions::operator()()
   auto& featureParentIds = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->FeatureParentIdsArrayName);
   featureParentIds.fill(-1);
 
+  // Execute the main grouping algorithm
+  messageHelper.sendMessage(fmt::format("Starting Grouping....."));
+
   execute();
 
   // handle active array resize
@@ -206,8 +216,8 @@ Result<> GroupMicroTextureRegions::operator()()
   }
 
   // By default we randomize grains !!! COMMENT OUT FOR DEMONSTRATION !!!
-  m_MessageHandler(IFilter::Message::Type::Info, "Randomizing Parent Ids");
-  RandomizeFeatureIds(totalPoints, m_NumTuples, cellParentIds, featureParentIds, featureIds, m_InputValues->SeedValue);
+  // m_MessageHandler(IFilter::Message::Type::Info, "Randomizing Parent Ids");
+  // RandomizeFeatureIds(totalPoints, m_NumTuples, cellParentIds, featureParentIds, featureIds, m_InputValues->SeedValue);
 
   return {};
 }
@@ -220,24 +230,32 @@ int GroupMicroTextureRegions::getSeed(int32 newFid)
 
   usize numFeatures = featurePhases.getNumberOfTuples();
 
-  float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
-  float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
-  int32 voxelSeed = -1;
+  float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
+  float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
+  int32 featureIdSeed = -1;
 
   // Precalculate some constants
-  int32 totalFMinus1 = numFeatures - 1;
+  const int32 totalFMinus1 = static_cast<int32>(numFeatures) - 1;
 
   usize counter = 0;
+  // This section finds a feature id that has not been grouped yet. It starts by
+  // randomly selecting a feature id between 0 and numFeatures-1. We then start
+  // looping. If the initial random value is valid then we exit the loop after
+  // a single iteration. If that feature has already been grouped, then we add one
+  // to the `randFeature` value and try again. If we get to the end of the range of
+  // featureIds then the algorithm will loop back to featureId = 0 and start incrementing
+  // from there. This is reasonably efficient as we only generate random numbers
+  // as needed.
   auto randFeature = static_cast<int32>(m_Distribution(m_Generator) * static_cast<float32>(totalFMinus1));
-  while(voxelSeed == -1 && counter < numFeatures)
+  while(featureIdSeed == -1 && counter < numFeatures)
   {
     if(randFeature > totalFMinus1)
     {
       randFeature = randFeature - numFeatures;
     }
     if(featureParentIds[randFeature] == -1)
     {
-      voxelSeed = randFeature;
+      featureIdSeed = randFeature;
     }
     randFeature++;
     counter++;
@@ -251,17 +269,17 @@ int GroupMicroTextureRegions::getSeed(int32 newFid)
   //    fout << fmt::format("Feature Parent Id: {} | X: {}, Y: {}\n", voxelSeed, centroids.getComponent(voxelSeed, 0), centroids.getComponent(voxelSeed, 1));
   //  }
 
-  if(voxelSeed >= 0)
+  if(featureIdSeed >= 0)
   {
-    featureParentIds[voxelSeed] = newFid;
+    featureParentIds[featureIdSeed] = newFid;
     m_NumTuples = newFid + 1;
 
     if(m_InputValues->UseRunningAverage)
     {
       auto& volumes = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->VolumesArrayPath);
       auto& avgQuats = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->AvgQuatsArrayPath);
 
-      usize index = voxelSeed * 4;
+      usize index = featureIdSeed * 4;
       OrientationTransformation::qu2om<QuatF, OrientationF>({avgQuats[index + 0], avgQuats[index + 1], avgQuats[index + 2], avgQuats[index + 3]}).toGMatrix(g1);
 
       std::array<float32, 3> c1 = {0.0f, 0.0f, 0.0f};
@@ -274,21 +292,34 @@ int GroupMicroTextureRegions::getSeed(int32 newFid)
       // dividing by the magnitudes (they would be 1)
       MatrixMath::Normalize3x1(c1.data());
       MatrixMath::Copy3x1(c1.data(), m_AvgCAxes.data());
-      MatrixMath::Multiply3x1withConstant(m_AvgCAxes.data(), volumes.getValue(voxelSeed));
+      MatrixMath::Multiply3x1withConstant(m_AvgCAxes.data(), volumes.getValue(featureIdSeed));
     }
   }
 
-  return voxelSeed;
+  return featureIdSeed;
 }
 
 // -----------------------------------------------------------------------------
 bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 neighborFeature, int32 newFid)
 {
   uint32 phase1 = 0;
-  float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
-  float32 g2[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
-  float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
-  float32 g2t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
+  /**
+   * referenceFeature is Cubic Phase
+   * neighborFeature is Hex Phase
+   * m_InputValues->UseRunningAverage = TRUE
+   * First `if` check is passed
+   * Second `if` check is passed, `phase1` stays at HEX
+   * Third `if` check will pass because the 2nd phase is HEX
+   * Probably should not be happening?
+   * Solution: Properly initialize the `phase` outside of all checks or just before the `phase2` initialization
+   * Bug introduced JAN 30, 2014 by J. Tucker commit `7e49e52f362005e44ea9bf21b7a717277b2af04e` in Original DREAM3D repository
+
+  */
+
+  float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
+  float32 g2[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
+  float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
+  float32 g2t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};
   std::array<float32, 3> c1 = {0.0f, 0.0f, 0.0f};
   std::array<float32, 3> caxis = {0.0f, 0.0f, 1.0f};
 
@@ -301,7 +332,6 @@ bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 n
     if(!m_InputValues->UseRunningAverage)
     {
       usize index = referenceFeature * 4;
-      phase1 = crystalStructures[featurePhases[referenceFeature]];
       OrientationTransformation::qu2om<QuatF, Orientation<float32>>({avgQuats[index + 0], avgQuats[index + 1], avgQuats[index + 2], avgQuats[index + 3]}).toGMatrix(g1);
 
       // transpose the g matrix so when c-axis is multiplied by it,
@@ -312,6 +342,7 @@ bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 n
       // dividing by the magnitudes (they would be 1)
       MatrixMath::Normalize3x1(c1.data());
     }
+    phase1 = crystalStructures[featurePhases[referenceFeature]];
     uint32 phase2 = crystalStructures[featurePhases[neighborFeature]];
     if(phase1 == phase2 && (phase1 == EbsdLib::CrystalStructure::Hexagonal_High))
     {
diff --git a/src/SimplnxReview/Filters/GroupMicroTextureRegionsFilter.cpp b/src/SimplnxReview/Filters/GroupMicroTextureRegionsFilter.cpp
@@ -55,17 +55,22 @@ Parameters GroupMicroTextureRegionsFilter::parameters() const
 
   // Create the parameter descriptors that are needed for this filter
   params.insertSeparator(Parameters::Separator{"Input Parameter(s)"});
+
+  params.insert(std::make_unique<BoolParameter>(k_UseRunningAverage_Key, "Group C-Axes With Running Average", "Group C-Axes With Running Average", true));
+  params.insert(std::make_unique<Float32Parameter>(k_CAxisTolerance_Key, "C-Axis Alignment Tolerance (Degrees)", "C-Axis Alignment Tolerance (Degrees)", 0.0f));
+  params.insert(std::make_unique<NeighborListSelectionParameter>(k_ContiguousNeighborListArrayPath_Key, "Contiguous Neighbor List", "List of contiguous neighbors for each Feature.", DataPath{},
+                                                                 NeighborListSelectionParameter::AllowedTypes{DataType::int32}));
+
+  params.insertSeparator(Parameters::Separator{"Non-Contiguous Neighborhood Option"});  
   params.insertLinkableParameter(std::make_unique<BoolParameter>(k_UseNonContiguousNeighbors_Key, "Use Non-Contiguous Neighbors", "Use non-contiguous neighborhoods", false));
   params.insert(std::make_unique<NeighborListSelectionParameter>(k_NonContiguousNeighborListArrayPath_Key, "Non-Contiguous Neighbor List", "List of non-contiguous neighbors for each Feature.",
                                                                  DataPath{}, NeighborListSelectionParameter::AllowedTypes{DataType::int32}));
-  params.insert(std::make_unique<NeighborListSelectionParameter>(k_ContiguousNeighborListArrayPath_Key, "Contiguous Neighbor List", "List of contiguous neighbors for each Feature.", DataPath{},
-                                                                 NeighborListSelectionParameter::AllowedTypes{DataType::int32}));
-  params.insert(std::make_unique<BoolParameter>(k_UseRunningAverage_Key, "Group C-Axes With Running Average", "Group C-Axes With Running Average", true));
-  params.insert(std::make_unique<Float32Parameter>(k_CAxisTolerance_Key, "C-Axis Alignment Tolerance (Degrees)", "C-Axis Alignment Tolerance (Degrees)", 0.0f));
+
 
   params.insertSeparator(Parameters::Separator{"Random Number Seed Parameters"});
   params.insertLinkableParameter(std::make_unique<BoolParameter>(k_UseSeed_Key, "Use Seed for Random Generation", "When true the user will be able to put in a seed for random generation", false));
   params.insert(std::make_unique<NumberParameter<uint64>>(k_SeedValue_Key, "Seed", "The seed fed into the random generator", std::mt19937::default_seed));
+  params.insert(std::make_unique<DataObjectNameParameter>(k_SeedArrayName_Key, "Stored Seed Value Array Name", "", "_Group_MicroTexture_Regions_Seed_Value_"));
 
   params.insertSeparator(Parameters::Separator{"Input Cell Data"});
   params.insert(std::make_unique<ArraySelectionParameter>(k_FeatureIdsArrayPath_Key, "Cell Feature Ids", "Data Array that specifies to which Feature each Element belongs", DataPath{},
@@ -89,8 +94,6 @@ Parameters GroupMicroTextureRegionsFilter::parameters() const
   params.insert(std::make_unique<DataGroupCreationParameter>(k_NewCellFeatureAttributeMatrixName_Key, "Created Microtexture Feature Attribute Matrix",
                                                              "Output Feature Attribute Matrix for Microtexture Regions", DataPath{}));
   params.insert(std::make_unique<DataObjectNameParameter>(k_ActiveArrayName_Key, "Active Array Name", "Output Active Array", "Active"));
-  params.insert(std::make_unique<DataObjectNameParameter>(k_SeedArrayName_Key, "Stored Seed Value Array Name", "Output data array to store the random number seed value",
-                                                          "_Group_MicroTexture_Regions_Seed_Value_"));
 
   // Associate the Linkable Parameter(s) to the children parameters that they control
   params.linkParameters(k_UseNonContiguousNeighbors_Key, k_NonContiguousNeighborListArrayPath_Key, true);
@@ -174,7 +177,7 @@ Result<> GroupMicroTextureRegionsFilter::executeImpl(DataStructure& dataStructur
 
   GroupMicroTextureRegionsInputValues inputValues;
 
-  inputValues.UseNonContiguousNeighbors = filterArgs.value<bool>(k_UseNonContiguousNeighbors_Key);
+  inputValues.UseNonContiguousNeighbors = true; // filterArgs.value<bool>(k_UseNonContiguousNeighbors_Key);
   inputValues.NonContiguousNeighborListArrayPath = filterArgs.value<DataPath>(k_NonContiguousNeighborListArrayPath_Key);
   inputValues.ContiguousNeighborListArrayPath = filterArgs.value<DataPath>(k_ContiguousNeighborListArrayPath_Key);
   inputValues.UseRunningAverage = filterArgs.value<bool>(k_UseRunningAverage_Key);

Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,10 @@`
`2`	`2`
`3`	`3`	`#include "simplnx/Common/Constants.hpp"`
`4`	`4`	`#include "simplnx/DataStructure/DataArray.hpp"`
`5`		`-#include "simplnx/DataStructure/DataGroup.hpp"`
`6`	`5`	`#include "simplnx/DataStructure/NeighborList.hpp"`
`7`	`6`	`#include "simplnx/Utilities/Math/GeometryMath.hpp"`
`8`	`7`	`#include "simplnx/Utilities/Math/MatrixMath.hpp"`
	`8`	`+#include "simplnx/Utilities/MessageHelper.hpp"`
`9`	`9`
`10`	`10`	`#include "EbsdLib/LaueOps/LaueOps.h"`
`11`	`11`
`@@ -81,35 +81,38 @@ bool GroupMicroTextureRegions::growGrouping(int32_t referenceFeature, int32_t ne`
`81`	`81`	`// -----------------------------------------------------------------------------`
`82`	`82`	`void GroupMicroTextureRegions::execute()`
`83`	`83`	`{`
`84`		`- NeighborList<int32>& neighborlist = m_DataStructure.getDataRefAs<NeighborList<int32>>(m_InputValues->ContiguousNeighborListArrayPath);`
	`84`	`+ MessageHelper messageHelper(m_MessageHandler);`
	`85`	`+ ThrottledMessenger throttledMessenger = messageHelper.createThrottledMessenger();`
	`86`	`+`
	`87`	`+ NeighborList<int32>& featureNeighborListRef = m_DataStructure.getDataRefAs<NeighborList<int32>>(m_InputValues->ContiguousNeighborListArrayPath);`
`85`	`88`	`NeighborList<int32>* nonContigNeighList = nullptr;`
`86`	`89`	`if(m_InputValues->UseNonContiguousNeighbors)`
`87`	`90`	`{`
`88`	`91`	`nonContigNeighList = m_DataStructure.getDataAs<NeighborList<int32>>(m_InputValues->NonContiguousNeighborListArrayPath);`
`89`	`92`	`}`
`90`	`93`
`91`		`- std::vector<int32> grouplist;`
	`94`	`+ std::vector<int32> groupList;`
`92`	`95`
`93`		`- int32 parentcount = 0;`
`94`		`- int32 seed = 0;`
`95`		`- int32 list1size = 0, list2size = 0, listsize = 0;`
	`96`	`+ int32 parentCount = 0;`
	`97`	`+ int32 featureSeed = 0;`
	`98`	`+ int32 list1size = 0, list2size = 0, listSize = 0;`
`96`	`99`	`int32 neigh = 0;`
`97`	`100`	`bool patchGrouping = false;`
`98`	`101`
`99`		`- while(seed >= 0)`
	`102`	`+ while(featureSeed >= 0)`
`100`	`103`	`{`
`101`		`- parentcount++;`
`102`		`- seed = getSeed(parentcount);`
`103`		`- if(seed >= 0)`
	`104`	`+ parentCount++;`
	`105`	`+ featureSeed = getSeed(parentCount);`
	`106`	`+ if(featureSeed >= 0)`
`104`	`107`	`{`
`105`		`- grouplist.push_back(seed);`
`106`		`- for(std::vector<int32>::size_type j = 0; j < grouplist.size(); j++)`
	`108`	`+ groupList.push_back(featureSeed);`
	`109`	`+ for(std::vector<int32>::size_type j = 0; j < groupList.size(); j++)`
`107`	`110`	`{`
`108`		`- int32 firstfeature = grouplist[j];`
`109`		`- list1size = int32(neighborlist[firstfeature].size());`
	`111`	`+ int32 firstFeature = groupList[j];`
	`112`	`+ list1size = static_cast<int32>(featureNeighborListRef[firstFeature].size());`
`110`	`113`	`if(m_InputValues->UseNonContiguousNeighbors)`
`111`	`114`	`{`
`112`		`- list2size = nonContigNeighList->getListSize(firstfeature);`
	`115`	`+ list2size = nonContigNeighList->getListSize(firstFeature);`
`113`	`116`	`}`
`114`	`117`	`for(int32 k = 0; k < 2; k++)`
`115`	`118`	`{`
`@@ -119,30 +122,30 @@ void GroupMicroTextureRegions::execute()`
`119`	`122`	`}`
`120`	`123`	`if(k == 0)`
`121`	`124`	`{`
`122`		`- listsize = list1size;`
	`125`	`+ listSize = list1size;`
`123`	`126`	`}`
`124`	`127`	`else if(k == 1)`
`125`	`128`	`{`
`126`		`- listsize = list2size;`
	`129`	`+ listSize = list2size;`
`127`	`130`	`}`
`128`		`- for(int32 l = 0; l < listsize; l++)`
	`131`	`+ for(int32 l = 0; l < listSize; l++)`
`129`	`132`	`{`
`130`	`133`	`if(k == 0)`
`131`	`134`	`{`
`132`		`- neigh = neighborlist[firstfeature][l];`
	`135`	`+ neigh = featureNeighborListRef[firstFeature][l];`
`133`	`136`	`}`
`134`	`137`	`else if(k == 1)`
`135`	`138`	`{`
`136`	`139`	`bool ok = false;`
`137`		`- neigh = nonContigNeighList->getValue(firstfeature, l, ok);`
	`140`	`+ neigh = nonContigNeighList->getValue(firstFeature, l, ok);`
`138`	`141`	`}`
`139`		`- if(neigh != firstfeature)`
	`142`	`+ if(neigh != firstFeature)`
`140`	`143`	`{`
`141`		`- if(determineGrouping(firstfeature, neigh, parentcount))`
	`144`	`+ if(determineGrouping(firstFeature, neigh, parentCount))`
`142`	`145`	`{`
`143`	`146`	`if(!patchGrouping)`
`144`	`147`	`{`
`145`		`- grouplist.push_back(neigh);`
	`148`	`+ groupList.push_back(neigh);`
`146`	`149`	`}`
`147`	`150`	`}`
`148`	`151`	`}`
`@@ -151,35 +154,39 @@ void GroupMicroTextureRegions::execute()`
`151`	`154`	`}`
`152`	`155`	`if(patchGrouping)`
`153`	`156`	`{`
`154`		`- if(growPatch(parentcount))`
	`157`	`+ if(growPatch(parentCount))`
`155`	`158`	`{`
`156`		`- for(std::vector<int32_t>::size_type j = 0; j < grouplist.size(); j++)`
	`159`	`+ for(std::vector<int32_t>::size_type j = 0; j < groupList.size(); j++)`
`157`	`160`	`{`
`158`		`- int32_t firstfeature = grouplist[j];`
`159`		`- listsize = int32_t(neighborlist[firstfeature].size());`
`160`		`- for(int32_t l = 0; l < listsize; l++)`
	`161`	`+ int32_t firstFeature = groupList[j];`
	`162`	`+ listSize = static_cast<int32_t>(featureNeighborListRef[firstFeature].size());`
	`163`	`+ for(int32_t l = 0; l < listSize; l++)`
`161`	`164`	`{`
`162`		`- neigh = neighborlist[firstfeature][l];`
`163`		`- if(neigh != firstfeature)`
	`165`	`+ neigh = featureNeighborListRef[firstFeature][l];`
	`166`	`+ if(neigh != firstFeature)`
`164`	`167`	`{`
`165`		`- if(growGrouping(firstfeature, neigh, parentcount))`
	`168`	`+ if(growGrouping(firstFeature, neigh, parentCount))`
`166`	`169`	`{`
`167`		`- grouplist.push_back(neigh);`
	`170`	`+ groupList.push_back(neigh);`
`168`	`171`	`}`
`169`	`172`	`}`
`170`	`173`	`}`
`171`	`174`	`}`
`172`	`175`	`}`
`173`	`176`	`}`
	`177`	`+`
	`178`	`+ throttledMessenger.sendThrottledMessage([&]() { return fmt::format("Parent Count: {}", parentCount); });`
`174`	`179`	`}`
`175`		`- grouplist.clear();`
	`180`	`+ groupList.clear();`
`176`	`181`	`}`
`177`	`182`	`}`
`178`	`183`
`179`	`184`	`// -----------------------------------------------------------------------------`
`180`	`185`	`Result<> GroupMicroTextureRegions::operator()()`
`181`	`186`	`{`
`182`		`- m_Generator = std::mt19937_64(m_InputValues->SeedValue);`
	`187`	`+ MessageHelper messageHelper(m_MessageHandler);`
	`188`	`+`
	`189`	`+ m_Generator = std::mt19937_64(std::mt19937::default_seed);`
`183`	`190`	`m_Distribution = std::uniform_real_distribution<float32>(0.0f, 1.0f);`
`184`	`191`
`185`	`192`	`m_AvgCAxes[0] = 0.0f;`
`@@ -188,6 +195,9 @@ Result<> GroupMicroTextureRegions::operator()()`
`188`	`195`	`auto& featureParentIds = m_DataStructure.getDataRefAs<Int32Array>(m_InputValues->FeatureParentIdsArrayName);`
`189`	`196`	`featureParentIds.fill(-1);`
`190`	`197`
	`198`	`+ // Execute the main grouping algorithm`
	`199`	`+ messageHelper.sendMessage(fmt::format("Starting Grouping....."));`
	`200`	`+`
`191`	`201`	`execute();`
`192`	`202`
`193`	`203`	`// handle active array resize`
`@@ -206,8 +216,8 @@ Result<> GroupMicroTextureRegions::operator()()`
`206`	`216`	`}`
`207`	`217`
`208`	`218`	`// By default we randomize grains !!! COMMENT OUT FOR DEMONSTRATION !!!`
`209`		`- m_MessageHandler(IFilter::Message::Type::Info, "Randomizing Parent Ids");`
`210`		`- RandomizeFeatureIds(totalPoints, m_NumTuples, cellParentIds, featureParentIds, featureIds, m_InputValues->SeedValue);`
	`219`	`+ // m_MessageHandler(IFilter::Message::Type::Info, "Randomizing Parent Ids");`
	`220`	`+ // RandomizeFeatureIds(totalPoints, m_NumTuples, cellParentIds, featureParentIds, featureIds, m_InputValues->SeedValue);`
`211`	`221`
`212`	`222`	`return {};`
`213`	`223`	`}`
`@@ -220,24 +230,32 @@ int GroupMicroTextureRegions::getSeed(int32 newFid)`
`220`	`230`
`221`	`231`	`usize numFeatures = featurePhases.getNumberOfTuples();`
`222`	`232`
`223`		`- float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
`224`		`- float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
`225`		`- int32 voxelSeed = -1;`
	`233`	`+ float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
	`234`	`+ float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
	`235`	`+ int32 featureIdSeed = -1;`
`226`	`236`
`227`	`237`	`// Precalculate some constants`
`228`		`- int32 totalFMinus1 = numFeatures - 1;`
	`238`	`+ const int32 totalFMinus1 = static_cast<int32>(numFeatures) - 1;`
`229`	`239`
`230`	`240`	`usize counter = 0;`
	`241`	`+ // This section finds a feature id that has not been grouped yet. It starts by`
	`242`	`+ // randomly selecting a feature id between 0 and numFeatures-1. We then start`
	`243`	`+ // looping. If the initial random value is valid then we exit the loop after`
	`244`	`+ // a single iteration. If that feature has already been grouped, then we add one`
	`245`	+ // to the `randFeature` value and try again. If we get to the end of the range of
	`246`	`+ // featureIds then the algorithm will loop back to featureId = 0 and start incrementing`
	`247`	`+ // from there. This is reasonably efficient as we only generate random numbers`
	`248`	`+ // as needed.`
`231`	`249`	`auto randFeature = static_cast<int32>(m_Distribution(m_Generator) * static_cast<float32>(totalFMinus1));`
`232`		`- while(voxelSeed == -1 && counter < numFeatures)`
	`250`	`+ while(featureIdSeed == -1 && counter < numFeatures)`
`233`	`251`	`{`
`234`	`252`	`if(randFeature > totalFMinus1)`
`235`	`253`	`{`
`236`	`254`	`randFeature = randFeature - numFeatures;`
`237`	`255`	`}`
`238`	`256`	`if(featureParentIds[randFeature] == -1)`
`239`	`257`	`{`
`240`		`- voxelSeed = randFeature;`
	`258`	`+ featureIdSeed = randFeature;`
`241`	`259`	`}`
`242`	`260`	`randFeature++;`
`243`	`261`	`counter++;`
`@@ -251,17 +269,17 @@ int GroupMicroTextureRegions::getSeed(int32 newFid)`
`251`	`269`	`// fout << fmt::format("Feature Parent Id: {} \| X: {}, Y: {}\n", voxelSeed, centroids.getComponent(voxelSeed, 0), centroids.getComponent(voxelSeed, 1));`
`252`	`270`	`// }`
`253`	`271`
`254`		`- if(voxelSeed >= 0)`
	`272`	`+ if(featureIdSeed >= 0)`
`255`	`273`	`{`
`256`		`- featureParentIds[voxelSeed] = newFid;`
	`274`	`+ featureParentIds[featureIdSeed] = newFid;`
`257`	`275`	`m_NumTuples = newFid + 1;`
`258`	`276`
`259`	`277`	`if(m_InputValues->UseRunningAverage)`
`260`	`278`	`{`
`261`	`279`	`auto& volumes = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->VolumesArrayPath);`
`262`	`280`	`auto& avgQuats = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->AvgQuatsArrayPath);`
`263`	`281`
`264`		`- usize index = voxelSeed * 4;`
	`282`	`+ usize index = featureIdSeed * 4;`
`265`	`283`	`OrientationTransformation::qu2om<QuatF, OrientationF>({avgQuats[index + 0], avgQuats[index + 1], avgQuats[index + 2], avgQuats[index + 3]}).toGMatrix(g1);`
`266`	`284`
`267`	`285`	`std::array<float32, 3> c1 = {0.0f, 0.0f, 0.0f};`
`@@ -274,21 +292,34 @@ int GroupMicroTextureRegions::getSeed(int32 newFid)`
`274`	`292`	`// dividing by the magnitudes (they would be 1)`
`275`	`293`	`MatrixMath::Normalize3x1(c1.data());`
`276`	`294`	`MatrixMath::Copy3x1(c1.data(), m_AvgCAxes.data());`
`277`		`- MatrixMath::Multiply3x1withConstant(m_AvgCAxes.data(), volumes.getValue(voxelSeed));`
	`295`	`+ MatrixMath::Multiply3x1withConstant(m_AvgCAxes.data(), volumes.getValue(featureIdSeed));`
`278`	`296`	`}`
`279`	`297`	`}`
`280`	`298`
`281`		`- return voxelSeed;`
	`299`	`+ return featureIdSeed;`
`282`	`300`	`}`
`283`	`301`
`284`	`302`	`// -----------------------------------------------------------------------------`
`285`	`303`	`bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 neighborFeature, int32 newFid)`
`286`	`304`	`{`
`287`	`305`	`uint32 phase1 = 0;`
`288`		`- float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
`289`		`- float32 g2[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
`290`		`- float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
`291`		`- float32 g2t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
	`306`	`+ /**`
	`307`	`+ * referenceFeature is Cubic Phase`
	`308`	`+ * neighborFeature is Hex Phase`
	`309`	`+ * m_InputValues->UseRunningAverage = TRUE`
	`310`	+ * First `if` check is passed
	`311`	+ * Second `if` check is passed, `phase1` stays at HEX
	`312`	+ * Third `if` check will pass because the 2nd phase is HEX
	`313`	`+ * Probably should not be happening?`
	`314`	+ * Solution: Properly initialize the `phase` outside of all checks or just before the `phase2` initialization
	`315`	+ * Bug introduced JAN 30, 2014 by J. Tucker commit `7e49e52f362005e44ea9bf21b7a717277b2af04e` in Original DREAM3D repository
	`316`	`+`
	`317`	`+ */`
	`318`	`+`
	`319`	`+ float32 g1[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
	`320`	`+ float32 g2[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
	`321`	`+ float32 g1t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
	`322`	`+ float32 g2t[3][3] = {{0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}, {0.0f, 0.0f, 0.0f}};`
`292`	`323`	`std::array<float32, 3> c1 = {0.0f, 0.0f, 0.0f};`
`293`	`324`	`std::array<float32, 3> caxis = {0.0f, 0.0f, 1.0f};`
`294`	`325`
`@@ -301,7 +332,6 @@ bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 n`
`301`	`332`	`if(!m_InputValues->UseRunningAverage)`
`302`	`333`	`{`
`303`	`334`	`usize index = referenceFeature * 4;`
`304`		`- phase1 = crystalStructures[featurePhases[referenceFeature]];`
`305`	`335`	`OrientationTransformation::qu2om<QuatF, Orientation<float32>>({avgQuats[index + 0], avgQuats[index + 1], avgQuats[index + 2], avgQuats[index + 3]}).toGMatrix(g1);`
`306`	`336`
`307`	`337`	`// transpose the g matrix so when c-axis is multiplied by it,`
`@@ -312,6 +342,7 @@ bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 n`
`312`	`342`	`// dividing by the magnitudes (they would be 1)`
`313`	`343`	`MatrixMath::Normalize3x1(c1.data());`
`314`	`344`	`}`
	`345`	`+ phase1 = crystalStructures[featurePhases[referenceFeature]];`
`315`	`346`	`uint32 phase2 = crystalStructures[featurePhases[neighborFeature]];`
`316`	`347`	`if(phase1 == phase2 && (phase1 == EbsdLib::CrystalStructure::Hexagonal_High))`
`317`	`348`	`{`