Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-10-05 01:49:02 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Clean up point mapping in CleanGrid

Browse Source 
Use the `MapFieldPermutation` function when mapping point coordinates
for points that are removed. (This function was already being used for
the rest of the fields.) Also remove some unneeded code in the
`CleanGrid` worklets.
This commit is contained in:
Kenneth Moreland 2023-01-31 15:20:47 -07:00
parent 3a02a45729
commit a478081dea
6 changed files with 37 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/changelog/interp-any-field.md
View File

@ -12,6 +12,7 @@ possible types. This is done by using the extract component functionality
to get data from any type of array. The following filters have been
updated.
* `CleanGrid`
* `ClipWithField`
* `ClipWithImplicitFunction`
* `Contour`

23
vtkm/filter/MapFieldPermutation.cxx
View File

@ -36,6 +36,29 @@ VTKM_FILTER_CORE_EXPORT VTKM_CONT bool vtkm::filter::MapFieldPermutation(
}
}
VTKM_FILTER_CORE_EXPORT VTKM_CONT bool vtkm::filter::MapFieldPermutation(
const vtkm::cont::CoordinateSystem& inputCoords,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::CoordinateSystem& outputCoords,
vtkm::Float64 invalidValue)
{
VTKM_LOG_SCOPE_FUNCTION(vtkm::cont::LogLevel::Perf);
try
{
vtkm::cont::UnknownArrayHandle outputArray =
vtkm::cont::internal::MapArrayPermutation(inputCoords.GetData(), permutation, invalidValue);
outputCoords =
vtkm::cont::Field(inputCoords.GetName(), inputCoords.GetAssociation(), outputArray);
return true;
}
catch (...)
{
VTKM_LOG_S(vtkm::cont::LogLevel::Warn, "Faild to coordinate system " << inputCoords.GetName());
return false;
}
}
VTKM_FILTER_CORE_EXPORT VTKM_CONT bool vtkm::filter::MapFieldPermutation(
const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,

7
vtkm/filter/MapFieldPermutation.h
View File

@ -12,6 +12,7 @@
#define vtk_m_filter_MapFieldPermutation_h
#include <vtkm/cont/ArrayHandle.h>
#include <vtkm/cont/CoordinateSystem.h>
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Field.h>
@ -49,6 +50,12 @@ VTKM_FILTER_CORE_EXPORT VTKM_CONT bool MapFieldPermutation(
vtkm::cont::Field& outputField,
vtkm::Float64 invalidValue = vtkm::Nan<vtkm::Float64>());
VTKM_FILTER_CORE_EXPORT VTKM_CONT bool MapFieldPermutation(
const vtkm::cont::CoordinateSystem& inputCoords,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::CoordinateSystem& outputCoords,
vtkm::Float64 invalidValue = vtkm::Nan<vtkm::Float64>());
/// \brief Maps a field by permuting it by a given index array.
///
/// This method will create a new field containing the data from the provided `inputField` but

7
vtkm/filter/clean_grid/CleanGrid.cxx
View File

@ -51,7 +51,7 @@ bool DoMapField(vtkm::cont::DataSet& result,
if (self.GetCompactPointFields())
{
bool success = vtkm::filter::MapFieldPermutation(
field, worklets.PointCompactor.GetPointScatter().GetOutputToInputMap(), compactedField);
field, worklets.PointCompactor.GetPermutationArray(), compactedField);
if (!success)
{
return false;
@ -111,9 +111,8 @@ vtkm::cont::DataSet CleanGrid::GenerateOutput(const vtkm::cont::DataSet& inData,
outputCellSet = worklets.PointCompactor.MapCellSet(outputCellSet);
activeCoordSystem = vtkm::cont::CoordinateSystem(
activeCoordSystem.GetName(),
worklets.PointCompactor.MapPointFieldDeep(activeCoordSystem.GetData()));
vtkm::filter::MapFieldPermutation(
activeCoordSystem, worklets.PointCompactor.GetPermutationArray(), activeCoordSystem);
}
// Optionally find and merge coincident points

40
vtkm/filter/clean_grid/worklet/PointMerge.h
View File

@ -462,46 +462,6 @@ public:
inCellSet, this->PointInputToOutputMap, this->MergeKeys.GetInputRange());
}
private:
struct MapPointFieldFunctor
{
template <typename T, typename S>
VTKM_CONT void operator()(const vtkm::cont::ArrayHandle<T, S>& inArray,
vtkm::cont::UnknownArrayHandle& outHolder,
const PointMerge& self) const
{
vtkm::cont::ArrayHandle<T> outArray;
self.MapPointField(inArray, outArray);
outHolder = vtkm::cont::UnknownArrayHandle(outArray);
}
};
public:
template <typename InArrayHandle, typename OutArrayHandle>
VTKM_CONT void MapPointField(const InArrayHandle& inArray, OutArrayHandle& outArray) const
{
vtkm::worklet::AverageByKey::Run(this->MergeKeys, inArray, outArray);
}
template <typename T, typename S>
VTKM_CONT vtkm::cont::ArrayHandle<T> MapPointField(
const vtkm::cont::ArrayHandle<T, S>& inArray) const
{
vtkm::cont::ArrayHandle<T> outArray;
this->MapPointField(inArray, outArray);
return outArray;
}
template <typename TL, typename SL>
VTKM_CONT vtkm::cont::UncertainArrayHandle<TL, SL> MapPointField(
const vtkm::cont::UncertainArrayHandle<TL, SL>& inArray) const
{
vtkm::cont::UncertainArrayHandle<TL, SL> outArray;
vtkm::cont::CastAndCall(inArray, MapPointFieldFunctor{}, outArray, *this);
return outArray;
}
vtkm::worklet::Keys<vtkm::Id> GetMergeKeys() const { return this->MergeKeys; }
private:

89
vtkm/filter/clean_grid/worklet/RemoveUnusedPoints.h
View File

@ -180,96 +180,13 @@ public:
return outCellSet;
}
/// \brief Maps a point field from the original points to the new reduced points
/// \brief Returns a permutation map that maps new points to old points.
///
/// Given an array handle that holds the values for a point field of the
/// original data set, returns a new array handle containing field values
/// rearranged to the new indices of the reduced point set.
///
/// This version of point mapping performs a shallow copy by using a
/// permutation array.
///
template <typename InArrayHandle>
VTKM_CONT vtkm::cont::ArrayHandlePermutation<vtkm::cont::ArrayHandle<vtkm::Id>, InArrayHandle>
MapPointFieldShallow(const InArrayHandle& inArray) const
VTKM_CONT vtkm::cont::ArrayHandle<vtkm::Id> GetPermutationArray() const
{
VTKM_IS_ARRAY_HANDLE(InArrayHandle);
VTKM_ASSERT(this->PointScatter);
return vtkm::cont::make_ArrayHandlePermutation(this->PointScatter->GetOutputToInputMap(),
inArray);
return this->PointScatter->GetOutputToInputMap();
}
private:
struct MapPointFieldDeepFunctor
{
template <typename InT, typename InS, typename OutT, typename OutS>
VTKM_CONT void operator()(const vtkm::cont::ArrayHandle<InT, InS>& inArray,
vtkm::cont::ArrayHandle<OutT, OutS>& outArray,
const RemoveUnusedPoints& self) const
{
self.MapPointFieldDeep(inArray, outArray);
}
template <typename InT, typename InS>
VTKM_CONT void operator()(const vtkm::cont::ArrayHandle<InT, InS>& inArray,
vtkm::cont::UnknownArrayHandle& outHolder,
const RemoveUnusedPoints& self) const
{
vtkm::cont::ArrayHandle<InT> outArray;
(*this)(inArray, outArray, self);
outHolder = vtkm::cont::UnknownArrayHandle{ outArray };
}
};
public:
///@{
/// \brief Maps a point field from the original points to the new reduced points
///
/// Given an array handle that holds the values for a point field of the
/// original data set, returns a new array handle containing field values
/// rearranged to the new indices of the reduced point set.
///
/// This version of point mapping performs a deep copy into the destination
/// array provided.
///
template <typename InT, typename InS, typename OutT, typename OutS>
VTKM_CONT void MapPointFieldDeep(const vtkm::cont::ArrayHandle<InT, InS>& inArray,
vtkm::cont::ArrayHandle<OutT, OutS>& outArray) const
{
vtkm::cont::ArrayCopyDevice(this->MapPointFieldShallow(inArray), outArray);
}
template <typename T, typename S>
VTKM_CONT vtkm::cont::ArrayHandle<T> MapPointFieldDeep(
const vtkm::cont::ArrayHandle<T, S>& inArray) const
{
vtkm::cont::ArrayHandle<T> outArray;
this->MapPointFieldDeep(inArray, outArray);
return outArray;
}
template <typename InValueTypes, typename InStorageTypes, typename OutArrayHandle>
VTKM_CONT void MapPointFieldDeep(
const vtkm::cont::UncertainArrayHandle<InValueTypes, InStorageTypes>& inArray,
OutArrayHandle& outArray) const
{
vtkm::cont::CastAndCall(inArray, MapPointFieldDeepFunctor{}, outArray, *this);
}
template <typename InValueTypes, typename InStorageTypes>
VTKM_CONT vtkm::cont::UncertainArrayHandle<InValueTypes, InStorageTypes> MapPointFieldDeep(
const vtkm::cont::UncertainArrayHandle<InValueTypes, InStorageTypes>& inArray) const
{
vtkm::cont::UncertainArrayHandle<InValueTypes, InStorageTypes> outArray;
vtkm::cont::CastAndCall(inArray, MapPointFieldDeepFunctor{}, outArray, *this);
return outArray;
}
///@}
const vtkm::worklet::ScatterCounting& GetPointScatter() const { return *this->PointScatter; }
private:
vtkm::cont::ArrayHandle<vtkm::IdComponent> MaskArray;