diff --git a/vtkm/cont/testing/UnitTestCellSetExtrude.cxx b/vtkm/cont/testing/UnitTestCellSetExtrude.cxx index 44a6ee6ed..2bac29ace 100644 --- a/vtkm/cont/testing/UnitTestCellSetExtrude.cxx +++ b/vtkm/cont/testing/UnitTestCellSetExtrude.cxx @@ -97,6 +97,17 @@ void verify_topo(vtkm::cont::ArrayHandle, S> const& handle, vtkm VTKM_TEST_ASSERT(test_equal(v, e), "incorrect conversion of topology to Cartesian space"); } +template +void verify_reverse_topo(vtkm::cont::ArrayHandle 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 output; vtkm::worklet::DispatcherMapTopology 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 pvalues(static_cast(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 cvalues(static_cast(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); } diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt index b15e65453..6974af34d 100644 --- a/vtkm/filter/CMakeLists.txt +++ b/vtkm/filter/CMakeLists.txt @@ -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 diff --git a/vtkm/filter/CellAverage.cxx b/vtkm/filter/CellAverage.cxx index 86d9d2b6e..db1f3b77e 100644 --- a/vtkm/filter/CellAverage.cxx +++ b/vtkm/filter/CellAverage.cxx @@ -16,6 +16,6 @@ namespace vtkm namespace filter { //----------------------------------------------------------------------------- -VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(CellAverage); +VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD(CellAverage); } } diff --git a/vtkm/filter/CellAverage.h b/vtkm/filter/CellAverage.h index 19ab115f4..a6c1d2fa2 100644 --- a/vtkm/filter/CellAverage.h +++ b/vtkm/filter/CellAverage.h @@ -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 +class VTKM_FILTER_COMMON_EXPORT CellAverage : public vtkm::filter::FilterField { public: template @@ -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 diff --git a/vtkm/filter/CellAverage.hxx b/vtkm/filter/CellAverage.hxx index 744cc37f7..c182a2991 100644 --- a/vtkm/filter/CellAverage.hxx +++ b/vtkm/filter/CellAverage.hxx @@ -20,11 +20,10 @@ namespace filter { //----------------------------------------------------------------------------- template -inline VTKM_CONT vtkm::cont::DataSet CellAverage::DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& inField, - const vtkm::filter::FieldMetadata& fieldMetadata, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet CellAverage::DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& inField, + const vtkm::filter::FieldMetadata& fieldMetadata, + vtkm::filter::PolicyBase policy) { if (!fieldMetadata.IsPointField()) { diff --git a/vtkm/filter/CleanGrid.cxx b/vtkm/filter/CleanGrid.cxx index 5fb40064c..ddcd8edc3 100644 --- a/vtkm/filter/CleanGrid.cxx +++ b/vtkm/filter/CleanGrid.cxx @@ -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 policy); } } diff --git a/vtkm/filter/CleanGrid.h b/vtkm/filter/CleanGrid.h index bef674d8c..198636895 100644 --- a/vtkm/filter/CleanGrid.h +++ b/vtkm/filter/CleanGrid.h @@ -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 +class VTKM_FILTER_COMMON_EXPORT CleanGrid : public vtkm::filter::FilterDataSet { 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); - VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field); template @@ -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); #endif } } // namespace vtkm::filter -#include - #endif //vtk_m_filter_CleanGrid_h diff --git a/vtkm/filter/CleanGrid.hxx b/vtkm/filter/CleanGrid.hxx index f2ec52133..321e3fc94 100644 --- a/vtkm/filter/CleanGrid.hxx +++ b/vtkm/filter/CleanGrid.hxx @@ -22,8 +22,8 @@ namespace filter { template -inline VTKM_CONT vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::DataSet& inData, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet CleanGrid::DoExecute(const vtkm::cont::DataSet& inData, + vtkm::filter::PolicyBase policy) { using CellSetType = vtkm::cont::CellSetExplicit<>; diff --git a/vtkm/filter/ClipWithField.h b/vtkm/filter/ClipWithField.h index 80ec8a7c1..7de599c2b 100644 --- a/vtkm/filter/ClipWithField.h +++ b/vtkm/filter/ClipWithField.h @@ -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 +class VTKM_FILTER_EXTRA_EXPORT ClipWithField + : public vtkm::filter::FilterDataSetWithField { 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 -#endif - #endif // vtk_m_filter_ClipWithField_h diff --git a/vtkm/filter/ClipWithField.hxx b/vtkm/filter/ClipWithField.hxx index 06a408932..a3955f33b 100644 --- a/vtkm/filter/ClipWithField.hxx +++ b/vtkm/filter/ClipWithField.hxx @@ -52,11 +52,10 @@ struct ClipWithFieldProcessCoords //----------------------------------------------------------------------------- template -inline VTKM_CONT vtkm::cont::DataSet ClipWithField::DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet ClipWithField::DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + vtkm::filter::PolicyBase policy) { if (fieldMeta.IsPointField() == false) { diff --git a/vtkm/filter/ClipWithFieldScalar.cxx b/vtkm/filter/ClipWithFieldScalar.cxx index b3c934c16..b1f96e431 100644 --- a/vtkm/filter/ClipWithFieldScalar.cxx +++ b/vtkm/filter/ClipWithFieldScalar.cxx @@ -12,6 +12,7 @@ #define vtkm_filter_ClipWithFieldExecuteScalar_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/ClipWithFieldSignedInteger.cxx b/vtkm/filter/ClipWithFieldSignedInteger.cxx index d00677ce2..41fd085ec 100644 --- a/vtkm/filter/ClipWithFieldSignedInteger.cxx +++ b/vtkm/filter/ClipWithFieldSignedInteger.cxx @@ -15,6 +15,7 @@ #define vtkm_filter_ClipWithFieldExecuteSignedInteger_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/ClipWithFieldSignedInteger.cxx.in b/vtkm/filter/ClipWithFieldSignedInteger.cxx.in index 4fe72de9e..58f9eb2fc 100644 --- a/vtkm/filter/ClipWithFieldSignedInteger.cxx.in +++ b/vtkm/filter/ClipWithFieldSignedInteger.cxx.in @@ -27,6 +27,7 @@ #define vtkm_filter_ClipWithFieldExecuteSignedInteger_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/ClipWithFieldSkipInstantiations.hxx b/vtkm/filter/ClipWithFieldSkipInstantiations.hxx index 92b62103e..62df0d965 100644 --- a/vtkm/filter/ClipWithFieldSkipInstantiations.hxx +++ b/vtkm/filter/ClipWithFieldSkipInstantiations.hxx @@ -15,6 +15,7 @@ #define vtk_m_filter_ClipWithFieldSkipInstantiations_hxx #include +#include #include #include diff --git a/vtkm/filter/ClipWithFieldSkipInstantiations.hxx.in b/vtkm/filter/ClipWithFieldSkipInstantiations.hxx.in index 137fd9851..e087eea7e 100644 --- a/vtkm/filter/ClipWithFieldSkipInstantiations.hxx.in +++ b/vtkm/filter/ClipWithFieldSkipInstantiations.hxx.in @@ -27,6 +27,7 @@ #define vtk_m_filter_ClipWithFieldSkipInstantiations_hxx #include +#include #include #include diff --git a/vtkm/filter/ClipWithFieldUnsignedInteger.cxx b/vtkm/filter/ClipWithFieldUnsignedInteger.cxx index 5a43984ca..5bb472856 100644 --- a/vtkm/filter/ClipWithFieldUnsignedInteger.cxx +++ b/vtkm/filter/ClipWithFieldUnsignedInteger.cxx @@ -15,6 +15,7 @@ #define vtkm_filter_ClipWithFieldExecuteUnsignedInteger_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/ClipWithFieldUnsignedInteger.cxx.in b/vtkm/filter/ClipWithFieldUnsignedInteger.cxx.in index 188b9cef7..0519c3ea5 100644 --- a/vtkm/filter/ClipWithFieldUnsignedInteger.cxx.in +++ b/vtkm/filter/ClipWithFieldUnsignedInteger.cxx.in @@ -27,6 +27,7 @@ #define vtkm_filter_ClipWithFieldExecuteUnsignedInteger_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/ClipWithImplicitFunction.cxx b/vtkm/filter/ClipWithImplicitFunction.cxx index b874afd6e..b09daa707 100644 --- a/vtkm/filter/ClipWithImplicitFunction.cxx +++ b/vtkm/filter/ClipWithImplicitFunction.cxx @@ -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&, diff --git a/vtkm/filter/ClipWithImplicitFunction.cxx.in b/vtkm/filter/ClipWithImplicitFunction.cxx.in index 6f86cbd33..90823723a 100644 --- a/vtkm/filter/ClipWithImplicitFunction.cxx.in +++ b/vtkm/filter/ClipWithImplicitFunction.cxx.in @@ -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 diff --git a/vtkm/filter/ClipWithImplicitFunction.h b/vtkm/filter/ClipWithImplicitFunction.h index d1e557003..bfae679d3 100644 --- a/vtkm/filter/ClipWithImplicitFunction.h +++ b/vtkm/filter/ClipWithImplicitFunction.h @@ -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 { 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 diff --git a/vtkm/filter/ClipWithImplicitFunction.hxx b/vtkm/filter/ClipWithImplicitFunction.hxx index 2e4c63c9a..0a2c2b9e2 100644 --- a/vtkm/filter/ClipWithImplicitFunction.hxx +++ b/vtkm/filter/ClipWithImplicitFunction.hxx @@ -49,7 +49,7 @@ struct ClipWithImplicitFunctionProcessCoords //----------------------------------------------------------------------------- template -inline vtkm::cont::DataSet ClipWithImplicitFunction::DoExecute( +vtkm::cont::DataSet ClipWithImplicitFunction::DoExecute( const vtkm::cont::DataSet& input, vtkm::filter::PolicyBase policy) { diff --git a/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx b/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx index 9c685d19b..10618c7eb 100644 --- a/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx +++ b/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx @@ -15,6 +15,7 @@ #define vtk_m_filter_ClipWithImplicitFunctionSkipInstantiations_hxx #include +#include #include #include diff --git a/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx.in b/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx.in index 601e413db..92fddccfd 100644 --- a/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx.in +++ b/vtkm/filter/ClipWithImplicitFunctionSkipInstantiations.hxx.in @@ -27,6 +27,7 @@ #define vtk_m_filter_ClipWithImplicitFunctionSkipInstantiations_hxx #include +#include #include #include diff --git a/vtkm/filter/Contour.cxx b/vtkm/filter/Contour.cxx index 20fb9cac6..3fbbfd9aa 100644 --- a/vtkm/filter/Contour.cxx +++ b/vtkm/filter/Contour.cxx @@ -16,7 +16,7 @@ namespace filter { //----------------------------------------------------------------------------- -VTKM_FILTER_CONTOUR_EXPORT Contour::Contour() +Contour::Contour() : vtkm::filter::FilterDataSetWithField() , 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(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(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& values) +void Contour::SetIsoValues(const std::vector& 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(index)]; } diff --git a/vtkm/filter/Contour.h b/vtkm/filter/Contour.h index 3bc5e97b8..de95d0e3c 100644 --- a/vtkm/filter/Contour.h +++ b/vtkm/filter/Contour.h @@ -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 +class VTKM_FILTER_CONTOUR_EXPORT Contour : public vtkm::filter::FilterDataSetWithField { public: using SupportedTypes = vtkm::List; - 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& 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 - #endif // vtk_m_filter_Contour_h diff --git a/vtkm/filter/Contour.hxx b/vtkm/filter/Contour.hxx index 74b1760b1..b08aa3f22 100644 --- a/vtkm/filter/Contour.hxx +++ b/vtkm/filter/Contour.hxx @@ -41,11 +41,10 @@ inline bool IsCellSetStructured(const vtkm::cont::DynamicCellSetBase -inline VTKM_CONT vtkm::cont::DataSet Contour::DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet Contour::DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + vtkm::filter::PolicyBase policy) { if (fieldMeta.IsPointField() == false) { diff --git a/vtkm/filter/ContourInteger.cxx b/vtkm/filter/ContourInteger.cxx index 1c13f83ba..5714a4ce2 100644 --- a/vtkm/filter/ContourInteger.cxx +++ b/vtkm/filter/ContourInteger.cxx @@ -12,6 +12,7 @@ #define vtk_m_filter_ContourExecuteInteger_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/ContourScalar.cxx b/vtkm/filter/ContourScalar.cxx index 180dfd1d0..06507afed 100644 --- a/vtkm/filter/ContourScalar.cxx +++ b/vtkm/filter/ContourScalar.cxx @@ -12,6 +12,7 @@ #define vtk_m_filter_ContourExecuteScalar_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/ExternalFaces.cxx b/vtkm/filter/ExternalFaces.cxx index 9a61b92f4..763d772a5 100644 --- a/vtkm/filter/ExternalFaces.cxx +++ b/vtkm/filter/ExternalFaces.cxx @@ -9,7 +9,9 @@ // PURPOSE. See the above copyright notice for more information. //============================================================================ #define vtkm_filter_ExternalFaces_cxx + #include +#include 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 policy); } } diff --git a/vtkm/filter/ExternalFaces.h b/vtkm/filter/ExternalFaces.h index e14186438..13814d979 100644 --- a/vtkm/filter/ExternalFaces.h +++ b/vtkm/filter/ExternalFaces.h @@ -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 +class VTKM_FILTER_EXTRA_EXPORT ExternalFaces : public vtkm::filter::FilterDataSet { 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 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 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); #endif } } // namespace vtkm::filter -#include - #endif // vtk_m_filter_ExternalFaces_h diff --git a/vtkm/filter/ExternalFaces.hxx b/vtkm/filter/ExternalFaces.hxx index 1d31c6f69..12e55acd1 100644 --- a/vtkm/filter/ExternalFaces.hxx +++ b/vtkm/filter/ExternalFaces.hxx @@ -18,9 +18,8 @@ namespace filter //----------------------------------------------------------------------------- template -inline VTKM_CONT vtkm::cont::DataSet ExternalFaces::DoExecute( - const vtkm::cont::DataSet& input, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet ExternalFaces::DoExecute(const vtkm::cont::DataSet& input, + vtkm::filter::PolicyBase policy) { //1. extract the cell set const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(); diff --git a/vtkm/filter/ExtractGeometry.cxx b/vtkm/filter/ExtractGeometry.cxx index beb7674a7..2ad4287a8 100644 --- a/vtkm/filter/ExtractGeometry.cxx +++ b/vtkm/filter/ExtractGeometry.cxx @@ -8,7 +8,9 @@ // PURPOSE. See the above copyright notice for more information. //============================================================================ #define vtkm_filter_ExtractGeometry_cxx + #include +#include #include @@ -18,7 +20,7 @@ namespace filter { //----------------------------------------------------------------------------- -VTKM_FILTER_COMMON_EXPORT ExtractGeometry::ExtractGeometry() +ExtractGeometry::ExtractGeometry() : vtkm::filter::FilterDataSet() , 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 policy); } } // namespace vtkm::filter diff --git a/vtkm/filter/ExtractGeometry.h b/vtkm/filter/ExtractGeometry.h index 208d58b14..dbd922166 100644 --- a/vtkm/filter/ExtractGeometry.h +++ b/vtkm/filter/ExtractGeometry.h @@ -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 +class VTKM_FILTER_COMMON_EXPORT ExtractGeometry + : public vtkm::filter::FilterDataSet { 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 vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy); + vtkm::filter::PolicyBase 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 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); #endif } } // namespace vtkm::filter -#include - #endif // vtk_m_filter_ExtractGeometry_h diff --git a/vtkm/filter/ExtractGeometry.hxx b/vtkm/filter/ExtractGeometry.hxx index 4ff4b0964..6eeb47639 100644 --- a/vtkm/filter/ExtractGeometry.hxx +++ b/vtkm/filter/ExtractGeometry.hxx @@ -67,9 +67,8 @@ namespace filter //----------------------------------------------------------------------------- template -inline VTKM_CONT vtkm::cont::DataSet ExtractGeometry::DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy) +vtkm::cont::DataSet ExtractGeometry::DoExecute(const vtkm::cont::DataSet& input, + vtkm::filter::PolicyBase policy) { // extract the input cell set and coordinates const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(); diff --git a/vtkm/filter/ExtractStructured.cxx b/vtkm/filter/ExtractStructured.cxx index 9aee477b4..17145b549 100644 --- a/vtkm/filter/ExtractStructured.cxx +++ b/vtkm/filter/ExtractStructured.cxx @@ -9,6 +9,7 @@ //============================================================================ #define vtkm_filter_ExtractStructured_cxx #include +#include #include @@ -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 policy); } } diff --git a/vtkm/filter/ExtractStructured.h b/vtkm/filter/ExtractStructured.h index cc8c4764e..c8e392438 100644 --- a/vtkm/filter/ExtractStructured.h +++ b/vtkm/filter/ExtractStructured.h @@ -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 +class VTKM_FILTER_COMMON_EXPORT ExtractStructured + : public vtkm::filter::FilterDataSet { 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 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 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 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); #endif } } // namespace vtkm::filter -#ifndef vtk_m_filter_ExtractStructured_hxx -#include -#endif #endif // vtk_m_filter_ExtractStructured_h diff --git a/vtkm/filter/ExtractStructured.hxx b/vtkm/filter/ExtractStructured.hxx index 106e1759e..d85da6727 100644 --- a/vtkm/filter/ExtractStructured.hxx +++ b/vtkm/filter/ExtractStructured.hxx @@ -18,9 +18,8 @@ namespace filter { //----------------------------------------------------------------------------- template -inline VTKM_CONT vtkm::cont::DataSet ExtractStructured::DoExecute( - const vtkm::cont::DataSet& input, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet ExtractStructured::DoExecute(const vtkm::cont::DataSet& input, + vtkm::filter::PolicyBase policy) { const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(); const vtkm::cont::CoordinateSystem& coordinates = input.GetCoordinateSystem(); diff --git a/vtkm/filter/Filter.h b/vtkm/filter/Filter.h index f1bae3ce0..20265e581 100644 --- a/vtkm/filter/Filter.h +++ b/vtkm/filter/Filter.h @@ -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::Execute(vtkm::cont::PartitionedDataSet const&, \ vtkm::filter::PolicyBase) -#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::Execute( \ vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase) -#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::Execute(vtkm::cont::PartitionedDataSet const&, \ + vtkm::filter::PolicyBase) +#define VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \ + template VTKM_FILTER_EXTRA_EXPORT vtkm::cont::PartitionedDataSet Filter::Execute( \ + vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase) + +#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::Execute(vtkm::cont::PartitionedDataSet const&, \ + vtkm::filter::PolicyBase) +#define VTKM_FILTER_CONTOUR_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \ + template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::PartitionedDataSet Filter::Execute( \ + vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase) + +#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::Execute(vtkm::cont::PartitionedDataSet const&, \ + vtkm::filter::PolicyBase) +#define VTKM_FILTER_GRADIENT_INSTANTIATE_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \ + template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::PartitionedDataSet Filter::Execute( \ + vtkm::cont::PartitionedDataSet const&, vtkm::filter::PolicyBase) + +#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 #endif diff --git a/vtkm/filter/Gradient.h b/vtkm/filter/Gradient.h index 800b2a9cd..da89785f9 100644 --- a/vtkm/filter/Gradient.h +++ b/vtkm/filter/Gradient.h @@ -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 +class VTKM_FILTER_GRADIENT_EXPORT Gradient : public vtkm::filter::FilterField { public: using SupportedTypes = vtkm::List; @@ -181,10 +181,28 @@ extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradien const vtkm::filter::FieldMetadata&, vtkm::filter::PolicyBase); +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>&, + const vtkm::filter::FieldMetadata&, + vtkm::filter::PolicyBase); + +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>&, + const vtkm::filter::FieldMetadata&, + vtkm::filter::PolicyBase); + #endif //vtkm_filter_Gradient_cxx } } // namespace vtkm::filter -#include - #endif // vtk_m_filter_Gradient_h diff --git a/vtkm/filter/GradientCartesianPoints.cxx b/vtkm/filter/GradientCartesianPoints.cxx new file mode 100644 index 000000000..e11536837 --- /dev/null +++ b/vtkm/filter/GradientCartesianPoints.cxx @@ -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 +#include + +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>&, + const vtkm::filter::FieldMetadata&, + vtkm::filter::PolicyBase); + +template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute( + const vtkm::cont::DataSet&, + const vtkm::cont::ArrayHandle< + vtkm::Vec3f_64, + vtkm::cont::StorageTagCartesianProduct>&, + const vtkm::filter::FieldMetadata&, + vtkm::filter::PolicyBase); +} +} + +#endif diff --git a/vtkm/filter/GradientScalar.cxx b/vtkm/filter/GradientScalar.cxx index 891391a60..e7e55c99b 100644 --- a/vtkm/filter/GradientScalar.cxx +++ b/vtkm/filter/GradientScalar.cxx @@ -12,6 +12,7 @@ #define vtk_m_filter_Gradient_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/GradientUniformPoints.cxx b/vtkm/filter/GradientUniformPoints.cxx index 5bb11ffa9..a90aedfd7 100644 --- a/vtkm/filter/GradientUniformPoints.cxx +++ b/vtkm/filter/GradientUniformPoints.cxx @@ -12,6 +12,7 @@ #define vtk_m_filter_Gradient_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/GradientVector.cxx b/vtkm/filter/GradientVector.cxx index af7b63cdf..3c2837c7f 100644 --- a/vtkm/filter/GradientVector.cxx +++ b/vtkm/filter/GradientVector.cxx @@ -12,6 +12,7 @@ #define vtk_m_filter_Gradient_cxx #include +#include namespace vtkm { diff --git a/vtkm/filter/PointAverage.cxx b/vtkm/filter/PointAverage.cxx index 979d20a4d..f23696584 100644 --- a/vtkm/filter/PointAverage.cxx +++ b/vtkm/filter/PointAverage.cxx @@ -16,6 +16,6 @@ namespace vtkm namespace filter { //----------------------------------------------------------------------------- -VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(PointAverage); +VTKM_FILTER_COMMON_INSTANTIATE_EXECUTE_METHOD(PointAverage); } } diff --git a/vtkm/filter/PointAverage.h b/vtkm/filter/PointAverage.h index c1122ba2a..769cddfa4 100644 --- a/vtkm/filter/PointAverage.h +++ b/vtkm/filter/PointAverage.h @@ -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 +class VTKM_FILTER_COMMON_EXPORT PointAverage : public vtkm::filter::FilterField { public: template @@ -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 diff --git a/vtkm/filter/PointAverage.hxx b/vtkm/filter/PointAverage.hxx index b441c8b6e..2bc0668e4 100644 --- a/vtkm/filter/PointAverage.hxx +++ b/vtkm/filter/PointAverage.hxx @@ -21,11 +21,10 @@ namespace filter //----------------------------------------------------------------------------- template -inline VTKM_CONT vtkm::cont::DataSet PointAverage::DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& inField, - const vtkm::filter::FieldMetadata& fieldMetadata, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet PointAverage::DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& inField, + const vtkm::filter::FieldMetadata& fieldMetadata, + vtkm::filter::PolicyBase policy) { if (!fieldMetadata.IsCellField()) { diff --git a/vtkm/filter/Threshold.cxx b/vtkm/filter/Threshold.cxx index 0efe2e40a..7e9bef692 100644 --- a/vtkm/filter/Threshold.cxx +++ b/vtkm/filter/Threshold.cxx @@ -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); } } diff --git a/vtkm/filter/Threshold.h b/vtkm/filter/Threshold.h index 121d35fb0..2c48e0418 100644 --- a/vtkm/filter/Threshold.h +++ b/vtkm/filter/Threshold.h @@ -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 +class VTKM_FILTER_COMMON_EXPORT Threshold : public vtkm::filter::FilterDataSetWithField { 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 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 diff --git a/vtkm/filter/Threshold.hxx b/vtkm/filter/Threshold.hxx index 8f26cbfc8..26dc0478e 100644 --- a/vtkm/filter/Threshold.hxx +++ b/vtkm/filter/Threshold.hxx @@ -58,11 +58,10 @@ namespace filter //----------------------------------------------------------------------------- template -inline VTKM_CONT vtkm::cont::DataSet Threshold::DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - vtkm::filter::PolicyBase policy) +vtkm::cont::DataSet Threshold::DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + vtkm::filter::PolicyBase policy) { //get the cells and coordinates of the dataset const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(); diff --git a/vtkm/filter/VectorMagnitude.cxx b/vtkm/filter/VectorMagnitude.cxx index ed15210bf..97dd2af36 100644 --- a/vtkm/filter/VectorMagnitude.cxx +++ b/vtkm/filter/VectorMagnitude.cxx @@ -25,6 +25,6 @@ VectorMagnitude::VectorMagnitude() } //----------------------------------------------------------------------------- -VTKM_FILTER_INSTANTIATE_EXECUTE_METHOD(VectorMagnitude); +VTKM_FILTER_EXTRA_INSTANTIATE_EXECUTE_METHOD(VectorMagnitude); } } diff --git a/vtkm/filter/VectorMagnitude.h b/vtkm/filter/VectorMagnitude.h index 63ab82963..cc08a9135 100644 --- a/vtkm/filter/VectorMagnitude.h +++ b/vtkm/filter/VectorMagnitude.h @@ -21,13 +21,12 @@ namespace vtkm namespace filter { -class VTKM_ALWAYS_EXPORT VectorMagnitude : public vtkm::filter::FilterField +class VTKM_FILTER_EXTRA_EXPORT VectorMagnitude : public vtkm::filter::FilterField { public: //currently the VectorMagnitude filter only works on vector data. using SupportedTypes = vtkm::TypeListVecCommon; - VTKM_FILTER_EXTRA_EXPORT VectorMagnitude(); template @@ -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 diff --git a/vtkm/filter/internal/ResolveFieldTypeAndExecute.h b/vtkm/filter/internal/ResolveFieldTypeAndExecute.h index 2aee447c0..767f658fd 100644 --- a/vtkm/filter/internal/ResolveFieldTypeAndExecute.h +++ b/vtkm/filter/internal/ResolveFieldTypeAndExecute.h @@ -24,7 +24,7 @@ namespace filter namespace internal { -struct ResolveFieldTypeAndExecute +struct VTKM_ALWAYS_EXPORT ResolveFieldTypeAndExecute { template +#include + +#include +#include +#include + +#include + +namespace +{ +std::vector points_rz = { 1.72485139f, 0.020562f, 1.73493571f, + 0.02052826f, 1.73478011f, 0.02299051f }; //really a vec +std::vector topology = { 0, 2, 1 }; +std::vector 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 pvalues(static_cast(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 cvalues(static_cast(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); +}