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

cmake: split vtkm_filter into common|extra|contour|gradient

Browse Source 
There is a limitation in Windows builds using VS2019 where libraries cannot be
bigger than 4GiB. This is normally not an issue but in `VTKm` due to its strong
template usage libraries can reach that size.

The `VTKm` filter library is can easily reach that size and it will halt the
build

This MR tries to avoid reaching those sizes for now by splitting the filter
library into four smaller libraries.

The proposal scheme is:

It splits vtkm-filter into:

  - vtkm-common, Classes that are dependencies of other filter libs.
  - vtkm-contour, Contour class and its instantiations.
  - vtkm-contour, Gradient class and its instantiations.
  - vtkm-extra, Classes other than Contour or Gradient that are
    not dependencies.

Signed-off-by: Vicente Adolfo Bolea Sanchez <vicente.bolea@kitware.com>
This commit is contained in:
Vicente Adolfo Bolea Sanchez 2020-08-19 19:20:43 -04:00
parent 62c2938b0e
commit afd394377e
29 changed files with 247 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
CMake/VTKmWrappers.cmake
View File

@ -66,7 +66,7 @@ function(vtkm_generate_export_header lib_name)
# Now generate a header that holds the macros needed to easily export
# template classes. This
string(TOUPPER ${kit_name} BASE_NAME_UPPER)
string(TOUPPER ${lib_name} BASE_NAME_UPPER)
set(EXPORT_MACRO_NAME "${BASE_NAME_UPPER}")
set(EXPORT_IS_BUILT_STATIC 0)
@ -81,17 +81,17 @@ function(vtkm_generate_export_header lib_name)
if(NOT EXPORT_IMPORT_CONDITION)
#set EXPORT_IMPORT_CONDITION to what the DEFINE_SYMBOL would be when
#building shared
set(EXPORT_IMPORT_CONDITION ${kit_name}_EXPORTS)
set(EXPORT_IMPORT_CONDITION ${lib_name}_EXPORTS)
endif()
configure_file(
${VTKm_SOURCE_DIR}/CMake/VTKmExportHeaderTemplate.h.in
${VTKm_BINARY_DIR}/include/${dir_prefix}/${kit_name}_export.h
${VTKm_BINARY_DIR}/include/${dir_prefix}/${lib_name}_export.h
@ONLY)
if(NOT VTKm_INSTALL_ONLY_LIBRARIES)
install(FILES ${VTKm_BINARY_DIR}/include/${dir_prefix}/${kit_name}_export.h
install(FILES ${VTKm_BINARY_DIR}/include/${dir_prefix}/${lib_name}_export.h
DESTINATION ${VTKm_INSTALL_INCLUDE_DIR}/${dir_prefix}
)
endif()

206
vtkm/filter/CMakeLists.txt
View File

@ -8,46 +8,74 @@
## PURPOSE. See the above copyright notice for more information.
##============================================================================
set(headers
set(common_headers
CellAverage.h
CellMeasures.h
CellSetConnectivity.h
CleanGrid.h
ExtractGeometry.h
ExtractPoints.h
ExtractStructured.h
FieldMetadata.h
FilterCell.h
FilterDataSet.h
FilterDataSetWithField.h
FilterField.h
Filter.h
FilterTraits.h
MapFieldMergeAverage.h
MapFieldPermutation.h
PolicyBase.h
PolicyDefault.h
PolicyExtrude.h
Threshold.h
ThresholdPoints.h
)
set(common_header_template_sources
CellAverage.hxx
CellMeasures.hxx
CleanGrid.hxx
ExtractGeometry.hxx
ExtractPoints.hxx
ExtractStructured.hxx
FilterDataSet.hxx
FilterDataSetWithField.hxx
FilterField.hxx
Filter.hxx
Threshold.hxx
ThresholdPoints.hxx
)
set(common_sources_device
CellAverage.cxx
CleanGrid.cxx
ExtractGeometry.cxx
ExtractStructured.cxx
MapFieldMergeAverage.cxx
MapFieldPermutation.cxx
Threshold.cxx
)
set(extra_headers
CellSetConnectivity.h
ClipWithField.h
ClipWithImplicitFunction.h
ComputeMoments.h
Contour.h
ContourTreeUniform.h
ContourTreeUniformAugmented.h
ContourTreeUniformDistributed.h
CoordinateSystemTransform.h
CreateResult.h
CrossProduct.h
DotProduct.h
Entropy.h
ExternalFaces.h
ExtractGeometry.h
ExtractPoints.h
ExtractStructured.h
FieldMetadata.h
FieldSelection.h
FieldToColors.h
Filter.h
FilterCell.h
FilterDataSet.h
FilterDataSetWithField.h
FilterField.h
FilterTraits.h
GhostCellClassify.h
GhostCellRemove.h
Gradient.h
Histogram.h
ImageConnectivity.h
ImageMedian.h
Lagrangian.h
LagrangianStructures.h
MapFieldMergeAverage.h
MapFieldPermutation.h
Mask.h
MaskPoints.h
MeshQuality.h
@ -58,17 +86,12 @@ set(headers
PointAverage.h
PointElevation.h
PointTransform.h
PolicyBase.h
PolicyDefault.h
PolicyExtrude.h
Probe.h
SplitSharpEdges.h
Streamline.h
StreamSurface.h
SurfaceNormals.h
Tetrahedralize.h
Threshold.h
ThresholdPoints.h
Triangulate.h
Tube.h
VectorMagnitude.h
@ -76,41 +99,26 @@ set(headers
WarpScalar.h
WarpVector.h
ZFPCompressor1D.h
ZFPDecompressor1D.h
ZFPCompressor2D.h
ZFPDecompressor2D.h
ZFPCompressor3D.h
ZFPDecompressor1D.h
ZFPDecompressor2D.h
ZFPDecompressor3D.h
)
)
set(header_template_sources
CellAverage.hxx
CellMeasures.hxx
set(extra_header_template_sources
CellSetConnectivity.hxx
CleanGrid.hxx
ClipWithField.hxx
ClipWithImplicitFunction.hxx
ComputeMoments.hxx
Contour.hxx
ContourTreeUniform.hxx
ContourTreeUniformAugmented.hxx
ContourTreeUniformDistributed.hxx
CoordinateSystemTransform.hxx
CrossProduct.hxx
DotProduct.hxx
Entropy.hxx
ExternalFaces.hxx
ExtractGeometry.hxx
ExtractPoints.hxx
ExtractStructured.hxx
FieldToColors.hxx
Filter.hxx
FilterDataSet.hxx
FilterDataSetWithField.hxx
FilterField.hxx
GhostCellClassify.hxx
GhostCellRemove.hxx
Gradient.hxx
Histogram.hxx
ImageConnectivity.hxx
ImageMedian.hxx
@ -132,8 +140,6 @@ set(header_template_sources
StreamSurface.hxx
SurfaceNormals.hxx
Tetrahedralize.hxx
Threshold.hxx
ThresholdPoints.hxx
Triangulate.hxx
Tube.hxx
VectorMagnitude.hxx
@ -141,50 +147,112 @@ set(header_template_sources
WarpScalar.hxx
WarpVector.hxx
ZFPCompressor1D.hxx
ZFPDecompressor1D.hxx
ZFPCompressor2D.hxx
ZFPDecompressor2D.hxx
ZFPCompressor3D.hxx
ZFPDecompressor1D.hxx
ZFPDecompressor2D.hxx
ZFPDecompressor3D.hxx
)
set(sources_device
CellAverage.cxx
CleanGrid.cxx
)
set(extra_sources_device
ClipWithField.cxx
ClipWithImplicitFunction.cxx
Contour.cxx
ContourInteger.cxx
ContourScalar.cxx
ExternalFaces.cxx
ExtractGeometry.cxx
ExtractStructured.cxx
GradientScalar.cxx
GradientUniformPoints.cxx
GradientVector.cxx
MapFieldMergeAverage.cxx
MapFieldPermutation.cxx
PointAverage.cxx
Threshold.cxx
VectorMagnitude.cxx
ExternalFaces.cxx
particleadvection/MemStream.cxx
particleadvection/Messenger.cxx
particleadvection/ParticleMessenger.cxx
)
set(contour_headers
Contour.h
ContourTreeUniformAugmented.h
ContourTreeUniformDistributed.h
ContourTreeUniform.h
)
set(contour_header_template_sources
Contour.hxx
ContourTreeUniformAugmented.hxx
ContourTreeUniformDistributed.hxx
ContourTreeUniform.hxx
)
set(contour_sources_device
Contour.cxx
ContourInteger.cxx
ContourScalar.cxx
)
set(gradient_headers
Gradient.h
)
set(gradient_header_template_sources
Gradient.hxx
)
set(gradient_sources_device
GradientScalar.cxx
GradientUniformPoints.cxx
GradientVector.cxx
)
set_source_files_properties(Contour.cxx ExtractStructured.cxx ClipWithField.cxx ClipWithImplicitFunction.cxx PROPERTIES SKIP_UNITY_BUILD_INCLUSION ON)
add_library(vtkm_filter INTERFACE)
vtkm_library(
NAME vtkm_filter
TEMPLATE_SOURCES ${header_template_sources}
HEADERS ${headers}
DEVICE_SOURCES ${sources_device}
NAME vtkm_filter_common
TEMPLATE_SOURCES ${common_header_template_sources}
HEADERS ${common_headers}
DEVICE_SOURCES ${common_sources_device}
USE_VTKM_JOB_POOL
)
target_link_libraries(vtkm_filter PUBLIC vtkm_worklet)
vtkm_library(
NAME vtkm_filter_extra
TEMPLATE_SOURCES ${extra_header_template_sources}
HEADERS ${extra_headers}
DEVICE_SOURCES ${extra_sources_device}
USE_VTKM_JOB_POOL
)
vtkm_library(
NAME vtkm_filter_contour
TEMPLATE_SOURCES ${contour_header_template_sources}
HEADERS ${contour_headers}
DEVICE_SOURCES ${contour_sources_device}
USE_VTKM_JOB_POOL
)
vtkm_library(
NAME vtkm_filter_gradient
TEMPLATE_SOURCES ${gradient_header_template_sources}
HEADERS ${gradient_headers}
DEVICE_SOURCES ${gradient_sources_device}
USE_VTKM_JOB_POOL
)
target_link_libraries(vtkm_filter_common PUBLIC vtkm_worklet)
target_link_libraries(vtkm_filter_extra PUBLIC vtkm_filter_common)
target_link_libraries(vtkm_filter_contour PUBLIC vtkm_filter_common)
target_link_libraries(vtkm_filter_gradient PUBLIC vtkm_filter_common)
if (VTKm_ENABLE_MPI)
target_link_libraries(vtkm_filter PUBLIC MPI::MPI_CXX)
target_link_libraries(vtkm_filter_common PUBLIC MPI::MPI_CXX)
target_link_libraries(vtkm_filter_extra PUBLIC MPI::MPI_CXX)
target_link_libraries(vtkm_filter_contour PUBLIC MPI::MPI_CXX)
target_link_libraries(vtkm_filter_gradient PUBLIC MPI::MPI_CXX)
endif()
target_link_libraries(vtkm_filter PUBLIC INTERFACE
vtkm_filter_extra
vtkm_filter_contour
vtkm_filter_gradient
vtkm_filter_common)
install(TARGETS vtkm_filter EXPORT ${VTKm_EXPORT_NAME})
add_subdirectory(internal)
add_subdirectory(particleadvection)

2
vtkm/filter/CellAverage.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_CellAverage_h
#define vtk_m_filter_CellAverage_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/filter/FilterField.h>

8
vtkm/filter/CleanGrid.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_CleanGrid_h
#define vtk_m_filter_CleanGrid_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
#include <vtkm/filter/FilterDataSet.h>
@ -40,7 +40,7 @@ namespace filter
class VTKM_ALWAYS_EXPORT CleanGrid : public vtkm::filter::FilterDataSet<CleanGrid>
{
public:
VTKM_FILTER_EXPORT
VTKM_FILTER_COMMON_EXPORT
CleanGrid();
/// When the CompactPointFields flag is true, the filter will identify any
@ -87,7 +87,7 @@ public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy);
VTKM_FILTER_EXPORT
VTKM_FILTER_COMMON_EXPORT
VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
@ -106,7 +106,7 @@ private:
bool RemoveDegenerateCells;
bool FastMerge;
VTKM_FILTER_EXPORT vtkm::cont::DataSet GenerateOutput(
VTKM_FILTER_COMMON_EXPORT vtkm::cont::DataSet GenerateOutput(
const vtkm::cont::DataSet& inData,
vtkm::cont::CellSetExplicit<>& outputCellSet);

2
vtkm/filter/ClipWithField.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_ClipWithField_h
#define vtk_m_filter_ClipWithField_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_extra_export.h>
#include <vtkm/filter/FilterDataSetWithField.h>
#include <vtkm/filter/MapFieldPermutation.h>

2
vtkm/filter/ClipWithImplicitFunction.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_ClipWithImplicitFunction_h
#define vtk_m_filter_ClipWithImplicitFunction_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_extra_export.h>
#include <vtkm/cont/ImplicitFunctionHandle.h>
#include <vtkm/filter/FilterDataSet.h>

12
vtkm/filter/Contour.cxx
View File

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

32
vtkm/filter/Contour.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_Contour_h
#define vtk_m_filter_Contour_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_contour_export.h>
#include <vtkm/filter/FilterDataSetWithField.h>
#include <vtkm/filter/MapFieldPermutation.h>
@ -34,25 +34,25 @@ class VTKM_ALWAYS_EXPORT Contour : public vtkm::filter::FilterDataSetWithField<C
public:
using SupportedTypes = vtkm::List<vtkm::UInt8, vtkm::Int8, vtkm::Float32, vtkm::Float64>;
VTKM_FILTER_EXPORT
VTKM_FILTER_CONTOUR_EXPORT
Contour();
VTKM_FILTER_EXPORT
VTKM_FILTER_CONTOUR_EXPORT
void SetNumberOfIsoValues(vtkm::Id num);
VTKM_FILTER_EXPORT
VTKM_FILTER_CONTOUR_EXPORT
vtkm::Id GetNumberOfIsoValues() const;
VTKM_FILTER_EXPORT
VTKM_FILTER_CONTOUR_EXPORT
void SetIsoValue(vtkm::Float64 v) { this->SetIsoValue(0, v); }
VTKM_FILTER_EXPORT
VTKM_FILTER_CONTOUR_EXPORT
void SetIsoValue(vtkm::Id index, vtkm::Float64);
VTKM_FILTER_EXPORT
VTKM_FILTER_CONTOUR_EXPORT
void SetIsoValues(const std::vector<vtkm::Float64>& values);
VTKM_FILTER_EXPORT
VTKM_FILTER_CONTOUR_EXPORT
vtkm::Float64 GetIsoValue(vtkm::Id index) const;
/// Set/Get whether the points generated should be unique for every triangle
@ -175,49 +175,49 @@ private:
#ifndef vtkm_filter_ContourExecute_cxx
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::UInt8>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::UInt8, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Int8>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Int8, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
extern template VTKM_FILTER_CONTOUR_TEMPLATE_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,

8
vtkm/filter/ContourInteger.cxx
View File

@ -17,25 +17,25 @@ namespace vtkm
{
namespace filter
{
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::UInt8>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::UInt8, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Int8>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Int8, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,

8
vtkm/filter/ContourScalar.cxx
View File

@ -17,25 +17,25 @@ namespace vtkm
{
namespace filter
{
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Contour::DoExecute(
template VTKM_FILTER_CONTOUR_EXPORT vtkm::cont::DataSet Contour::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,

13
vtkm/filter/ExternalFaces.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_ExternalFaces_h
#define vtk_m_filter_ExternalFaces_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_extra_export.h>
#include <vtkm/filter/CleanGrid.h>
#include <vtkm/filter/FilterDataSet.h>
@ -34,7 +34,7 @@ namespace filter
class VTKM_ALWAYS_EXPORT ExternalFaces : public vtkm::filter::FilterDataSet<ExternalFaces>
{
public:
VTKM_FILTER_EXPORT
VTKM_FILTER_EXTRA_EXPORT
ExternalFaces();
// When CompactPoints is set, instead of copying the points and point fields
@ -60,8 +60,8 @@ public:
VTKM_CONT 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);
VTKM_FILTER_EXTRA_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,
@ -75,8 +75,9 @@ private:
bool CompactPoints;
bool PassPolyData;
VTKM_FILTER_EXPORT vtkm::cont::DataSet GenerateOutput(const vtkm::cont::DataSet& input,
vtkm::cont::CellSetExplicit<>& outCellSet);
VTKM_FILTER_EXTRA_EXPORT vtkm::cont::DataSet GenerateOutput(
const vtkm::cont::DataSet& input,
vtkm::cont::CellSetExplicit<>& outCellSet);
vtkm::filter::CleanGrid Compactor;
vtkm::worklet::ExternalFaces Worklet;

6
vtkm/filter/ExtractGeometry.cxx
View File

@ -18,7 +18,7 @@ namespace filter
{
//-----------------------------------------------------------------------------
VTKM_FILTER_EXPORT ExtractGeometry::ExtractGeometry()
VTKM_FILTER_COMMON_EXPORT ExtractGeometry::ExtractGeometry()
: vtkm::filter::FilterDataSet<ExtractGeometry>()
, ExtractInside(true)
, ExtractBoundaryCells(false)
@ -26,8 +26,8 @@ VTKM_FILTER_EXPORT ExtractGeometry::ExtractGeometry()
{
}
VTKM_FILTER_EXPORT bool ExtractGeometry::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field)
VTKM_FILTER_COMMON_EXPORT bool ExtractGeometry::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field)
{
if (field.IsFieldPoint())
{

8
vtkm/filter/ExtractGeometry.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_ExtractGeometry_h
#define vtk_m_filter_ExtractGeometry_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
#include <vtkm/cont/ImplicitFunctionHandle.h>
#include <vtkm/filter/FilterDataSet.h>
@ -43,7 +43,7 @@ public:
//currently the ExtractGeometry filter only works on scalar data.
using SupportedTypes = TypeListScalarAll;
VTKM_FILTER_EXPORT VTKM_CONT ExtractGeometry();
VTKM_FILTER_COMMON_EXPORT VTKM_CONT ExtractGeometry();
// Set the volume of interest to extract
void SetImplicitFunction(const vtkm::cont::ImplicitFunctionHandle& func)
@ -84,8 +84,8 @@ public:
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field);
VTKM_FILTER_COMMON_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,

12
vtkm/filter/ExtractStructured.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_ExtractStructured_h
#define vtk_m_filter_ExtractStructured_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
#include <vtkm/filter/FilterDataSet.h>
#include <vtkm/worklet/ExtractStructured.h>
@ -39,7 +39,7 @@ namespace filter
class VTKM_ALWAYS_EXPORT ExtractStructured : public vtkm::filter::FilterDataSet<ExtractStructured>
{
public:
VTKM_FILTER_EXPORT
VTKM_FILTER_COMMON_EXPORT
ExtractStructured();
// Set the bounding box for the volume of interest
@ -87,8 +87,8 @@ public:
VTKM_CONT 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);
VTKM_FILTER_COMMON_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,
@ -99,8 +99,8 @@ public:
}
VTKM_FILTER_EXPORT VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet&,
vtkm::cont::PartitionedDataSet&);
VTKM_FILTER_COMMON_EXPORT VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet&,
vtkm::cont::PartitionedDataSet&);
template <typename DerivedPolicy>
VTKM_CONT void PostExecute(const vtkm::cont::PartitionedDataSet& input,

5
vtkm/filter/Filter.h
View File

@ -20,6 +20,7 @@
#include <vtkm/filter/FieldSelection.h>
#include <vtkm/filter/FilterTraits.h>
#include <vtkm/filter/PolicyBase.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
namespace vtkm
@ -304,11 +305,11 @@ private:
} // namespace vtkm::filter
#define VTKM_FILTER_EXPORT_EXECUTE_METHOD_WITH_POLICY(Name, Policy) \
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::PartitionedDataSet \
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) \
template VTKM_FILTER_EXPORT vtkm::cont::PartitionedDataSet Filter<Name>::Execute( \
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) \

20
vtkm/filter/Gradient.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_Gradient_h
#define vtk_m_filter_Gradient_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_gradient_export.h>
#include <vtkm/filter/FilterField.h>
@ -111,55 +111,55 @@ private:
#ifndef vtkm_filter_Gradient_cxx
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f_32>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
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::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f_64>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
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::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
extern template VTKM_FILTER_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
extern template VTKM_FILTER_GRADIENT_TEMPLATE_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagUniformPoints>&,
const vtkm::filter::FieldMetadata&,

8
vtkm/filter/GradientScalar.cxx
View File

@ -17,25 +17,25 @@ namespace vtkm
{
namespace filter
{
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float32, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Float64, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,

2
vtkm/filter/GradientUniformPoints.cxx
View File

@ -17,7 +17,7 @@ namespace vtkm
{
namespace filter
{
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f, vtkm::cont::StorageTagUniformPoints>&,
const vtkm::filter::FieldMetadata&,

8
vtkm/filter/GradientVector.cxx
View File

@ -17,25 +17,25 @@ namespace vtkm
{
namespace filter
{
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f_32>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f_32, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f_64>&,
const vtkm::filter::FieldMetadata&,
vtkm::filter::PolicyBase<vtkm::filter::PolicyDefault>);
template VTKM_FILTER_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
template VTKM_FILTER_GRADIENT_EXPORT vtkm::cont::DataSet Gradient::DoExecute(
const vtkm::cont::DataSet&,
const vtkm::cont::ArrayHandle<vtkm::Vec3f_64, vtkm::cont::StorageTagVirtual>&,
const vtkm::filter::FieldMetadata&,

6
vtkm/filter/MapFieldMergeAverage.h
View File

@ -17,7 +17,7 @@
#include <vtkm/worklet/Keys.h>
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
namespace vtkm
{
@ -41,7 +41,7 @@ namespace filter
/// `true`, then the results in `outputField` are valid. If it is `false`, then `outputField`
/// should not be used.
///
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldMergeAverage(
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldMergeAverage(
const vtkm::cont::Field& inputField,
const vtkm::worklet::internal::KeysBase& keys,
vtkm::cont::Field& outputField);
@ -63,7 +63,7 @@ VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldMergeAverage(
/// `true`, then `outputData` has the merged field. If it is `false`, then the field is not
/// placed in `outputData`.
///
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldMergeAverage(
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldMergeAverage(
const vtkm::cont::Field& inputField,
const vtkm::worklet::internal::KeysBase& keys,
vtkm::cont::DataSet& outputData);

18
vtkm/filter/MapFieldPermutation.cxx
View File

@ -72,10 +72,11 @@ struct DoMapFieldPermutation
} // anonymous namespace
bool vtkm::filter::MapFieldPermutation(const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::Field& outputField,
vtkm::Float64 invalidValue)
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool vtkm::filter::MapFieldPermutation(
const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::Field& outputField,
vtkm::Float64 invalidValue)
{
vtkm::cont::VariantArrayHandle outputArray;
DoMapFieldPermutation functor;
@ -92,10 +93,11 @@ bool vtkm::filter::MapFieldPermutation(const vtkm::cont::Field& inputField,
return functor.CalledMap;
}
bool vtkm::filter::MapFieldPermutation(const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::DataSet& outputData,
vtkm::Float64 invalidValue)
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool vtkm::filter::MapFieldPermutation(
const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::DataSet& outputData,
vtkm::Float64 invalidValue)
{
vtkm::cont::Field outputField;
bool success =

6
vtkm/filter/MapFieldPermutation.h
View File

@ -15,7 +15,7 @@
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Field.h>
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
namespace vtkm
{
@ -43,7 +43,7 @@ namespace filter
/// size of the array), then the resulting outputField will be given `invalidValue` (converted as
/// best as possible to the correct data type).
///
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldPermutation(
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldPermutation(
const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::Field& outputField,
@ -71,7 +71,7 @@ VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldPermutation(
/// size of the array), then the resulting outputField will be given `invalidValue` (converted as
/// best as possible to the correct data type).
///
VTKM_FILTER_EXPORT VTKM_CONT bool MapFieldPermutation(
VTKM_FILTER_COMMON_EXPORT VTKM_CONT bool MapFieldPermutation(
const vtkm::cont::Field& inputField,
const vtkm::cont::ArrayHandle<vtkm::Id>& permutation,
vtkm::cont::DataSet& outputData,

2
vtkm/filter/PointAverage.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_PointAverage_h
#define vtk_m_filter_PointAverage_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_extra_export.h>
#include <vtkm/cont/ArrayHandleUniformPointCoordinates.h>
#include <vtkm/cont/CellSetExtrude.h>

4
vtkm/filter/Threshold.cxx
View File

@ -17,8 +17,8 @@ namespace vtkm
namespace filter
{
VTKM_FILTER_EXPORT bool Threshold::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field)
VTKM_FILTER_COMMON_EXPORT bool Threshold::MapFieldOntoOutput(vtkm::cont::DataSet& result,
const vtkm::cont::Field& field)
{
if (field.IsFieldPoint() || field.IsFieldGlobal())
{

6
vtkm/filter/Threshold.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_Threshold_h
#define vtk_m_filter_Threshold_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_common_export.h>
#include <vtkm/filter/FilterDataSetWithField.h>
#include <vtkm/worklet/Threshold.h>
@ -53,8 +53,8 @@ public:
//Map a new field onto the resulting dataset after running the filter
//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);
VTKM_FILTER_COMMON_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,

4
vtkm/filter/VectorMagnitude.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_VectorMagnitude_h
#define vtk_m_filter_VectorMagnitude_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_extra_export.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/worklet/Magnitude.h>
@ -27,7 +27,7 @@ public:
//currently the VectorMagnitude filter only works on vector data.
using SupportedTypes = vtkm::TypeListVecCommon;
VTKM_FILTER_EXPORT
VTKM_FILTER_EXTRA_EXPORT
VectorMagnitude();
template <typename T, typename StorageType, typename DerivedPolicy>

2
vtkm/filter/particleadvection/MemStream.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_MemStream_h
#define vtk_m_filter_MemStream_h
#include <vtkm/filter/vtkm_filter_export.h>
#include <vtkm/filter/vtkm_filter_extra_export.h>
#include <cstring>
#include <iostream>

2
vtkm/filter/particleadvection/Messenger.h
View File

@ -31,7 +31,7 @@ namespace filter
namespace particleadvection
{
class VTKM_FILTER_EXPORT Messenger
class VTKM_FILTER_EXTRA_EXPORT Messenger
{
public:
VTKM_CONT Messenger(vtkmdiy::mpi::communicator& comm);

2
vtkm/filter/particleadvection/ParticleMessenger.h
View File

@ -27,7 +27,7 @@ namespace filter
namespace particleadvection
{
class VTKM_FILTER_EXPORT ParticleMessenger : public vtkm::filter::particleadvection::Messenger
class VTKM_FILTER_EXTRA_EXPORT ParticleMessenger : public vtkm::filter::particleadvection::Messenger
{
//sendRank, message
using MsgCommType = std::pair<int, std::vector<int>>;