Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Convert CleanGrid (and dependents) to use precompiled field map

Browse Source
This commit is contained in:
Kenneth Moreland 2020-02-04 22:44:10 -06:00
parent 2383a7fffd
commit 4a5dbb65db
15 changed files with 126 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
vtkm/filter/CleanGrid.cxx
View File

@ -12,6 +12,9 @@
#include <vtkm/filter/CleanGrid.h> #include <vtkm/filter/CleanGrid.h>
#include <vtkm/filter/CleanGrid.hxx> #include <vtkm/filter/CleanGrid.hxx>
#include <vtkm/filter/MapFieldMergeAverage.h>
#include <vtkm/filter/MapFieldPermutation.h>
namespace vtkm namespace vtkm
{ {
namespace filter namespace filter
@ -116,6 +119,46 @@ vtkm::cont::DataSet CleanGrid::GenerateOutput(const vtkm::cont::DataSet& inData,
return outData; return outData;
} }
bool CleanGrid::MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field)
{
if (field.IsFieldPoint() && (this->GetCompactPointFields() || this->GetMergePoints()))
{
vtkm::cont::Field compactedField;
if (this->GetCompactPointFields())
{
bool success = vtkm::filter::MapFieldPermutation(
field, this->PointCompactor.GetPointScatter().GetOutputToInputMap(), compactedField);
if (!success)
{
return false;
}
}
else
{
compactedField = field;
}
if (this->GetMergePoints())
{
return vtkm::filter::MapFieldMergeAverage(
compactedField, this->PointMerger.GetMergeKeys(), result);
}
else
{
result.AddField(compactedField);
return true;
}
}
else if (field.IsFieldCell() && this->GetRemoveDegenerateCells())
{
return vtkm::filter::MapFieldPermutation(field, this->CellCompactor.GetValidCellIds(), result);
}
else
{
result.AddField(field);
return true;
}
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(CleanGrid); VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(CleanGrid);
} }

39
vtkm/filter/CleanGrid.h
View File

@ -87,40 +87,15 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData, VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy); vtkm::filter::PolicyBase<Policy> policy);
VTKM_FILTER_EXPORT
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field);
template <typename ValueType, typename Storage, typename Policy> template <typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result, VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<ValueType, Storage>& input, const vtkm::cont::Field& field,
const vtkm::filter::FieldMetadata& fieldMeta, vtkm::filter::PolicyBase<DerivedPolicy>)
vtkm::filter::PolicyBase<Policy>)
{ {
if (fieldMeta.IsPointField() && (this->GetCompactPointFields() || this->GetMergePoints())) return this->MapFieldOntoOutput(result, field);
{
vtkm::cont::ArrayHandle<ValueType> compactedArray;
if (this->GetCompactPointFields())
{
compactedArray = this->PointCompactor.MapPointFieldDeep(input);
if (this->GetMergePoints())
{
compactedArray = this->PointMerger.MapPointField(compactedArray);
}
}
else if (this->GetMergePoints())
{
compactedArray = this->PointMerger.MapPointField(input);
}
result.AddField(fieldMeta.AsField(compactedArray));
}
else if (fieldMeta.IsCellField() && this->GetRemoveDegenerateCells())
{
result.AddField(fieldMeta.AsField(this->CellCompactor.ProcessCellField(input)));
}
else
{
result.AddField(fieldMeta.AsField(input));
}
return true;
} }
private: private:

22
vtkm/filter/ExternalFaces.cxx
View File

@ -64,6 +64,28 @@ vtkm::cont::DataSet ExternalFaces::GenerateOutput(const vtkm::cont::DataSet& inp
} }
} }
bool ExternalFaces::MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field)
{
if (field.IsFieldPoint())
{
if (this->CompactPoints)
{
return this->Compactor.MapFieldOntoOutput(result, field);
}
else
{
result.AddField(field);
return true;
}
}
else if (field.IsFieldCell())
{
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetCellIdMap(), result);
}
return false;
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ExternalFaces); VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ExternalFaces);
} }

37
vtkm/filter/ExternalFaces.h
View File

@ -15,6 +15,7 @@
#include <vtkm/filter/CleanGrid.h> #include <vtkm/filter/CleanGrid.h>
#include <vtkm/filter/FilterDataSet.h> #include <vtkm/filter/FilterDataSet.h>
#include <vtkm/filter/MapFieldPermutation.h>
#include <vtkm/worklet/ExternalFaces.h> #include <vtkm/worklet/ExternalFaces.h>
namespace vtkm namespace vtkm
@ -59,35 +60,15 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input, VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy); vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
//this call is only valid const vtkm::cont::Field& field);
template <typename T, typename StorageType, typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
if (fieldMeta.IsPointField())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
}
else
{
result.AddField(fieldMeta.AsField(input));
return true;
}
}
else if (fieldMeta.IsCellField())
{
vtkm::cont::ArrayHandle<T> fieldArray;
fieldArray = this->Worklet.ProcessCellField(input);
result.AddField(fieldMeta.AsField(fieldArray));
return true;
}
return false; template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>)
{
return this->MapFieldOntoOutput(result, field);
} }
private: private:

9
vtkm/filter/ExtractPoints.h
View File

@ -64,11 +64,10 @@ public:
vtkm::filter::PolicyBase<DerivedPolicy> policy); vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter //Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy> template <typename DerivedPolicy>
bool DoMapField(vtkm::cont::DataSet& result, VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input, const vtkm::cont::Field& field,
const vtkm::filter::FieldMetadata& fieldMeta, vtkm::filter::PolicyBase<DerivedPolicy>);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private: private:
bool ExtractInside; bool ExtractInside;

13
vtkm/filter/ExtractPoints.hxx
View File

@ -65,23 +65,22 @@ inline vtkm::cont::DataSet ExtractPoints::DoExecute(const vtkm::cont::DataSet& i
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy> template <typename DerivedPolicy>
inline VTKM_CONT bool ExtractPoints::DoMapField( inline VTKM_CONT bool ExtractPoints::MapFieldOntoOutput(
vtkm::cont::DataSet& result, vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input, const vtkm::cont::Field& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy) vtkm::filter::PolicyBase<DerivedPolicy> policy)
{ {
// point data is copied as is because it was not collapsed // point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField()) if (field.IsFieldPoint())
{ {
if (this->CompactPoints) if (this->CompactPoints)
{ {
return this->Compactor.DoMapField(result, input, fieldMeta, policy); return this->Compactor.MapFieldOntoOutput(result, field, policy);
} }
else else
{ {
result.AddField(fieldMeta.AsField(input)); result.AddField(field);
return true; return true;
} }
} }

6
vtkm/filter/MapFieldPermutation.cxx
View File

@ -59,9 +59,9 @@ bool vtkm::filter::MapFieldPermutation(const vtkm::cont::Field& inputField,
return functor.CalledMap; return functor.CalledMap;
} }
bool MapFieldPermutation(const vtkm::cont::Field& inputField, bool vtkm::filter::MapFieldPermutation(const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation, const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::DataSet& outputData) vtkm::cont::DataSet& outputData)
{ {
vtkm::cont::Field outputField; vtkm::cont::Field outputField;
bool success = vtkm::filter::MapFieldPermutation(inputField, permutation, outputField); bool success = vtkm::filter::MapFieldPermutation(inputField, permutation, outputField);

9
vtkm/filter/MaskPoints.h
View File

@ -46,11 +46,10 @@ public:
vtkm::filter::PolicyBase<DerivedPolicy> policy); vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter //Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy> template <typename DerivedPolicy>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result, VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input, const vtkm::cont::Field& field,
const vtkm::filter::FieldMetadata& fieldMeta, vtkm::filter::PolicyBase<DerivedPolicy>);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private: private:
vtkm::Id Stride; vtkm::Id Stride;

15
vtkm/filter/MaskPoints.hxx
View File

@ -58,22 +58,21 @@ inline VTKM_CONT vtkm::cont::DataSet MaskPoints::DoExecute(
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy> template <typename DerivedPolicy>
inline VTKM_CONT bool MaskPoints::DoMapField(vtkm::cont::DataSet& result, inline VTKM_CONT bool MaskPoints::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input, const vtkm::cont::Field& field,
const vtkm::filter::FieldMetadata& fieldMeta, vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{ {
// point data is copied as is because it was not collapsed // point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField()) if (field.IsFieldPoint())
{ {
if (this->CompactPoints) if (this->CompactPoints)
{ {
return this->Compactor.DoMapField(result, input, fieldMeta, policy); return this->Compactor.MapFieldOntoOutput(result, field, policy);
} }
else else
{ {
result.AddField(fieldMeta.AsField(input)); result.AddField(field);
return true; return true;
} }
} }

11
vtkm/filter/ThresholdPoints.h
View File

@ -58,13 +58,10 @@ public:
const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy); vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter template <typename DerivedPolicy>
//this call is only valid VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
template <typename T, typename StorageType, typename DerivedPolicy> const vtkm::cont::Field& field,
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result, vtkm::filter::PolicyBase<DerivedPolicy>);
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
private: private:
double LowerValue; double LowerValue;

13
vtkm/filter/ThresholdPoints.hxx
View File

@ -187,23 +187,22 @@ inline VTKM_CONT vtkm::cont::DataSet ThresholdPoints::DoExecute(
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy> template <typename DerivedPolicy>
inline VTKM_CONT bool ThresholdPoints::DoMapField( inline VTKM_CONT bool ThresholdPoints::MapFieldOntoOutput(
vtkm::cont::DataSet& result, vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input, const vtkm::cont::Field& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy) vtkm::filter::PolicyBase<DerivedPolicy> policy)
{ {
// point data is copied as is because it was not collapsed // point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField()) if (field.IsFieldPoint())
{ {
if (this->CompactPoints) if (this->CompactPoints)
{ {
return this->Compactor.DoMapField(result, input, fieldMeta, policy); return this->Compactor.MapFieldOntoOutput(result, field, policy);
} }
else else
{ {
result.AddField(fieldMeta.AsField(input)); result.AddField(field);
return true; return true;
} }
} }

2
vtkm/worklet/ExternalFaces.h
View File

@ -953,6 +953,8 @@ public:
} }
} }
vtkm::cont::ArrayHandle<vtkm::Id> GetCellIdMap() const { return this->CellIdMap; }
private: private:
vtkm::cont::ArrayHandle<vtkm::Id> CellIdMap; vtkm::cont::ArrayHandle<vtkm::Id> CellIdMap;
bool PassPolyData; bool PassPolyData;

2
vtkm/worklet/PointMerge.h
View File

@ -473,6 +473,8 @@ public:
return outArray; return outArray;
} }
vtkm::worklet::Keys<vtkm::Id> GetMergeKeys() const { return this->MergeKeys; }
private: private:
vtkm::worklet::Keys<vtkm::Id> MergeKeys; vtkm::worklet::Keys<vtkm::Id> MergeKeys;
vtkm::cont::ArrayHandle<vtkm::Id> PointInputToOutputMap; vtkm::cont::ArrayHandle<vtkm::Id> PointInputToOutputMap;

2
vtkm/worklet/RemoveDegenerateCells.h
View File

@ -166,6 +166,8 @@ struct RemoveDegenerateCells
return result; return result;
} }
vtkm::cont::ArrayHandle<vtkm::Id> GetValidCellIds() const { return this->ValidCellIds; }
private: private:
vtkm::cont::ArrayHandle<vtkm::Id> ValidCellIds; vtkm::cont::ArrayHandle<vtkm::Id> ValidCellIds;
}; };

5
vtkm/worklet/RemoveUnusedPoints.h
View File

@ -239,6 +239,11 @@ public:
return outArray; return outArray;
} }
const vtkm::worklet::ScatterCounting& GetPointScatter() const
{
return *this->PointScatter.get();
}
private: private:
vtkm::cont::ArrayHandle<vtkm::IdComponent> MaskArray; vtkm::cont::ArrayHandle<vtkm::IdComponent> MaskArray;