Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-07-30 02:34:02 +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.hxx>
#include <vtkm/filter/MapFieldMergeAverage.h>
#include <vtkm/filter/MapFieldPermutation.h>
namespace vtkm
{
namespace filter
@ -116,6 +119,46 @@ vtkm::cont::DataSet CleanGrid::GenerateOutput(const vtkm::cont::DataSet& inData,
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);
}

39
vtkm/filter/CleanGrid.h
View File

@ -87,40 +87,15 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
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>
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<ValueType, Storage>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<Policy>)
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>)
{
if (fieldMeta.IsPointField() && (this->GetCompactPointFields() || this->GetMergePoints()))
{
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;
return this->MapFieldOntoOutput(result, field);
}
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);
}

37
vtkm/filter/ExternalFaces.h
View File

@ -15,6 +15,7 @@
#include <vtkm/filter/CleanGrid.h>
#include <vtkm/filter/FilterDataSet.h>
#include <vtkm/filter/MapFieldPermutation.h>
#include <vtkm/worklet/ExternalFaces.h>
namespace vtkm
@ -59,35 +60,15 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
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;
}
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field);
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:

9
vtkm/filter/ExtractPoints.h
View File

@ -64,11 +64,10 @@ public:
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy>
bool DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>);
private:
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>
inline VTKM_CONT bool ExtractPoints::DoMapField(
template <typename DerivedPolicy>
inline VTKM_CONT bool ExtractPoints::MapFieldOntoOutput(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
if (field.IsFieldPoint())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
return this->Compactor.MapFieldOntoOutput(result, field, policy);
}
else
{
result.AddField(fieldMeta.AsField(input));
result.AddField(field);
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;
}
bool MapFieldPermutation(const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::DataSet& outputData)
bool vtkm::filter::MapFieldPermutation(const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::DataSet& outputData)
{
vtkm::cont::Field 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);
//Map a new field onto the resulting dataset after running the filter
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);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>);
private:
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>
inline VTKM_CONT bool MaskPoints::DoMapField(vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
template <typename DerivedPolicy>
inline VTKM_CONT bool MaskPoints::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
if (field.IsFieldPoint())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
return this->Compactor.MapFieldOntoOutput(result, field, policy);
}
else
{
result.AddField(fieldMeta.AsField(input));
result.AddField(field);
return true;
}
}

11
vtkm/filter/ThresholdPoints.h
View File

@ -58,13 +58,10 @@ public:
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
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);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy>);
private:
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>
inline VTKM_CONT bool ThresholdPoints::DoMapField(
template <typename DerivedPolicy>
inline VTKM_CONT bool ThresholdPoints::MapFieldOntoOutput(
vtkm::cont::DataSet& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::cont::Field& field,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// point data is copied as is because it was not collapsed
if (fieldMeta.IsPointField())
if (field.IsFieldPoint())
{
if (this->CompactPoints)
{
return this->Compactor.DoMapField(result, input, fieldMeta, policy);
return this->Compactor.MapFieldOntoOutput(result, field, policy);
}
else
{
result.AddField(fieldMeta.AsField(input));
result.AddField(field);
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:
vtkm::cont::ArrayHandle<vtkm::Id> CellIdMap;
bool PassPolyData;

2
vtkm/worklet/PointMerge.h
View File

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

2
vtkm/worklet/RemoveDegenerateCells.h
View File

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

5
vtkm/worklet/RemoveUnusedPoints.h
View File

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