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

Reduce compiler memory usage by removing auto hxx inclusion

Browse Source 
A large portion of the VTK-m filters are now compiled into the
vtkm_filter library. These pre-built filters now don't include
the respective hxx file to remove the amount of template
instantiation users do.

To verify that this removal reduces compiler memory ( and maybe time)
I profiled the compiler while it building filter tests in debug mode.
Here is a selection of results:

```
CleanGrid           10.25s => 9.01s,  901MB => 795MB
ExternalFaces       13.40s => 5.96s, 1122MB => 744MB
ExtractStructured    4.69s => 4.75s,  492MB => 492MB
GradientExplicit    22.97s => 5.88s, 1296MB => 740MB
```
This commit is contained in:
Robert Maynard 2020-11-17 14:37:05 -05:00
parent 60f19f3f9e
commit 7eaedfe84b
54 changed files with 324 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
vtkm/cont/testing/UnitTestCellSetExtrude.cxx
View File

@ -97,6 +97,17 @@ void verify_topo(vtkm::cont::ArrayHandle<vtkm::Vec<T, 6>, S> const& handle, vtkm
VTKM_TEST_ASSERT(test_equal(v, e), "incorrect conversion of topology to Cartesian space");
}
template <typename T, typename S>
void verify_reverse_topo(vtkm::cont::ArrayHandle<T, S> const& handle, vtkm::Id expectedLen)
{
auto portal = handle.ReadPortal();
VTKM_TEST_ASSERT(portal.GetNumberOfValues() == expectedLen, "topology portal size is incorrect");
for (vtkm::Id i = 0; i < expectedLen - 1; ++i)
{
auto v = portal.Get(i);
VTKM_TEST_ASSERT((v <= 2), "incorrect conversion to reverse topology");
}
}
int TestCellSetExtrude()
{
const std::size_t numPlanes = 8;
@ -121,47 +132,14 @@ int TestCellSetExtrude()
vtkm::cont::ArrayHandle<int> output;
vtkm::worklet::DispatcherMapTopology<CopyReverseCellCount> dispatcher;
dispatcher.Invoke(cells, output);
// verify_topo(output, 8);
verify_reverse_topo(output, 24);
}
//test a filter
vtkm::cont::DataSet dataset;
dataset.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coords", coords));
dataset.SetCellSet(cells);
// verify that a constant value point field can be accessed
std::vector<float> pvalues(static_cast<size_t>(coords.GetNumberOfValues()), 42.0f);
vtkm::cont::Field pfield = vtkm::cont::make_Field(
"pfield", vtkm::cont::Field::Association::POINTS, pvalues, vtkm::CopyFlag::Off);
dataset.AddField(pfield);
// verify that a constant cell value can be accessed
std::vector<float> cvalues(static_cast<size_t>(cells.GetNumberOfCells()), 42.0f);
vtkm::cont::Field cfield = vtkm::cont::make_Field(
"cfield", vtkm::cont::Field::Association::CELL_SET, cvalues, vtkm::CopyFlag::Off);
dataset.AddField(cfield);
vtkm::filter::PointAverage avg;
try
{
avg.SetActiveField("cfield");
auto result = avg.Execute(dataset);
VTKM_TEST_ASSERT(result.HasPointField("cfield"), "filter resulting dataset should be valid");
}
catch (const vtkm::cont::Error& err)
{
std::cout << err.GetMessage() << std::endl;
VTKM_TEST_ASSERT(false, "Filter execution threw an exception");
}
return 0;
}
}
int UnitTestCellSetExtrude(int argc, char* argv[])
{
vtkm::cont::GetRuntimeDeviceTracker().ForceDevice(vtkm::cont::DeviceAdapterTagSerial{});
return vtkm::cont::testing::Testing::Run(TestCellSetExtrude, argc, argv);
}

9
vtkm/filter/CMakeLists.txt
View File

@ -42,6 +42,7 @@ set(common_header_template_sources
FilterDataSetWithField.hxx
FilterField.hxx
Filter.hxx
PointAverage.hxx
Threshold.hxx
ThresholdPoints.hxx
)
@ -53,6 +54,7 @@ set(common_sources_device
ExtractStructured.cxx
MapFieldMergeAverage.cxx
MapFieldPermutation.cxx
PointAverage.cxx
Threshold.cxx
)
@ -135,7 +137,6 @@ set(extra_header_template_sources
ParticleDensityNearestGridPoint.hxx
ParticleAdvection.hxx
Pathline.hxx
PointAverage.hxx
PointElevation.hxx
PointTransform.hxx
Probe.hxx
@ -159,13 +160,12 @@ set(extra_header_template_sources
)
set(extra_sources_device
ClipWithFieldScalar.cxx
ClipWithFieldSignedInteger.cxx
ClipWithFieldUnsignedInteger.cxx
ClipWithFieldScalar.cxx
ClipWithImplicitFunction.cxx
PointAverage.cxx
VectorMagnitude.cxx
ExternalFaces.cxx
VectorMagnitude.cxx
particleadvection/Messenger.cxx
particleadvection/ParticleMessenger.cxx
)
@ -199,6 +199,7 @@ set(gradient_header_template_sources
)
set(gradient_sources_device
GradientCartesianPoints.cxx
GradientScalar.cxx
GradientUniformPoints.cxx
GradientVector.cxx

2
vtkm/filter/CellAverage.cxx
View File

@ -16,6 +16,6 @@ namespace vtkm
namespace filter
{
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(CellAverage);
VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD(CellAverage);
}
}

4
vtkm/filter/CellAverage.h
View File

@ -28,7 +28,7 @@ namespace filter
/// The method of transformation is based on averaging the data
/// values of all points used by particular cell.
///
class VTKM_ALWAYS_EXPORT CellAverage : public vtkm::filter::FilterField<CellAverage>
class VTKM_FILTER_COMMON_EXPORT CellAverage : public vtkm::filter::FilterField<CellAverage>
{
public:
template <typename T, typename StorageType, typename DerivedPolicy>
@ -42,7 +42,7 @@ private:
};
#ifndef vtkm_filter_CellAverage_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(CellAverage);
VTKM_FILTER_COMMON_EXPORT_EXECUTE_METHOD(CellAverage);
#endif
}
} // namespace vtkm::filter

9
vtkm/filter/CellAverage.hxx
View File

@ -20,11 +20,10 @@ namespace filter
{
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet CellAverage::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet CellAverage::DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
if (!fieldMetadata.IsPointField())
{

4
vtkm/filter/CleanGrid.cxx
View File

@ -160,6 +160,8 @@ bool CleanGrid::MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont
}
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(CleanGrid);
template VTKM_FILTER_COMMON_TEMPLATE_EXPORT vtkm::cont::DataSet CleanGrid::DoExecute(
const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault> policy);
}
}

15
vtkm/filter/CleanGrid.h
View File

@ -37,10 +37,9 @@ namespace filter
/// \todo Add a feature to merge points that are coincident or within a
/// tolerance.
///
class VTKM_ALWAYS_EXPORT CleanGrid : public vtkm::filter::FilterDataSet<CleanGrid>
class VTKM_FILTER_COMMON_EXPORT CleanGrid : public vtkm::filter::FilterDataSet<CleanGrid>
{
public:
VTKM_FILTER_COMMON_EXPORT
CleanGrid();
/// When the CompactPointFields flag is true, the filter will identify any
@ -87,7 +86,6 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy);
VTKM_FILTER_COMMON_EXPORT
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
@ -106,9 +104,8 @@ private:
bool RemoveDegenerateCells;
bool FastMerge;
VTKM_FILTER_COMMON_EXPORT vtkm::cont::DataSet GenerateOutput(
const vtkm::cont::DataSet& inData,
vtkm::cont::CellSetExplicit<>& outputCellSet);
vtkm::cont::DataSet GenerateOutput(const vtkm::cont::DataSet& inData,
vtkm::cont::CellSetExplicit<>& outputCellSet);
vtkm::worklet::RemoveUnusedPoints PointCompactor;
vtkm::worklet::RemoveDegenerateCells CellCompactor;
@ -116,11 +113,11 @@ private:
};
#ifndef vtkm_filter_CleanGrid_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(CleanGrid);
extern template VTKM_FILTER_COMMON_TEMPLATE_EXPORT vtkm::cont::DataSet CleanGrid::DoExecute(
const vtkm::cont::DataSet&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
#endif
}
} // namespace vtkm::filter
#include <vtkm/filter/CleanGrid.hxx>
#endif //vtk_m_filter_CleanGrid_h

4
vtkm/filter/CleanGrid.hxx
View File

@ -22,8 +22,8 @@ namespace filter
{
template <typename Policy>
inline VTKM_CONT vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy)
vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy)
{
using CellSetType = vtkm::cont::CellSetExplicit<>;

9
vtkm/filter/ClipWithField.h
View File

@ -28,7 +28,8 @@ namespace filter
/// value are considered outside, and will be discarded. All points that are greater
/// are kept.
/// The resulting geometry will not be water tight.
class VTKM_ALWAYS_EXPORT ClipWithField : public vtkm::filter::FilterDataSetWithField<ClipWithField>
class VTKM_FILTER_EXTRA_EXPORT ClipWithField
: public vtkm::filter::FilterDataSetWithField<ClipWithField>
{
public:
using SupportedTypes = vtkm::TypeListScalarAll;
@ -103,13 +104,9 @@ private:
};
#ifndef vtkm_filter_Clip_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(ClipWithField);
VTKM_FILTER_EXTRA_EXPORT_EXECUTE_METHOD(ClipWithField);
#endif
}
} // namespace vtkm::filter
#ifndef vtk_m_filter_ClipWithField_hxx
#include <vtkm/filter/ClipWithField.hxx>
#endif
#endif // vtk_m_filter_ClipWithField_h

9
vtkm/filter/ClipWithField.hxx
View File

@ -52,11 +52,10 @@ struct ClipWithFieldProcessCoords
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ClipWithField::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet ClipWithField::DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
if (fieldMeta.IsPointField() == false)
{

1
vtkm/filter/ClipWithFieldScalar.cxx
View File

@ -12,6 +12,7 @@
#define vtkm_filter_ClipWithFieldExecuteScalar_cxx
#include <vtkm/filter/ClipWithField.h>
#include <vtkm/filter/ClipWithField.hxx>
namespace vtkm
{

1
vtkm/filter/ClipWithFieldSignedInteger.cxx
View File

@ -15,6 +15,7 @@
#define vtkm_filter_ClipWithFieldExecuteSignedInteger_cxx
#include <vtkm/filter/ClipWithField.h>
#include <vtkm/filter/ClipWithField.hxx>
namespace vtkm
{

1
vtkm/filter/ClipWithFieldSignedInteger.cxx.in
View File

@ -27,6 +27,7 @@
#define vtkm_filter_ClipWithFieldExecuteSignedInteger_cxx
#include <vtkm/filter/ClipWithField.h>
#include <vtkm/filter/ClipWithField.hxx>
namespace vtkm
{

1
vtkm/filter/ClipWithFieldSkipInstantiations.hxx
View File

@ -15,6 +15,7 @@
#define vtk_m_filter_ClipWithFieldSkipInstantiations_hxx
#include <vtkm/filter/ClipWithField.h>
#include <vtkm/filter/ClipWithField.hxx>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/CellSetPermutation.h>

1
vtkm/filter/ClipWithFieldSkipInstantiations.hxx.in
View File

@ -27,6 +27,7 @@
#define vtk_m_filter_ClipWithFieldSkipInstantiations_hxx
#include <vtkm/filter/ClipWithField.h>
#include <vtkm/filter/ClipWithField.hxx>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/CellSetPermutation.h>

1
vtkm/filter/ClipWithFieldUnsignedInteger.cxx
View File

@ -15,6 +15,7 @@
#define vtkm_filter_ClipWithFieldExecuteUnsignedInteger_cxx
#include <vtkm/filter/ClipWithField.h>
#include <vtkm/filter/ClipWithField.hxx>
namespace vtkm
{

1
vtkm/filter/ClipWithFieldUnsignedInteger.cxx.in
View File

@ -27,6 +27,7 @@
#define vtkm_filter_ClipWithFieldExecuteUnsignedInteger_cxx
#include <vtkm/filter/ClipWithField.h>
#include <vtkm/filter/ClipWithField.hxx>
namespace vtkm
{

2
vtkm/filter/ClipWithImplicitFunction.cxx
View File

@ -19,7 +19,7 @@ namespace vtkm
namespace filter
{
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ClipWithImplicitFunction);
VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD(ClipWithImplicitFunction);
template VTKM_FILTER_EXTRA_EXPORT bool ClipWithImplicitFunction::DoMapField(
vtkm::cont::DataSet&,

2
vtkm/filter/ClipWithImplicitFunction.cxx.in
View File

@ -31,7 +31,7 @@ namespace vtkm
namespace filter
{
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ClipWithImplicitFunction);
VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD(ClipWithImplicitFunction);
$py(
# These values are taken from vtkm/TypeList.h

4
vtkm/filter/ClipWithImplicitFunction.h
View File

@ -27,7 +27,7 @@ namespace filter
/// Clip a dataset using a given implicit function value, such as vtkm::Sphere
/// or vtkm::Frustum.
/// The resulting geometry will not be water tight.
class VTKM_ALWAYS_EXPORT ClipWithImplicitFunction
class VTKM_FILTER_EXTRA_EXPORT ClipWithImplicitFunction
: public vtkm::filter::FilterDataSet<ClipWithImplicitFunction>
{
public:
@ -100,7 +100,7 @@ private:
};
#ifndef vtkm_filter_ClipWithImplicitFunction_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(ClipWithImplicitFunction);
VTKM_FILTER_EXTRA_EXPORT_EXECUTE_METHOD(ClipWithImplicitFunction);
#endif
}
} // namespace vtkm::filter

2
vtkm/filter/ClipWithImplicitFunction.hxx
View File

@ -49,7 +49,7 @@ struct ClipWithImplicitFunctionProcessCoords
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline vtkm::cont::DataSet ClipWithImplicitFunction::DoExecute(
vtkm::cont::DataSet ClipWithImplicitFunction::DoExecute(
const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{

1
vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx
View File

@ -15,6 +15,7 @@
#define vtk_m_filter_ClipWithImplicitFunctionSkipInstantiations_hxx
#include <vtkm/filter/ClipWithImplicitFunction.h>
#include <vtkm/filter/ClipWithImplicitFunction.hxx>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/CellSetPermutation.h>

1
vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx.in
View File

@ -27,6 +27,7 @@
#define vtk_m_filter_ClipWithImplicitFunctionSkipInstantiations_hxx
#include <vtkm/filter/ClipWithImplicitFunction.h>
#include <vtkm/filter/ClipWithImplicitFunction.hxx>
#include <vtkm/cont/ArrayHandlePermutation.h>
#include <vtkm/cont/CellSetPermutation.h>

12
vtkm/filter/Contour.cxx
View File

@ -16,7 +16,7 @@ namespace filter
{
//-----------------------------------------------------------------------------
VTKM_FILTER_CONTOUR_EXPORT Contour::Contour()
Contour::Contour()
: vtkm::filter::FilterDataSetWithField<Contour>()
, IsoValues()
, GenerateNormals(false)
@ -31,7 +31,7 @@ VTKM_FILTER_CONTOUR_EXPORT Contour::Contour()
}
//-----------------------------------------------------------------------------
VTKM_FILTER_CONTOUR_EXPORT void Contour::SetNumberOfIsoValues(vtkm::Id num)
void Contour::SetNumberOfIsoValues(vtkm::Id num)
{
if (num >= 0)
{
@ -40,13 +40,13 @@ VTKM_FILTER_CONTOUR_EXPORT void Contour::SetNumberOfIsoValues(vtkm::Id num)
}
//-----------------------------------------------------------------------------
VTKM_FILTER_CONTOUR_EXPORT vtkm::Id Contour::GetNumberOfIsoValues() const
vtkm::Id Contour::GetNumberOfIsoValues() const
{
return static_cast<vtkm::Id>(this->IsoValues.size());
}
//-----------------------------------------------------------------------------
VTKM_FILTER_CONTOUR_EXPORT void Contour::SetIsoValue(vtkm::Id index, vtkm::Float64 v)
void Contour::SetIsoValue(vtkm::Id index, vtkm::Float64 v)
{
std::size_t i = static_cast<std::size_t>(index);
if (i >= this->IsoValues.size())
@ -57,13 +57,13 @@ VTKM_FILTER_CONTOUR_EXPORT void Contour::SetIsoValue(vtkm::Id index, vtkm::Float
}
//-----------------------------------------------------------------------------
VTKM_FILTER_CONTOUR_EXPORT void Contour::SetIsoValues(const std::vector<vtkm::Float64>& values)
void Contour::SetIsoValues(const std::vector<vtkm::Float64>& values)
{
this->IsoValues = values;
}
//-----------------------------------------------------------------------------
VTKM_FILTER_CONTOUR_EXPORT vtkm::Float64 Contour::GetIsoValue(vtkm::Id index) const
vtkm::Float64 Contour::GetIsoValue(vtkm::Id index) const
{
return this->IsoValues[static_cast<std::size_t>(index)];
}

11
vtkm/filter/Contour.h
View File

@ -29,30 +29,23 @@ namespace filter
/// Multiple contour values must be specified to generate the isosurfaces.
/// @warning
/// This filter is currently only supports 3D volumes.
class VTKM_ALWAYS_EXPORT Contour : public vtkm::filter::FilterDataSetWithField<Contour>
class VTKM_FILTER_CONTOUR_EXPORT Contour : public vtkm::filter::FilterDataSetWithField<Contour>
{
public:
using SupportedTypes = vtkm::List<vtkm::UInt8, vtkm::Int8, vtkm::Float32, vtkm::Float64>;
VTKM_FILTER_CONTOUR_EXPORT
Contour();
VTKM_FILTER_CONTOUR_EXPORT
void SetNumberOfIsoValues(vtkm::Id num);
VTKM_FILTER_CONTOUR_EXPORT
vtkm::Id GetNumberOfIsoValues() const;
VTKM_FILTER_CONTOUR_EXPORT
void SetIsoValue(vtkm::Float64 v) { this->SetIsoValue(0, v); }
VTKM_FILTER_CONTOUR_EXPORT
void SetIsoValue(vtkm::Id index, vtkm::Float64);
VTKM_FILTER_CONTOUR_EXPORT
void SetIsoValues(const std::vector<vtkm::Float64>& values);
VTKM_FILTER_CONTOUR_EXPORT
vtkm::Float64 GetIsoValue(vtkm::Id index) const;
/// Set/Get whether the points generated should be unique for every triangle
@ -247,6 +240,4 @@ VTKM_DEPRECATED_SUPPRESS_END
}
} // namespace vtkm::filter
#include <vtkm/filter/Contour.hxx>
#endif // vtk_m_filter_Contour_h

9
vtkm/filter/Contour.hxx
View File

@ -41,11 +41,10 @@ inline bool IsCellSetStructured(const vtkm::cont::DynamicCellSetBase<CellSetList
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet Contour::DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
if (fieldMeta.IsPointField() == false)
{

1
vtkm/filter/ContourInteger.cxx
View File

@ -12,6 +12,7 @@
#define vtk_m_filter_ContourExecuteInteger_cxx
#include <vtkm/filter/Contour.h>
#include <vtkm/filter/Contour.hxx>
namespace vtkm
{

1
vtkm/filter/ContourScalar.cxx
View File

@ -12,6 +12,7 @@
#define vtk_m_filter_ContourExecuteScalar_cxx
#include <vtkm/filter/Contour.h>
#include <vtkm/filter/Contour.hxx>
namespace vtkm
{

6
vtkm/filter/ExternalFaces.cxx
View File

@ -9,7 +9,9 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#define vtkm_filter_ExternalFaces_cxx
#include <vtkm/filter/ExternalFaces.h>
#include <vtkm/filter/ExternalFaces.hxx>
namespace vtkm
{
@ -94,6 +96,8 @@ bool ExternalFaces::MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::
}
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ExternalFaces);
template VTKM_FILTER_EXTRA_TEMPLATE_EXPORT vtkm::cont::DataSet ExternalFaces::DoExecute(
const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault> policy);
}
}

17
vtkm/filter/ExternalFaces.h
View File

@ -31,10 +31,9 @@ namespace filter
/// @warning
/// This filter is currently only supports propagation of point properties
///
class VTKM_ALWAYS_EXPORT ExternalFaces : public vtkm::filter::FilterDataSet<ExternalFaces>
class VTKM_FILTER_EXTRA_EXPORT ExternalFaces : public vtkm::filter::FilterDataSet<ExternalFaces>
{
public:
VTKM_FILTER_EXTRA_EXPORT
ExternalFaces();
// When CompactPoints is set, instead of copying the points and point fields
@ -60,8 +59,7 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
VTKM_FILTER_EXTRA_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field);
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
@ -75,19 +73,18 @@ private:
bool CompactPoints;
bool PassPolyData;
VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet GenerateOutput(
const vtkm::cont::DataSet& input,
vtkm::cont::CellSetExplicit<>& outCellSet);
vtkm::cont::DataSet GenerateOutput(const vtkm::cont::DataSet& input,
vtkm::cont::CellSetExplicit<>& outCellSet);
vtkm::filter::CleanGrid Compactor;
vtkm::worklet::ExternalFaces Worklet;
};
#ifndef vtkm_filter_ExternalFaces_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(ExternalFaces);
extern template VTKM_FILTER_EXTRA_TEMPLATE_EXPORT vtkm::cont::DataSet ExternalFaces::DoExecute(
const vtkm::cont::DataSet&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
#endif
}
} // namespace vtkm::filter
#include <vtkm/filter/ExternalFaces.hxx>
#endif // vtk_m_filter_ExternalFaces_h

5
vtkm/filter/ExternalFaces.hxx
View File

@ -18,9 +18,8 @@ namespace filter
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ExternalFaces::DoExecute(
const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet ExternalFaces::DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
//1. extract the cell set
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet();

12
vtkm/filter/ExtractGeometry.cxx
View File

@ -8,7 +8,9 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#define vtkm_filter_ExtractGeometry_cxx
#include <vtkm/filter/ExtractGeometry.h>
#include <vtkm/filter/ExtractGeometry.hxx>
#include <vtkm/filter/MapFieldPermutation.h>
@ -18,7 +20,7 @@ namespace filter
{
//-----------------------------------------------------------------------------
VTKM_FILTER_COMMON_EXPORT ExtractGeometry::ExtractGeometry()
ExtractGeometry::ExtractGeometry()
: vtkm::filter::FilterDataSet<ExtractGeometry>()
, ExtractInside(true)
, ExtractBoundaryCells(false)
@ -26,8 +28,8 @@ VTKM_FILTER_COMMON_EXPORT ExtractGeometry::ExtractGeometry()
{
}
VTKM_FILTER_COMMON_EXPORT bool ExtractGeometry::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field)
bool ExtractGeometry::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field)
{
if (field.IsFieldPoint())
{
@ -51,6 +53,8 @@ VTKM_FILTER_COMMON_EXPORT bool ExtractGeometry::MapFieldOntoOutput(vtkm::cont::D
}
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ExtractGeometry);
template VTKM_FILTER_COMMON_TEMPLATE_EXPORT vtkm::cont::DataSet ExtractGeometry::DoExecute(
const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault> policy);
}
} // namespace vtkm::filter

16
vtkm/filter/ExtractGeometry.h
View File

@ -37,13 +37,14 @@ 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 VTKM_ALWAYS_EXPORT ExtractGeometry : public vtkm::filter::FilterDataSet<ExtractGeometry>
class VTKM_FILTER_COMMON_EXPORT ExtractGeometry
: public vtkm::filter::FilterDataSet<ExtractGeometry>
{
public:
//currently the ExtractGeometry filter only works on scalar data.
using SupportedTypes = TypeListScalarAll;
VTKM_FILTER_COMMON_EXPORT VTKM_CONT ExtractGeometry();
VTKM_CONT ExtractGeometry();
// Set the volume of interest to extract
void SetImplicitFunction(const vtkm::cont::ImplicitFunctionHandle& func)
@ -82,10 +83,9 @@ public:
template <typename DerivedPolicy>
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
vtkm::filter::PolicyBase<DerivedPolicy> policy);
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field);
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
@ -104,11 +104,11 @@ private:
};
#ifndef vtkm_filter_ExtractGeometry_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(ExtractGeometry);
extern template VTKM_FILTER_COMMON_TEMPLATE_EXPORT vtkm::cont::DataSet ExtractGeometry::DoExecute(
const vtkm::cont::DataSet&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
#endif
}
} // namespace vtkm::filter
#include <vtkm/filter/ExtractGeometry.hxx>
#endif // vtk_m_filter_ExtractGeometry_h

5
vtkm/filter/ExtractGeometry.hxx
View File

@ -67,9 +67,8 @@ namespace filter
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ExtractGeometry::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
vtkm::cont::DataSet ExtractGeometry::DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
// extract the input cell set and coordinates
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet();

5
vtkm/filter/ExtractStructured.cxx
View File

@ -9,6 +9,7 @@
//============================================================================
#define vtkm_filter_ExtractStructured_cxx
#include <vtkm/filter/ExtractStructured.h>
#include <vtkm/filter/ExtractStructured.hxx>
#include <vtkm/filter/MapFieldPermutation.h>
@ -60,6 +61,8 @@ void ExtractStructured::PostExecute(const vtkm::cont::PartitionedDataSet&,
}
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(ExtractStructured);
template VTKM_FILTER_COMMON_TEMPLATE_EXPORT vtkm::cont::DataSet ExtractStructured::DoExecute(
const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault> policy);
}
}

18
vtkm/filter/ExtractStructured.h
View File

@ -36,10 +36,10 @@ namespace filter
/// for image processing, subsampling large volumes to reduce data size, or
/// extracting regions of a volume with interesting data.
///
class VTKM_ALWAYS_EXPORT ExtractStructured : public vtkm::filter::FilterDataSet<ExtractStructured>
class VTKM_FILTER_COMMON_EXPORT ExtractStructured
: public vtkm::filter::FilterDataSet<ExtractStructured>
{
public:
VTKM_FILTER_COMMON_EXPORT
ExtractStructured();
// Set the bounding box for the volume of interest
@ -87,8 +87,7 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy);
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field);
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
@ -99,8 +98,8 @@ public:
}
VTKM_FILTER_COMMON_EXPORT VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet&,
vtkm::cont::PartitionedDataSet&);
VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet&,
vtkm::cont::PartitionedDataSet&);
template <typename DerivedPolicy>
VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet& input,
@ -122,13 +121,12 @@ private:
};
#ifndef vtkm_filter_ExtractStructured_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(ExtractStructured);
extern template VTKM_FILTER_COMMON_TEMPLATE_EXPORT vtkm::cont::DataSet ExtractStructured::DoExecute(
const vtkm::cont::DataSet&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
#endif
}
} // namespace vtkm::filter
#ifndef vtk_m_filter_ExtractStructured_hxx
#include <vtkm/filter/ExtractStructured.hxx>
#endif
#endif // vtk_m_filter_ExtractStructured_h

5
vtkm/filter/ExtractStructured.hxx
View File

@ -18,9 +18,8 @@ namespace filter
{
//-----------------------------------------------------------------------------
template <typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet ExtractStructured::DoExecute(
const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet ExtractStructured::DoExecute(const vtkm::cont::DataSet& input,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet();
const vtkm::cont::CoordinateSystem& coordinates = input.GetCoordinateSystem();

53
vtkm/filter/Filter.h
View File

@ -304,18 +304,59 @@ private:
}
} // namespace vtkm::filter
#define VTKM_FILTER_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
#define VTKM_FILTER_COMMON_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
extern template VTKM_FILTER_COMMON_TEMPLATE_EXPORT vtkm::cont::PartitionedDataSet \
vtkm::filter::Filter<Name>::Execute(vtkm::cont::PartitionedDataSet const&, \
vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
#define VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
template VTKM_FILTER_COMMON_EXPORT vtkm::cont::PartitionedDataSet Filter<Name>::Execute( \
vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_EXPORT_EXECUTE_METHOD(Name) \
VTKM_FILTER_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(Name) \
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_COMMON_EXPORT_EXECUTE_METHOD(Name) \
VTKM_FILTER_COMMON_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD(Name) \
VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_EXTRA_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
extern template VTKM_FILTER_EXTRA_TEMPLATE_EXPORT vtkm::cont::PartitionedDataSet \
vtkm::filter::Filter<Name>::Execute(vtkm::cont::PartitionedDataSet const&, \
vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::PartitionedDataSet Filter<Name>::Execute( \
vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_EXTRA_EXPORT_EXECUTE_METHOD(Name) \
VTKM_FILTER_EXTRA_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD(Name) \
VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_CONTOUR_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::PartitionedDataSet \
vtkm::filter::Filter<Name>::Execute(vtkm::cont::PartitionedDataSet const&, \
vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_CONTOUR_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::PartitionedDataSet Filter<Name>::Execute( \
vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_CONTOUR_EXPORT_EXECUTE_METHOD(Name) \
VTKM_FILTER_CONTOUR_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_CONTOUR_INSTANTIATE_EXECUTE_METHOD(Name) \
VTKM_FILTER_CONTOUR_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_GRADIENT_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::PartitionedDataSet \
vtkm::filter::Filter<Name>::Execute(vtkm::cont::PartitionedDataSet const&, \
vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_GRADIENT_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::PartitionedDataSet Filter<Name>::Execute( \
vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase<Policy>)
#define VTKM_FILTER_GRADIENT_EXPORT_EXECUTE_METHOD(Name) \
VTKM_FILTER_GRADIENT_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#define VTKM_FILTER_GRADIENT_INSTANTIATE_EXECUTE_METHOD(Name) \
VTKM_FILTER_GRADIENT_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, vtkm::filter::PolicyDefault)
#include <vtkm/filter/Filter.hxx>
#endif

24
vtkm/filter/Gradient.h
View File

@ -29,7 +29,7 @@ namespace filter
///
/// Note: If no explicit name for the output field is provided the filter will
/// default to "Gradients"
class Gradient : public vtkm::filter::FilterField<Gradient>
class VTKM_FILTER_GRADIENT_EXPORT Gradient : public vtkm::filter::FilterField<Gradient>
{
public:
using SupportedTypes = vtkm::List<vtkm::Float32, vtkm::Float64, vtkm::Vec3f_32, vtkm::Vec3f_64>;
@ -181,10 +181,28 @@ extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradien
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<
vtkm::Vec3f_32,
vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic>>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<
vtkm::Vec3f_64,
vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic>>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
#endif //vtkm_filter_Gradient_cxx
}
} // namespace vtkm::filter
#include <vtkm/filter/Gradient.hxx>
#endif // vtk_m_filter_Gradient_h

43
vtkm/filter/GradientCartesianPoints.cxx Normal file
View File

@ -0,0 +1,43 @@
//============================================================================
// 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.
//============================================================================
#ifndef vtk_m_filter_Gradient_cxx
#define vtk_m_filter_Gradient_cxx
#include <vtkm/filter/Gradient.h>
#include <vtkm/filter/Gradient.hxx>
namespace vtkm
{
namespace filter
{
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<
vtkm::Vec3f_32,
vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic>>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<
vtkm::Vec3f_64,
vtkm::cont::StorageTagCartesianProduct<vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic,
vtkm::cont::StorageTagBasic>>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
}
}
#endif

1
vtkm/filter/GradientScalar.cxx
View File

@ -12,6 +12,7 @@
#define vtk_m_filter_Gradient_cxx
#include <vtkm/filter/Gradient.h>
#include <vtkm/filter/Gradient.hxx>
namespace vtkm
{

1
vtkm/filter/GradientUniformPoints.cxx
View File

@ -12,6 +12,7 @@
#define vtk_m_filter_Gradient_cxx
#include <vtkm/filter/Gradient.h>
#include <vtkm/filter/Gradient.hxx>
namespace vtkm
{

1
vtkm/filter/GradientVector.cxx
View File

@ -12,6 +12,7 @@
#define vtk_m_filter_Gradient_cxx
#include <vtkm/filter/Gradient.h>
#include <vtkm/filter/Gradient.hxx>
namespace vtkm
{

2
vtkm/filter/PointAverage.cxx
View File

@ -16,6 +16,6 @@ namespace vtkm
namespace filter
{
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(PointAverage);
VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD(PointAverage);
}
}

4
vtkm/filter/PointAverage.h
View File

@ -28,7 +28,7 @@ namespace filter
/// specified per cell) into point data (i.e., data specified at cell
/// points). The method of transformation is based on averaging the data
/// values of all cells using a particular point.
class VTKM_ALWAYS_EXPORT PointAverage : public vtkm::filter::FilterField<PointAverage>
class VTKM_FILTER_COMMON_EXPORT PointAverage : public vtkm::filter::FilterField<PointAverage>
{
public:
template <typename T, typename StorageType, typename DerivedPolicy>
@ -47,7 +47,7 @@ private:
};
#ifndef vtkm_filter_PointAverage_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(PointAverage);
VTKM_FILTER_COMMON_EXPORT_EXECUTE_METHOD(PointAverage);
#endif
}
} // namespace vtkm::filter

9
vtkm/filter/PointAverage.hxx
View File

@ -21,11 +21,10 @@ namespace filter
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet PointAverage::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet PointAverage::DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
if (!fieldMetadata.IsCellField())
{

5
vtkm/filter/Threshold.cxx
View File

@ -17,8 +17,7 @@ namespace vtkm
namespace filter
{
VTKM_FILTER_COMMON_EXPORT bool Threshold::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field)
bool Threshold::MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field)
{
if (field.IsFieldPoint() || field.IsFieldGlobal())
{
@ -37,6 +36,6 @@ VTKM_FILTER_COMMON_EXPORT bool Threshold::MapFieldOntoOutput(vtkm::cont::DataSet
}
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(Threshold);
VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD(Threshold);
}
}

7
vtkm/filter/Threshold.h
View File

@ -30,7 +30,7 @@ namespace filter
/// filter is an permutation of the input dataset.
///
/// You can threshold either on point or cell fields
class VTKM_ALWAYS_EXPORT Threshold : public vtkm::filter::FilterDataSetWithField<Threshold>
class VTKM_FILTER_COMMON_EXPORT Threshold : public vtkm::filter::FilterDataSetWithField<Threshold>
{
public:
using SupportedTypes = vtkm::TypeListScalarAll;
@ -53,8 +53,7 @@ public:
//Map a new field onto the resulting dataset after running the filter
//this call is only valid after DoExecute is called
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field);
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
@ -71,7 +70,7 @@ private:
};
#ifndef vtkm_filter_Threshold_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(Threshold);
VTKM_FILTER_COMMON_EXPORT_EXECUTE_METHOD(Threshold);
#endif
}
} // namespace vtkm::filter

9
vtkm/filter/Threshold.hxx
View File

@ -58,11 +58,10 @@ namespace filter
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy>
inline VTKM_CONT vtkm::cont::DataSet Threshold::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
vtkm::cont::DataSet Threshold::DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<DerivedPolicy> policy)
{
//get the cells and coordinates of the dataset
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet();

2
vtkm/filter/VectorMagnitude.cxx
View File

@ -25,6 +25,6 @@ VectorMagnitude::VectorMagnitude()
}
//-----------------------------------------------------------------------------
VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(VectorMagnitude);
VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD(VectorMagnitude);
}
}

5
vtkm/filter/VectorMagnitude.h
View File

@ -21,13 +21,12 @@ namespace vtkm
namespace filter
{
class VTKM_ALWAYS_EXPORT VectorMagnitude : public vtkm::filter::FilterField<VectorMagnitude>
class VTKM_FILTER_EXTRA_EXPORT VectorMagnitude : public vtkm::filter::FilterField<VectorMagnitude>
{
public:
//currently the VectorMagnitude filter only works on vector data.
using SupportedTypes = vtkm::TypeListVecCommon;
VTKM_FILTER_EXTRA_EXPORT
VectorMagnitude();
template <typename T, typename StorageType, typename DerivedPolicy>
@ -40,7 +39,7 @@ private:
vtkm::worklet::Magnitude Worklet;
};
#ifndef vtkm_filter_VectorMagnitude_cxx
VTKM_FILTER_EXPORT_EXECUTE_METHOD(VectorMagnitude);
VTKM_FILTER_EXTRA_EXPORT_EXECUTE_METHOD(VectorMagnitude);
#endif
}
} // namespace vtkm::filter

2
vtkm/filter/internal/ResolveFieldTypeAndExecute.h
View File

@ -24,7 +24,7 @@ namespace filter
namespace internal
{
struct ResolveFieldTypeAndExecute
struct VTKM_ALWAYS_EXPORT ResolveFieldTypeAndExecute
{
template <typename T,
typename Storage,

1
vtkm/filter/testing/CMakeLists.txt
View File

@ -50,6 +50,7 @@ set(unit_tests
UnitTestPartitionedDataSetFilters.cxx
UnitTestPartitionedDataSetHistogramFilter.cxx
UnitTestPointAverageFilter.cxx
UnitTestPointAverageCellSetExtrude.cxx
UnitTestPointElevationFilter.cxx
UnitTestPointTransform.cxx
UnitTestProbe.cxx

74
vtkm/filter/testing/UnitTestPointAverageCellSetExtrude.cxx Normal file
View File

@ -0,0 +1,74 @@
//============================================================================
// 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.
//============================================================================
#include <vtkm/worklet/DispatcherMapTopology.h>
#include <vtkm/worklet/WorkletMapTopology.h>
#include <vtkm/cont/ArrayHandleExtrudeCoords.h>
#include <vtkm/cont/CellSetExtrude.h>
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/PointAverage.h>
namespace
{
std::vector<float> points_rz = { 1.72485139f, 0.020562f, 1.73493571f,
0.02052826f, 1.73478011f, 0.02299051f }; //really a vec<float,2>
std::vector<int> topology = { 0, 2, 1 };
std::vector<int> nextNode = { 0, 1, 2 };
int TestCellSetExtrude()
{
const std::size_t numPlanes = 8;
auto coords = vtkm::cont::make_ArrayHandleExtrudeCoords(points_rz, numPlanes, false);
auto cells = vtkm::cont::make_CellSetExtrude(topology, coords, nextNode);
VTKM_TEST_ASSERT(cells.GetNumberOfPoints() == coords.GetNumberOfValues(),
"number of points don't match between cells and coordinates");
//test a filter
vtkm::cont::DataSet dataset;
dataset.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coords", coords));
dataset.SetCellSet(cells);
// verify that a constant value point field can be accessed
std::vector<float> pvalues(static_cast<size_t>(coords.GetNumberOfValues()), 42.0f);
vtkm::cont::Field pfield = vtkm::cont::make_Field(
"pfield", vtkm::cont::Field::Association::POINTS, pvalues, vtkm::CopyFlag::Off);
dataset.AddField(pfield);
// verify that a constant cell value can be accessed
std::vector<float> cvalues(static_cast<size_t>(cells.GetNumberOfCells()), 42.0f);
vtkm::cont::Field cfield = vtkm::cont::make_Field(
"cfield", vtkm::cont::Field::Association::CELL_SET, cvalues, vtkm::CopyFlag::Off);
dataset.AddField(cfield);
vtkm::filter::PointAverage avg;
try
{
avg.SetActiveField("cfield");
auto result = avg.Execute(dataset);
VTKM_TEST_ASSERT(result.HasPointField("cfield"), "filter resulting dataset should be valid");
}
catch (const vtkm::cont::Error& err)
{
std::cout << err.GetMessage() << std::endl;
VTKM_TEST_ASSERT(false, "Filter execution threw an exception");
}
return 0;
}
}
int UnitTestPointAverageCellSetExtrude(int argc, char* argv[])
{
return vtkm::cont::testing::Testing::Run(TestCellSetExtrude, argc, argv);
}