FILT: ComputeEquivalentDiameterCirclesFilter

CMakeLists.txt

@@ -27,7 +27,6 @@ set(${PLUGIN_NAME}_SOURCE_DIR ${CMAKE_CURRENT_LIST_DIR})
 # These are all the filters in the plugin. All filters should be kept in the
 # SimplnxReview/src/SimplnxReview/Filters/ directory.
 set(FilterList
-  ComputeGroupingDensityFilter
   ComputeLocalAverageCAxisMisalignmentsFilter
   ComputeMicroTextureRegionsFilter
   ComputeSaltykovSizesFilter
@@ -44,7 +43,11 @@ set(ActionList
 # This should be integrated with the `create_simplnx_plugin` function call
 # ------------------------------------------------------------------------------
 set(AlgorithmList
+<<<<<<< HEAD
+=======
+  ComputeEquivalentDiameterCircles
   ComputeGroupingDensity
+>>>>>>> c376c60 (FILT: ComputeEquivalentDiameterCirclesFilter)
   ComputeLocalAverageCAxisMisalignments
   ComputeMicroTextureRegions
   ComputeSaltykovSizes

docs/ComputeEquivalentDiameterCirclesFilter.md

@@ -0,0 +1,28 @@
+# Compute Equivalent Diameter Circles
+
+**THIS FILTER IS UNTESTED, UNVERIFIED AND UNVALIDATED. IT IS AN EXPERIMENTAL FILTER THAT IS UNDERGOING LONG TERM DEVELOPMENT
+AND TESTING. USE AT YOUR OWN RISK**
+
+## Group (Subgroup)
+
+Visualization Helpers
+
+## Description
+
+This filter will generate an Edge Geometry that holds N number of circles where each circle is centered at a given centroid and the radius of the circle is based on the Equivalent Spherical Diameter(ESD) values that are also provided by the user.
+
+This filter was meant to generate 2D circles in the XY plane. This filter will not work well with 3D centroids or centroids that have differing Z Values.
+
+% Auto generated parameter table will be inserted here
+
+## References
+
+## Example Pipelines
+
+## 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/SimplnxReview/Filters/Algorithms/ComputeEquivalentDiameterCircles.cpp

@@ -0,0 +1,84 @@
+#include "ComputeEquivalentDiameterCircles.hpp"
+
+#include "simplnx/Common/Constants.hpp"
+#include "simplnx/Common/Result.hpp"
+#include "simplnx/Common/Types.hpp"
+#include "simplnx/DataStructure/DataArray.hpp"
+#include "simplnx/DataStructure/DataPath.hpp"
+#include "simplnx/DataStructure/DataStructure.hpp"
+#include "simplnx/DataStructure/Geometry/EdgeGeom.hpp"
+#include "simplnx/Filter/IFilter.hpp"
+
+#include <atomic>
+#include <cmath>
+
+using namespace nx::core;
+
+// -----------------------------------------------------------------------------
+ComputeEquivalentDiameterCircles::ComputeEquivalentDiameterCircles(DataStructure& dataStructure, const IFilter::MessageHandler& mesgHandler, const std::atomic_bool& shouldCancel,
+                                                                   ComputeEquivalentDiameterCirclesInputValues* inputValues)
+: m_DataStructure(dataStructure)
+, m_InputValues(inputValues)
+, m_ShouldCancel(shouldCancel)
+, m_MessageHandler(mesgHandler)
+{
+}
+
+// -----------------------------------------------------------------------------
+const std::atomic_bool& ComputeEquivalentDiameterCircles::getCancel()
+{
+  return m_ShouldCancel;
+}
+
+// -----------------------------------------------------------------------------
+Result<> ComputeEquivalentDiameterCircles::operator()()
+{
+  auto& centroidsArray = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->CentroidsArrayPath);
+  auto& equivalentDiametersArray = m_DataStructure.getDataRefAs<Float32Array>(m_InputValues->EquivalentDiametersArrayPath);
+  const DataPath featureIdsPath = m_InputValues->OutputEdgeGeometryPath.createChildPath(m_InputValues->EdgeAttributeMatrixName).createChildPath(m_InputValues->FeatureIdsArrayName);
+  auto& featureIdsArray = m_DataStructure.getDataRefAs<Int32Array>(featureIdsPath);
+  auto& outputEdgeGeom = m_DataStructure.getDataRefAs<EdgeGeom>(m_InputValues->OutputEdgeGeometryPath);
+  Float32Array& verticesArray = outputEdgeGeom.getVerticesRef();
+  UInt64Array& edgesArray = outputEdgeGeom.getEdgesRef();
+
+  const usize circleResolution = m_InputValues->CircleResolution;
+  const usize verticesPerCircle = circleResolution + 1;
+  usize edgeIdx = 0;
+
+  for(usize i = 1; i < centroidsArray.getNumberOfTuples(); ++i)
+  {
+    const float32 r = equivalentDiametersArray[i] / 2.0f;
+    const float32 cx = centroidsArray.getComponent(i, 0);
+    const float32 cy = centroidsArray.getComponent(i, 1);
+
+    const usize circleVertexStart = (i - 1) * verticesPerCircle;
+
+    for(usize v = 0; v < verticesPerCircle; ++v)
+    {
+      const usize vertexIdx = circleVertexStart + v;
+
+      const float32 theta = 2.0f * nx::core::Constants::k_PiF * static_cast<float32>(v) / static_cast<float32>(circleResolution);
+
+      const float32 x = cx + r * std::cos(theta);
+      const float32 y = cy + r * std::sin(theta);
+
+      verticesArray.setComponent(vertexIdx, 0, x);
+      verticesArray.setComponent(vertexIdx, 1, y);
+      verticesArray.setComponent(vertexIdx, 2, static_cast<float32>(m_InputValues->ZPlane));
+    }
+
+    for(usize e = 0; e < circleResolution; ++e)
+    {
+      const usize v0 = circleVertexStart + e;
+      const usize v1 = circleVertexStart + e + 1;
+
+      featureIdsArray.setValue(edgeIdx, static_cast<int32>(i));
+
+      edgesArray.setComponent(edgeIdx, 0, v0);
+      edgesArray.setComponent(edgeIdx, 1, v1);
+      edgeIdx++;
+    }
+  }
+
+  return {};
+}

src/SimplnxReview/Filters/Algorithms/ComputeEquivalentDiameterCircles.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "SimplnxReview/SimplnxReview_export.hpp"
+
+#include "simplnx/DataStructure/DataPath.hpp"
+#include "simplnx/DataStructure/DataStructure.hpp"
+#include "simplnx/Filter/IFilter.hpp"
+
+namespace nx::core
+{
+
+struct SIMPLNXREVIEW_EXPORT ComputeEquivalentDiameterCirclesInputValues
+{
+  DataPath CentroidsArrayPath;
+  DataPath EquivalentDiametersArrayPath;
+  uint64 CircleResolution;
+  int64 ZPlane;
+  DataPath OutputEdgeGeometryPath;
+  std::string EdgeAttributeMatrixName;
+  std::string FeatureIdsArrayName;
+};
+
+/**
+ * @class ComputeEquivalentDiameterCircles
+ * @brief This filter determines the average C-axis location of each Feature.
+ */
+
+class SIMPLNXREVIEW_EXPORT ComputeEquivalentDiameterCircles
+{
+public:
+  ComputeEquivalentDiameterCircles(DataStructure& dataStructure, const IFilter::MessageHandler& mesgHandler, const std::atomic_bool& shouldCancel,
+                                   ComputeEquivalentDiameterCirclesInputValues* inputValues);
+  ~ComputeEquivalentDiameterCircles() noexcept = default;
+
+  ComputeEquivalentDiameterCircles(const ComputeEquivalentDiameterCircles&) = delete;
+  ComputeEquivalentDiameterCircles(ComputeEquivalentDiameterCircles&&) noexcept = delete;
+  ComputeEquivalentDiameterCircles& operator=(const ComputeEquivalentDiameterCircles&) = delete;
+  ComputeEquivalentDiameterCircles& operator=(ComputeEquivalentDiameterCircles&&) noexcept = delete;
+
+  Result<> operator()();
+
+  const std::atomic_bool& getCancel();
+
+private:
+  DataStructure& m_DataStructure;
+  const ComputeEquivalentDiameterCirclesInputValues* m_InputValues = nullptr;
+  const std::atomic_bool& m_ShouldCancel;
+  const IFilter::MessageHandler& m_MessageHandler;
+};
+
+} // namespace nx::core