API: Update code to match SIMPLNX MessageHandler API changes

src/SimplnxReview/Filters/Algorithms/ComputeLocalAverageCAxisMisalignments.cpp

@@ -18,9 +18,11 @@ template <class MisalignmentArguments = MisalignmentArguments<false, false>>
 class FindLocalAverageMisalignments
 {
 public:
-  FindLocalAverageMisalignments(const std::atomic_bool& shouldCancel, const Int32Array& featureParentIds, const Float32Array& avgCAxisMisalignments, Int32NeighborList& neighborList,
-                                Float32NeighborList& cAxisMisalignmentList, Int32Array& numFeaturesPerParent, Float32Array& unbiasedLocalCAxisMisalignments, Float32Array& localCAxisMisalignments)
+  FindLocalAverageMisalignments(const std::atomic_bool& shouldCancel, ThrottledMessageHandler& progressThrottle, const Int32Array& featureParentIds, const Float32Array& avgCAxisMisalignments,
+                                Int32NeighborList& neighborList, Float32NeighborList& cAxisMisalignmentList, Int32Array& numFeaturesPerParent, Float32Array& unbiasedLocalCAxisMisalignments,
+                                Float32Array& localCAxisMisalignments)
   : m_ShouldCancel(shouldCancel)
+  , m_Throttle(progressThrottle)
   , m_FeatureParentIds(featureParentIds)
   , m_AvgCAxisMisalignments(avgCAxisMisalignments)
   , m_NeighborList(neighborList)
@@ -50,12 +52,14 @@ class FindLocalAverageMisalignments
       numUnbiasedFeaturesPerParent.resize(numFeatures);
     }
 
+    m_Throttle.reset(numFeatures > 1 ? numFeatures - 1 : 0, "Computing Local Average CAxis Misalignments");
     for(usize i = 1; i < numFeatures; i++)
     {
       if(m_ShouldCancel)
       {
         return {};
       }
+      m_Throttle.updatePercent(i - 1);
 
       int32 parentId = m_FeatureParentIds[i];
       if constexpr(MisalignmentArguments::CalculatingUnbiasedAverage)
@@ -77,12 +81,14 @@ class FindLocalAverageMisalignments
       }
     }
 
+    m_Throttle.reset(newNumFeatures > 1 ? newNumFeatures - 1 : 0, "Normalizing Parent Misalignments");
     for(usize i = 1; i < newNumFeatures; i++)
     {
       if(m_ShouldCancel)
       {
         return {};
       }
+      m_Throttle.updatePercent(i - 1);
 
       if constexpr(MisalignmentArguments::CalculatingBiasedAverage)
       {
@@ -107,6 +113,7 @@ class FindLocalAverageMisalignments
 
 private:
   const std::atomic_bool& m_ShouldCancel;
+  ThrottledMessageHandler& m_Throttle;
 
   // Unmodified Arrays
   const Int32Array& m_FeatureParentIds;
@@ -128,6 +135,7 @@ ComputeLocalAverageCAxisMisalignments::ComputeLocalAverageCAxisMisalignments(Dat
 , m_InputValues(inputValues)
 , m_ShouldCancel(shouldCancel)
 , m_MessageHandler(mesgHandler)
+, m_Throttle(mesgHandler)
 {
 }
 
@@ -155,15 +163,15 @@ Result<> ComputeLocalAverageCAxisMisalignments::operator()()
   {
     if(m_InputValues->CalcUnbiasedAvg)
     {
-      return ::FindLocalAverageMisalignments<MisalignmentArguments<true, true>>(getCancel(), featureParentIds, avgCAxisMisalignments, neighborList, cAxisMisalignmentList, numFeaturesPerParent,
-                                                                                unbiasedLocalCAxisMisalignments, localCAxisMisalignments)();
+      return ::FindLocalAverageMisalignments<MisalignmentArguments<true, true>>(getCancel(), m_Throttle, featureParentIds, avgCAxisMisalignments, neighborList, cAxisMisalignmentList,
+                                                                                numFeaturesPerParent, unbiasedLocalCAxisMisalignments, localCAxisMisalignments)();
     }
-    return ::FindLocalAverageMisalignments<MisalignmentArguments<true, false>>(getCancel(), featureParentIds, avgCAxisMisalignments, neighborList, cAxisMisalignmentList, numFeaturesPerParent,
-                                                                               unbiasedLocalCAxisMisalignments, localCAxisMisalignments)();
+    return ::FindLocalAverageMisalignments<MisalignmentArguments<true, false>>(getCancel(), m_Throttle, featureParentIds, avgCAxisMisalignments, neighborList, cAxisMisalignmentList,
+                                                                               numFeaturesPerParent, unbiasedLocalCAxisMisalignments, localCAxisMisalignments)();
   }
 
   // Since we validate that at least one of the bool options is true in preflight we know that
   // by reaching this point in the logic we m_InputValues->CalcUnbiasedAvg must be true
-  return ::FindLocalAverageMisalignments<MisalignmentArguments<false, true>>(getCancel(), featureParentIds, avgCAxisMisalignments, neighborList, cAxisMisalignmentList, numFeaturesPerParent,
-                                                                             unbiasedLocalCAxisMisalignments, localCAxisMisalignments)();
+  return ::FindLocalAverageMisalignments<MisalignmentArguments<false, true>>(getCancel(), m_Throttle, featureParentIds, avgCAxisMisalignments, neighborList, cAxisMisalignmentList,
+                                                                             numFeaturesPerParent, unbiasedLocalCAxisMisalignments, localCAxisMisalignments)();
 }

src/SimplnxReview/Filters/Algorithms/ComputeLocalAverageCAxisMisalignments.hpp

@@ -8,6 +8,7 @@
 #include "simplnx/Parameters/ArraySelectionParameter.hpp"
 #include "simplnx/Parameters/DataGroupSelectionParameter.hpp"
 #include "simplnx/Parameters/StringParameter.hpp"
+#include "simplnx/Utilities/ThrottledMessageHandler.hpp"
 
 namespace nx::core
 {
@@ -49,5 +50,6 @@ class SIMPLNXREVIEW_EXPORT ComputeLocalAverageCAxisMisalignments
   const ComputeLocalAverageCAxisMisalignmentsInputValues* m_InputValues = nullptr;
   const std::atomic_bool& m_ShouldCancel;
   const IFilter::MessageHandler& m_MessageHandler;
+  ThrottledMessageHandler m_Throttle;
 };
 } // namespace nx::core

src/SimplnxReview/Filters/Algorithms/ComputeMicroTextureRegions.cpp

@@ -2,6 +2,7 @@
 
 #include "simplnx/DataStructure/DataArray.hpp"
 #include "simplnx/DataStructure/Geometry/ImageGeom.hpp"
+#include "simplnx/Utilities/ThrottledMessageHandler.hpp"
 
 #include <algorithm>
 
@@ -49,10 +50,17 @@ Result<> ComputeMicroTextureRegions::operator()()
 
   std::for_each(featureIds.begin(), featureIds.end(), [&microTextureRegionNumCells](const int32 id) mutable { microTextureRegionNumCells[id].inc(); });
 
+  ThrottledMessageHandler progressThrottle(m_MessageHandler);
+  progressThrottle.reset(zPoints, "Finding MicroTexture Region Bounds");
+
   float32 x, y, z;
   usize zStride, yStride;
   for(usize i = 0; i < zPoints; i++)
   {
+    if(m_ShouldCancel)
+    {
+      return {};
+    }
     zStride = i * xPoints * yPoints;
     for(usize j = 0; j < yPoints; j++)
     {
@@ -89,11 +97,17 @@ Result<> ComputeMicroTextureRegions::operator()()
         }
       }
     }
+    progressThrottle.updateCount(i + 1);
   }
 
   auto& microTextureRegionFractionOccupied = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->MicroTextureRegionFractionOccupiedArrayPath);
+  progressThrottle.reset(numMicroTextureRegions > 1 ? numMicroTextureRegions - 1 : 0, "Computing MicroTexture Region Fractions");
   for(usize i = 1; i < numMicroTextureRegions; i++)
   {
+    if(m_ShouldCancel)
+    {
+      return {};
+    }
     float32 xLength = (microTextureRegionXMaxs[i] - microTextureRegionXMins[i]) + spacing[0];
     float32 yLength = (microTextureRegionYMaxs[i] - microTextureRegionYMins[i]) + spacing[1];
     if(zPoints == 1)
@@ -107,6 +121,7 @@ Result<> ComputeMicroTextureRegions::operator()()
       float32 rectangleVolume = xLength * yLength;
       microTextureRegionFractionOccupied[i] = (static_cast<float32>(microTextureRegionNumCells[i]) * spacing[0] * spacing[1]) / rectangleVolume;
     }
+    progressThrottle.updateCount(i);
   }
 
   return {};

src/SimplnxReview/Filters/Algorithms/ComputeSaltykovSizes.cpp

@@ -2,6 +2,7 @@
 
 #include "simplnx/DataStructure/DataArray.hpp"
 #include "simplnx/DataStructure/DataGroup.hpp"
+#include "simplnx/Utilities/ThrottledMessageHandler.hpp"
 
 #include <random>
 
@@ -126,8 +127,17 @@ Result<> ComputeSaltykovSizes::operator()()
   // the feature eq dia.  But, it is important to note that the Saltykov eq dia
   // is not a direct transformation of the particular eq dia that it is matched
   // up with
+  ThrottledMessageHandler progressThrottle(m_MessageHandler);
+  usize fittingAttempt = 0;
   while(saltykovLength != numFeatures - 1)
   {
+    if(m_ShouldCancel)
+    {
+      return {};
+    }
+    fittingAttempt++;
+    progressThrottle.queueMessage("Fitting Saltykov bins: attempt {}, {} bins", fittingAttempt, numberOfBins);
+
     // find the bin length
     binLength = maxEqDia / static_cast<float32>(numberOfBins - 1);
 
@@ -260,8 +270,14 @@ Result<> ComputeSaltykovSizes::operator()()
     std::sort(saltykovEquivalentDiameters.begin(), saltykovEquivalentDiameters.end(), std::less<>());
 
     // this nested loop matches the Saltykov eq dia's with the feature eq dia's in ascending order
+    progressThrottle.reset(numFeatures > 1 ? numFeatures - 1 : 0, "Matching Saltykov Diameters");
     for(usize i = 1; i < numFeatures; i++)
     {
+      if(m_ShouldCancel)
+      {
+        return {};
+      }
+      progressThrottle.updatePercent(i - 1);
       for(usize j = 1; j < numFeatures; j++)
       {
         if(equivalentDiameters[j] == currentMinimum)

src/SimplnxReview/Filters/Algorithms/InterpolateValuesToUnstructuredGrid.cpp

@@ -37,25 +37,22 @@ class CalculateClosestVerticesImpl
 
   void generate(size_t start, size_t end) const
   {
-    auto startTime = std::chrono::steady_clock::now();
     usize counter = 0;
-    usize increment = (end - start) / 100;
+    // A count stride keeps the seam out of the per-vertex hot path. The throttle behind the seam
+    // decides when a message is actually due, so this loop never reads the clock.
+    const usize increment = std::max<usize>(1, (end - start) / 100);
     for(usize destVertexId = start; destVertexId < end; destVertexId++)
     {
       if(m_ShouldCancel)
       {
+        m_Filter->sendThreadSafeProgressMessage(counter);
         return;
       }
 
       if(counter > increment)
       {
-        auto now = std::chrono::steady_clock::now();
-        if(std::chrono::duration_cast<std::chrono::milliseconds>(now - startTime).count() > 1000)
-        {
-          m_Filter->sendThreadSafeProgressMessage(counter);
-          counter = 0;
-          startTime = std::chrono::steady_clock::now();
-        }
+        m_Filter->sendThreadSafeProgressMessage(counter);
+        counter = 0;
       }
 
       Vec3<float32> destVertexCoord = m_DestGeometry.getVertexCoordinate(destVertexId);
@@ -112,6 +109,7 @@ InterpolateValuesToUnstructuredGrid::InterpolateValuesToUnstructuredGrid(DataStr
 , m_InputValues(inputValues)
 , m_ShouldCancel(shouldCancel)
 , m_MessageHandler(mesgHandler)
+, m_Throttle(mesgHandler)
 {
 }
 
@@ -134,12 +132,17 @@ Result<> InterpolateValuesToUnstructuredGrid::operator()()
 
   // set up thread-safe messenger
   m_TotalElements = destGeometry.getNumberOfVertices();
+  m_Throttle.reset(m_TotalElements, "Calculating Closest Vertices");
 
   // Parallel algorithm to calculate closest vertices
   ParallelDataAlgorithm dataAlg;
   dataAlg.setRange(0ULL, static_cast<usize>(destGeometry.getNumberOfVertices()));
   dataAlg.execute(CalculateClosestVerticesImpl(this, srcGeometry, destGeometry, closestSrcIds, m_MessageHandler, m_ShouldCancel));
-  m_MessageHandler(IFilter::Message::Type::Info, "Calculating Closest Vertices || 100%");
+  if(m_ShouldCancel)
+  {
+    return {};
+  }
+  m_MessageHandler.sendProgressCount("Calculating Closest Vertices", m_TotalElements, m_TotalElements);
 
   DataPath interpolatedAttrMatrixPath;
   if(m_InputValues->UseExistingAttrMatrix)
@@ -151,20 +154,24 @@ Result<> InterpolateValuesToUnstructuredGrid::operator()()
     interpolatedAttrMatrixPath = m_InputValues->DestinationGeomPath.createChildPath(m_InputValues->CreatedAttrMatrixName);
   }
 
+  ProgressEstimator arrayEstimator;
   for(usize i = 0; i < m_InputValues->InputDataPaths.size(); i++)
   {
     const auto& dataPath = m_InputValues->InputDataPaths[i];
-    m_MessageHandler(IFilter::Message::Type::Info, fmt::format("Interpolating \"{}\" Array Values || {}/{}", dataPath.getTargetName(), i + 1, m_InputValues->InputDataPaths.size()));
 
     if(m_ShouldCancel)
     {
       return {};
     }
 
+    m_MessageHandler.sendInfoMessage(fmt::format("Interpolating \"{}\" Array Values", dataPath.getTargetName()));
+
     const auto& srcDataArray = m_DataStructure.getDataRefAs<IDataArray>(dataPath);
     auto& destDataArray = m_DataStructure.getDataRefAs<IDataArray>(interpolatedAttrMatrixPath.createChildPath(dataPath.getTargetName()));
 
     ExecuteDataFunction(ExecuteInterpolation{}, srcDataArray.getDataType(), srcDataArray, destDataArray, closestSrcIds);
+
+    m_MessageHandler.sendProgressCount("Interpolating Array Values", i + 1, m_InputValues->InputDataPaths.size(), arrayEstimator.estimate(i + 1, m_InputValues->InputDataPaths.size()));
   }
 
   return {};
@@ -174,18 +181,5 @@ Result<> InterpolateValuesToUnstructuredGrid::operator()()
 void InterpolateValuesToUnstructuredGrid::sendThreadSafeProgressMessage(usize counter)
 {
   std::lock_guard<std::mutex> guard(m_ProgressMessage_Mutex);
-
-  m_ProgressCounter += counter;
-  auto now = std::chrono::steady_clock::now();
-  if(std::chrono::duration_cast<std::chrono::milliseconds>(now - m_InitialPoint).count() > 1000)
-  {
-    return;
-  }
-
-  auto progressInt = static_cast<usize>((static_cast<float32>(m_ProgressCounter) / static_cast<float32>(m_TotalElements)) * 100.0f);
-  std::string ss = fmt::format("Calculating Closest Vertices || {}%", progressInt);
-  m_MessageHandler(IFilter::Message::Type::Info, ss);
-
-  m_LastProgressInt = progressInt;
-  m_InitialPoint = std::chrono::steady_clock::now();
+  m_Throttle.incrementPercent(counter);
 }

src/SimplnxReview/Filters/Algorithms/InterpolateValuesToUnstructuredGrid.hpp

@@ -13,6 +13,8 @@
 #include "simplnx/Parameters/NumberParameter.hpp"
 #include "simplnx/Parameters/VectorParameter.hpp"
 #include "simplnx/Utilities/ImageRotationUtilities.hpp"
+#include "simplnx/Utilities/ProgressEstimator.hpp"
+#include "simplnx/Utilities/ThrottledMessageHandler.hpp"
 
 #include <Eigen/Dense>
 
@@ -59,11 +61,9 @@ class SIMPLNXREVIEW_EXPORT InterpolateValuesToUnstructuredGrid
   const IFilter::MessageHandler& m_MessageHandler;
 
   // Thread safe Progress Message
-  std::chrono::steady_clock::time_point m_InitialPoint = std::chrono::steady_clock::now();
   mutable std::mutex m_ProgressMessage_Mutex;
-  size_t m_TotalElements = 0;
-  size_t m_ProgressCounter = 0;
-  size_t m_LastProgressInt = 0;
+  usize m_TotalElements = 0;
+  ThrottledMessageHandler m_Throttle;
 };
 
 } // namespace nx::core