Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-07-06 07:17:25 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Rename NewFilter base classes to Filter

Browse Source 
During the VTK-m 1.8 and 1.9 development, the filter infrastructure was
overhauled. Part of this created a completely new set of base classes. To
avoid confusion with the original filter base classes and ease transition,
the new filter base classes were named `NewFilter*`. Eventually after all
filters were transitioned, the old filter base classes were deprecated.

With the release of VTK-m 2.0, the old filter base classes are removed. The
"new" filter base classes are no longer new. Thus, they have been renamed
simply `Filter` (and `FilterField`).
This commit is contained in:
Kenneth Moreland 2022-12-01 13:07:56 -07:00
parent 3716f920e6
commit 405643ddbb
115 changed files with 278 additions and 276 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
docs/changelog/rename-filter-base.md Normal file
View File

@ -0,0 +1,11 @@
# Rename NewFilter base classes to Filter
During the VTK-m 1.8 and 1.9 development, the filter infrastructure was
overhauled. Part of this created a completely new set of base classes. To
avoid confusion with the original filter base classes and ease transition,
the new filter base classes were named `NewFilter*`. Eventually after all
filters were transitioned, the old filter base classes were deprecated.
With the release of VTK-m 2.0, the old filter base classes are removed. The
"new" filter base classes are no longer new. Thus, they have been renamed
simply `Filter` (and `FilterField`).

4
examples/game_of_life/GameOfLife.cxx
View File

@ -26,7 +26,7 @@
#include <vtkm/interop/TransferToOpenGL.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/worklet/WorkletPointNeighborhood.h>
#include <vtkm/cont/Invoker.h>
@ -95,7 +95,7 @@ struct UpdateLifeState : public vtkm::worklet::WorkletPointNeighborhood
};
class GameOfLife : public vtkm::filter::NewFilterField
class GameOfLife : public vtkm::filter::FilterField
{
public:
VTKM_CONT GameOfLife() { this->SetActiveField("state", vtkm::cont::Field::Association::Points); }

4
examples/hello_worklet/HelloWorklet.cxx
View File

@ -10,7 +10,7 @@
#include <vtkm/worklet/WorkletMapField.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/io/VTKDataSetReader.h>
#include <vtkm/io/VTKDataSetWriter.h>
@ -43,7 +43,7 @@ namespace vtkm
namespace filter
{
class HelloField : public vtkm::filter::NewFilterField
class HelloField : public vtkm::filter::FilterField
{
public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inDataSet)

2
examples/histogram/HistogramMPI.cxx
View File

@ -160,7 +160,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet HistogramMPI::DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& input)
{
this->PreExecute(input);
auto result = this->NewFilter::DoExecutePartitions(input);
auto result = this->Filter::DoExecutePartitions(input);
this->PostExecute(input, result);
return result;
}

4
examples/histogram/HistogramMPI.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_examples_histogram_HistogramMPI_h
#define vtk_m_examples_histogram_HistogramMPI_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
namespace example
{
@ -19,7 +19,7 @@ namespace example
///
/// Construct a HistogramMPI with a default of 10 bins.
///
class HistogramMPI : public vtkm::filter::NewFilterField
class HistogramMPI : public vtkm::filter::FilterField
{
public:
//currently the HistogramMPI filter only works on scalar data.

4
examples/multi_backend/MultiDeviceGradient.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_examples_multibackend_MultiDeviceGradient_h
#define vtk_m_examples_multibackend_MultiDeviceGradient_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include "TaskQueue.h"
@ -22,7 +22,7 @@ using RuntimeTaskQueue = TaskQueue<std::function<void()>>;
///
/// The Policy used with MultiDeviceGradient must include the TBB and CUDA
/// backends.
class MultiDeviceGradient : public vtkm::filter::NewFilterField
class MultiDeviceGradient : public vtkm::filter::FilterField
{
public:
//Construct a MultiDeviceGradient and worker pool

4
examples/redistribute_points/RedistributePoints.h
View File

@ -10,12 +10,12 @@
#ifndef example_RedistributePoints_h
#define example_RedistributePoints_h
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
namespace example
{
class RedistributePoints : public vtkm::filter::NewFilter
class RedistributePoints : public vtkm::filter::Filter
{
public:
VTKM_CONT RedistributePoints() {}

4
tutorial/extract_edges.cxx
View File

@ -20,9 +20,9 @@
#include <vtkm/io/VTKDataSetReader.h>
#include <vtkm/io/VTKDataSetWriter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/MapFieldMergeAverage.h>
#include <vtkm/filter/MapFieldPermutation.h>
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/contour/Contour.h>
#include <vtkm/worklet/WorkletMapTopology.h>
@ -149,7 +149,7 @@ VTKM_CONT bool DoMapField(
} // anonymous namespace
class ExtractEdges : public vtkm::filter::NewFilter
class ExtractEdges : public vtkm::filter::Filter
{
public:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;

4
tutorial/mag_grad.cxx
View File

@ -12,7 +12,7 @@
#include <vtkm/cont/Initialize.h>
#include <vtkm/cont/Invoker.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/vector_analysis/Gradient.h>
#include <vtkm/io/VTKDataSetReader.h>
#include <vtkm/io/VTKDataSetWriter.h>
@ -32,7 +32,7 @@ struct ComputeMagnitude : vtkm::worklet::WorkletMapField
// The filter class used by external code to run the algorithm. Normally the class definition
// is in a separate header file.
class FieldMagnitude : public vtkm::filter::NewFilterField
class FieldMagnitude : public vtkm::filter::FilterField
{
protected:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inDataSet) override;

4
tutorial/point_to_cell.cxx
View File

@ -46,14 +46,14 @@ struct ConvertPointFieldToCells : vtkm::worklet::WorkletVisitCellsWithPoints
} // namespace worklet
} // namespace vtkm
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
namespace vtkm
{
namespace filter
{
struct ConvertPointFieldToCells : vtkm::filter::NewFilterField
struct ConvertPointFieldToCells : vtkm::filter::FilterField
{
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inDataSet) override;
};

8
vtkm/filter/CMakeLists.txt
View File

@ -10,20 +10,20 @@
set(core_headers
FieldSelection.h
NewFilter.h
NewFilterField.h
Filter.h
FilterField.h
MapFieldMergeAverage.h
MapFieldPermutation.h
TaskQueue.h
)
set(core_sources
FieldSelection.cxx
NewFilterField.cxx
FilterField.cxx
)
set(core_sources_device
MapFieldMergeAverage.cxx
MapFieldPermutation.cxx
NewFilter.cxx
Filter.cxx
)
vtkm_library(

24
vtkm/filter/NewFilter.cxx → vtkm/filter/Filter.cxx
View File

@ -11,7 +11,7 @@
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/TaskQueue.h>
#include <future>
@ -23,9 +23,7 @@ namespace filter
namespace
{
void RunFilter(NewFilter* self,
vtkm::filter::DataSetQueue& input,
vtkm::filter::DataSetQueue& output)
void RunFilter(Filter* self, vtkm::filter::DataSetQueue& input, vtkm::filter::DataSetQueue& output)
{
auto& tracker = vtkm::cont::GetRuntimeDeviceTracker();
bool prevVal = tracker.GetThreadFriendlyMemAlloc();
@ -44,15 +42,15 @@ void RunFilter(NewFilter* self,
}
NewFilter::~NewFilter() = default;
Filter::~Filter() = default;
bool NewFilter::CanThread() const
bool Filter::CanThread() const
{
return true;
}
//----------------------------------------------------------------------------
vtkm::cont::PartitionedDataSet NewFilter::DoExecutePartitions(
vtkm::cont::PartitionedDataSet Filter::DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& input)
{
vtkm::cont::PartitionedDataSet output;
@ -91,22 +89,22 @@ vtkm::cont::PartitionedDataSet NewFilter::DoExecutePartitions(
return this->CreateResult(input, output);
}
vtkm::cont::DataSet NewFilter::Execute(const vtkm::cont::DataSet& input)
vtkm::cont::DataSet Filter::Execute(const vtkm::cont::DataSet& input)
{
return this->DoExecute(input);
}
vtkm::cont::PartitionedDataSet NewFilter::Execute(const vtkm::cont::PartitionedDataSet& input)
vtkm::cont::PartitionedDataSet Filter::Execute(const vtkm::cont::PartitionedDataSet& input)
{
VTKM_LOG_SCOPE(vtkm::cont::LogLevel::Perf,
"NewFilter (%d partitions): '%s'",
"Filter (%d partitions): '%s'",
(int)input.GetNumberOfPartitions(),
vtkm::cont::TypeToString<decltype(*this)>().c_str());
return this->DoExecutePartitions(input);
}
vtkm::cont::DataSet NewFilter::CreateResult(const vtkm::cont::DataSet& inDataSet) const
vtkm::cont::DataSet Filter::CreateResult(const vtkm::cont::DataSet& inDataSet) const
{
auto fieldMapper = [](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
out.AddField(fieldToPass);
@ -114,7 +112,7 @@ vtkm::cont::DataSet NewFilter::CreateResult(const vtkm::cont::DataSet& inDataSet
return this->CreateResult(inDataSet, inDataSet.GetCellSet(), fieldMapper);
}
vtkm::cont::PartitionedDataSet NewFilter::CreateResult(
vtkm::cont::PartitionedDataSet Filter::CreateResult(
const vtkm::cont::PartitionedDataSet& input,
const vtkm::cont::PartitionedDataSet& resultPartitions) const
{
@ -124,7 +122,7 @@ vtkm::cont::PartitionedDataSet NewFilter::CreateResult(
return this->CreateResult(input, resultPartitions, fieldMapper);
}
vtkm::Id NewFilter::DetermineNumberOfThreads(const vtkm::cont::PartitionedDataSet& input)
vtkm::Id Filter::DetermineNumberOfThreads(const vtkm::cont::PartitionedDataSet& input)
{
vtkm::Id numDS = input.GetNumberOfPartitions();

18
vtkm/filter/NewFilter.h → vtkm/filter/Filter.h
View File

@ -7,8 +7,8 @@
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_NewFilter_h
#define vtk_m_filter_NewFilter_h
#ifndef vtk_m_filter_Filter_h
#define vtk_m_filter_Filter_h
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/Field.h>
@ -79,7 +79,7 @@ namespace filter
/// In many uses cases, one subclasses one of the immediate subclasses of this class such as
/// FilterField, FilterParticleAdvection, etc. Those may impose additional constraints on the
/// methods to implement in the subclasses. Here, we describes the things to consider when directly
/// subclassing vtkm::filter::NewFilter.
/// subclassing vtkm::filter::Filter.
///
/// \subsection FilterExecution Execute
///
@ -103,7 +103,7 @@ namespace filter
/// it. If there are any errors, the subclass must throw an exception
/// (e.g. `vtkm::cont::ErrorFilterExecution`).
///
/// In this simple case, the NewFilter superclass handles iterating over multiple partitions in the
/// In this simple case, the Filter superclass handles iterating over multiple partitions in the
/// input PartitionedDataSet and calling `DoExecute(DataSet&)` iteratively.
///
/// The aforementioned approach is also suitable for filters that need special handling for
@ -117,7 +117,7 @@ namespace filter
/// const vtkm::cont::PartitionedDataSet& input)
/// {
/// // Do pre execute stuff, e.g. scattering to each DataSet
/// auto output = this->NewFilter::DoExecutePartitions(input);
/// auto output = this->Filter::DoExecutePartitions(input);
/// // Do post execute stuff, e.g gather/reduce from DataSets
/// return output;
/// }
@ -133,8 +133,8 @@ namespace filter
///
/// For subclasses that map input fields into output fields, the implementation of its
/// `DoExecute(DataSet&)` should create the `DataSet` to be returned with a call to
/// `NewFilter::CreateResult` or a similar method in a subclass (such as
/// `NewFilterField::CreateResultField`).
/// `Filter::CreateResult` or a similar method in a subclass (such as
/// `FilterField::CreateResultField`).
///
/// \code{cpp}
/// VTKM_CONT DataSet SomeFilter::DoExecute(const vtkm::cont::DataSet& input)
@ -215,11 +215,11 @@ namespace filter
/// Implementations of Filter subclass can also override
/// `DetermineNumberOfThreads()` to provide implementation specific heuristic.
///
class VTKM_FILTER_CORE_EXPORT NewFilter
class VTKM_FILTER_CORE_EXPORT Filter
{
public:
VTKM_CONT
virtual ~NewFilter();
virtual ~Filter();
VTKM_CONT
virtual bool CanThread() const;

8
vtkm/filter/NewFilterField.cxx → vtkm/filter/FilterField.cxx
View File

@ -7,15 +7,15 @@
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
namespace vtkm
{
namespace filter
{
vtkm::cont::DataSet NewFilterField::CreateResultField(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::Field& resultField) const
vtkm::cont::DataSet FilterField::CreateResultField(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::Field& resultField) const
{
vtkm::cont::DataSet outDataSet = this->CreateResult(inDataSet);
outDataSet.AddField(resultField);
@ -24,7 +24,7 @@ vtkm::cont::DataSet NewFilterField::CreateResultField(const vtkm::cont::DataSet&
return outDataSet;
}
void NewFilterField::ResizeIfNeeded(size_t index_st)
void FilterField::ResizeIfNeeded(size_t index_st)
{
if (this->ActiveFieldNames.size() <= index_st)
{

12
vtkm/filter/NewFilterField.h → vtkm/filter/FilterField.h
View File

@ -8,20 +8,20 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_NewFilterField_h
#define vtk_m_filter_NewFilterField_h
#ifndef vtk_m_filter_FilterField_h
#define vtk_m_filter_FilterField_h
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
namespace vtkm
{
namespace filter
{
class VTKM_FILTER_CORE_EXPORT NewFilterField : public vtkm::filter::NewFilter
class VTKM_FILTER_CORE_EXPORT FilterField : public vtkm::filter::Filter
{
public:
NewFilterField() { this->SetActiveCoordinateSystem(0); }
FilterField() { this->SetActiveCoordinateSystem(0); }
VTKM_CONT
void SetOutputFieldName(const std::string& name) { this->OutputFieldName = name; }
@ -300,4 +300,4 @@ private:
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_NewFilterField_h
#endif // vtk_m_filter_FilterField_h

4
vtkm/filter/clean_grid/CleanGrid.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_clean_grid_CleanGrid_h
#define vtk_m_filter_clean_grid_CleanGrid_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/clean_grid/vtkm_filter_clean_grid_export.h>
namespace vtkm
@ -37,7 +37,7 @@ struct SharedStates;
/// \todo Add a feature to merge points that are coincident or within a
/// tolerance.
///
class VTKM_FILTER_CLEAN_GRID_EXPORT CleanGrid : public vtkm::filter::NewFilterField
class VTKM_FILTER_CLEAN_GRID_EXPORT CleanGrid : public vtkm::filter::FilterField
{
public:
/// When the CompactPointFields flag is true, the filter will identify any

5
vtkm/filter/connected_components/CellSetConnectivity.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_connected_components_CellSetConnectivity_h
#define vtk_m_filter_connected_components_CellSetConnectivity_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/connected_components/vtkm_filter_connected_components_export.h>
namespace vtkm
@ -28,8 +28,7 @@ namespace connected_components
/// number of components and assigns each component a unique integer.
/// The result of the filter is a cell field of type vtkm::Id with the default name of 'component'.
/// Each entry in the cell field will be a number that identifies to which component the cell belongs.
class VTKM_FILTER_CONNECTED_COMPONENTS_EXPORT CellSetConnectivity
: public vtkm::filter::NewFilterField
class VTKM_FILTER_CONNECTED_COMPONENTS_EXPORT CellSetConnectivity : public vtkm::filter::FilterField
{
public:
VTKM_CONT CellSetConnectivity() { this->SetOutputFieldName("component"); }

5
vtkm/filter/connected_components/ImageConnectivity.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_connected_components_ImageConnectivity_h
#define vtk_m_filter_connected_components_ImageConnectivity_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/connected_components/vtkm_filter_connected_components_export.h>
/// \brief Groups connected points that have the same field value
@ -30,8 +30,7 @@ namespace filter
{
namespace connected_components
{
class VTKM_FILTER_CONNECTED_COMPONENTS_EXPORT ImageConnectivity
: public vtkm::filter::NewFilterField
class VTKM_FILTER_CONNECTED_COMPONENTS_EXPORT ImageConnectivity : public vtkm::filter::FilterField
{
public:
VTKM_CONT ImageConnectivity() { this->SetOutputFieldName("component"); }

4
vtkm/filter/contour/ClipWithField.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_contour_ClipWithField_h
#define vtk_m_filter_contour_ClipWithField_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/contour/vtkm_filter_contour_export.h>
namespace vtkm
@ -26,7 +26,7 @@ namespace contour
/// 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_FILTER_CONTOUR_EXPORT ClipWithField : public vtkm::filter::NewFilterField
class VTKM_FILTER_CONTOUR_EXPORT ClipWithField : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/contour/ClipWithImplicitFunction.h
View File

@ -12,7 +12,7 @@
#include <vtkm/ImplicitFunction.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/contour/vtkm_filter_contour_export.h>
namespace vtkm
@ -26,7 +26,7 @@ namespace contour
/// 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_FILTER_CONTOUR_EXPORT ClipWithImplicitFunction : public vtkm::filter::NewFilterField
class VTKM_FILTER_CONTOUR_EXPORT ClipWithImplicitFunction : public vtkm::filter::FilterField
{
public:
void SetImplicitFunction(const vtkm::ImplicitFunctionGeneral& func) { this->Function = func; }

4
vtkm/filter/contour/Contour.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_contour_Contour_h
#define vtk_m_filter_contour_Contour_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/contour/vtkm_filter_contour_export.h>
namespace vtkm
@ -27,7 +27,7 @@ namespace contour
/// Multiple contour values must be specified to generate the isosurfaces.
/// @warning
/// This filter is currently only supports 3D volumes.
class VTKM_FILTER_CONTOUR_EXPORT Contour : public vtkm::filter::NewFilterField
class VTKM_FILTER_CONTOUR_EXPORT Contour : public vtkm::filter::FilterField
{
public:
void SetNumberOfIsoValues(vtkm::Id num)

4
vtkm/filter/contour/MIRFilter.h
View File

@ -11,7 +11,7 @@
#ifndef vtkm_m_filter_contour_MIRFilter_h
#define vtkm_m_filter_contour_MIRFilter_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/contour/vtkm_filter_contour_export.h>
namespace vtkm
@ -48,7 +48,7 @@ namespace contour
/// total error % of the entire dataset is less than the specified amount (defaults to 1.0, returns after first iteration). Finally,
/// the error scaling and scaling decay allows for setting how much the cell VFs should react to the delta between target and calculated cell VFs.
/// the error scaling will decay by the decay variable every iteration (multiplicitively).
class VTKM_FILTER_CONTOUR_EXPORT MIRFilter : public vtkm::filter::NewFilterField
class VTKM_FILTER_CONTOUR_EXPORT MIRFilter : public vtkm::filter::FilterField
{
public:
/// @brief Sets the name of the offset/position cellset field in the dataset passed to the filter

4
vtkm/filter/density_estimate/Entropy.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_density_estimate_Entropy_h
#define vtk_m_filter_density_estimate_Entropy_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
@ -24,7 +24,7 @@ namespace density_estimate
///
/// Construct a histogram which is used to compute the entropy with a default of 10 bins
///
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT Entropy : public vtkm::filter::NewFilterField
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT Entropy : public vtkm::filter::FilterField
{
public:
//currently the Entropy filter only works on scalar data.

2
vtkm/filter/density_estimate/Histogram.cxx
View File

@ -225,7 +225,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet Histogram::DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& input)
{
this->PreExecute(input);
auto result = this->NewFilter::DoExecutePartitions(input);
auto result = this->Filter::DoExecutePartitions(input);
this->PostExecute(input, result);
return result;
}

4
vtkm/filter/density_estimate/Histogram.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_density_estimate_Histogram_h
#define vtk_m_filter_density_estimate_Histogram_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
@ -24,7 +24,7 @@ namespace density_estimate
///
/// Construct a histogram with a default of 10 bins.
///
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT Histogram : public vtkm::filter::NewFilterField
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT Histogram : public vtkm::filter::FilterField
{
public:
//Construct a histogram with a default of 10 bins

4
vtkm/filter/density_estimate/NDEntropy.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_density_estimate_NDEntropy_h
#define vtk_m_filter_density_estimate_NDEntropy_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
@ -23,7 +23,7 @@ namespace density_estimate
///
/// This filter calculate the entropy of input N-Dims fields.
///
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT NDEntropy : public vtkm::filter::NewFilterField
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT NDEntropy : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/density_estimate/NDHistogram.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_density_estimate_NDHistogram_h
#define vtk_m_filter_density_estimate_NDHistogram_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
@ -31,7 +31,7 @@ namespace density_estimate
/// The first three numbers are binIDs for FieldA, FieldB and FieldC. Frequency[i] stores
/// the frequency for this bin (FieldA[i], FieldB[i], FieldC[i]).
///
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT NDHistogram : public vtkm::filter::NewFilterField
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT NDHistogram : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/density_estimate/ParticleDensityBase.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_density_estimate_ParticleDensityBase_h
#define vtk_m_filter_density_estimate_ParticleDensityBase_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/density_estimate/vtkm_filter_density_estimate_export.h>
namespace vtkm
@ -20,7 +20,7 @@ namespace filter
{
namespace density_estimate
{
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT ParticleDensityBase : public vtkm::filter::NewFilterField
class VTKM_FILTER_DENSITY_ESTIMATE_EXPORT ParticleDensityBase : public vtkm::filter::FilterField
{
protected:
ParticleDensityBase() = default;

4
vtkm/filter/entity_extraction/ExternalFaces.h
View File

@ -11,7 +11,7 @@
#ifndef vtkm_filter_entity_extraction_ExternalFaces_h
#define vtkm_filter_entity_extraction_ExternalFaces_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -32,7 +32,7 @@ namespace entity_extraction
/// @warning
/// This filter is currently only supports propagation of point properties
///
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ExternalFaces : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ExternalFaces : public vtkm::filter::FilterField
{
public:
ExternalFaces();

4
vtkm/filter/entity_extraction/ExtractGeometry.h
View File

@ -12,7 +12,7 @@
#define vtk_m_fulter_entity_extraction_ExtractGeometry_h
#include <vtkm/ImplicitFunction.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -36,7 +36,7 @@ namespace entity_extraction
/// 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_FILTER_ENTITY_EXTRACTION_EXPORT ExtractGeometry : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ExtractGeometry : public vtkm::filter::FilterField
{
public:
// Set the volume of interest to extract

4
vtkm/filter/entity_extraction/ExtractPoints.h
View File

@ -13,7 +13,7 @@
#include <vtkm/ImplicitFunction.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -31,7 +31,7 @@ namespace entity_extraction
/// Note that while any geometry type can be provided as input, the output is
/// represented by an explicit representation of points using
/// vtkm::cont::CellSetSingleType
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ExtractPoints : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ExtractPoints : public vtkm::filter::FilterField
{
public:
/// When CompactPoints is set, instead of copying the points and point fields

4
vtkm/filter/entity_extraction/ExtractStructured.h
View File

@ -12,7 +12,7 @@
#define vtk_m_filter_entity_extraction_ExtractStructured_h
#include <vtkm/RangeId3.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -37,7 +37,7 @@ namespace entity_extraction
/// for image processing, subsampling large volumes to reduce data size, or
/// extracting regions of a volume with interesting data.
///
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ExtractStructured : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ExtractStructured : public vtkm::filter::FilterField
{
public:
// Set the bounding box for the volume of interest

4
vtkm/filter/entity_extraction/GhostCellRemove.h
View File

@ -12,7 +12,7 @@
#define vtk_m_filter_entity_extraction_GhostCellRemove_h
#include <vtkm/CellClassification.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -23,7 +23,7 @@ namespace entity_extraction
{
/// \brief Removes ghost cells
///
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT GhostCellRemove : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT GhostCellRemove : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/entity_extraction/Mask.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_entity_extraction_Mask_h
#define vtk_m_filter_entity_extraction_Mask_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -23,7 +23,7 @@ namespace entity_extraction
/// \brief Subselect cells using a stride
///
/// Extract only every Nth cell where N is equal to a stride value
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT Mask : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT Mask : public vtkm::filter::FilterField
{
public:
// When CompactPoints is set, instead of copying the points and point fields

4
vtkm/filter/entity_extraction/MaskPoints.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_entity_extraction_MaskPoints_h
#define vtk_m_filter_entity_extraction_MaskPoints_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -23,7 +23,7 @@ namespace entity_extraction
/// \brief Subselect points using a stride
///
/// Extract only every Nth point where N is equal to a stride value
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT MaskPoints : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT MaskPoints : public vtkm::filter::FilterField
{
public:
// When CompactPoints is set, instead of copying the points and point fields

4
vtkm/filter/entity_extraction/Threshold.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_entity_extraction_Threshold_h
#define vtk_m_filter_entity_extraction_Threshold_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -26,7 +26,7 @@ namespace entity_extraction
/// The output of this filter is an permutation of the input dataset.
///
/// You can threshold either on point or cell fields
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT Threshold : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT Threshold : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/entity_extraction/ThresholdPoints.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_entity_extraction_ThresholdPoints_h
#define vtk_m_filter_entity_extraction_ThresholdPoints_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
namespace vtkm
@ -20,7 +20,7 @@ namespace filter
{
namespace entity_extraction
{
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ThresholdPoints : public vtkm::filter::NewFilterField
class VTKM_FILTER_ENTITY_EXTRACTION_EXPORT ThresholdPoints : public vtkm::filter::FilterField
{
public:
// When CompactPoints is set, instead of copying the points and point fields

4
vtkm/filter/field_conversion/CellAverage.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_field_conversion_CellAverage_h
#define vtk_m_filter_field_conversion_CellAverage_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_conversion/vtkm_filter_field_conversion_export.h>
namespace vtkm
@ -27,7 +27,7 @@ namespace field_conversion
/// The method of transformation is based on averaging the data
/// values of all points used by particular cell.
///
class VTKM_FILTER_FIELD_CONVERSION_EXPORT CellAverage : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_CONVERSION_EXPORT CellAverage : public vtkm::filter::FilterField
{
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;

4
vtkm/filter/field_conversion/PointAverage.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_field_conversion_PointAverage_h
#define vtk_m_filter_field_conversion_PointAverage_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_conversion/vtkm_filter_field_conversion_export.h>
namespace vtkm
@ -26,7 +26,7 @@ namespace field_conversion
/// 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_FILTER_FIELD_CONVERSION_EXPORT PointAverage : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_CONVERSION_EXPORT PointAverage : public vtkm::filter::FilterField
{
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;

4
vtkm/filter/field_transform/CylindricalCoordinateTransform.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_field_transform_CylindricalCoordinateTransform_h
#define vtk_m_filter_field_transform_CylindricalCoordinateTransform_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -24,7 +24,7 @@ namespace field_transform
///
/// Generate a coordinate transformation on coordinates from a dataset.
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT CylindricalCoordinateTransform
: public vtkm::filter::NewFilterField
: public vtkm::filter::FilterField
{
public:
VTKM_CONT CylindricalCoordinateTransform();

4
vtkm/filter/field_transform/FieldToColors.h
View File

@ -12,7 +12,7 @@
#define vtk_m_filter_field_transform_FieldToColors_h
#include <vtkm/cont/ColorTable.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -23,7 +23,7 @@ namespace field_transform
{
/// \brief Convert an arbitrary field to an RGB or RGBA field
///
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT FieldToColors : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT FieldToColors : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/field_transform/GenerateIds.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_field_transform_GenerateIds_h
#define vtk_m_filter_field_transform_GenerateIds_h
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -28,7 +28,7 @@ namespace field_transform
/// convenient for adding indices to operations designed for fields and generally
/// creating test data.
///
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT GenerateIds : public vtkm::filter::NewFilter
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT GenerateIds : public vtkm::filter::Filter
{
std::string PointFieldName = "pointids";
std::string CellFieldName = "cellids";

6
vtkm/filter/field_transform/LogValues.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_field_transform_LogValues_h
#define vtk_m_filter_field_transform_LogValues_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -22,9 +22,9 @@ namespace field_transform
/// \brief Adds field to a `DataSet` that gives the log values for the user specified field.
///
/// This filter use the ActiveField defined in the NewFilterField to store the log values.
/// This filter use the ActiveField defined in the FilterField to store the log values.
///
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT LogValues : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT LogValues : public vtkm::filter::FilterField
{
public:
enum struct LogBase

4
vtkm/filter/field_transform/PointElevation.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_field_transform_PointElevation_h
#define vtk_m_filter_field_transform_PointElevation_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -27,7 +27,7 @@ namespace field_transform
/// are generated by computing a projection of each dataset point onto
/// a line. The line can be oriented arbitrarily. A typical example is
/// to generate scalars based on elevation or height above a plane.
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT PointElevation : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT PointElevation : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/field_transform/PointTransform.h
View File

@ -14,7 +14,7 @@
#include <vtkm/Matrix.h>
#include <vtkm/Transform3D.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -26,7 +26,7 @@ namespace field_transform
/// \brief
///
/// Generate scalar field from a dataset.
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT PointTransform : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT PointTransform : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/field_transform/SphericalCoordinateTransform.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_field_transform_SphericalCoordinateTransform_h
#define vtk_m_filter_field_transform_SphericalCoordinateTransform_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -22,7 +22,7 @@ namespace field_transform
{
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT SphericalCoordinateTransform
: public vtkm::filter::NewFilterField
: public vtkm::filter::FilterField
{
public:
VTKM_CONT SphericalCoordinateTransform();

4
vtkm/filter/field_transform/WarpScalar.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_field_transform_WarpScalar_h
#define vtk_m_filter_field_transform_WarpScalar_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -28,7 +28,7 @@ namespace field_transform
/// It's a VTK-m version of the vtkWarpScalar in VTK.
/// Useful for creating carpet or x-y-z plots.
/// It doesn't modify the point coordinates, but creates a new point coordinates that have been warped.
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT WarpScalar : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT WarpScalar : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/field_transform/WarpVector.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_field_transform_WarpVector_h
#define vtk_m_filter_field_transform_WarpVector_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
@ -28,7 +28,7 @@ namespace field_transform
/// Useful for showing flow profiles or mechanical deformation.
/// This worklet does not modify the input points but generate new point
/// coordinate instance that has been warped.
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT WarpVector : public vtkm::filter::NewFilterField
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT WarpVector : public vtkm::filter::FilterField
{
public:
VTKM_CONT

12
vtkm/filter/flow/CMakeLists.txt
View File

@ -9,10 +9,10 @@
##============================================================================
set(flow_headers
FilterParticleAdvection.h
FilterParticleAdvectionSteadyState.h
FilterParticleAdvectionUnsteadyState.h
FlowTypes.h
NewFilterParticleAdvection.h
NewFilterParticleAdvectionSteadyState.h
NewFilterParticleAdvectionUnsteadyState.h
Lagrangian.h
LagrangianStructures.h
ParticleAdvection.h
@ -24,7 +24,7 @@ set(flow_headers
set(flow_sources
internal/Messenger.cxx
NewFilterParticleAdvection.cxx
FilterParticleAdvection.cxx
ParticleAdvection.cxx
Pathline.cxx
PathParticle.cxx
@ -34,8 +34,8 @@ set(flow_sources
set(flow_device_sources
Lagrangian.cxx
LagrangianStructures.cxx
NewFilterParticleAdvectionSteadyState.cxx
NewFilterParticleAdvectionUnsteadyState.cxx
FilterParticleAdvectionSteadyState.cxx
FilterParticleAdvectionUnsteadyState.cxx
StreamSurface.cxx
)

7
vtkm/filter/flow/NewFilterParticleAdvection.cxx → vtkm/filter/flow/FilterParticleAdvection.cxx
View File

@ -11,7 +11,7 @@
#include <vtkm/Particle.h>
#include <vtkm/cont/ErrorFilterExecution.h>
#include <vtkm/filter/flow/NewFilterParticleAdvection.h>
#include <vtkm/filter/flow/FilterParticleAdvection.h>
namespace vtkm
{
@ -20,8 +20,7 @@ namespace filter
namespace flow
{
VTKM_CONT vtkm::cont::DataSet NewFilterParticleAdvection::DoExecute(
const vtkm::cont::DataSet& inData)
VTKM_CONT vtkm::cont::DataSet FilterParticleAdvection::DoExecute(const vtkm::cont::DataSet& inData)
{
auto out = this->DoExecutePartitions(inData);
if (out.GetNumberOfPartitions() != 1)
@ -30,7 +29,7 @@ VTKM_CONT vtkm::cont::DataSet NewFilterParticleAdvection::DoExecute(
return out.GetPartition(0);
}
VTKM_CONT void NewFilterParticleAdvection::ValidateOptions() const
VTKM_CONT void FilterParticleAdvection::ValidateOptions() const
{
if (this->GetUseCoordinateSystemAsField())
throw vtkm::cont::ErrorFilterExecution("Coordinate system as field not supported");

10
vtkm/filter/flow/NewFilterParticleAdvection.h → vtkm/filter/flow/FilterParticleAdvection.h
View File

@ -8,11 +8,11 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_flow_NewFilterParticleAdvection_h
#define vtk_m_filter_flow_NewFilterParticleAdvection_h
#ifndef vtk_m_filter_flow_FilterParticleAdvection_h
#define vtk_m_filter_flow_FilterParticleAdvection_h
#include <vtkm/Particle.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
@ -28,7 +28,7 @@ namespace flow
/// Takes as input a vector field and seed locations and advects the seeds
/// through the flow field.
class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvection : public vtkm::filter::NewFilterField
class VTKM_FILTER_FLOW_EXPORT FilterParticleAdvection : public vtkm::filter::FilterField
{
public:
VTKM_CONT
@ -107,4 +107,4 @@ private:
}
} // namespace vtkm::filter::flow
#endif // vtk_m_filter_flow_NewFilterParticleAdvection_h
#endif // vtk_m_filter_flow_FilterParticleAdvection_h

4
vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.cxx → vtkm/filter/flow/FilterParticleAdvectionSteadyState.cxx
View File

@ -8,7 +8,7 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
#include <vtkm/filter/flow/FilterParticleAdvectionSteadyState.h>
#include <vtkm/filter/flow/internal/DataSetIntegratorSteadyState.h>
#include <vtkm/filter/flow/internal/BoundsMap.h>
@ -62,7 +62,7 @@ CreateDataSetIntegrators(
} //anonymous namespace
VTKM_CONT vtkm::cont::PartitionedDataSet NewFilterParticleAdvectionSteadyState::DoExecutePartitions(
VTKM_CONT vtkm::cont::PartitionedDataSet FilterParticleAdvectionSteadyState::DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& input)
{
using DSIType = vtkm::filter::flow::internal::DataSetIntegratorSteadyState;

11
vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h → vtkm/filter/flow/FilterParticleAdvectionSteadyState.h
View File

@ -8,11 +8,11 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
#define vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
#ifndef vtk_m_filter_flow_FilterParticleAdvectionSteadyState_h
#define vtk_m_filter_flow_FilterParticleAdvectionSteadyState_h
#include <vtkm/filter/flow/FilterParticleAdvection.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/NewFilterParticleAdvection.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
namespace vtkm
@ -21,8 +21,7 @@ namespace filter
{
namespace flow
{
class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionSteadyState
: public NewFilterParticleAdvection
class VTKM_FILTER_FLOW_EXPORT FilterParticleAdvectionSteadyState : public FilterParticleAdvection
{
private:
VTKM_CONT vtkm::cont::PartitionedDataSet DoExecutePartitions(
@ -33,4 +32,4 @@ private:
}
} // namespace vtkm::filter::flow
#endif // vtk_m_filter_flow_NewFilterParticleAdvectionSteadyState_h
#endif // vtk_m_filter_flow_FilterParticleAdvectionSteadyState_h

9
vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.cxx → vtkm/filter/flow/FilterParticleAdvectionUnsteadyState.cxx
View File

@ -8,7 +8,7 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
#include <vtkm/filter/flow/FilterParticleAdvectionUnsteadyState.h>
#include <vtkm/filter/flow/internal/DataSetIntegratorUnsteadyState.h>
#include <vtkm/filter/flow/internal/ParticleAdvector.h>
@ -51,15 +51,14 @@ CreateDataSetIntegrators(const vtkm::cont::PartitionedDataSet& input,
}
} // anonymous namespace
VTKM_CONT void NewFilterParticleAdvectionUnsteadyState::ValidateOptions() const
VTKM_CONT void FilterParticleAdvectionUnsteadyState::ValidateOptions() const
{
this->NewFilterParticleAdvection::ValidateOptions();
this->FilterParticleAdvection::ValidateOptions();
if (this->Time1 >= this->Time2)
throw vtkm::cont::ErrorFilterExecution("PreviousTime must be less than NextTime");
}
VTKM_CONT vtkm::cont::PartitionedDataSet
NewFilterParticleAdvectionUnsteadyState::DoExecutePartitions(
VTKM_CONT vtkm::cont::PartitionedDataSet FilterParticleAdvectionUnsteadyState::DoExecutePartitions(
const vtkm::cont::PartitionedDataSet& input)
{
using DSIType = vtkm::filter::flow::internal::DataSetIntegratorUnsteadyState;

11
vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h → vtkm/filter/flow/FilterParticleAdvectionUnsteadyState.h
View File

@ -8,10 +8,10 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
#define vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
#ifndef vtk_m_filter_flow_FilterParticleAdvectionUnsteadyState_h
#define vtk_m_filter_flow_FilterParticleAdvectionUnsteadyState_h
#include <vtkm/filter/flow/NewFilterParticleAdvection.h>
#include <vtkm/filter/flow/FilterParticleAdvection.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
namespace vtkm
@ -21,8 +21,7 @@ namespace filter
namespace flow
{
class VTKM_FILTER_FLOW_EXPORT NewFilterParticleAdvectionUnsteadyState
: public NewFilterParticleAdvection
class VTKM_FILTER_FLOW_EXPORT FilterParticleAdvectionUnsteadyState : public FilterParticleAdvection
{
public:
VTKM_CONT void SetPreviousTime(vtkm::FloatDefault t1) { this->Time1 = t1; }
@ -49,4 +48,4 @@ private:
}
} // namespace vtkm::filter::flow
#endif // vtk_m_filter_flow_NewFilterParticleAdvectionUnsteadyState_h
#endif // vtk_m_filter_flow_FilterParticleAdvectionUnsteadyState_h

4
vtkm/filter/flow/Lagrangian.h
View File

@ -12,7 +12,7 @@
#define vtk_m_filter_flow_Lagrangian_h
#include <vtkm/Particle.h>
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
namespace vtkm
@ -22,7 +22,7 @@ namespace filter
namespace flow
{
class VTKM_FILTER_FLOW_EXPORT Lagrangian : public vtkm::filter::NewFilterField
class VTKM_FILTER_FLOW_EXPORT Lagrangian : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/flow/LagrangianStructures.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_flow_LagrangianStructures_h
#define vtk_m_filter_flow_LagrangianStructures_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
@ -22,7 +22,7 @@ namespace filter
namespace flow
{
class VTKM_FILTER_FLOW_EXPORT LagrangianStructures : public vtkm::filter::NewFilterField
class VTKM_FILTER_FLOW_EXPORT LagrangianStructures : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/flow/ParticleAdvection.h
View File

@ -11,8 +11,8 @@
#ifndef vtk_m_filter_flow_ParticleAdvection_h
#define vtk_m_filter_flow_ParticleAdvection_h
#include <vtkm/filter/flow/FilterParticleAdvectionSteadyState.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
namespace vtkm
@ -28,7 +28,7 @@ namespace flow
/// end points for each seed through the vector field.
class VTKM_FILTER_FLOW_EXPORT ParticleAdvection
: public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
: public vtkm::filter::flow::FilterParticleAdvectionSteadyState
{
public:
private:

4
vtkm/filter/flow/PathParticle.h
View File

@ -11,8 +11,8 @@
#ifndef vtk_m_filter_flow_PathParticle_h
#define vtk_m_filter_flow_PathParticle_h
#include <vtkm/filter/flow/FilterParticleAdvectionUnsteadyState.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
namespace vtkm
@ -28,7 +28,7 @@ namespace flow
/// end points for each seed through the vector field.
class VTKM_FILTER_FLOW_EXPORT PathParticle
: public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
: public vtkm::filter::flow::FilterParticleAdvectionUnsteadyState
{
private:
VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override;

4
vtkm/filter/flow/Pathline.h
View File

@ -11,8 +11,8 @@
#ifndef vtk_m_filter_flow_Pathline_h
#define vtk_m_filter_flow_Pathline_h
#include <vtkm/filter/flow/FilterParticleAdvectionUnsteadyState.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/NewFilterParticleAdvectionUnsteadyState.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
namespace vtkm
@ -28,7 +28,7 @@ namespace flow
/// end points for each seed through the vector field.
class VTKM_FILTER_FLOW_EXPORT Pathline
: public vtkm::filter::flow::NewFilterParticleAdvectionUnsteadyState
: public vtkm::filter::flow::FilterParticleAdvectionUnsteadyState
{
private:
VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override;

4
vtkm/filter/flow/StreamSurface.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_flow_StreamSurface_h
#define vtk_m_filter_flow_StreamSurface_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
@ -27,7 +27,7 @@ namespace flow
/// Takes as input a vector field and seed locations and generates the
/// paths taken by the seeds through the vector field.
class VTKM_FILTER_FLOW_EXPORT StreamSurface : public vtkm::filter::NewFilterField
class VTKM_FILTER_FLOW_EXPORT StreamSurface : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/flow/Streamline.h
View File

@ -11,8 +11,8 @@
#ifndef vtk_m_filter_flow_Streamline_h
#define vtk_m_filter_flow_Streamline_h
#include <vtkm/filter/flow/FilterParticleAdvectionSteadyState.h>
#include <vtkm/filter/flow/FlowTypes.h>
#include <vtkm/filter/flow/NewFilterParticleAdvectionSteadyState.h>
#include <vtkm/filter/flow/vtkm_filter_flow_export.h>
namespace vtkm
@ -28,7 +28,7 @@ namespace flow
/// end points for each seed through the vector field.
class VTKM_FILTER_FLOW_EXPORT Streamline
: public vtkm::filter::flow::NewFilterParticleAdvectionSteadyState
: public vtkm::filter::flow::FilterParticleAdvectionSteadyState
{
private:
VTKM_CONT vtkm::filter::flow::FlowResultType GetResultType() const override;

4
vtkm/filter/geometry_refinement/SplitSharpEdges.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_geometry_refinement_SplitSharpEdges_h
#define vtk_m_filter_geometry_refinement_SplitSharpEdges_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/geometry_refinement/vtkm_filter_geometry_refinement_export.h>
namespace vtkm
@ -33,7 +33,7 @@ namespace geometry_refinement
/// to (5,4,3).
/// By default, all old point's fields would be copied to the new point.
/// Use with caution.
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT SplitSharpEdges : public vtkm::filter::NewFilterField
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT SplitSharpEdges : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/geometry_refinement/Tetrahedralize.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_geometry_refinement_Tetrahedralize_h
#define vtk_m_filter_geometry_refinement_Tetrahedralize_h
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/geometry_refinement/vtkm_filter_geometry_refinement_export.h>
namespace vtkm
@ -20,7 +20,7 @@ namespace filter
{
namespace geometry_refinement
{
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Tetrahedralize : public vtkm::filter::NewFilter
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Tetrahedralize : public vtkm::filter::Filter
{
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};

4
vtkm/filter/geometry_refinement/Triangulate.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_geometry_refinement_Triangulate_h
#define vtk_m_filter_geometry_refinement_Triangulate_h
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/geometry_refinement/vtkm_filter_geometry_refinement_export.h>
namespace vtkm
@ -20,7 +20,7 @@ namespace filter
{
namespace geometry_refinement
{
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Triangulate : public vtkm::filter::NewFilter
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Triangulate : public vtkm::filter::Filter
{
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};

4
vtkm/filter/geometry_refinement/Tube.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_geometry_refinement_Tube_h
#define vtk_m_filter_geometry_refinement_Tube_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/geometry_refinement/vtkm_filter_geometry_refinement_export.h>
namespace vtkm
@ -25,7 +25,7 @@ namespace geometry_refinement
/// Takes as input a set of polylines, radius, num sides and capping flag.
/// Produces tubes along each polyline
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Tube : public vtkm::filter::NewFilterField
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Tube : public vtkm::filter::FilterField
{
public:
VTKM_CONT

4
vtkm/filter/geometry_refinement/VertexClustering.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_geometry_refinement_VertexClustering_h
#define vtk_m_filter_geometry_refinement_VertexClustering_h
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/geometry_refinement/vtkm_filter_geometry_refinement_export.h>
namespace vtkm
@ -48,7 +48,7 @@ namespace geometry_refinement
/// @warning
/// This filter currently doesn't propagate cell or point fields
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT VertexClustering : public vtkm::filter::NewFilter
class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT VertexClustering : public vtkm::filter::Filter
{
public:
VTKM_CONT

4
vtkm/filter/image_processing/ComputeMoments.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_image_processing_ComputeMoments_h
#define vtk_m_filter_image_processing_ComputeMoments_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/image_processing/vtkm_filter_image_processing_export.h>
namespace vtkm
@ -19,7 +19,7 @@ namespace filter
{
namespace image_processing
{
class VTKM_FILTER_IMAGE_PROCESSING_EXPORT ComputeMoments : public vtkm::filter::NewFilterField
class VTKM_FILTER_IMAGE_PROCESSING_EXPORT ComputeMoments : public vtkm::filter::FilterField
{
public:
VTKM_CONT ComputeMoments();

4
vtkm/filter/image_processing/ImageDifference.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_image_processing_ImageDifference_h
#define vtk_m_filter_image_processing_ImageDifference_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/image_processing/vtkm_filter_image_processing_export.h>
namespace vtkm
@ -29,7 +29,7 @@ namespace image_processing
/// The threshold-output is calculated for each pixel using the `vtkm::Magnitude` vector function
/// on the individual pixel difference.
///
class VTKM_FILTER_IMAGE_PROCESSING_EXPORT ImageDifference : public vtkm::filter::NewFilterField
class VTKM_FILTER_IMAGE_PROCESSING_EXPORT ImageDifference : public vtkm::filter::FilterField
{
public:
VTKM_CONT ImageDifference();

4
vtkm/filter/image_processing/ImageMedian.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_image_processing_ImageMedian_h
#define vtk_m_filter_image_processing_ImageMedian_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/image_processing/vtkm_filter_image_processing_export.h>
/// \brief Median algorithm for general image blur
@ -30,7 +30,7 @@ namespace filter
{
namespace image_processing
{
class VTKM_FILTER_IMAGE_PROCESSING_EXPORT ImageMedian : public vtkm::filter::NewFilterField
class VTKM_FILTER_IMAGE_PROCESSING_EXPORT ImageMedian : public vtkm::filter::FilterField
{
public:
VTKM_CONT ImageMedian() { this->SetOutputFieldName("median"); }

4
vtkm/filter/mesh_info/CellMeasures.h
View File

@ -11,7 +11,7 @@
#ifndef vtk_m_filter_mesh_info_CellMeasures_h
#define vtk_m_filter_mesh_info_CellMeasures_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -47,7 +47,7 @@ VTKM_EXEC_CONT inline IntegrationType operator|(IntegrationType left, Integratio
/// or 0 (if measure is not well defined or the cell type is unsupported).
///
/// By default, the new cell-data array is named "measure".
class VTKM_FILTER_MESH_INFO_EXPORT CellMeasures : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT CellMeasures : public vtkm::filter::FilterField
{
public:
VTKM_CONT

6
vtkm/filter/mesh_info/GhostCellClassify.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_mesh_info_GhostCellClassify_h
#define vtk_m_filter_mesh_info_GhostCellClassify_h
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -19,14 +19,14 @@ namespace filter
{
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT GhostCellClassify : public vtkm::filter::NewFilter
class VTKM_FILTER_MESH_INFO_EXPORT GhostCellClassify : public vtkm::filter::Filter
{
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& inData) override;
std::string GhostCellName;
public:
VTKM_CONT GhostCellClassify()
: NewFilter()
: Filter()
, GhostCellName(vtkm::cont::GetGlobalGhostCellFieldName())
{
}

2
vtkm/filter/mesh_info/MeshQuality.cxx
View File

@ -89,7 +89,7 @@ VTKM_CONT MeshQuality::MeshQuality(CellMetric metric)
VTKM_CONT vtkm::cont::DataSet MeshQuality::DoExecute(const vtkm::cont::DataSet& input)
{
std::unique_ptr<vtkm::filter::NewFilterField> implementation;
std::unique_ptr<vtkm::filter::FilterField> implementation;
switch (this->MyMetric)
{
case vtkm::filter::mesh_info::CellMetric::Area:

4
vtkm/filter/mesh_info/MeshQuality.h
View File

@ -21,7 +21,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQuality_h
#define vtk_m_filter_mesh_info_MeshQuality_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -66,7 +66,7 @@ enum struct CellMetric
* Each field contains the metric summary statistics for the cell type.
* Summary statists with all 0 values imply that the specified metric does not support the cell type.
*/
class VTKM_FILTER_MESH_INFO_EXPORT MeshQuality : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQuality : public vtkm::filter::FilterField
{
public:
VTKM_CONT explicit MeshQuality(CellMetric);

4
vtkm/filter/mesh_info/MeshQualityArea.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityArea_h
#define vtk_m_filter_mesh_info_MeshQualityArea_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityArea : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityArea : public vtkm::filter::FilterField
{
public:
MeshQualityArea();

4
vtkm/filter/mesh_info/MeshQualityAspectGamma.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityAspectGamma_h
#define vtk_m_filter_mesh_info_MeshQualityAspectGamma_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityAspectGamma : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityAspectGamma : public vtkm::filter::FilterField
{
public:
MeshQualityAspectGamma();

4
vtkm/filter/mesh_info/MeshQualityAspectRatio.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityAspectRatio_h
#define vtk_m_filter_mesh_info_MeshQualityAspectRatio_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityAspectRatio : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityAspectRatio : public vtkm::filter::FilterField
{
public:
MeshQualityAspectRatio();

4
vtkm/filter/mesh_info/MeshQualityCondition.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityCondition_h
#define vtk_m_filter_mesh_info_MeshQualityCondition_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityCondition : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityCondition : public vtkm::filter::FilterField
{
public:
MeshQualityCondition();

4
vtkm/filter/mesh_info/MeshQualityDiagonalRatio.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityDiagonalRatio_h
#define vtk_m_filter_mesh_info_MeshQualityDiagonalRatio_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityDiagonalRatio : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityDiagonalRatio : public vtkm::filter::FilterField
{
public:
MeshQualityDiagonalRatio();

4
vtkm/filter/mesh_info/MeshQualityDimension.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityDimension_h
#define vtk_m_filter_mesh_info_MeshQualityDimension_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityDimension : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityDimension : public vtkm::filter::FilterField
{
public:
MeshQualityDimension();

4
vtkm/filter/mesh_info/MeshQualityJacobian.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityJacobian_h
#define vtk_m_filter_mesh_info_MeshQualityJacobian_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityJacobian : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityJacobian : public vtkm::filter::FilterField
{
public:
MeshQualityJacobian();

4
vtkm/filter/mesh_info/MeshQualityMaxAngle.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityMaxAngle_h
#define vtk_m_filter_mesh_info_MeshQualityMaxAngle_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMaxAngle : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMaxAngle : public vtkm::filter::FilterField
{
public:
MeshQualityMaxAngle();

4
vtkm/filter/mesh_info/MeshQualityMaxDiagonal.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityMaxDiagonal_h
#define vtk_m_filter_mesh_info_MeshQualityMaxDiagonal_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMaxDiagonal : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMaxDiagonal : public vtkm::filter::FilterField
{
public:
MeshQualityMaxDiagonal();

4
vtkm/filter/mesh_info/MeshQualityMinAngle.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityMinAngle_h
#define vtk_m_filter_mesh_info_MeshQualityMinAngle_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMinAngle : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMinAngle : public vtkm::filter::FilterField
{
public:
MeshQualityMinAngle();

4
vtkm/filter/mesh_info/MeshQualityMinDiagonal.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityMinDiagonal_h
#define vtk_m_filter_mesh_info_MeshQualityMinDiagonal_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMinDiagonal : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityMinDiagonal : public vtkm::filter::FilterField
{
public:
MeshQualityMinDiagonal();

4
vtkm/filter/mesh_info/MeshQualityOddy.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityOddy_h
#define vtk_m_filter_mesh_info_MeshQualityOddy_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityOddy : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityOddy : public vtkm::filter::FilterField
{
public:
MeshQualityOddy();

5
vtkm/filter/mesh_info/MeshQualityRelativeSizeSquared.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityRelativeSizeSquared_h
#define vtk_m_filter_mesh_info_MeshQualityRelativeSizeSquared_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,8 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityRelativeSizeSquared
: public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityRelativeSizeSquared : public vtkm::filter::FilterField
{
public:
MeshQualityRelativeSizeSquared();

4
vtkm/filter/mesh_info/MeshQualityScaledJacobian.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityScaledJacobian_h
#define vtk_m_filter_mesh_info_MeshQualityScaledJacobian_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityScaledJacobian : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityScaledJacobian : public vtkm::filter::FilterField
{
public:
MeshQualityScaledJacobian();

4
vtkm/filter/mesh_info/MeshQualityShape.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityShape_h
#define vtk_m_filter_mesh_info_MeshQualityShape_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityShape : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityShape : public vtkm::filter::FilterField
{
public:
MeshQualityShape();

4
vtkm/filter/mesh_info/MeshQualityShapeAndSize.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityShapeAndSize_h
#define vtk_m_filter_mesh_info_MeshQualityShapeAndSize_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityShapeAndSize : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityShapeAndSize : public vtkm::filter::FilterField
{
public:
MeshQualityShapeAndSize();

4
vtkm/filter/mesh_info/MeshQualityShear.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityShear_h
#define vtk_m_filter_mesh_info_MeshQualityShear_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityShear : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityShear : public vtkm::filter::FilterField
{
public:
MeshQualityShear();

4
vtkm/filter/mesh_info/MeshQualitySkew.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualitySkew_h
#define vtk_m_filter_mesh_info_MeshQualitySkew_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualitySkew : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualitySkew : public vtkm::filter::FilterField
{
public:
MeshQualitySkew();

4
vtkm/filter/mesh_info/MeshQualityStretch.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityStretch_h
#define vtk_m_filter_mesh_info_MeshQualityStretch_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityStretch : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityStretch : public vtkm::filter::FilterField
{
public:
MeshQualityStretch();

4
vtkm/filter/mesh_info/MeshQualityTaper.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityTaper_h
#define vtk_m_filter_mesh_info_MeshQualityTaper_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityTaper : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityTaper : public vtkm::filter::FilterField
{
public:
MeshQualityTaper();

4
vtkm/filter/mesh_info/MeshQualityVolume.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityVolume_h
#define vtk_m_filter_mesh_info_MeshQualityVolume_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityVolume : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityVolume : public vtkm::filter::FilterField
{
public:
MeshQualityVolume();

4
vtkm/filter/mesh_info/MeshQualityWarpage.h
View File

@ -20,7 +20,7 @@
#ifndef vtk_m_filter_mesh_info_MeshQualityWarpage_h
#define vtk_m_filter_mesh_info_MeshQualityWarpage_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/mesh_info/vtkm_filter_mesh_info_export.h>
namespace vtkm
@ -30,7 +30,7 @@ namespace filter
namespace mesh_info
{
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityWarpage : public vtkm::filter::NewFilterField
class VTKM_FILTER_MESH_INFO_EXPORT MeshQualityWarpage : public vtkm::filter::FilterField
{
public:
MeshQualityWarpage();

4
vtkm/filter/multi_block/AmrArrays.h
View File

@ -12,7 +12,7 @@
#include <vtkm/cont/ErrorFilterExecution.h>
#include <vtkm/filter/NewFilter.h>
#include <vtkm/filter/Filter.h>
#include <vtkm/filter/multi_block/vtkm_filter_multi_block_export.h>
namespace vtkm
@ -21,7 +21,7 @@ namespace filter
{
namespace multi_block
{
class VTKM_FILTER_MULTI_BLOCK_EXPORT AmrArrays : public vtkm::filter::NewFilter
class VTKM_FILTER_MULTI_BLOCK_EXPORT AmrArrays : public vtkm::filter::Filter
{
private:
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet&) override

4
vtkm/filter/resampling/Probe.h
View File

@ -10,7 +10,7 @@
#ifndef vtk_m_filter_resampling_Probe_h
#define vtk_m_filter_resampling_Probe_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/resampling/vtkm_filter_resampling_export.h>
namespace vtkm
@ -19,7 +19,7 @@ namespace filter
{
namespace resampling
{
class VTKM_FILTER_RESAMPLING_EXPORT Probe : public vtkm::filter::NewFilterField
class VTKM_FILTER_RESAMPLING_EXPORT Probe : public vtkm::filter::FilterField
{
public:
VTKM_CONT

6
vtkm/filter/scalar_topology/ContourTreeUniform.h
View File

@ -57,7 +57,7 @@
#ifndef vtk_m_filter_scalar_topology_ContourTreeUniform_h
#define vtk_m_filter_scalar_topology_ContourTreeUniform_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/FilterField.h>
#include <vtkm/filter/scalar_topology/vtkm_filter_scalar_topology_export.h>
namespace vtkm
@ -72,7 +72,7 @@ namespace scalar_topology
/// peak of contour
/// Based on the algorithm presented in the paper:
// “Parallel Peak Pruning for Scalable SMP Contour Tree Computation.”
class VTKM_FILTER_SCALAR_TOPOLOGY_EXPORT ContourTreeMesh2D : public vtkm::filter::NewFilterField
class VTKM_FILTER_SCALAR_TOPOLOGY_EXPORT ContourTreeMesh2D : public vtkm::filter::FilterField
{
public:
VTKM_CONT
@ -89,7 +89,7 @@ private:
/// peak of contour
/// Based on the algorithm presented in the paper:
// “Parallel Peak Pruning for Scalable SMP Contour Tree Computation.”
class VTKM_FILTER_SCALAR_TOPOLOGY_EXPORT ContourTreeMesh3D : public vtkm::filter::NewFilterField
class VTKM_FILTER_SCALAR_TOPOLOGY_EXPORT ContourTreeMesh3D : public vtkm::filter::FilterField
{
public:
VTKM_CONT

2
vtkm/filter/scalar_topology/ContourTreeUniformAugmented.cxx
View File

@ -222,7 +222,7 @@ VTKM_CONT vtkm::cont::PartitionedDataSet ContourTreeAugmented::DoExecutePartitio
const vtkm::cont::PartitionedDataSet& input)
{
this->PreExecute(input);
auto result = this->NewFilter::DoExecutePartitions(input);
auto result = this->Filter::DoExecutePartitions(input);
this->PostExecute(input, result);
return result;
}

Some files were not shown because too many files have changed in this diff Show More