diff --git a/src/SimplnxReview/Filters/Algorithms/ComputeGroupingDensity.cpp b/src/SimplnxReview/Filters/Algorithms/ComputeGroupingDensity.cpp index 5d80379..31e20a2 100644 --- a/src/SimplnxReview/Filters/Algorithms/ComputeGroupingDensity.cpp +++ b/src/SimplnxReview/Filters/Algorithms/ComputeGroupingDensity.cpp @@ -2,6 +2,7 @@ #include "simplnx/DataStructure/DataArray.hpp" #include "simplnx/DataStructure/NeighborList.hpp" +#include "simplnx/Utilities/MessageHelper.hpp" using namespace nx::core; @@ -66,30 +67,13 @@ class FindDensityGrouping // Default value-initialized to zeroes: https://en.cppreference.com/w/cpp/named_req/DefaultInsertable checkedFeatureVolumes.resize(numFeatures); } - int32_t progInt = 0; - usize prevParentId = 1; - usize currentParentId = 1; - auto start = std::chrono::steady_clock::now(); + MessageHelper messageHelper(m_MessageHandler); + ThrottledMessenger throttledMessenger = messageHelper.createThrottledMessenger(); for(usize parentIdx = 1; parentIdx < numParents; parentIdx++) { - progInt = static_cast(parentIdx) / static_cast(numParents) * 100.0f; - auto now = std::chrono::steady_clock::now(); - // Only send updates every 1 second - if(std::chrono::duration_cast(now - start).count() > 1000) - { - currentParentId = parentIdx; - auto totalParentIds = currentParentId - prevParentId; - auto rate = static_cast(totalParentIds) / static_cast(std::chrono::duration_cast(now - start).count()); - - auto remainingParents = numParents - parentIdx; - auto minutesRemain = (remainingParents / rate) / 60; // Convert to minutes + throttledMessenger.sendThrottledMessage([&]() { return fmt::format("[{}%]", CalculatePercentComplete(parentIdx, numParents)); }); - std::string message = fmt::format("{}/{} [{}%] at {} parents/sec. Time Remain: {:.2f} Minutes", parentIdx, numParents, progInt, rate, minutesRemain); - m_MessageHandler(nx::core::IFilter::ProgressMessage{nx::core::IFilter::Message::Type::Info, message, progInt}); - start = std::chrono::steady_clock::now(); - prevParentId = currentParentId; - } if(m_ShouldCancel) { return {}; diff --git a/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.cpp b/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.cpp index 36a0187..aa2e1f9 100644 --- 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" @@ -54,6 +54,11 @@ GroupMicroTextureRegions::GroupMicroTextureRegions(DataStructure& dataStructure, , m_InputValues(inputValues) , m_ShouldCancel(shouldCancel) , m_MessageHandler(mesgHandler) +, m_FeaturePhases(m_DataStructure.getDataRefAs(m_InputValues->FeaturePhasesArrayPath)) +, m_FeatureParentIds(m_DataStructure.getDataRefAs(m_InputValues->FeatureParentIdsArrayName)) +, m_CrystalStructures(m_DataStructure.getDataRefAs(m_InputValues->CrystalStructuresArrayPath)) +, m_AvgQuats(m_DataStructure.getDataRefAs(m_InputValues->AvgQuatsArrayPath)) +, m_Volumes(m_DataStructure.getDataRefAs(m_InputValues->VolumesArrayPath)) { } @@ -81,35 +86,38 @@ bool GroupMicroTextureRegions::growGrouping(int32_t referenceFeature, int32_t ne // ----------------------------------------------------------------------------- void GroupMicroTextureRegions::execute() { - NeighborList& neighborlist = m_DataStructure.getDataRefAs>(m_InputValues->ContiguousNeighborListArrayPath); + MessageHelper messageHelper(m_MessageHandler); + ThrottledMessenger throttledMessenger = messageHelper.createThrottledMessenger(); + + NeighborList& featureNeighborListRef = m_DataStructure.getDataRefAs>(m_InputValues->ContiguousNeighborListArrayPath); NeighborList* nonContigNeighList = nullptr; if(m_InputValues->UseNonContiguousNeighbors) { nonContigNeighList = m_DataStructure.getDataAs>(m_InputValues->NonContiguousNeighborListArrayPath); } - std::vector grouplist; + std::vector 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::size_type j = 0; j < grouplist.size(); j++) + groupList.push_back(featureSeed); + for(std::vector::size_type j = 0; j < groupList.size(); j++) { - int32 firstfeature = grouplist[j]; - list1size = int32(neighborlist[firstfeature].size()); + int32 firstFeature = groupList[j]; + list1size = static_cast(featureNeighborListRef[firstFeature].size()); if(m_InputValues->UseNonContiguousNeighbors) { - list2size = nonContigNeighList->getListSize(firstfeature); + list2size = nonContigNeighList->getListSize(firstFeature); } for(int32 k = 0; k < 2; k++) { @@ -119,30 +127,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,42 +159,48 @@ void GroupMicroTextureRegions::execute() } if(patchGrouping) { - if(growPatch(parentcount)) + if(growPatch(parentCount)) { - for(std::vector::size_type j = 0; j < grouplist.size(); j++) + for(std::vector::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(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(0.0f, 1.0f); m_AvgCAxes[0] = 0.0f; m_AvgCAxes[1] = 0.0f; m_AvgCAxes[2] = 0.0f; - auto& featureParentIds = m_DataStructure.getDataRefAs(m_InputValues->FeatureParentIdsArrayName); - featureParentIds.fill(-1); + m_FeatureParentIds.fill(-1); + + // Execute the main grouping algorithm + messageHelper.sendMessage(fmt::format("Starting Grouping.....")); execute(); @@ -202,12 +216,12 @@ Result<> GroupMicroTextureRegions::operator()() usize totalPoints = featureIds.getNumberOfTuples(); for(usize k = 0; k < totalPoints; k++) { - cellParentIds[k] = featureParentIds[featureIds[k]]; + cellParentIds[k] = m_FeatureParentIds[featureIds[k]]; } // 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, m_FeatureParentIds, featureIds, m_InputValues->SeedValue); return {}; } @@ -215,29 +229,34 @@ Result<> GroupMicroTextureRegions::operator()() // ----------------------------------------------------------------------------- int GroupMicroTextureRegions::getSeed(int32 newFid) { - auto& featureParentIds = m_DataStructure.getDataRefAs(m_InputValues->FeatureParentIdsArrayName); - auto& featurePhases = m_DataStructure.getDataRefAs(m_InputValues->FeaturePhasesArrayPath); - - usize numFeatures = featurePhases.getNumberOfTuples(); + usize numFeatures = m_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(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(m_Distribution(m_Generator) * static_cast(totalFMinus1)); - while(voxelSeed == -1 && counter < numFeatures) + while(featureIdSeed == -1 && counter < numFeatures) { if(randFeature > totalFMinus1) { randFeature = randFeature - numFeatures; } - if(featureParentIds[randFeature] == -1) + if(m_FeatureParentIds.getValue(randFeature) == -1) { - voxelSeed = randFeature; + featureIdSeed = randFeature; } randFeature++; counter++; @@ -251,18 +270,16 @@ 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; + m_FeatureParentIds[featureIdSeed] = newFid; m_NumTuples = newFid + 1; if(m_InputValues->UseRunningAverage) { - auto& volumes = m_DataStructure.getDataRefAs(m_InputValues->VolumesArrayPath); - auto& avgQuats = m_DataStructure.getDataRefAs(m_InputValues->AvgQuatsArrayPath); - - usize index = voxelSeed * 4; - OrientationTransformation::qu2om({avgQuats[index + 0], avgQuats[index + 1], avgQuats[index + 2], avgQuats[index + 3]}).toGMatrix(g1); + usize index = featureIdSeed * 4; + OrientationTransformation::qu2om({m_AvgQuats.getValue(index + 0), m_AvgQuats.getValue(index + 1), m_AvgQuats.getValue(index + 2), m_AvgQuats.getValue(index + 3)}) + .toGMatrix(g1); std::array c1 = {0.0f, 0.0f, 0.0f}; std::array cAxis = {0.0f, 0.0f, 1.0f}; @@ -274,35 +291,47 @@ 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(), m_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 c1 = {0.0f, 0.0f, 0.0f}; std::array caxis = {0.0f, 0.0f, 1.0f}; - auto& featurePhases = m_DataStructure.getDataRefAs(m_InputValues->FeaturePhasesArrayPath); - auto& featureParentIds = m_DataStructure.getDataRefAs(m_InputValues->FeatureParentIdsArrayName); - auto& crystalStructures = m_DataStructure.getDataRefAs(m_InputValues->CrystalStructuresArrayPath); - if(featureParentIds[neighborFeature] == -1 && featurePhases[referenceFeature] > 0 && featurePhases[neighborFeature] > 0) + int32 neighborParentId = m_FeatureParentIds.getValue(neighborFeature); + int32 referenceFeaturePhase = m_FeaturePhases.getValue(referenceFeature); + int32 neighborFeaturePhase = m_FeaturePhases.getValue(neighborFeature); + + if(neighborParentId == -1 && referenceFeaturePhase > 0 && neighborFeaturePhase > 0) { - auto& avgQuats = m_DataStructure.getDataRefAs(m_InputValues->AvgQuatsArrayPath); if(!m_InputValues->UseRunningAverage) { usize index = referenceFeature * 4; - phase1 = crystalStructures[featurePhases[referenceFeature]]; - OrientationTransformation::qu2om>({avgQuats[index + 0], avgQuats[index + 1], avgQuats[index + 2], avgQuats[index + 3]}).toGMatrix(g1); + OrientationTransformation::qu2om>({m_AvgQuats[index + 0], m_AvgQuats[index + 1], m_AvgQuats[index + 2], m_AvgQuats[index + 3]}).toGMatrix(g1); // transpose the g matrix so when c-axis is multiplied by it, // it will give the sample direction that the c-axis is along @@ -312,11 +341,12 @@ bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 n // dividing by the magnitudes (they would be 1) MatrixMath::Normalize3x1(c1.data()); } - uint32 phase2 = crystalStructures[featurePhases[neighborFeature]]; + phase1 = m_CrystalStructures.getValue(referenceFeaturePhase); + uint32 phase2 = m_CrystalStructures.getValue(neighborFeaturePhase); if(phase1 == phase2 && (phase1 == EbsdLib::CrystalStructure::Hexagonal_High)) { usize index = neighborFeature * 4; - OrientationTransformation::qu2om({avgQuats[index + 0], avgQuats[index + 1], avgQuats[index + 2], avgQuats[index + 3]}).toGMatrix(g2); + OrientationTransformation::qu2om({m_AvgQuats[index + 0], m_AvgQuats[index + 1], m_AvgQuats[index + 2], m_AvgQuats[index + 3]}).toGMatrix(g2); std::array c2 = {0.0f, 0.0f, 0.0f}; // transpose the g matrix so when c-axis is multiplied by it, @@ -337,25 +367,16 @@ bool GroupMicroTextureRegions::determineGrouping(int32 referenceFeature, int32 n w = GeometryMath::CosThetaBetweenVectors(Point3Df{c1}, Point3Df{c2}); } - if(w < -1.0f) - { - w = -1.0f; - } - else if(w > 1.0f) - { - w = 1.0f; - } - w = std::acos(w); + w = std::acos(std::clamp(w, -1.0f, 1.0f)); // Convert user defined tolerance to radians. float32 cAxisToleranceRad = m_InputValues->CAxisTolerance * nx::core::Constants::k_PiD / 180.0f; if(w <= cAxisToleranceRad || (nx::core::Constants::k_PiD - w) <= cAxisToleranceRad) { - featureParentIds[neighborFeature] = newFid; + m_FeatureParentIds.setValue(neighborFeature, newFid); if(m_InputValues->UseRunningAverage) { - auto& volumes = m_DataStructure.getDataRefAs(m_InputValues->VolumesArrayPath); - MatrixMath::Multiply3x1withConstant(c2.data(), volumes.getValue(neighborFeature)); + MatrixMath::Multiply3x1withConstant(c2.data(), m_Volumes.getValue(neighborFeature)); MatrixMath::Add3x1s(m_AvgCAxes.data(), c2.data(), m_AvgCAxes.data()); } return true; diff --git a/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.hpp b/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.hpp index 247116c..d10888d 100644 --- a/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.hpp +++ b/src/SimplnxReview/Filters/Algorithms/GroupMicroTextureRegions.hpp @@ -2,6 +2,7 @@ #include "SimplnxReview/SimplnxReview_export.hpp" +#include "simplnx/DataStructure/DataArray.hpp" #include "simplnx/DataStructure/DataPath.hpp" #include "simplnx/DataStructure/DataStructure.hpp" #include "simplnx/Filter/IFilter.hpp" @@ -70,5 +71,13 @@ class SIMPLNXREVIEW_EXPORT GroupMicroTextureRegions std::array m_AvgCAxes = {0.0f, 0.0f, 0.0f}; std::mt19937_64 m_Generator = {}; std::uniform_real_distribution m_Distribution = {}; + + // These are so that we don't have to keep getting the references while we are running + + Int32Array& m_FeaturePhases; + Int32Array& m_FeatureParentIds; + UInt32Array& m_CrystalStructures; + Float32Array& m_AvgQuats; + Float32Array& m_Volumes; }; } // namespace nx::core diff --git a/src/SimplnxReview/Filters/ComputeGroupingDensityFilter.cpp b/src/SimplnxReview/Filters/ComputeGroupingDensityFilter.cpp index cb5dc3a..bd47605 100644 --- a/src/SimplnxReview/Filters/ComputeGroupingDensityFilter.cpp +++ b/src/SimplnxReview/Filters/ComputeGroupingDensityFilter.cpp @@ -251,5 +251,4 @@ Result ComputeGroupingDensityFilter::FromSIMPLJson(const nlohmann::js return ConvertResultTo(std::move(conversionResult), std::move(args)); } - } // namespace nx::core diff --git a/src/SimplnxReview/Filters/ComputeLocalAverageCAxisMisalignmentsFilter.cpp b/src/SimplnxReview/Filters/ComputeLocalAverageCAxisMisalignmentsFilter.cpp index a78332a..1a71d7b 100644 --- a/src/SimplnxReview/Filters/ComputeLocalAverageCAxisMisalignmentsFilter.cpp +++ b/src/SimplnxReview/Filters/ComputeLocalAverageCAxisMisalignmentsFilter.cpp @@ -295,5 +295,4 @@ Result ComputeLocalAverageCAxisMisalignmentsFilter::FromSIMPLJson(con return ConvertResultTo(std::move(conversionResult), std::move(args)); } - } // namespace nx::core diff --git a/src/SimplnxReview/Filters/ComputeMicroTextureRegionsFilter.cpp b/src/SimplnxReview/Filters/ComputeMicroTextureRegionsFilter.cpp index e6d1993..49a4de5 100644 --- a/src/SimplnxReview/Filters/ComputeMicroTextureRegionsFilter.cpp +++ b/src/SimplnxReview/Filters/ComputeMicroTextureRegionsFilter.cpp @@ -159,5 +159,4 @@ Result ComputeMicroTextureRegionsFilter::FromSIMPLJson(const nlohmann return ConvertResultTo(std::move(conversionResult), std::move(args)); } - } // namespace nx::core diff --git a/src/SimplnxReview/Filters/ComputeSaltykovSizesFilter.cpp b/src/SimplnxReview/Filters/ComputeSaltykovSizesFilter.cpp index 868ebbd..2f7372f 100644 --- a/src/SimplnxReview/Filters/ComputeSaltykovSizesFilter.cpp +++ b/src/SimplnxReview/Filters/ComputeSaltykovSizesFilter.cpp @@ -147,5 +147,4 @@ Result ComputeSaltykovSizesFilter::FromSIMPLJson(const nlohmann::json return ConvertResultTo(std::move(conversionResult), std::move(args)); } - } // namespace nx::core diff --git a/src/SimplnxReview/Filters/GroupMicroTextureRegionsFilter.cpp b/src/SimplnxReview/Filters/GroupMicroTextureRegionsFilter.cpp index 0266a03..d8cb659 100644 --- a/src/SimplnxReview/Filters/GroupMicroTextureRegionsFilter.cpp +++ b/src/SimplnxReview/Filters/GroupMicroTextureRegionsFilter.cpp @@ -56,17 +56,21 @@ 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(k_UseRunningAverage_Key, "Group C-Axes With Running Average", "Group C-Axes With Running Average", true)); + params.insert(std::make_unique(k_CAxisTolerance_Key, "C-Axis Alignment Tolerance (Degrees)", "C-Axis Alignment Tolerance (Degrees)", 0.0f)); + params.insert(std::make_unique(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(k_UseNonContiguousNeighbors_Key, "Use Non-Contiguous Neighbors", "Use non-contiguous neighborhoods", false)); params.insert(std::make_unique(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(k_ContiguousNeighborListArrayPath_Key, "Contiguous Neighbor List", "List of contiguous neighbors for each Feature.", DataPath{}, - NeighborListSelectionParameter::AllowedTypes{DataType::int32})); - params.insert(std::make_unique(k_UseRunningAverage_Key, "Group C-Axes With Running Average", "Group C-Axes With Running Average", true)); - params.insert(std::make_unique(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(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>(k_SeedValue_Key, "Seed", "The seed fed into the random generator", std::mt19937::default_seed)); + params.insert(std::make_unique(k_SeedArrayName_Key, "Stored Seed Value Array Name", "Name of array holding the seed value", "_Group_MicroTexture_Regions_Seed_Value_")); params.insertSeparator(Parameters::Separator{"Input Cell Data"}); params.insert(std::make_unique(k_FeatureIdsArrayPath_Key, "Cell Feature Ids", "Data Array that specifies to which Feature each Element belongs", DataPath{}, @@ -90,8 +94,6 @@ Parameters GroupMicroTextureRegionsFilter::parameters() const params.insert(std::make_unique(k_NewCellFeatureAttributeMatrixName_Key, "Created Microtexture Feature Attribute Matrix", "Output Feature Attribute Matrix for Microtexture Regions", DataPath{})); params.insert(std::make_unique(k_ActiveArrayName_Key, "Active Array Name", "Output Active Array", "Active")); - params.insert(std::make_unique(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); @@ -243,5 +245,4 @@ Result GroupMicroTextureRegionsFilter::FromSIMPLJson(const nlohmann:: return ConvertResultTo(std::move(conversionResult), std::move(args)); } - } // namespace nx::core diff --git a/src/SimplnxReview/Filters/InterpolateValuesToUnstructuredGridFilter.cpp b/src/SimplnxReview/Filters/InterpolateValuesToUnstructuredGridFilter.cpp index ae91e87..5b34607 100644 --- a/src/SimplnxReview/Filters/InterpolateValuesToUnstructuredGridFilter.cpp +++ b/src/SimplnxReview/Filters/InterpolateValuesToUnstructuredGridFilter.cpp @@ -172,5 +172,4 @@ Result InterpolateValuesToUnstructuredGridFilter::FromSIMPLJson(const return ConvertResultTo(std::move(conversionResult), std::move(args)); } - } // namespace nx::core diff --git a/src/SimplnxReview/Filters/MergeColoniesFilter.cpp b/src/SimplnxReview/Filters/MergeColoniesFilter.cpp index 559e08c..6e00796 100644 --- a/src/SimplnxReview/Filters/MergeColoniesFilter.cpp +++ b/src/SimplnxReview/Filters/MergeColoniesFilter.cpp @@ -250,5 +250,4 @@ Result MergeColoniesFilter::FromSIMPLJson(const nlohmann::json& json) return ConvertResultTo(std::move(conversionResult), std::move(args)); } - } // namespace nx::core