mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-10-05 01:49:02 +00:00
Convert filters to use precompiled field map functions where applicable
This commit is contained in:
parent
98f20ec269
commit
3c4e8a2ea5
@ -133,11 +133,10 @@ public:
|
||||
return output;
|
||||
}
|
||||
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
VTKM_CONT bool DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -152,6 +152,7 @@ set(sources_device
|
||||
ContourInteger.cxx
|
||||
ContourScalar.cxx
|
||||
ExternalFaces.cxx
|
||||
ExtractGeometry.cxx
|
||||
ExtractStructured.cxx
|
||||
GradientScalar.cxx
|
||||
GradientUniformPoints.cxx
|
||||
|
@ -11,10 +11,35 @@
|
||||
|
||||
#include <vtkm/filter/ClipWithField.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
{
|
||||
|
||||
VTKM_FILTER_EXPORT bool ClipWithField::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// Handled by DoMapField, which the superclass will call.
|
||||
// Actually already done by other version of MapFieldOntoOutput. (Stupid policies.)
|
||||
//return this->FilterDataSetWithField<ClipWithField>::MapFieldOntoOutput(result, field, policy);
|
||||
VTKM_ASSERT(false && "Should not be here");
|
||||
return false;
|
||||
}
|
||||
else if (field.IsFieldCell())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> permutation = this->Worklet.GetCellMapOutputToInput();
|
||||
return vtkm::filter::MapFieldPermutation(field, permutation, result);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ClipWithField);
|
||||
}
|
||||
|
@ -46,6 +46,25 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field);
|
||||
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// DIE, POLICIES, DIE!
|
||||
return this->FilterDataSetWithField<ClipWithField>::MapFieldOntoOutput(result, field, policy);
|
||||
}
|
||||
else
|
||||
{
|
||||
return this->MapFieldOntoOutput(result, field);
|
||||
}
|
||||
}
|
||||
|
||||
//Map a new field onto the resulting dataset after running the filter.
|
||||
//This call is only valid after Execute has been called.
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
@ -54,20 +73,11 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> output;
|
||||
// All other conditions should be handled by MapFieldOntoOutput directly.
|
||||
VTKM_ASSERT(fieldMeta.IsPointField());
|
||||
|
||||
if (fieldMeta.IsPointField())
|
||||
{
|
||||
output = this->Worklet.ProcessPointField(input);
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
{
|
||||
output = this->Worklet.ProcessCellField(input);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
vtkm::cont::ArrayHandle<T> output;
|
||||
output = this->Worklet.ProcessPointField(input);
|
||||
|
||||
//use the same meta data as the input so we get the same field name, etc.
|
||||
result.AddField(fieldMeta.AsField(output));
|
||||
|
@ -11,10 +11,34 @@
|
||||
#define vtkm_filter_ClipWithImplicitFunction_cxx
|
||||
#include <vtkm/filter/ClipWithImplicitFunction.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
{
|
||||
|
||||
VTKM_FILTER_EXPORT bool ClipWithImplicitFunction::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// Handled by DoMapField, which the superclass will call.
|
||||
// Actually already done by other version of MapFieldOntoOutput. (Stupid policies.)
|
||||
//return this->FilterDataSet<ClipWithImplicitFunction>::MapFieldOntoOutput(result, field, policy);
|
||||
VTKM_ASSERT(false && "Should not be here");
|
||||
return false;
|
||||
}
|
||||
else if (field.IsFieldCell())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> permutation = this->Worklet.GetCellMapOutputToInput();
|
||||
return vtkm::filter::MapFieldPermutation(field, permutation, result);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
//-----------------------------------------------------------------------------
|
||||
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ClipWithImplicitFunction);
|
||||
}
|
||||
|
@ -43,6 +43,26 @@ public:
|
||||
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field);
|
||||
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// DIE, POLICIES, DIE!
|
||||
return this->FilterDataSet<ClipWithImplicitFunction>::MapFieldOntoOutput(
|
||||
result, field, policy);
|
||||
}
|
||||
else
|
||||
{
|
||||
return this->MapFieldOntoOutput(result, field);
|
||||
}
|
||||
}
|
||||
|
||||
//Map a new field onto the resulting dataset after running the filter.
|
||||
//This call is only valid after Execute has been called.
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
@ -51,24 +71,14 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> output;
|
||||
// All other conditions should be handled by MapFieldOntoOutput directly.
|
||||
VTKM_ASSERT(fieldMeta.IsPointField());
|
||||
|
||||
if (fieldMeta.IsPointField())
|
||||
{
|
||||
output = this->Worklet.ProcessPointField(input);
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
{
|
||||
output = this->Worklet.ProcessCellField(input);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
vtkm::cont::ArrayHandle<T> output;
|
||||
output = this->Worklet.ProcessPointField(input);
|
||||
|
||||
//use the same meta data as the input so we get the same field name, etc.
|
||||
result.AddField(fieldMeta.AsField(output));
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -10,6 +10,8 @@
|
||||
#define vtkm_filter_Contour_cxx
|
||||
#include <vtkm/filter/Contour.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
@ -67,5 +69,28 @@ VTKM_FILTER_EXPORT vtkm::Float64 Contour::GetIsoValue(vtkm::Id index) const
|
||||
{
|
||||
return this->IsoValues[static_cast<std::size_t>(index)];
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
VTKM_FILTER_EXPORT bool Contour::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// Handled by DoMapField, which the superclass will call.
|
||||
// Actually already done by other version of MapFieldOntoOutput. (Stupid policies.)
|
||||
//return this->FilterDataSetWithField<Contour>::MapFieldOntoOutput(result, field, policy);
|
||||
VTKM_ASSERT(false && "Should not be here");
|
||||
return false;
|
||||
}
|
||||
else if (field.IsFieldCell())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> permutation = this->Worklet.GetCellIdMap();
|
||||
return vtkm::filter::MapFieldPermutation(field, permutation, result);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -111,6 +111,25 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field);
|
||||
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// DIE, POLICIES, DIE!
|
||||
return this->FilterDataSetWithField<Contour>::MapFieldOntoOutput(result, field, policy);
|
||||
}
|
||||
else
|
||||
{
|
||||
return this->MapFieldOntoOutput(result, field);
|
||||
}
|
||||
}
|
||||
|
||||
//Map a new field onto the resulting dataset after running the filter
|
||||
//this call is only valid
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
@ -119,20 +138,12 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
// All other conditions should be handled by MapFieldOntoOutput directly.
|
||||
VTKM_ASSERT(fieldMeta.IsPointField());
|
||||
|
||||
vtkm::cont::ArrayHandle<T> fieldArray;
|
||||
|
||||
if (fieldMeta.IsPointField())
|
||||
{
|
||||
fieldArray = this->Worklet.ProcessPointField(input);
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
{
|
||||
fieldArray = this->Worklet.ProcessCellField(input);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
fieldArray = this->Worklet.ProcessPointField(input);
|
||||
|
||||
//use the same meta data as the input so we get the same field name, etc.
|
||||
result.AddField(fieldMeta.AsField(fieldArray));
|
||||
|
51
vtkm/filter/ExtractGeometry.cxx
Normal file
51
vtkm/filter/ExtractGeometry.cxx
Normal file
@ -0,0 +1,51 @@
|
||||
//============================================================================
|
||||
// Copyright (c) Kitware, Inc.
|
||||
// All rights reserved.
|
||||
// See LICENSE.txt for details.
|
||||
//
|
||||
// This software is distributed WITHOUT ANY WARRANTY; without even
|
||||
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
||||
// PURPOSE. See the above copyright notice for more information.
|
||||
//============================================================================
|
||||
#define vtkm_filter_ExtractGeometry_cxx
|
||||
#include <vtkm/filter/ExtractGeometry.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
{
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
VTKM_FILTER_EXPORT ExtractGeometry::ExtractGeometry()
|
||||
: vtkm::filter::FilterDataSet<ExtractGeometry>()
|
||||
, ExtractInside(true)
|
||||
, ExtractBoundaryCells(false)
|
||||
, ExtractOnlyBoundaryCells(false)
|
||||
{
|
||||
}
|
||||
|
||||
VTKM_FILTER_EXPORT bool ExtractGeometry::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
result.AddField(field);
|
||||
return true;
|
||||
}
|
||||
else if (field.IsFieldCell())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> permutation = this->Worklet.GetValidCellIds();
|
||||
return vtkm::filter::MapFieldPermutation(field, permutation, result);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ExtractGeometry);
|
||||
}
|
||||
} // namespace vtkm::filter
|
@ -11,6 +11,8 @@
|
||||
#ifndef vtk_m_filter_ExtractGeometry_h
|
||||
#define vtk_m_filter_ExtractGeometry_h
|
||||
|
||||
#include <vtkm/filter/vtkm_filter_export.h>
|
||||
|
||||
#include <vtkm/cont/ImplicitFunctionHandle.h>
|
||||
#include <vtkm/filter/FilterDataSet.h>
|
||||
#include <vtkm/worklet/ExtractGeometry.h>
|
||||
@ -35,14 +37,13 @@ namespace filter
|
||||
/// This differs from Clip in that Clip will subdivide boundary cells into new
|
||||
/// cells, while this filter will not, producing a more 'crinkly' output.
|
||||
///
|
||||
class ExtractGeometry : public vtkm::filter::FilterDataSet<ExtractGeometry>
|
||||
class VTKM_ALWAYS_EXPORT ExtractGeometry : public vtkm::filter::FilterDataSet<ExtractGeometry>
|
||||
{
|
||||
public:
|
||||
//currently the ExtractGeometry filter only works on scalar data.
|
||||
using SupportedTypes = TypeListScalarAll;
|
||||
|
||||
VTKM_CONT
|
||||
ExtractGeometry();
|
||||
VTKM_FILTER_EXPORT VTKM_CONT ExtractGeometry();
|
||||
|
||||
// Set the volume of interest to extract
|
||||
void SetImplicitFunction(const vtkm::cont::ImplicitFunctionHandle& func)
|
||||
@ -83,12 +84,16 @@ public:
|
||||
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
|
||||
const 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,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field);
|
||||
|
||||
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:
|
||||
bool ExtractInside;
|
||||
@ -97,6 +102,10 @@ private:
|
||||
vtkm::cont::ImplicitFunctionHandle Function;
|
||||
vtkm::worklet::ExtractGeometry Worklet;
|
||||
};
|
||||
|
||||
#ifndef vtkm_filter_ExtractGeometry_cxx
|
||||
VTKM_FILTER_EXPORT_EXECUTE_METHOD(ExtractGeometry);
|
||||
#endif
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
|
@ -65,15 +65,6 @@ namespace vtkm
|
||||
namespace filter
|
||||
{
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
inline VTKM_CONT ExtractGeometry::ExtractGeometry()
|
||||
: vtkm::filter::FilterDataSet<ExtractGeometry>()
|
||||
, ExtractInside(true)
|
||||
, ExtractBoundaryCells(false)
|
||||
, ExtractOnlyBoundaryCells(false)
|
||||
{
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT vtkm::cont::DataSet ExtractGeometry::DoExecute(
|
||||
@ -101,34 +92,6 @@ inline VTKM_CONT vtkm::cont::DataSet ExtractGeometry::DoExecute(
|
||||
output.SetCellSet(outCells);
|
||||
return output;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool ExtractGeometry::DoMapField(
|
||||
vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
vtkm::cont::VariantArrayHandle output;
|
||||
|
||||
if (fieldMeta.IsPointField())
|
||||
{
|
||||
output = input; // pass through, points aren't changed.
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
{
|
||||
output = this->Worklet.ProcessCellField(input);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// use the same meta data as the input so we get the same field name, etc.
|
||||
result.AddField(fieldMeta.AsField(output));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -10,6 +10,8 @@
|
||||
#define vtkm_filter_ExtractStructured_cxx
|
||||
#include <vtkm/filter/ExtractStructured.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
@ -26,6 +28,30 @@ ExtractStructured::ExtractStructured()
|
||||
{
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
bool ExtractStructured::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
return vtkm::filter::MapFieldPermutation(field, this->PointFieldMap, result);
|
||||
}
|
||||
|
||||
if (field.IsFieldCell())
|
||||
{
|
||||
return vtkm::filter::MapFieldPermutation(field, this->CellFieldMap, result);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
void ExtractStructured::PostExecute(const vtkm::cont::PartitionedDataSet&,
|
||||
vtkm::cont::PartitionedDataSet&)
|
||||
{
|
||||
this->CellFieldMap.ReleaseResources();
|
||||
this->PointFieldMap.ReleaseResources();
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ExtractStructured);
|
||||
|
@ -87,31 +87,27 @@ public:
|
||||
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
// Map 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>)
|
||||
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field);
|
||||
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
if (fieldMeta.IsPointField())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessPointField(input);
|
||||
return this->MapFieldOntoOutput(result, field);
|
||||
}
|
||||
|
||||
result.AddField(fieldMeta.AsField(output));
|
||||
return true;
|
||||
}
|
||||
|
||||
// cell data must be scattered to the cells created per input cell
|
||||
if (fieldMeta.IsCellField())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input);
|
||||
VTKM_FILTER_EXPORT VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet&,
|
||||
vtkm::cont::PartitionedDataSet&);
|
||||
|
||||
result.AddField(fieldMeta.AsField(output));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet& input,
|
||||
vtkm::cont::PartitionedDataSet& output,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
this->PostExecute(input, output);
|
||||
}
|
||||
|
||||
private:
|
||||
@ -120,6 +116,9 @@ private:
|
||||
bool IncludeBoundary;
|
||||
bool IncludeOffset;
|
||||
vtkm::worklet::ExtractStructured Worklet;
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> CellFieldMap;
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> PointFieldMap;
|
||||
};
|
||||
|
||||
#ifndef vtkm_filter_ExtractStructured_cxx
|
||||
@ -128,6 +127,8 @@ VTKM_FILTER_EXPORT_EXECUTE_METHOD(ExtractStructured);
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_ExtractStructured_hxx
|
||||
#include <vtkm/filter/ExtractStructured.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_ExtractStructured_h
|
||||
|
@ -10,6 +10,7 @@
|
||||
|
||||
#ifndef vtk_m_filter_ExtractStructured_hxx
|
||||
#define vtk_m_filter_ExtractStructured_hxx
|
||||
#include <vtkm/filter/ExtractStructured.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
@ -36,6 +37,14 @@ inline VTKM_CONT vtkm::cont::DataSet ExtractStructured::DoExecute(
|
||||
vtkm::cont::DataSet output;
|
||||
output.SetCellSet(vtkm::cont::DynamicCellSet(cellset));
|
||||
output.AddCoordinateSystem(outputCoordinates);
|
||||
|
||||
// Create map arrays for mapping fields. Could potentially save some time to first check to see
|
||||
// if these arrays would be used.
|
||||
this->CellFieldMap =
|
||||
this->Worklet.ProcessCellField(vtkm::cont::ArrayHandleIndex(input.GetNumberOfCells()));
|
||||
this->PointFieldMap =
|
||||
this->Worklet.ProcessPointField(vtkm::cont::ArrayHandleIndex(input.GetNumberOfPoints()));
|
||||
|
||||
return output;
|
||||
}
|
||||
}
|
||||
|
@ -63,12 +63,11 @@ public:
|
||||
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);
|
||||
//this call is only valid after DoExecute is run
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
private:
|
||||
bool RemoveAll;
|
||||
|
@ -19,6 +19,7 @@
|
||||
|
||||
#include <vtkm/RangeId3.h>
|
||||
#include <vtkm/filter/ExtractStructured.h>
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
#include <vtkm/worklet/CellDeepCopy.h>
|
||||
|
||||
namespace
|
||||
@ -360,24 +361,20 @@ inline VTKM_CONT vtkm::cont::DataSet GhostCellRemove::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool GhostCellRemove::DoMapField(
|
||||
vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool GhostCellRemove::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
if (fieldMeta.IsPointField())
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
//we copy the input handle to the result dataset, reusing the metadata
|
||||
result.AddField(fieldMeta.AsField(input));
|
||||
result.AddField(field);
|
||||
return true;
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
else if (field.IsFieldCell())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessCellField(input);
|
||||
result.AddField(fieldMeta.AsField(out));
|
||||
return true;
|
||||
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetValidCellIds(), result);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -79,11 +79,10 @@ public:
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
|
||||
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> policy);
|
||||
|
||||
private:
|
||||
vtkm::Id rank;
|
||||
|
@ -326,11 +326,10 @@ inline VTKM_CONT vtkm::cont::DataSet Lagrangian::DoExecute(
|
||||
}
|
||||
|
||||
//---------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Lagrangian::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Lagrangian::MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -67,12 +67,11 @@ public:
|
||||
const 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);
|
||||
//this call is only valid after calling DoExecute
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
private:
|
||||
vtkm::FloatDefault StepSize;
|
||||
|
@ -155,11 +155,10 @@ inline VTKM_CONT vtkm::cont::DataSet LagrangianStructures::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool LagrangianStructures::DoMapField(
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool LagrangianStructures::MapFieldOntoOutput(
|
||||
vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
|
@ -45,11 +45,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> policy);
|
||||
|
||||
private:
|
||||
vtkm::Id Stride;
|
||||
|
@ -10,6 +10,8 @@
|
||||
#ifndef vtk_m_filter_Mask_hxx
|
||||
#define vtk_m_filter_Mask_hxx
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
@ -66,29 +68,24 @@ inline VTKM_CONT vtkm::cont::DataSet Mask::DoExecute(const vtkm::cont::DataSet&
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Mask::DoMapField(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Mask::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
vtkm::cont::Field output;
|
||||
|
||||
if (fieldMeta.IsPointField())
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
output = fieldMeta.AsField(input); // pass through
|
||||
result.AddField(field); // pass through
|
||||
return true;
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
else if (field.IsFieldCell())
|
||||
{
|
||||
output = fieldMeta.AsField(this->Worklet.ProcessCellField(input));
|
||||
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetValidCellIds(), result);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
result.AddField(output);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -33,11 +33,10 @@ public:
|
||||
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
|
||||
vtkm::filter::PolicyBase<Policy> policy);
|
||||
|
||||
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> policy);
|
||||
|
||||
private:
|
||||
std::vector<vtkm::Id> NumOfBins;
|
||||
|
@ -57,11 +57,10 @@ inline VTKM_CONT vtkm::cont::DataSet NDEntropy::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool NDEntropy::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool NDEntropy::MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -51,11 +51,10 @@ public:
|
||||
VTKM_CONT
|
||||
vtkm::Range GetDataRange(size_t fieldIdx);
|
||||
|
||||
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> policy);
|
||||
|
||||
private:
|
||||
std::vector<vtkm::Id> NumOfBins;
|
||||
|
@ -78,11 +78,10 @@ inline VTKM_CONT vtkm::cont::DataSet NDHistogram::DoExecute(const vtkm::cont::Da
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool NDHistogram::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool NDHistogram::MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -56,13 +56,10 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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> policy);
|
||||
|
||||
private:
|
||||
vtkm::worklet::Streamline Worklet;
|
||||
|
@ -90,11 +90,10 @@ inline VTKM_CONT vtkm::cont::DataSet Pathline::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Pathline::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Pathline::MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -29,7 +29,12 @@ public:
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
//Map a new field onto the resulting dataset after running the filter
|
||||
//this call is only valid
|
||||
//this call is only valid after calling DoExecute.
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>);
|
||||
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
@ -43,6 +48,8 @@ private:
|
||||
}
|
||||
} // vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_Probe_hxx
|
||||
#include <vtkm/filter/Probe.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_Probe_h
|
||||
|
@ -10,6 +10,10 @@
|
||||
#ifndef vtk_m_filter_Probe_hxx
|
||||
#define vtk_m_filter_Probe_hxx
|
||||
|
||||
#include <vtkm/filter/Probe.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
@ -43,27 +47,37 @@ VTKM_CONT inline vtkm::cont::DataSet Probe::DoExecute(
|
||||
return output;
|
||||
}
|
||||
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT inline bool Probe::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// This is a special interpolation that is handled by DoMapField. The superclass'
|
||||
// MapFieldOntoOutput will handle this.
|
||||
return this->FilterDataSet<Probe>::MapFieldOntoOutput(result, field, policy);
|
||||
}
|
||||
|
||||
if (field.IsFieldCell())
|
||||
{
|
||||
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetCellIds(), result);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
VTKM_CONT inline bool Probe::DoMapField(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
if (fieldMeta.IsPointField())
|
||||
{
|
||||
auto fieldArray =
|
||||
this->Worklet.ProcessPointField(input, typename DerivedPolicy::AllCellSetList());
|
||||
result.AddField(fieldMeta.AsField(fieldArray));
|
||||
return true;
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
{
|
||||
auto fieldArray = this->Worklet.ProcessCellField(input);
|
||||
result.AddField(fieldMeta.AsField(fieldArray));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
VTKM_ASSERT(fieldMeta.IsPointField());
|
||||
auto fieldArray =
|
||||
this->Worklet.ProcessPointField(input, typename DerivedPolicy::AllCellSetList());
|
||||
result.AddField(fieldMeta.AsField(fieldArray));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
} // vtkm::filter
|
||||
|
@ -54,11 +54,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> policy);
|
||||
|
||||
private:
|
||||
vtkm::FloatDefault FeatureAngle;
|
||||
@ -67,6 +66,8 @@ private:
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_SplitSharpEdges_hxx
|
||||
#include <vtkm/filter/SplitSharpEdges.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_SplitSharpEdges_h
|
||||
|
@ -10,12 +10,15 @@
|
||||
|
||||
#ifndef vtk_m_filter_SplitSharpEdges_hxx
|
||||
#define vtk_m_filter_SplitSharpEdges_hxx
|
||||
#include <vtkm/filter/SplitSharpEdges.h>
|
||||
|
||||
#include <vtkm/cont/ArrayHandlePermutation.h>
|
||||
#include <vtkm/cont/CellSetExplicit.h>
|
||||
#include <vtkm/cont/CoordinateSystem.h>
|
||||
#include <vtkm/cont/DynamicCellSet.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
@ -56,23 +59,18 @@ inline VTKM_CONT vtkm::cont::DataSet SplitSharpEdges::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool SplitSharpEdges::DoMapField(
|
||||
vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool SplitSharpEdges::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
if (fieldMeta.IsPointField())
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
// We copy the input handle to the result dataset, reusing the metadata
|
||||
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessPointField(input);
|
||||
result.AddField(fieldMeta.AsField(out));
|
||||
return true;
|
||||
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetNewPointsIdArray(), result);
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
else if (field.IsFieldCell())
|
||||
{
|
||||
result.AddField(fieldMeta.AsField(input));
|
||||
result.AddField(field); // pass through
|
||||
return true;
|
||||
}
|
||||
else
|
||||
|
@ -49,13 +49,10 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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> policy);
|
||||
|
||||
private:
|
||||
vtkm::Id NumberOfSteps;
|
||||
@ -66,6 +63,8 @@ private:
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_StreamSurface_hxx
|
||||
#include <vtkm/filter/StreamSurface.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_StreamSurface_h
|
||||
|
@ -11,6 +11,8 @@
|
||||
#ifndef vtk_m_filter_StreamSurface_hxx
|
||||
#define vtk_m_filter_StreamSurface_hxx
|
||||
|
||||
#include <vtkm/filter/StreamSurface.h>
|
||||
|
||||
#include <vtkm/cont/ArrayCopy.h>
|
||||
#include <vtkm/cont/ArrayHandleIndex.h>
|
||||
#include <vtkm/cont/ErrorFilterExecution.h>
|
||||
@ -79,11 +81,10 @@ inline VTKM_CONT vtkm::cont::DataSet StreamSurface::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool StreamSurface::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool StreamSurface::MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -48,13 +48,10 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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> policy);
|
||||
|
||||
private:
|
||||
vtkm::Id NumberOfSteps;
|
||||
@ -65,6 +62,8 @@ private:
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_Streamline_hxx
|
||||
#include <vtkm/filter/Streamline.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_Streamline_h
|
||||
|
@ -10,6 +10,8 @@
|
||||
#ifndef vtk_m_filter_Streamline_hxx
|
||||
#define vtk_m_filter_Streamline_hxx
|
||||
|
||||
#include <vtkm/filter/Streamline.h>
|
||||
|
||||
#include <vtkm/cont/ArrayCopy.h>
|
||||
#include <vtkm/cont/ArrayHandleIndex.h>
|
||||
#include <vtkm/cont/ErrorFilterExecution.h>
|
||||
@ -80,11 +82,10 @@ inline VTKM_CONT vtkm::cont::DataSet Streamline::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Streamline::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Streamline::MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
@ -30,11 +30,10 @@ public:
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
|
||||
// Map 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> policy);
|
||||
|
||||
private:
|
||||
vtkm::worklet::Tetrahedralize Worklet;
|
||||
@ -42,6 +41,8 @@ private:
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_Tetrahedralize_hxx
|
||||
#include <vtkm/filter/Tetrahedralize.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_Tetrahedralize_h
|
||||
|
@ -11,6 +11,10 @@
|
||||
#ifndef vtk_m_filter_Tetrahedralize_hxx
|
||||
#define vtk_m_filter_Tetrahedralize_hxx
|
||||
|
||||
#include <vtkm/filter/Tetrahedralize.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace
|
||||
{
|
||||
struct DeduceCellSet
|
||||
@ -59,27 +63,24 @@ inline VTKM_CONT vtkm::cont::DataSet Tetrahedralize::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Tetrahedralize::DoMapField(
|
||||
vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Tetrahedralize::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
// point data is copied as is because it was not collapsed
|
||||
if (fieldMeta.IsPointField())
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
result.AddField(fieldMeta.AsField(input));
|
||||
result.AddField(field);
|
||||
return true;
|
||||
}
|
||||
|
||||
// cell data must be scattered to the cells created per input cell
|
||||
if (fieldMeta.IsCellField())
|
||||
if (field.IsFieldCell())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input);
|
||||
|
||||
result.AddField(fieldMeta.AsField(output));
|
||||
return true;
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> permutation =
|
||||
this->Worklet.GetOutCellScatter().GetOutputToInputMap();
|
||||
return vtkm::filter::MapFieldPermutation(field, permutation, result);
|
||||
}
|
||||
|
||||
return false;
|
||||
|
@ -10,10 +10,31 @@
|
||||
#define vtkm_filter_Threshold_cxx
|
||||
#include <vtkm/filter/Threshold.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
{
|
||||
|
||||
VTKM_FILTER_EXPORT bool Threshold::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field)
|
||||
{
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
//we copy the input handle to the result dataset, reusing the metadata
|
||||
result.AddField(field);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (field.IsFieldCell())
|
||||
{
|
||||
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetValidCellIds(), result);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(Threshold);
|
||||
}
|
||||
|
@ -52,29 +52,16 @@ public:
|
||||
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>)
|
||||
//this call is only valid after DoExecute is called
|
||||
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field);
|
||||
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
if (fieldMeta.IsPointField())
|
||||
{
|
||||
//we copy the input handle to the result dataset, reusing the metadata
|
||||
result.AddField(fieldMeta.AsField(input));
|
||||
return true;
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> out = this->Worklet.ProcessCellField(input);
|
||||
result.AddField(fieldMeta.AsField(out));
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return this->MapFieldOntoOutput(result, field);
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -30,11 +30,10 @@ public:
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
// Map 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> policy);
|
||||
|
||||
private:
|
||||
vtkm::worklet::Triangulate Worklet;
|
||||
@ -42,6 +41,8 @@ private:
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_Triangulate_hxx
|
||||
#include <vtkm/filter/Triangulate.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_Triangulate_h
|
||||
|
@ -10,16 +10,20 @@
|
||||
#ifndef vtk_m_filter_Triangulate_hxx
|
||||
#define vtk_m_filter_Triangulate_hxx
|
||||
|
||||
#include <vtkm/filter/Triangulate.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
class DeduceCellSet
|
||||
{
|
||||
mutable vtkm::worklet::Triangulate Worklet;
|
||||
vtkm::worklet::Triangulate& Worklet;
|
||||
vtkm::cont::CellSetSingleType<>& OutCellSet;
|
||||
|
||||
public:
|
||||
DeduceCellSet(vtkm::worklet::Triangulate worklet, vtkm::cont::CellSetSingleType<>& outCellSet)
|
||||
DeduceCellSet(vtkm::worklet::Triangulate& worklet, vtkm::cont::CellSetSingleType<>& outCellSet)
|
||||
: Worklet(worklet)
|
||||
, OutCellSet(outCellSet)
|
||||
{
|
||||
@ -81,26 +85,24 @@ inline VTKM_CONT vtkm::cont::DataSet Triangulate::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Triangulate::DoMapField(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Triangulate::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
// point data is copied as is because it was not collapsed
|
||||
if (fieldMeta.IsPointField())
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
result.AddField(fieldMeta.AsField(input));
|
||||
result.AddField(field);
|
||||
return true;
|
||||
}
|
||||
|
||||
// cell data must be scattered to the cells created per input cell
|
||||
if (fieldMeta.IsCellField())
|
||||
if (field.IsFieldCell())
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> output = this->Worklet.ProcessCellField(input);
|
||||
|
||||
result.AddField(fieldMeta.AsField(output));
|
||||
return true;
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> permutation =
|
||||
this->Worklet.GetOutCellScatter().GetOutputToInputMap();
|
||||
return vtkm::filter::MapFieldPermutation(field, permutation, result);
|
||||
}
|
||||
|
||||
return false;
|
||||
|
@ -43,12 +43,11 @@ public:
|
||||
vtkm::filter::PolicyBase<Policy> policy);
|
||||
|
||||
//Map a new field onto the resulting dataset after running the filter
|
||||
//this call is only valid
|
||||
template <typename T, typename StorageType, typename Policy>
|
||||
VTKM_CONT bool DoMapField(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<Policy> policy);
|
||||
//this call is only valid after DoExecute is called
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
private:
|
||||
vtkm::worklet::Tube Worklet;
|
||||
@ -59,6 +58,8 @@ private:
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_Tube_hxx
|
||||
#include <vtkm/filter/Tube.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_Tube_h
|
||||
|
@ -10,10 +10,13 @@
|
||||
#ifndef vtk_m_filter_Tube_hxx
|
||||
#define vtk_m_filter_Tube_hxx
|
||||
|
||||
#include <vtkm/filter/Tube.h>
|
||||
|
||||
#include <vtkm/cont/ArrayCopy.h>
|
||||
#include <vtkm/cont/ArrayHandleIndex.h>
|
||||
#include <vtkm/cont/ErrorFilterExecution.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
#include <vtkm/filter/PolicyBase.h>
|
||||
|
||||
namespace vtkm
|
||||
@ -51,24 +54,24 @@ inline VTKM_CONT vtkm::cont::DataSet Tube::DoExecute(const vtkm::cont::DataSet&
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Tube::DoMapField(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool Tube::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> fieldArray;
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
return vtkm::filter::MapFieldPermutation(
|
||||
field, this->Worklet.GetOutputPointSourceIndex(), result);
|
||||
}
|
||||
|
||||
if (fieldMeta.IsPointField())
|
||||
fieldArray = this->Worklet.ProcessPointField(input);
|
||||
else if (fieldMeta.IsCellField())
|
||||
fieldArray = this->Worklet.ProcessCellField(input);
|
||||
else
|
||||
return false;
|
||||
if (field.IsFieldCell())
|
||||
{
|
||||
return vtkm::filter::MapFieldPermutation(
|
||||
field, this->Worklet.GetOutputCellSourceIndex(), result);
|
||||
}
|
||||
|
||||
//use the same meta data as the input so we get the same field name, etc.
|
||||
result.AddField(fieldMeta.AsField(fieldArray));
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
@ -64,12 +64,11 @@ public:
|
||||
const 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);
|
||||
//this call is only valid after calling DoExecute
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy> policy);
|
||||
|
||||
private:
|
||||
vtkm::worklet::VertexClustering Worklet;
|
||||
@ -78,6 +77,8 @@ private:
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
||||
#ifndef vtk_m_filter_VertexClustering_hxx
|
||||
#include <vtkm/filter/VertexClustering.hxx>
|
||||
#endif
|
||||
|
||||
#endif // vtk_m_filter_VertexClustering_h
|
||||
|
@ -10,6 +10,10 @@
|
||||
#ifndef vtk_m_filter_VertexClustering_hxx
|
||||
#define vtk_m_filter_VertexClustering_hxx
|
||||
|
||||
#include <vtkm/filter/VertexClustering.h>
|
||||
|
||||
#include <vtkm/filter/MapFieldPermutation.h>
|
||||
|
||||
namespace vtkm
|
||||
{
|
||||
namespace filter
|
||||
@ -43,32 +47,22 @@ inline VTKM_CONT vtkm::cont::DataSet VertexClustering::DoExecute(
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool VertexClustering::DoMapField(
|
||||
vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>& input,
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
template <typename DerivedPolicy>
|
||||
inline VTKM_CONT bool VertexClustering::MapFieldOntoOutput(vtkm::cont::DataSet& result,
|
||||
const vtkm::cont::Field& field,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> fieldArray;
|
||||
|
||||
if (fieldMeta.IsPointField())
|
||||
if (field.IsFieldPoint())
|
||||
{
|
||||
fieldArray = this->Worklet.ProcessPointField(input);
|
||||
}
|
||||
else if (fieldMeta.IsCellField())
|
||||
{
|
||||
fieldArray = this->Worklet.ProcessCellField(input);
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetPointIdMap(), result);
|
||||
}
|
||||
|
||||
//use the same meta data as the input so we get the same field name, etc.
|
||||
result.AddField(fieldMeta.AsField(fieldArray));
|
||||
if (field.IsFieldCell())
|
||||
{
|
||||
return vtkm::filter::MapFieldPermutation(field, this->Worklet.GetCellIdMap(), result);
|
||||
}
|
||||
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -41,13 +41,13 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
vtkm::Float64 rate;
|
||||
|
@ -56,16 +56,6 @@ inline VTKM_CONT vtkm::cont::DataSet ZFPCompressor1D::DoExecute(
|
||||
dataset.AddField(vtkm::cont::make_FieldPoint("compressed", compressed));
|
||||
return dataset;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool ZFPCompressor1D::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
#endif
|
||||
|
@ -41,13 +41,13 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
vtkm::Float64 rate;
|
||||
|
@ -62,16 +62,6 @@ inline VTKM_CONT vtkm::cont::DataSet ZFPCompressor2D::DoExecute(
|
||||
|
||||
return dataset;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool ZFPCompressor2D::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
#endif
|
||||
|
@ -40,13 +40,13 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
vtkm::Float64 rate;
|
||||
|
@ -62,16 +62,6 @@ inline VTKM_CONT vtkm::cont::DataSet ZFPCompressor3D::DoExecute(
|
||||
|
||||
return dataset;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool ZFPCompressor3D::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
#endif
|
||||
|
@ -48,13 +48,13 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
vtkm::Float64 rate;
|
||||
|
@ -53,16 +53,6 @@ inline VTKM_CONT vtkm::cont::DataSet ZFPDecompressor1D::DoExecute(
|
||||
dataset.AddField(vtkm::cont::make_FieldPoint("decompressed", decompress));
|
||||
return dataset;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool ZFPDecompressor1D::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
#endif
|
||||
|
@ -48,13 +48,13 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
vtkm::Float64 rate;
|
||||
|
@ -58,16 +58,6 @@ inline VTKM_CONT vtkm::cont::DataSet ZFPDecompressor2D::DoExecute(
|
||||
dataset.AddField(vtkm::cont::make_FieldPoint("decompressed", decompress));
|
||||
return dataset;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool ZFPDecompressor2D::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
#endif
|
||||
|
@ -48,13 +48,13 @@ public:
|
||||
const vtkm::filter::FieldMetadata& fieldMeta,
|
||||
const 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,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
|
||||
template <typename DerivedPolicy>
|
||||
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::Field&,
|
||||
vtkm::filter::PolicyBase<DerivedPolicy>)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
vtkm::Float64 rate;
|
||||
|
@ -57,16 +57,6 @@ inline VTKM_CONT vtkm::cont::DataSet ZFPDecompressor3D::DoExecute(
|
||||
dataset.AddField(vtkm::cont::make_FieldPoint("decompressed", decompress));
|
||||
return dataset;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
template <typename T, typename StorageType, typename DerivedPolicy>
|
||||
inline VTKM_CONT bool ZFPDecompressor3D::DoMapField(vtkm::cont::DataSet&,
|
||||
const vtkm::cont::ArrayHandle<T, StorageType>&,
|
||||
const vtkm::filter::FieldMetadata&,
|
||||
const vtkm::filter::PolicyBase<DerivedPolicy>&)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
#endif
|
||||
|
@ -82,12 +82,20 @@ const std::vector<vtkm::Float32>& GetExpectedPointData()
|
||||
const std::vector<vtkm::Float32>& GetExpectedCellData()
|
||||
{
|
||||
static std::vector<vtkm::Float32> expected = {
|
||||
0.0f, 0.7f, 0.7f, 0.7f, 1.4f, 1.4f, 1.4f, 0.0f, 0.0f, 2.1f, 2.8f, 2.8f, 2.8f, 3.5f,
|
||||
3.5f, 3.5f, 0.0f, 0.0f, 2.1f, 2.8f, 2.8f, 2.8f, 3.5f, 3.5f, 3.5f, 0.0f, 0.0f, 2.1f,
|
||||
2.8f, 2.8f, 2.8f, 3.5f, 3.5f, 3.5f, 0.0f, 0.0f, 4.2f, 4.9f, 4.9f, 4.9f, 5.6f, 5.6f,
|
||||
5.6f, 0.0f, 0.0f, 4.2f, 4.9f, 4.9f, 4.9f, 5.6f, 5.6f, 5.6f, 0.0f, 0.0f, 4.2f, 4.9f,
|
||||
4.9f, 4.9f, 5.6f, 5.6f, 5.6f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f,
|
||||
0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f
|
||||
0.0f, 0.7f, 0.7f, 0.7f, 1.4f, 1.4f,
|
||||
1.4f, vtkm::Nan32(), vtkm::Nan32(), 2.1f, 2.8f, 2.8f,
|
||||
2.8f, 3.5f, 3.5f, 3.5f, vtkm::Nan32(), vtkm::Nan32(),
|
||||
2.1f, 2.8f, 2.8f, 2.8f, 3.5f, 3.5f,
|
||||
3.5f, vtkm::Nan32(), vtkm::Nan32(), 2.1f, 2.8f, 2.8f,
|
||||
2.8f, 3.5f, 3.5f, 3.5f, vtkm::Nan32(), vtkm::Nan32(),
|
||||
4.2f, 4.9f, 4.9f, 4.9f, 5.6f, 5.6f,
|
||||
5.6f, vtkm::Nan32(), vtkm::Nan32(), 4.2f, 4.9f, 4.9f,
|
||||
4.9f, 5.6f, 5.6f, 5.6f, vtkm::Nan32(), vtkm::Nan32(),
|
||||
4.2f, 4.9f, 4.9f, 4.9f, 5.6f, 5.6f,
|
||||
5.6f, vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(),
|
||||
vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(),
|
||||
vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32(),
|
||||
vtkm::Nan32(), vtkm::Nan32(), vtkm::Nan32()
|
||||
};
|
||||
return expected;
|
||||
}
|
||||
|
@ -548,20 +548,22 @@ struct TestEqualImpl
|
||||
return this->DoIt(matrix1, matrix2, tolerance, vtkm::TypeTraitsVectorTag());
|
||||
}
|
||||
|
||||
VTKM_EXEC_CONT bool DoIt(T1 scalar1,
|
||||
T2 scalar2,
|
||||
vtkm::Float64 tolerance,
|
||||
vtkm::TypeTraitsScalarTag) const
|
||||
VTKM_EXEC_CONT bool DoIt(vtkm::Float64 value1,
|
||||
vtkm::Float64 value2,
|
||||
vtkm::Float64 tolerance) const
|
||||
{
|
||||
// If you get a compiler error here, it means you are comparing a scalar to
|
||||
// a vector, in which case the types are non-comparable.
|
||||
VTKM_STATIC_ASSERT_MSG((std::is_same<typename vtkm::TypeTraits<T2>::DimensionalityTag,
|
||||
vtkm::TypeTraitsScalarTag>::type::value),
|
||||
"Trying to compare a scalar with a vector.");
|
||||
|
||||
// Do all comparisons using 64-bit floats.
|
||||
vtkm::Float64 value1 = vtkm::Float64(scalar1);
|
||||
vtkm::Float64 value2 = vtkm::Float64(scalar2);
|
||||
// Handle non-finites. Normally, non-finites are never "equal" to each other (for valid
|
||||
// mathematical reasons), but for testing purposes if the two values are the same type of
|
||||
// non-finite, then they are the same in the sense that they gave the same result.
|
||||
if (vtkm::IsNan(value1) && vtkm::IsNan(value2))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (vtkm::IsInf(value1) && vtkm::IsInf(value2) &&
|
||||
(vtkm::IsNegative(value1) == vtkm::IsNegative(value2)))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
if (vtkm::Abs(value1 - value2) <= tolerance)
|
||||
{
|
||||
@ -596,6 +598,22 @@ struct TestEqualImpl
|
||||
}
|
||||
}
|
||||
|
||||
VTKM_EXEC_CONT bool DoIt(T1 scalar1,
|
||||
T2 scalar2,
|
||||
vtkm::Float64 tolerance,
|
||||
vtkm::TypeTraitsScalarTag) const
|
||||
{
|
||||
// If you get a compiler error here, it means you are comparing a scalar to
|
||||
// a vector, in which case the types are non-comparable.
|
||||
VTKM_STATIC_ASSERT_MSG((std::is_same<typename vtkm::TypeTraits<T2>::DimensionalityTag,
|
||||
vtkm::TypeTraitsScalarTag>::type::value),
|
||||
"Trying to compare a scalar with a vector.");
|
||||
|
||||
// Do all comparisons using 64-bit floats.
|
||||
return DoIt(
|
||||
static_cast<vtkm::Float64>(scalar1), static_cast<vtkm::Float64>(scalar2), tolerance);
|
||||
}
|
||||
|
||||
VTKM_EXEC_CONT bool operator()(T1 value1, T2 value2, vtkm::Float64 tolerance) const
|
||||
{
|
||||
return this->DoIt(
|
||||
|
@ -901,6 +901,11 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetCellMapOutputToInput() const
|
||||
{
|
||||
return this->CellMapOutputToInput;
|
||||
}
|
||||
|
||||
private:
|
||||
internal::ClipTables ClipTablesInstance;
|
||||
vtkm::cont::ArrayHandle<EdgeInterpolation> EdgePointsInterpolation;
|
||||
|
@ -84,6 +84,9 @@ public:
|
||||
//----------------------------------------------------------------------------
|
||||
bool GetMergeDuplicatePoints() const { return this->SharedState.MergeDuplicatePoints; }
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetCellIdMap() const { return this->SharedState.CellIdMap; }
|
||||
|
||||
//----------------------------------------------------------------------------
|
||||
template <typename ValueType,
|
||||
typename CellSetType,
|
||||
|
@ -168,6 +168,8 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetValidCellIds() const { return this->ValidCellIds; }
|
||||
|
||||
private:
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> ValidCellIds;
|
||||
};
|
||||
|
@ -58,6 +58,8 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetValidCellIds() const { return this->ValidCellIds; }
|
||||
|
||||
private:
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> ValidCellIds;
|
||||
};
|
||||
|
@ -257,6 +257,8 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetCellIds() const { return this->CellIds; }
|
||||
|
||||
//============================================================================
|
||||
struct HiddenPointsWorklet : public WorkletMapField
|
||||
{
|
||||
|
@ -516,6 +516,8 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetNewPointsIdArray() const { return this->NewPointsIdArray; }
|
||||
|
||||
private:
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> NewPointsIdArray;
|
||||
};
|
||||
|
@ -45,7 +45,7 @@ public:
|
||||
};
|
||||
|
||||
Tetrahedralize()
|
||||
: OutCellsPerCell()
|
||||
: OutCellScatter(vtkm::cont::ArrayHandle<vtkm::IdComponent>{})
|
||||
{
|
||||
}
|
||||
|
||||
@ -54,14 +54,20 @@ public:
|
||||
vtkm::cont::CellSetSingleType<> Run(const CellSetType& cellSet)
|
||||
{
|
||||
TetrahedralizeExplicit worklet;
|
||||
return worklet.Run(cellSet, this->OutCellsPerCell);
|
||||
vtkm::cont::ArrayHandle<vtkm::IdComponent> outCellsPerCell;
|
||||
vtkm::cont::CellSetSingleType<> result = worklet.Run(cellSet, outCellsPerCell);
|
||||
this->OutCellScatter = DistributeCellData::MakeScatter(outCellsPerCell);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Tetrahedralize structured data set, save number of tetra cells per input
|
||||
vtkm::cont::CellSetSingleType<> Run(const vtkm::cont::CellSetStructured<3>& cellSet)
|
||||
{
|
||||
TetrahedralizeStructured worklet;
|
||||
return worklet.Run(cellSet, this->OutCellsPerCell);
|
||||
vtkm::cont::ArrayHandle<vtkm::IdComponent> outCellsPerCell;
|
||||
vtkm::cont::CellSetSingleType<> result = worklet.Run(cellSet, outCellsPerCell);
|
||||
this->OutCellScatter = DistributeCellData::MakeScatter(outCellsPerCell);
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::CellSetSingleType<> Run(const vtkm::cont::CellSetStructured<2>&)
|
||||
@ -76,15 +82,16 @@ public:
|
||||
{
|
||||
vtkm::cont::ArrayHandle<T> output;
|
||||
|
||||
vtkm::worklet::DispatcherMapField<DistributeCellData> dispatcher(
|
||||
DistributeCellData::MakeScatter(this->OutCellsPerCell));
|
||||
vtkm::worklet::DispatcherMapField<DistributeCellData> dispatcher(this->OutCellScatter);
|
||||
dispatcher.Invoke(input, output);
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
DistributeCellData::ScatterType GetOutCellScatter() const { return this->OutCellScatter; }
|
||||
|
||||
private:
|
||||
vtkm::cont::ArrayHandle<vtkm::IdComponent> OutCellsPerCell;
|
||||
DistributeCellData::ScatterType OutCellScatter;
|
||||
};
|
||||
}
|
||||
} // namespace vtkm::worklet
|
||||
|
@ -185,6 +185,8 @@ public:
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetValidCellIds() const { return this->ValidCellIds; }
|
||||
|
||||
private:
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> ValidCellIds;
|
||||
};
|
||||
|
@ -44,7 +44,7 @@ public:
|
||||
};
|
||||
|
||||
Triangulate()
|
||||
: OutCellsPerCell()
|
||||
: OutCellScatter(vtkm::cont::ArrayHandle<vtkm::IdComponent>{})
|
||||
{
|
||||
}
|
||||
|
||||
@ -53,14 +53,20 @@ public:
|
||||
vtkm::cont::CellSetSingleType<> Run(const CellSetType& cellSet)
|
||||
{
|
||||
TriangulateExplicit worklet;
|
||||
return worklet.Run(cellSet, this->OutCellsPerCell);
|
||||
vtkm::cont::ArrayHandle<vtkm::IdComponent> outCellsPerCell;
|
||||
vtkm::cont::CellSetSingleType<> result = worklet.Run(cellSet, outCellsPerCell);
|
||||
this->OutCellScatter = DistributeCellData::MakeScatter(outCellsPerCell);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Triangulate structured data set, save number of triangulated cells per input
|
||||
vtkm::cont::CellSetSingleType<> Run(const vtkm::cont::CellSetStructured<2>& cellSet)
|
||||
{
|
||||
TriangulateStructured worklet;
|
||||
return worklet.Run(cellSet, this->OutCellsPerCell);
|
||||
vtkm::cont::ArrayHandle<vtkm::IdComponent> outCellsPerCell;
|
||||
vtkm::cont::CellSetSingleType<> result = worklet.Run(cellSet, outCellsPerCell);
|
||||
this->OutCellScatter = DistributeCellData::MakeScatter(outCellsPerCell);
|
||||
return result;
|
||||
}
|
||||
|
||||
vtkm::cont::CellSetSingleType<> Run(const vtkm::cont::CellSetStructured<3>&)
|
||||
@ -75,15 +81,16 @@ public:
|
||||
{
|
||||
vtkm::cont::ArrayHandle<ValueType> output;
|
||||
|
||||
vtkm::worklet::DispatcherMapField<DistributeCellData> dispatcher(
|
||||
DistributeCellData::MakeScatter(this->OutCellsPerCell));
|
||||
vtkm::worklet::DispatcherMapField<DistributeCellData> dispatcher(this->OutCellScatter);
|
||||
dispatcher.Invoke(input, output);
|
||||
|
||||
return output;
|
||||
}
|
||||
|
||||
DistributeCellData::ScatterType GetOutCellScatter() const { return this->OutCellScatter; }
|
||||
|
||||
private:
|
||||
vtkm::cont::ArrayHandle<vtkm::IdComponent> OutCellsPerCell;
|
||||
DistributeCellData::ScatterType OutCellScatter;
|
||||
};
|
||||
}
|
||||
} // namespace vtkm::worklet
|
||||
|
@ -628,6 +628,15 @@ public:
|
||||
return output;
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetOutputCellSourceIndex() const
|
||||
{
|
||||
return this->OutputCellSourceIndex;
|
||||
}
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetOutputPointSourceIndex() const
|
||||
{
|
||||
return this->OutputPointSourceIndex;
|
||||
}
|
||||
|
||||
private:
|
||||
bool Capping;
|
||||
vtkm::Id NumSides;
|
||||
|
@ -122,10 +122,6 @@ vtkm::cont::ArrayHandle<T> copyFromVec(vtkm::cont::ArrayHandle<vtkm::Vec<T, N>>
|
||||
|
||||
struct VertexClustering
|
||||
{
|
||||
using PointIdMapType = vtkm::cont::ArrayHandlePermutation<
|
||||
vtkm::cont::ArrayHandleView<vtkm::cont::ArrayHandle<vtkm::Id>>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Id>>;
|
||||
|
||||
struct GridInfo
|
||||
{
|
||||
vtkm::Id3 dim;
|
||||
@ -383,8 +379,7 @@ public:
|
||||
|
||||
// For mapping properties, this map will select an arbitrary point from
|
||||
// the cluster:
|
||||
this->PointIdMap =
|
||||
vtkm::cont::make_ArrayHandlePermutation(keysView, keys.GetSortedValuesMap());
|
||||
this->PointIdMap = internal::ConcretePermutationArray(keysView, keys.GetSortedValuesMap());
|
||||
|
||||
// Compute representative points from each cluster (may not match the
|
||||
// PointIdMap indexing)
|
||||
@ -548,8 +543,11 @@ public:
|
||||
return internal::ConcretePermutationArray(this->CellIdMap, input);
|
||||
}
|
||||
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetPointIdMap() const { return this->PointIdMap; }
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> GetCellIdMap() const { return this->CellIdMap; }
|
||||
|
||||
private:
|
||||
PointIdMapType PointIdMap;
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> PointIdMap;
|
||||
vtkm::cont::ArrayHandle<vtkm::Id> CellIdMap;
|
||||
}; // struct VertexClustering
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user