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

Merge topic 'better-deprecated-headers'

Browse Source 
5cb9792bd SurfaceNormal -> SurfaceNormals
b2947a1d7 Improve deprecation support of CellMeasures
5b7893a3f Support deprecated MeshQuality features
d22a509b5 Split CoordinateSystemTransform.h
c238cfea5 Improve deprecation support for moved or renamed headers

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !2718
This commit is contained in:
Kenneth Moreland 2022-03-04 19:40:14 +00:00 committed by Kitware Robot
commit 55143ef894
122 changed files with 1024 additions and 821 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
examples/mesh_quality/MeshQuality.cxx
View File

@ -258,7 +258,7 @@ int main(int argc, char* argv[])
// A cell metric is now computed for every shape type that exists in the
// input dataset.
vtkm::filter::mesh_info::CellMetric shapeMetric = vtkm::filter::mesh_info::CellMetric::VOLUME;
vtkm::filter::mesh_info::CellMetric shapeMetric = vtkm::filter::mesh_info::CellMetric::Volume;
try
{

227
vtkm/cont/DynamicCellSet.h
View File

@ -10,21 +10,8 @@
#ifndef vtk_m_cont_DynamicCellSet_h
#define vtk_m_cont_DynamicCellSet_h
#include <vtkm/cont/CastAndCall.h>
#include <vtkm/cont/CellSet.h>
#include <vtkm/cont/CellSetList.h>
#include <vtkm/cont/DefaultTypes.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Logging.h>
#include <vtkm/cont/UncertainCellSet.h>
#include <vtkm/Deprecated.h>
namespace vtkm
{
namespace cont
{
struct VTKM_DEPRECATED(1.8, "Use UnknownCellSet.h or UncertainCellSet.h.")
DynamicCellSet_h_header_is_deprecated
{
@ -37,218 +24,4 @@ inline void EmitDynamicCellSetHDeprecationWarning()
++x.x;
}
// This is a deprecated class. Don't warn about deprecation while implementing
// deprecated functionality.
VTKM_DEPRECATED_SUPPRESS_BEGIN
/// \brief Holds a cell set without having to specify concrete type.
///
/// \c DynamicCellSet holds a \c CellSet object using runtime polymorphism to
/// manage different subclass types and template parameters of the subclasses
/// rather than compile-time templates. This adds a programming convenience
/// that helps avoid a proliferation of templates. It also provides the
/// management necessary to interface VTK-m with data sources where types will
/// not be known until runtime.
///
/// To interface between the runtime polymorphism and the templated algorithms
/// in VTK-m, \c DynamicCellSet contains a method named \c CastAndCall that
/// will determine the correct type from some known list of cell set types.
/// This mechanism is used internally by VTK-m's worklet invocation mechanism
/// to determine the type when running algorithms.
///
/// By default, \c DynamicCellSet will assume that the value type in the array
/// matches one of the types specified by \c VTKM_DEFAULT_CELL_SET_LIST.
/// This list can be changed by using the \c ResetCellSetList method. It is
/// worthwhile to match these lists closely to the possible types that might be
/// used. If a type is missing you will get a runtime error. If there are more
/// types than necessary, then the template mechanism will create a lot of
/// object code that is never used, and keep in mind that the number of
/// combinations grows exponentially when using multiple \c Dynamic* objects.
///
/// The actual implementation of \c DynamicCellSet is in a templated class
/// named \c DynamicCellSetBase, which is templated on the list of cell set
/// types. \c DynamicCellSet is really just a typedef of \c DynamicCellSetBase
/// with the default cell set list.
///
template <typename CellSetList>
class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.8,
"Use vtkm::cont::UncertainCellSet.") DynamicCellSetBase
: public vtkm::cont::UncertainCellSet<CellSetList>
{
using Superclass = vtkm::cont::UncertainCellSet<CellSetList>;
public:
using Superclass::Superclass;
VTKM_CONT DynamicCellSetBase<CellSetList> NewInstance() const
{
return DynamicCellSetBase<CellSetList>(this->Superclass::NewInstance());
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList(NewCellSetList) const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList() const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
};
struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.8, "Use vtkm::cont::UnknownCellSet.") DynamicCellSet
: public vtkm::cont::UnknownCellSet
{
using UnknownCellSet::UnknownCellSet;
DynamicCellSet() = default;
DynamicCellSet(const vtkm::cont::UnknownCellSet& src)
: UnknownCellSet(src)
{
}
operator vtkm::cont::DynamicCellSetBase<VTKM_DEFAULT_CELL_SET_LIST>() const
{
return vtkm::cont::DynamicCellSetBase<VTKM_DEFAULT_CELL_SET_LIST>{ *this };
}
VTKM_CONT vtkm::cont::DynamicCellSet NewInstance() const
{
return vtkm::cont::DynamicCellSet(this->UnknownCellSet::NewInstance());
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList(NewCellSetList) const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList() const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
};
namespace internal
{
template <typename CellSetList>
struct DynamicTransformTraits<vtkm::cont::DynamicCellSetBase<CellSetList>>
{
using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
};
template <>
struct DynamicTransformTraits<vtkm::cont::DynamicCellSet>
{
using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
};
} // namespace internal
namespace internal
{
/// Checks to see if the given object is a dynamic cell set. It contains a
/// typedef named \c type that is either std::true_type or std::false_type.
/// Both of these have a typedef named value with the respective boolean value.
///
template <typename T>
struct DynamicCellSetCheck
{
using type = vtkm::cont::internal::UnknownCellSetCheck<T>;
};
#define VTKM_IS_DYNAMIC_CELL_SET(T) \
VTKM_STATIC_ASSERT(::vtkm::cont::internal::DynamicCellSetCheck<T>::type::value)
#define VTKM_IS_DYNAMIC_OR_STATIC_CELL_SET(T) \
VTKM_STATIC_ASSERT(::vtkm::cont::internal::CellSetCheck<T>::type::value || \
::vtkm::cont::internal::DynamicCellSetCheck<T>::type::value)
} // namespace internal
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
/// @cond SERIALIZATION
namespace mangled_diy_namespace
{
namespace internal
{
struct DynamicCellSetSerializeFunctor
{
template <typename CellSetType>
void operator()(const CellSetType& cs, BinaryBuffer& bb) const
{
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<CellSetType>::Get());
vtkmdiy::save(bb, cs);
}
};
template <typename CellSetTypes>
struct DynamicCellSetDeserializeFunctor
{
template <typename CellSetType>
void operator()(CellSetType,
vtkm::cont::DynamicCellSetBase<CellSetTypes>& dh,
const std::string& typeString,
bool& success,
BinaryBuffer& bb) const
{
if (!success && (typeString == vtkm::cont::SerializableTypeString<CellSetType>::Get()))
{
CellSetType cs;
vtkmdiy::load(bb, cs);
dh = vtkm::cont::DynamicCellSetBase<CellSetTypes>(cs);
success = true;
}
}
};
} // internal
template <typename CellSetTypes>
struct Serialization<vtkm::cont::DynamicCellSetBase<CellSetTypes>>
{
private:
using Type = vtkm::cont::DynamicCellSetBase<CellSetTypes>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& obj)
{
obj.CastAndCall(internal::DynamicCellSetSerializeFunctor{}, bb);
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& obj)
{
std::string typeString;
vtkmdiy::load(bb, typeString);
bool success = false;
vtkm::ListForEach(internal::DynamicCellSetDeserializeFunctor<CellSetTypes>{},
CellSetTypes{},
obj,
typeString,
success,
bb);
if (!success)
{
throw vtkm::cont::ErrorBadType("Error deserializing DynamicCellSet. Message TypeString: " +
typeString);
}
}
};
} // diy
/// @endcond SERIALIZATION
VTKM_DEPRECATED_SUPPRESS_END
#endif //vtk_m_cont_DynamicCellSet_h

138
vtkm/cont/UncertainCellSet.h
View File

@ -201,4 +201,142 @@ public:
/// @endcond SERIALIZATION
// Implement the deprecated functionality of DynamicCellSetBase, which was replaced
// by UnknownCellSet/UncertainCellSet. Everything below this line (up to the #endif
// for the include guard) can be deleted once the deprecated functionality is removed.
namespace vtkm
{
namespace cont
{
// This is a deprecated class. Don't warn about deprecation while implementing
// deprecated functionality.
VTKM_DEPRECATED_SUPPRESS_BEGIN
template <typename CellSetList>
class VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.8,
"Use vtkm::cont::UncertainCellSet.") DynamicCellSetBase
: public vtkm::cont::UncertainCellSet<CellSetList>
{
using Superclass = vtkm::cont::UncertainCellSet<CellSetList>;
public:
using Superclass::Superclass;
VTKM_CONT DynamicCellSetBase<CellSetList> NewInstance() const
{
return DynamicCellSetBase<CellSetList>(this->Superclass::NewInstance());
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList(NewCellSetList) const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList() const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
};
inline DynamicCellSet::operator vtkm::cont::DynamicCellSetBase<VTKM_DEFAULT_CELL_SET_LIST>() const
{
return vtkm::cont::DynamicCellSetBase<VTKM_DEFAULT_CELL_SET_LIST>{ *this };
}
namespace internal
{
template <typename CellSetList>
struct DynamicTransformTraits<vtkm::cont::DynamicCellSetBase<CellSetList>>
{
using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
};
} // namespace internal
}
} // namespace vtkm::cont
//=============================================================================
// Specializations of serialization related classes
/// @cond SERIALIZATION
namespace mangled_diy_namespace
{
namespace internal
{
struct DynamicCellSetSerializeFunctor
{
template <typename CellSetType>
void operator()(const CellSetType& cs, BinaryBuffer& bb) const
{
vtkmdiy::save(bb, vtkm::cont::SerializableTypeString<CellSetType>::Get());
vtkmdiy::save(bb, cs);
}
};
template <typename CellSetTypes>
struct DynamicCellSetDeserializeFunctor
{
template <typename CellSetType>
void operator()(CellSetType,
vtkm::cont::DynamicCellSetBase<CellSetTypes>& dh,
const std::string& typeString,
bool& success,
BinaryBuffer& bb) const
{
if (!success && (typeString == vtkm::cont::SerializableTypeString<CellSetType>::Get()))
{
CellSetType cs;
vtkmdiy::load(bb, cs);
dh = vtkm::cont::DynamicCellSetBase<CellSetTypes>(cs);
success = true;
}
}
};
} // internal
template <typename CellSetTypes>
struct Serialization<vtkm::cont::DynamicCellSetBase<CellSetTypes>>
{
private:
using Type = vtkm::cont::DynamicCellSetBase<CellSetTypes>;
public:
static VTKM_CONT void save(BinaryBuffer& bb, const Type& obj)
{
obj.CastAndCall(internal::DynamicCellSetSerializeFunctor{}, bb);
}
static VTKM_CONT void load(BinaryBuffer& bb, Type& obj)
{
std::string typeString;
vtkmdiy::load(bb, typeString);
bool success = false;
vtkm::ListForEach(internal::DynamicCellSetDeserializeFunctor<CellSetTypes>{},
CellSetTypes{},
obj,
typeString,
success,
bb);
if (!success)
{
throw vtkm::cont::ErrorBadType("Error deserializing DynamicCellSet. Message TypeString: " +
typeString);
}
}
};
} // diy
/// @endcond SERIALIZATION
VTKM_DEPRECATED_SUPPRESS_END
#endif //vtk_m_cont_UncertainCellSet_h

117
vtkm/cont/UnknownCellSet.h
View File

@ -14,6 +14,8 @@
#include <vtkm/cont/CellSet.h>
#include <vtkm/cont/DefaultTypes.h>
#include <vtkm/Deprecated.h>
#include <vtkm/cont/vtkm_cont_export.h>
#include <memory>
@ -392,4 +394,119 @@ public:
/// @endcond SERIALIZATION
// Implement the deprecated functionality of DynamicCellSet, which was replaced
// by UnknownCellSet/UncertainCellSet. Everything below this line (up to the #endif
// for the include guard) can be deleted once the deprecated functionality is removed.
// Headers originally included from DynamicCellSet.h but not UnknownCellSet.h
#include <vtkm/cont/CellSetList.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Logging.h>
namespace vtkm
{
namespace cont
{
// This is a deprecated class. Don't warn about deprecation while implementing
// deprecated functionality.
VTKM_DEPRECATED_SUPPRESS_BEGIN
// Forward declaration
template <typename CellSetList>
class DynamicCellSetBase;
/// \brief Holds a cell set without having to specify concrete type.
///
/// \c DynamicCellSet holds a \c CellSet object using runtime polymorphism to
/// manage different subclass types and template parameters of the subclasses
/// rather than compile-time templates. This adds a programming convenience
/// that helps avoid a proliferation of templates. It also provides the
/// management necessary to interface VTK-m with data sources where types will
/// not be known until runtime.
///
/// To interface between the runtime polymorphism and the templated algorithms
/// in VTK-m, \c DynamicCellSet contains a method named \c CastAndCall that
/// will determine the correct type from some known list of cell set types.
/// This mechanism is used internally by VTK-m's worklet invocation mechanism
/// to determine the type when running algorithms.
///
/// By default, \c DynamicCellSet will assume that the value type in the array
/// matches one of the types specified by \c VTKM_DEFAULT_CELL_SET_LIST.
/// This list can be changed by using the \c ResetCellSetList method. It is
/// worthwhile to match these lists closely to the possible types that might be
/// used. If a type is missing you will get a runtime error. If there are more
/// types than necessary, then the template mechanism will create a lot of
/// object code that is never used, and keep in mind that the number of
/// combinations grows exponentially when using multiple \c Dynamic* objects.
///
/// The actual implementation of \c DynamicCellSet is in a templated class
/// named \c DynamicCellSetBase, which is templated on the list of cell set
/// types. \c DynamicCellSet is really just a typedef of \c DynamicCellSetBase
/// with the default cell set list.
///
struct VTKM_ALWAYS_EXPORT VTKM_DEPRECATED(1.8, "Use vtkm::cont::UnknownCellSet.") DynamicCellSet
: public vtkm::cont::UnknownCellSet
{
using UnknownCellSet::UnknownCellSet;
DynamicCellSet() = default;
DynamicCellSet(const vtkm::cont::UnknownCellSet& src)
: UnknownCellSet(src)
{
}
operator vtkm::cont::DynamicCellSetBase<VTKM_DEFAULT_CELL_SET_LIST>() const;
VTKM_CONT vtkm::cont::DynamicCellSet NewInstance() const
{
return vtkm::cont::DynamicCellSet(this->UnknownCellSet::NewInstance());
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList(NewCellSetList) const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
template <typename NewCellSetList>
VTKM_CONT vtkm::cont::DynamicCellSetBase<NewCellSetList> ResetCellSetList() const
{
return vtkm::cont::DynamicCellSetBase<NewCellSetList>(*this);
}
};
namespace internal
{
template <>
struct DynamicTransformTraits<vtkm::cont::DynamicCellSet>
{
using DynamicTag = vtkm::cont::internal::DynamicTransformTagCastAndCall;
};
/// Checks to see if the given object is a dynamic cell set. It contains a
/// typedef named \c type that is either std::true_type or std::false_type.
/// Both of these have a typedef named value with the respective boolean value.
///
template <typename T>
struct DynamicCellSetCheck
{
using type = vtkm::cont::internal::UnknownCellSetCheck<T>;
};
#define VTKM_IS_DYNAMIC_CELL_SET(T) \
VTKM_STATIC_ASSERT(::vtkm::cont::internal::DynamicCellSetCheck<T>::type::value)
#define VTKM_IS_DYNAMIC_OR_STATIC_CELL_SET(T) \
VTKM_STATIC_ASSERT(::vtkm::cont::internal::CellSetCheck<T>::type::value || \
::vtkm::cont::internal::DynamicCellSetCheck<T>::type::value)
} // namespace internal
}
} // namespace vtkm::cont
VTKM_DEPRECATED_SUPPRESS_END
#endif //vtk_m_cont_UnknownCellSet_h

2
vtkm/filter/CMakeLists.txt
View File

@ -46,7 +46,7 @@ set(deprecated_headers
PointTransform.h
Slice.h
SplitSharpEdges.h
SurfaceNormal.h
SurfaceNormals.h
Tetrahedralize.h
Threshold.h
ThresholdPoints.h

6
vtkm/filter/CellAverage.h
View File

@ -28,12 +28,6 @@ inline void CellAverage_deprecated_warning()
CellAverage_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_conversion::CellAverage.") CellAverage
: public vtkm::filter::field_conversion::CellAverage
{
using field_conversion::CellAverage::CellAverage;
};
}
} // namespace vtkm::filter

65
vtkm/filter/CellMeasures.h
View File

@ -13,68 +13,6 @@
#include <vtkm/Deprecated.h>
#include <vtkm/filter/mesh_info/CellMeasures.h>
namespace vtkm
{
struct VTKM_DEPRECATED(1.8, "IntegrateOver is no longer supported") IntegrateOver
{
};
struct VTKM_DEPRECATED(1.8, "IntegrateOverCurve is no longer supported") IntegrateOverCurve
: IntegrateOver
{
static constexpr IntegrationType value = ArcLength;
};
struct VTKM_DEPRECATED(1.8, "IntegrateOverSurface is no longer supported") IntegrateOverSurface
: IntegrateOver
{
static constexpr IntegrationType value = Area;
};
struct VTKM_DEPRECATED(1.8, "IntegrateOverSurface is no longer supported") IntegrateOverSolid
: IntegrateOver
{
static constexpr IntegrationType value = Volume;
};
// Lists of acceptable types of integration
using ArcLength VTKM_DEPRECATED(1.8, "Use vtkm::filter::mesh_info::IntegrationType::ArcLength") =
vtkm::List<IntegrateOverCurve>;
using Area VTKM_DEPRECATED(1.8, "Use vtkm::filter::mesh_info::IntegrationType::Area") =
vtkm::List<IntegrateOverSurface>;
using Volume VTKM_DEPRECATED(1.8, "Use vtkm::filter::mesh_info::IntegrationType::Volume") =
vtkm::List<IntegrateOverSolid>;
using AllMeasures VTKM_DEPRECATED(1.8,
"Use vtkm::filter::mesh_info::IntegrationType::AllMeasures") =
vtkm::List<IntegrateOverSolid, IntegrateOverSurface, IntegrateOverCurve>;
namespace detail
{
IntegrationType OldToNewIntegrationType(vtkm::List<>)
{
return static_cast<IntegrationType>(0);
}
template <typename T, typename... Ts>
IntegrationType OldToNewIntegrationType(vtkm::List<T, Ts...>)
{
return T::value | OldToNewIntegrationType(vtkm::List<Ts...>{});
}
} // namespace detail
namespace filter
{
template <typename IntegrationTypeList>
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::mesh_info::CellMeasures.") CellMeasures
: public vtkm::filter::mesh_info::CellMeasures
{
public:
CellMeasures()
: vtkm::filter::mesh_info::CellMeasures(vtkm::detail::OldToNewIntegrationType(IntegrationTypeList{})
{
}
};
VTKM_DEPRECATED(1.8,
"Use vtkm/filter/mesh_info/CellMeasures.h instead of vtkm/filter/CellMeasures.h.")
inline void CellMeasures_deprecated() {}
@ -83,7 +21,4 @@ inline void CellMeasures_deprecated_warning()
{
CellMeasures_deprecated();
}
} // namespace filter
} // namespace vtkm
#endif //vtk_m_filter_CellMeasures_h

6
vtkm/filter/CellSetConnectivity.h
View File

@ -28,12 +28,6 @@ inline void CellSetConnectivity_deprecated_warning()
CellSetConnectivity_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::connected_components::CellSetConnectivity.")
CellSetConnectivity : public vtkm::filter::connected_components::CellSetConnectivity
{
using connected_components::CellSetConnectivity::CellSetConnectivity;
};
}
} // namespace vtkm::filter

6
vtkm/filter/CleanGrid.h
View File

@ -26,12 +26,6 @@ inline void CleanGrid_deprecated_warning()
CleanGrid_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::clean_grid::CleanGrid.") CleanGrid
: public vtkm::filter::clean_grid::CleanGrid
{
using clean_grid::CleanGrid::CleanGrid;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ClipWithField.h
View File

@ -27,12 +27,6 @@ inline void ClipWithField_deprecated_warning()
ClipWithField_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::ClipWithField.") ClipWithField
: public vtkm::filter::contour::ClipWithField
{
using contour::ClipWithField::ClipWithField;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ClipWithImplicitFunction.h
View File

@ -28,12 +28,6 @@ inline void ClipWithImplicitFunction_deprecated_warning()
ClipWithImplicitFunction_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::ClipWithImplicitFunction.")
ClipWithImplicitFunction : public vtkm::filter::contour::ClipWithImplicitFunction
{
using contour::ClipWithImplicitFunction::ClipWithImplicitFunction;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ComputeMoments.h
View File

@ -28,12 +28,6 @@ inline void ComputeMoments_deprecated_warning()
ComputeMoments_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::image_processing::ComputeMoments.") ComputeMoments
: public vtkm::filter::image_processing::ComputeMoments
{
using image_processing::ComputeMoments::ComputeMoments;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Contour.h
View File

@ -26,12 +26,6 @@ inline void Contour_deprecated_warning()
Contour_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::Contour.") Contour
: public vtkm::filter::contour::Contour
{
using contour::Contour::Contour;
};
}
} // namespace vtkm::filter

12
vtkm/filter/CoordinateSystemTransform.h
View File

@ -11,7 +11,8 @@
#define vtk_m_filter_CoordinateSystemTransform_h
#include <vtkm/Deprecated.h>
#include <vtkm/filter/field_transform/CoordinateSystemTransform.h>
#include <vtkm/filter/field_transform/CylindricalCoordinateTransform.h>
#include <vtkm/filter/field_transform/SphericalCoordinateTransform.h>
namespace vtkm
{
@ -19,7 +20,8 @@ namespace filter
{
VTKM_DEPRECATED(1.8,
"Use vtkm/filter/field_transform/CoordinateSystemTransform.h instead of "
"Use vtkm/filter/field_transform/CylindricalCoordinateTransform.h or "
"vtkm/filter/field_transform/SphericalCoordinateTransform.h instead of "
"vtkm/filter/CoordinateSystemTransform.h.")
inline void CoordinateSystemTransform_deprecated() {}
@ -28,12 +30,6 @@ inline void CoordinateSystemTransform_deprecated_warning()
CoordinateSystemTransform_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::CoordinateSystemTransform.")
CoordinateSystemTransform : public vtkm::filter::field_transform::CoordinateSystemTransform
{
using field_transform::CoordinateSystemTransform::CoordinateSystemTransform;
};
}
} // namespace vtkm::filter

6
vtkm/filter/CrossProduct.h
View File

@ -29,12 +29,6 @@ inline void CrossProduct_deprecated_warning()
CrossProduct_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::vector_analysis::CrossProduct.") CrossProduct
: public vtkm::filter::vector_analysis::CrossProduct
{
using vector_analysis::CrossProduct::CrossProduct;
};
}
} // namespace vtkm::filter

5
vtkm/filter/DotProduct.h
View File

@ -27,11 +27,6 @@ inline void DotProduct_deprecated_warning()
DotProduct_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::vector_analysis::DotProduct.") DotProduct
: public vtkm::filter::vector_analysis::DotProduct
{
using vector_analysis::DotProduct::DotProduct;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Entropy.h
View File

@ -26,12 +26,6 @@ inline void Entropy_deprecated_warning()
Entropy_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::Entropy.") Entropy
: public vtkm::filter::density_estimate::Entropy
{
using density_estimate::Entropy::Entropy;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ExternalFaces.h
View File

@ -28,12 +28,6 @@ inline void ExternalFaces_deprecated_warning()
ExternalFaces_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ExternalFaces.") ExternalFaces
: public vtkm::filter::entity_extraction::ExternalFaces
{
using entity_extraction::ExternalFaces::ExternalFaces;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ExtractGeometry.h
View File

@ -28,12 +28,6 @@ inline void ExtractGeometry_deprecated_warning()
ExtractGeometry_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ExtractGeometry.") ExtractGeometry
: public vtkm::filter::entity_extraction::ExtractGeometry
{
using entity_extraction::ExtractGeometry::ExtractGeometry;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ExtractPoints.h
View File

@ -28,12 +28,6 @@ inline void ExtractPoints_deprecated_warning()
ExtractPoints_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ExtractPoints.") ExtractPoints
: public vtkm::filter::entity_extraction::ExtractPoints
{
using entity_extraction::ExtractPoints::ExtractPoints;
};
}
} // namespace vtkm::filter

7
vtkm/filter/ExtractStructured.h
View File

@ -28,13 +28,6 @@ inline void ExtractStructured_deprecated_warning()
ExtractStructured_deprecated();
}
class VTKM_DEPRECATED(1.8,
"Use vtkm::filter::entity_extraction::ExtractStructured.") ExtractStructured
: public vtkm::filter::entity_extraction::ExtractStructured
{
using entity_extraction::ExtractStructured::ExtractStructured;
};
}
} // namespace vtkm::filter

6
vtkm/filter/FieldToColors.h
View File

@ -28,12 +28,6 @@ inline void FieldToColors_deprecated_warning()
FieldToColors_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::FieldToColors.") FieldToColors
: public vtkm::filter::field_transform::FieldToColors
{
using field_transform::FieldToColors::FieldToColors;
};
}
} // namespace vtkm::filter

6
vtkm/filter/GenerateIds.h
View File

@ -28,12 +28,6 @@ inline void GenerateIds_deprecated_warning()
GenerateIds_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::GenerateIds.") GenerateIds
: public vtkm::filter::field_transform::GenerateIds
{
using field_transform::GenerateIds::GenerateIds;
};
}
} // namespace vtkm::filter

6
vtkm/filter/GhostCellClassify.h
View File

@ -28,12 +28,6 @@ inline void GhostCellClassify_deprecated_warning()
GhostCellClassify_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::mesh_info::GhostCellClassify.") GhostCellClassify
: public vtkm::filter::mesh_info::GhostCellClassify
{
using mesh_info::GhostCellClassify::GhostCellClassify;
};
}
} // namespace vtkm::filter

6
vtkm/filter/GhostCellRemove.h
View File

@ -28,12 +28,6 @@ inline void GhostCellRemove_deprecated_warning()
GhostCellRemove_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::GhostCellRemove.") GhostCellRemove
: public vtkm::filter::entity_extraction::GhostCellRemove
{
using entity_extraction::GhostCellRemove::GhostCellRemove;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Gradient.h
View File

@ -27,12 +27,6 @@ inline void Gradient_deprecated_warning()
Gradient_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::vector_analysis::Gradient.") Gradient
: public vtkm::filter::vector_analysis::Gradient
{
using vector_analysis::Gradient::Gradient;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Histogram.h
View File

@ -27,12 +27,6 @@ inline void Histogram_deprecated_warning()
Histogram_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::Histogram.") Histogram
: public vtkm::filter::density_estimate::Histogram
{
using density_estimate::Histogram::Histogram;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ImageConnectivity.h
View File

@ -28,12 +28,6 @@ inline void ImageConnectivity_deprecated_warning()
ImageConnectivity_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::connected_components::ImageConnectivity.")
ImageConnectivity : public vtkm::filter::connected_components::ImageConnectivity
{
using connected_components::ImageConnectivity::ImageConnectivity;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ImageDifference.h
View File

@ -28,12 +28,6 @@ inline void ImageDifference_deprecated_warning()
ImageDifference_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::image_processing::ImageDifference.") ImageDifference
: public vtkm::filter::image_processing::ImageDifference
{
using image_processing::ImageDifference::ImageDifference;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ImageMedian.h
View File

@ -28,12 +28,6 @@ inline void ImageMedian_deprecated_warning()
ImageMedian_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::image_processing::ImageMedian.") ImageMedian
: public vtkm::filter::image_processing::ImageMedian
{
using image_processing::ImageMedian::ImageMedian;
};
}
} // namespace vtkm::filter

4
vtkm/filter/MIRFilter.hxx
View File

@ -100,8 +100,8 @@ inline VTKM_CONT vtkm::cont::DataSet MIRFilter::DoExecute(
input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex());
vtkm::cont::ArrayHandle<vtkm::Float64> avgSizeTot;
vtkm::worklet::MeshQuality getVol;
getVol.SetMetric(c3 > 0 ? vtkm::filter::mesh_info::CellMetric::VOLUME
: vtkm::filter::mesh_info::CellMetric::AREA);
getVol.SetMetric(c3 > 0 ? vtkm::filter::mesh_info::CellMetric::Volume
: vtkm::filter::mesh_info::CellMetric::Area);
this->Invoke(getVol,
vtkm::filter::ApplyPolicyCellSet(input.GetCellSet(), policy, *this),
inputCoords.GetData(),

6
vtkm/filter/Mask.h
View File

@ -26,12 +26,6 @@ inline void Mask_deprecated_warning()
Mask_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::Mask.") Mask
: public vtkm::filter::entity_extraction::Mask
{
using entity_extraction::Mask::Mask;
};
}
} // namespace vtkm::filter

6
vtkm/filter/MaskPoints.h
View File

@ -28,12 +28,6 @@ inline void MaskPoints_deprecated_warning()
MaskPoints_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::MaskPoints.") MaskPoints
: public vtkm::filter::entity_extraction::MaskPoints
{
using entity_extraction::MaskPoints::MaskPoints;
};
}
} // namespace vtkm::filter

6
vtkm/filter/MeshQuality.h
View File

@ -27,12 +27,6 @@ inline void MeshQuality_deprecated_warning()
MeshQuality_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::mesh_info::MeshQuality.") MeshQuality
: public vtkm::filter::mesh_info::MeshQuality
{
using mesh_info::MeshQuality::MeshQuality;
};
}
} // namespace vtkm::filter

6
vtkm/filter/NDEntropy.h
View File

@ -27,12 +27,6 @@ inline void NDEntropy_deprecated_warning()
NDEntropy_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::NDEntropy.") NDEntropy
: public vtkm::filter::density_estimate::NDEntropy
{
using density_estimate::NDEntropy::NDEntropy;
};
}
} // namespace vtkm::filter

6
vtkm/filter/NDHistogram.h
View File

@ -28,12 +28,6 @@ inline void NDHistogram_deprecated_warning()
NDHistogram_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::NDHistogram.") NDHistogram
: public vtkm::filter::density_estimate::NDHistogram
{
using density_estimate::NDHistogram::NDHistogram;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ParticleDensityCloudInCell.h
View File

@ -28,12 +28,6 @@ inline void ParticleDensityCloudInCell_deprecated_warning()
ParticleDensityCloudInCell_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::ParticleDensityCloudInCell.")
ParticleDensityCloudInCell : public vtkm::filter::density_estimate::ParticleDensityCloudInCell
{
using density_estimate::ParticleDensityCloudInCell::ParticleDensityCloudInCell;
};
}
} // namespace vtkm::filter

7
vtkm/filter/ParticleDensityNearestGridPoint.h
View File

@ -28,13 +28,6 @@ inline void ParticleDensityNearestGridPoint_deprecated_warning()
ParticleDensityNearestGridPoint_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::ParticleDensityNearestGridPoint.")
ParticleDensityNearestGridPoint
: public vtkm::filter::density_estimate::ParticleDensityNearestGridPoint
{
using density_estimate::ParticleDensityNearestGridPoint::ParticleDensityNearestGridPoint;
};
}
} // namespace vtkm::filter

6
vtkm/filter/PointAverage.h
View File

@ -28,12 +28,6 @@ inline void PointAverage_deprecated_warning()
PointAverage_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_conversion::PointAverage.") PointAverage
: public vtkm::filter::field_conversion::PointAverage
{
using field_conversion::PointAverage::PointAverage;
};
}
} // namespace vtkm::filter

6
vtkm/filter/PointElevation.h
View File

@ -28,12 +28,6 @@ inline void PointElevation_deprecated_warning()
PointElevation_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::PointElevation.") PointElevation
: public vtkm::filter::field_transform::PointElevation
{
using field_transform::PointElevation::PointElevation;
};
}
} // namespace vtkm::filter

6
vtkm/filter/PointTransform.h
View File

@ -28,12 +28,6 @@ inline void PointTransform_deprecated_warning()
PointTransform_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::PointTransform.") PointTransform
: public vtkm::filter::field_transform::PointTransform
{
using field_transform::PointTransform::PointTransform;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Slice.h
View File

@ -26,12 +26,6 @@ inline void Slice_deprecated_warning()
Slice_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::Slice.") Slice
: public vtkm::filter::contour::Slice
{
using contour::Slice::Slice;
};
}
} // namespace vtkm::filter

7
vtkm/filter/SplitSharpEdges.h
View File

@ -28,13 +28,6 @@ inline void SplitSharpEdges_deprecated_warning()
SplitSharpEdges_deprecated();
}
class VTKM_DEPRECATED(1.8,
"Use vtkm::filter::geometry_refinement::SplitSharpEdges.") SplitSharpEdges
: public vtkm::filter::geometry_refinement::SplitSharpEdges
{
using geometry_refinement::SplitSharpEdges::SplitSharpEdges;
};
}
} // namespace vtkm::filter

40
vtkm/filter/SurfaceNormal.h
View File

@ -1,40 +0,0 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_SurfaceNormal_h
#define vtk_m_filter_SurfaceNormal_h
#include <vtkm/Deprecated.h>
#include <vtkm/filter/vector_analysis/SurfaceNormal.h>
namespace vtkm
{
namespace filter
{
VTKM_DEPRECATED(
1.8,
"Use vtkm/filter/vector_analysis/SurfaceNormal.h instead of vtkm/filter/SurfaceNormal.h.")
inline void SurfaceNormal_deprecated() {}
inline void SurfaceNormal_deprecated_warning()
{
SurfaceNormal_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::vector_analysis::SurfaceNormal.") SurfaceNormal
: public vtkm::filter::vector_analysis::SurfaceNormal
{
using vector_analysis::SurfaceNormal::SurfaceNormal;
};
}
} // namespace vtkm::filter
#endif //vtk_m_filter_SurfaceNormal_h

34
vtkm/filter/SurfaceNormals.h Normal file
View File

@ -0,0 +1,34 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_SurfaceNormals_h
#define vtk_m_filter_SurfaceNormals_h
#include <vtkm/Deprecated.h>
#include <vtkm/filter/vector_analysis/SurfaceNormals.h>
namespace vtkm
{
namespace filter
{
VTKM_DEPRECATED(
1.8,
"Use vtkm/filter/vector_analysis/SurfaceNormals.h instead of vtkm/filter/SurfaceNormals.h.")
inline void SurfaceNormals_deprecated() {}
inline void SurfaceNormals_deprecated_warning()
{
SurfaceNormals_deprecated();
}
}
} // namespace vtkm::filter
#endif //vtk_m_filter_SurfaceNormals_h

6
vtkm/filter/Tetrahedralize.h
View File

@ -28,12 +28,6 @@ inline void Tetrahedralize_deprecated_warning()
Tetrahedralize_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::geometry_refinement::Tetrahedralize.") Tetrahedralize
: public vtkm::filter::geometry_refinement::Tetrahedralize
{
using geometry_refinement::Tetrahedralize::Tetrahedralize;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Threshold.h
View File

@ -27,12 +27,6 @@ inline void Threshold_deprecated_warning()
Threshold_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::Threshold.") Threshold
: public vtkm::filter::entity_extraction::Threshold
{
using entity_extraction::Threshold::Threshold;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ThresholdPoints.h
View File

@ -28,12 +28,6 @@ inline void ThresholdPoints_deprecated_warning()
ThresholdPoints_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ThresholdPoints.") ThresholdPoints
: public vtkm::filter::entity_extraction::ThresholdPoints
{
using entity_extraction::ThresholdPoints::ThresholdPoints;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Triangulate.h
View File

@ -28,12 +28,6 @@ inline void Triangulate_deprecated_warning()
Triangulate_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::geometry_refinement::Triangulate.") Triangulate
: public vtkm::filter::geometry_refinement::Triangulate
{
using geometry_refinement::Triangulate::Triangulate;
};
}
} // namespace vtkm::filter

6
vtkm/filter/Tube.h
View File

@ -26,12 +26,6 @@ inline void Tube_deprecated_warning()
Tube_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::geometry_refinement::Tube.") Tube
: public vtkm::filter::geometry_refinement::Tube
{
using geometry_refinement::Tube::Tube;
};
}
} // namespace vtkm::filter

6
vtkm/filter/VectorMagnitude.h
View File

@ -28,12 +28,6 @@ inline void VectorMagnitude_deprecated_warning()
VectorMagnitude_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::vector_analysis::VectorMagnitude.") VectorMagnitude
: public vtkm::filter::vector_analysis::VectorMagnitude
{
using vector_analysis::VectorMagnitude::VectorMagnitude;
};
}
} // namespace vtkm::filter

6
vtkm/filter/VertexClustering.h
View File

@ -28,12 +28,6 @@ inline void VertexClustering_deprecated_warning()
VertexClustering_deprecated();
}
class VTKM_DEPRECATED(1.8,
"Use vtkm::filter::geometry_refinement::VertexClustering.") VertexClustering
: public vtkm::filter::geometry_refinement::VertexClustering
{
using geometry_refinement::VertexClustering::VertexClustering;
};
}
} // namespace vtkm::filter

6
vtkm/filter/WarpScalar.h
View File

@ -27,12 +27,6 @@ inline void WarpScalar_deprecated_warning()
WarpScalar_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::WarpScalar.") WarpScalar
: public vtkm::filter::field_transform::WarpScalar
{
using field_transform::WarpScalar::WarpScalar;
};
}
} // namespace vtkm::filter

6
vtkm/filter/WarpVector.h
View File

@ -27,12 +27,6 @@ inline void WarpVector_deprecated_warning()
WarpVector_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::WarpVector.") WarpVector
: public vtkm::filter::field_transform::WarpVector
{
using field_transform::WarpVector::WarpVector;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ZFPCompressor1D.h
View File

@ -27,12 +27,6 @@ inline void ZFPCompressor1D_deprecated_warning()
ZFPCompressor1D_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::zfp::ZFPCompressor1D.") ZFPCompressor1D
: public vtkm::filter::zfp::ZFPCompressor1D
{
using zfp::ZFPCompressor1D::ZFPCompressor1D;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ZFPCompressor2D.h
View File

@ -27,12 +27,6 @@ inline void ZFPCompressor2D_deprecated_warning()
ZFPCompressor2D_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::zfp::ZFPCompressor2D.") ZFPCompressor2D
: public vtkm::filter::zfp::ZFPCompressor2D
{
using zfp::ZFPCompressor2D::ZFPCompressor2D;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ZFPCompressor3D.h
View File

@ -27,12 +27,6 @@ inline void ZFPCompressor3D_deprecated_warning()
ZFPCompressor3D_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::zfp::ZFPCompressor3D.") ZFPCompressor3D
: public vtkm::filter::zfp::ZFPCompressor3D
{
using zfp::ZFPCompressor3D::ZFPCompressor3D;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ZFPDecompressor1D.h
View File

@ -28,12 +28,6 @@ inline void ZFPDecompressor1D_deprecated_warning()
ZFPDecompressor1D_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::zfp::ZFPDecompressor1D.") ZFPDecompressor1D
: public vtkm::filter::zfp::ZFPDecompressor1D
{
using zfp::ZFPDecompressor1D::ZFPDecompressor1D;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ZFPDecompressor2D.h
View File

@ -28,12 +28,6 @@ inline void ZFPDecompressor2D_deprecated_warning()
ZFPDecompressor2D_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::zfp::ZFPDecompressor2D.") ZFPDecompressor2D
: public vtkm::filter::zfp::ZFPDecompressor2D
{
using zfp::ZFPDecompressor2D::ZFPDecompressor2D;
};
}
} // namespace vtkm::filter

6
vtkm/filter/ZFPDecompressor3D.h
View File

@ -28,12 +28,6 @@ inline void ZFPDecompressor3D_deprecated_warning()
ZFPDecompressor3D_deprecated();
}
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::zfp::ZFPDecompressor3D.") ZFPDecompressor3D
: public vtkm::filter::zfp::ZFPDecompressor3D
{
using zfp::ZFPDecompressor3D::ZFPDecompressor3D;
};
}
} // namespace vtkm::filter

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

@ -96,6 +96,13 @@ private:
bool FastMerge = true;
};
} // namespace clean_grid
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::clean_grid::CleanGrid.") CleanGrid
: public vtkm::filter::clean_grid::CleanGrid
{
using clean_grid::CleanGrid::CleanGrid;
};
} // namespace filter
} // namespace vtkm

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

@ -20,6 +20,7 @@ namespace filter
{
namespace connected_components
{
/// \brief Finds groups of cells that are connected together through their topology.
///
/// Finds and labels groups of cells that are connected together through their topology.
@ -37,8 +38,16 @@ private:
VTKM_CONT
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
}
}
}
} // namespace connected_components
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::connected_components::CellSetConnectivity.")
CellSetConnectivity : public vtkm::filter::connected_components::CellSetConnectivity
{
using connected_components::CellSetConnectivity::CellSetConnectivity;
};
} // namespace filter
} // namespace vtkm
#endif //vtk_m_filter_connected_components_CellSetConnectivity_h

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

@ -41,6 +41,13 @@ private:
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace connected_components
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::connected_components::ImageConnectivity.")
ImageConnectivity : public vtkm::filter::connected_components::ImageConnectivity
{
using connected_components::ImageConnectivity::ImageConnectivity;
};
} // namespace filter
} // namespace vtkm

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

@ -45,6 +45,11 @@ private:
bool Invert = false;
};
} // namespace contour
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::ClipWithField.") ClipWithField
: public vtkm::filter::contour::ClipWithField
{
using contour::ClipWithField::ClipWithField;
};
} // namespace filter
} // namespace vtkm

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

@ -42,6 +42,11 @@ private:
bool Invert = false;
};
} // namespace contour
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::ClipWithImplicitFunction.")
ClipWithImplicitFunction : public vtkm::filter::contour::ClipWithImplicitFunction
{
using contour::ClipWithImplicitFunction::ClipWithImplicitFunction;
};
} // namespace filter
} // namespace vtkm

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

@ -128,6 +128,11 @@ protected:
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& result) override;
};
} // namespace contour
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::Contour.") Contour
: public vtkm::filter::contour::Contour
{
using contour::Contour::Contour;
};
} // namespace filter
} // namespace vtkm

5
vtkm/filter/contour/Slice.h
View File

@ -37,6 +37,11 @@ private:
vtkm::ImplicitFunctionGeneral Function;
};
} // namespace contour
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::contour::Slice.") Slice
: public vtkm::filter::contour::Slice
{
using contour::Slice::Slice;
};
} // namespace filter
} // namespace vtkm

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

@ -45,6 +45,11 @@ private:
vtkm::Id NumberOfBins = 10;
};
} // namespace density_estimate
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::Entropy.") Entropy
: public vtkm::filter::density_estimate::Entropy
{
using density_estimate::Entropy::Entropy;
};
} // namespace filter
} // namespace vtkm

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

@ -78,6 +78,11 @@ private:
vtkm::Range Range;
};
} // namespace density_estimate
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::Histogram.") Histogram
: public vtkm::filter::density_estimate::Histogram
{
using density_estimate::Histogram::Histogram;
};
} // namespace filter
} // namespace vtkm

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

@ -35,8 +35,13 @@ private:
std::vector<vtkm::Id> NumOfBins;
std::vector<std::string> FieldNames;
};
}
}
} // namespace vtkm::filter
} // namespace density_estimate
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::NDEntropy.") NDEntropy
: public vtkm::filter::density_estimate::NDEntropy
{
using density_estimate::NDEntropy::NDEntropy;
};
} // namespace filter
} // namespace vtkm
#endif //vtk_m_filter_density_estimate_NDEntropy_h

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

@ -56,6 +56,11 @@ private:
std::vector<vtkm::Range> DataRanges; //Min Max of the field
};
} // namespace density_estimate
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::NDHistogram.") NDHistogram
: public vtkm::filter::density_estimate::NDHistogram
{
using density_estimate::NDHistogram::NDHistogram;
};
} // namespace filter
} // namespace vtm

5
vtkm/filter/density_estimate/ParticleDensityCloudInCell.h
View File

@ -50,6 +50,11 @@ private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace density_estimate
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::ParticleDensityCloudInCell.")
ParticleDensityCloudInCell : public vtkm::filter::density_estimate::ParticleDensityCloudInCell
{
using density_estimate::ParticleDensityCloudInCell::ParticleDensityCloudInCell;
};
} // namespace filter
} // namespace vtkm

6
vtkm/filter/density_estimate/ParticleDensityNearestGridPoint.h
View File

@ -50,6 +50,12 @@ private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace density_estimate
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::density_estimate::ParticleDensityNearestGridPoint.")
ParticleDensityNearestGridPoint
: public vtkm::filter::density_estimate::ParticleDensityNearestGridPoint
{
using density_estimate::ParticleDensityNearestGridPoint::ParticleDensityNearestGridPoint;
};
} // namespace filter
} // namespace vtkm
#endif //vtk_m_filter_density_estimate_ParticleDensityNGP_h

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

@ -76,6 +76,11 @@ private:
std::unique_ptr<vtkm::worklet::ExternalFaces> Worklet;
};
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ExternalFaces.") ExternalFaces
: public vtkm::filter::entity_extraction::ExternalFaces
{
using entity_extraction::ExternalFaces::ExternalFaces;
};
} // namespace filter
} // namespace vtkm

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

@ -80,8 +80,13 @@ private:
bool ExtractOnlyBoundaryCells = false;
vtkm::ImplicitFunctionGeneral Function;
};
}
}
} // namespace vtkm::filter
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ExtractGeometry.") ExtractGeometry
: public vtkm::filter::entity_extraction::ExtractGeometry
{
using entity_extraction::ExtractGeometry::ExtractGeometry;
};
} // namespace filter
} // namespace vtkm
#endif // vtk_m_fulter_entity_extraction_ExtractGeometry_h

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

@ -69,6 +69,11 @@ private:
bool CompactPoints = false;
};
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ExtractPoints.") ExtractPoints
: public vtkm::filter::entity_extraction::ExtractPoints
{
using entity_extraction::ExtractPoints::ExtractPoints;
};
} // namespace filter
} // namespace vtkm

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

@ -92,6 +92,12 @@ private:
};
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8,
"Use vtkm::filter::entity_extraction::ExtractStructured.") ExtractStructured
: public vtkm::filter::entity_extraction::ExtractStructured
{
using entity_extraction::ExtractStructured::ExtractStructured;
};
} // namespace filter
} // namespace vtkm

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

@ -59,6 +59,11 @@ private:
};
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::GhostCellRemove.") GhostCellRemove
: public vtkm::filter::entity_extraction::GhostCellRemove
{
using entity_extraction::GhostCellRemove::GhostCellRemove;
};
} // namespace filter
} // namespace vtkm

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

@ -8,8 +8,8 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_Mask_h
#define vtk_m_filter_Mask_h
#ifndef vtk_m_filter_entity_extraction_Mask_h
#define vtk_m_filter_entity_extraction_Mask_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/entity_extraction/vtkm_filter_entity_extraction_export.h>
@ -47,7 +47,12 @@ private:
bool CompactPoints = false;
};
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::Mask.") Mask
: public vtkm::filter::entity_extraction::Mask
{
using entity_extraction::Mask::Mask;
};
} // namespace filter
} // namespace vtk
#endif // vtk_m_filter_Mask_h
#endif // vtk_m_filter_entity_extraction_Mask_h

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

@ -46,6 +46,11 @@ private:
bool CompactPoints = true;
};
} // namespace eneity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::MaskPoints.") MaskPoints
: public vtkm::filter::entity_extraction::MaskPoints
{
using entity_extraction::MaskPoints::MaskPoints;
};
} // namespace filter
} // namespace vtkm

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

@ -60,6 +60,11 @@ private:
bool ReturnAllInRange = false;
};
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::Threshold.") Threshold
: public vtkm::filter::entity_extraction::Threshold
{
using entity_extraction::Threshold::Threshold;
};
} // namespace filter
} // namespace vtkm

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

@ -62,6 +62,11 @@ private:
bool CompactPoints = false;
};
} // namespace entity_extraction
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::entity_extraction::ThresholdPoints.") ThresholdPoints
: public vtkm::filter::entity_extraction::ThresholdPoints
{
using entity_extraction::ThresholdPoints::ThresholdPoints;
};
} // namespace filter
} // namespace vtkm

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

@ -33,6 +33,11 @@ private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace field_conversion
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_conversion::CellAverage.") CellAverage
: public vtkm::filter::field_conversion::CellAverage
{
using field_conversion::CellAverage::CellAverage;
};
} // namespace filter
} // namespace vtkm

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

@ -32,6 +32,11 @@ private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace field_conversion
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_conversion::PointAverage.") PointAverage
: public vtkm::filter::field_conversion::PointAverage
{
using field_conversion::PointAverage::PointAverage;
};
} // namespace filter
} // namespace vtkm

6
vtkm/filter/field_transform/CMakeLists.txt
View File

@ -8,21 +8,23 @@
## PURPOSE. See the above copyright notice for more information.
##============================================================================
set(field_transform_headers
CoordinateSystemTransform.h
CylindricalCoordinateTransform.h
FieldToColors.h
GenerateIds.h
PointElevation.h
PointTransform.h
SphericalCoordinateTransform.h
WarpScalar.h
WarpVector.h
)
set(field_transform_sources
CoordinateSystemTransform.cxx
CylindricalCoordinateTransform.cxx
FieldToColors.cxx
GenerateIds.cxx
PointElevation.cxx
PointTransform.cxx
SphericalCoordinateTransform.cxx
WarpScalar.cxx
WarpVector.cxx
)

28
vtkm/filter/field_transform/CoordinateSystemTransform.cxx → vtkm/filter/field_transform/CylindricalCoordinateTransform.cxx
View File

@ -8,7 +8,7 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/field_transform/CoordinateSystemTransform.h>
#include <vtkm/filter/field_transform/CylindricalCoordinateTransform.h>
#include <vtkm/filter/field_transform/worklet/CoordinateSystemTransform.h>
namespace vtkm
@ -17,7 +17,7 @@ namespace filter
{
namespace field_transform
{
//-----------------------------------------------------------------------------
vtkm::cont::DataSet CylindricalCoordinateTransform::DoExecute(const vtkm::cont::DataSet& inDataSet)
{
vtkm::cont::UnknownArrayHandle outArray;
@ -42,30 +42,6 @@ vtkm::cont::DataSet CylindricalCoordinateTransform::DoExecute(const vtkm::cont::
return outDataSet;
}
//-----------------------------------------------------------------------------
vtkm::cont::DataSet SphericalCoordinateTransform::DoExecute(const vtkm::cont::DataSet& inDataSet)
{
vtkm::cont::UnknownArrayHandle outArray;
auto resolveType = [&](const auto& concrete) {
// use std::decay to remove const ref from the decltype of concrete.
using T = typename std::decay_t<decltype(concrete)>::ValueType;
vtkm::cont::ArrayHandle<T> result;
vtkm::worklet::SphericalCoordinateTransform worklet{ this->CartesianToSpherical };
worklet.Run(concrete, result);
outArray = result;
};
this->CastAndCallVecField<3>(this->GetFieldFromDataSet(inDataSet), resolveType);
vtkm::cont::DataSet outDataSet =
this->CreateResult(inDataSet,
inDataSet.GetCellSet(),
vtkm::cont::CoordinateSystem("coordinates", outArray),
[](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
out.AddField(fieldToPass);
});
return outDataSet;
}
} // namespace field_transform
} // namespace filter
} // namespace vtkm

25
vtkm/filter/field_transform/CoordinateSystemTransform.h → vtkm/filter/field_transform/CylindricalCoordinateTransform.h
View File

@ -8,8 +8,8 @@
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_field_transform_CoordinateSystemTransform_h
#define vtk_m_filter_field_transform_CoordinateSystemTransform_h
#ifndef vtk_m_filter_field_transform_CylindricalCoordinateTransform_h
#define vtk_m_filter_field_transform_CylindricalCoordinateTransform_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
@ -35,21 +35,14 @@ private:
bool CartesianToCylindrical = true;
};
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT SphericalCoordinateTransform
: public vtkm::filter::NewFilterField
{
public:
VTKM_CONT void SetCartesianToSpherical() { CartesianToSpherical = true; }
VTKM_CONT void SetSphericalToCartesian() { CartesianToSpherical = false; }
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
bool CartesianToSpherical = true;
};
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::CylindricalCoordinateTransform.")
CylindricalCoordinateTransform
: public vtkm::filter::field_transform::CylindricalCoordinateTransform
{
using field_transform::CylindricalCoordinateTransform::CylindricalCoordinateTransform;
};
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_field_transform_CoordinateSystemTransform_h
#endif //vtk_m_filter_field_transform_CylindricalCoordinateTransform_h

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

@ -85,6 +85,11 @@ private:
vtkm::Id ModifiedCount = -1;
};
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::FieldToColors.") FieldToColors
: public vtkm::filter::field_transform::FieldToColors
{
using field_transform::FieldToColors::FieldToColors;
};
} // namespace filter
} // namespace vtkm

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

@ -89,6 +89,11 @@ private:
vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::GenerateIds.") GenerateIds
: public vtkm::filter::field_transform::GenerateIds
{
using field_transform::GenerateIds::GenerateIds;
};
} // namespace vtkm::filter
} // namespace vtkm

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

@ -60,6 +60,11 @@ private:
vtkm::Float64 RangeLow = 0.0, RangeHigh = 1.0;
};
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::PointElevation.") PointElevation
: public vtkm::filter::field_transform::PointElevation
{
using field_transform::PointElevation::PointElevation;
};
} // namespace filter
} // namespace vtkm

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

@ -103,8 +103,13 @@ private:
vtkm::Matrix<vtkm::FloatDefault, 4, 4> matrix;
bool ChangeCoordinateSystem = true;
};
}
}
} // namespace vtkm::filter
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::PointTransform.") PointTransform
: public vtkm::filter::field_transform::PointTransform
{
using field_transform::PointTransform::PointTransform;
};
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_field_transform_PointTransform_h

45
vtkm/filter/field_transform/SphericalCoordinateTransform.cxx Normal file
View File

@ -0,0 +1,45 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#include <vtkm/filter/field_transform/SphericalCoordinateTransform.h>
#include <vtkm/filter/field_transform/worklet/CoordinateSystemTransform.h>
namespace vtkm
{
namespace filter
{
namespace field_transform
{
vtkm::cont::DataSet SphericalCoordinateTransform::DoExecute(const vtkm::cont::DataSet& inDataSet)
{
vtkm::cont::UnknownArrayHandle outArray;
auto resolveType = [&](const auto& concrete) {
// use std::decay to remove const ref from the decltype of concrete.
using T = typename std::decay_t<decltype(concrete)>::ValueType;
vtkm::cont::ArrayHandle<T> result;
vtkm::worklet::SphericalCoordinateTransform worklet{ this->CartesianToSpherical };
worklet.Run(concrete, result);
outArray = result;
};
this->CastAndCallVecField<3>(this->GetFieldFromDataSet(inDataSet), resolveType);
vtkm::cont::DataSet outDataSet =
this->CreateResult(inDataSet,
inDataSet.GetCellSet(),
vtkm::cont::CoordinateSystem("coordinates", outArray),
[](vtkm::cont::DataSet& out, const vtkm::cont::Field& fieldToPass) {
out.AddField(fieldToPass);
});
return outDataSet;
}
} // namespace field_transform
} // namespace filter
} // namespace vtkm

45
vtkm/filter/field_transform/SphericalCoordinateTransform.h Normal file
View File

@ -0,0 +1,45 @@
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
//
// This software is distributed WITHOUT ANY WARRANTY; without even
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
// PURPOSE. See the above copyright notice for more information.
//============================================================================
#ifndef vtk_m_filter_field_transform_SphericalCoordinateTransform_h
#define vtk_m_filter_field_transform_SphericalCoordinateTransform_h
#include <vtkm/filter/NewFilterField.h>
#include <vtkm/filter/field_transform/vtkm_filter_field_transform_export.h>
namespace vtkm
{
namespace filter
{
namespace field_transform
{
class VTKM_FILTER_FIELD_TRANSFORM_EXPORT SphericalCoordinateTransform
: public vtkm::filter::NewFilterField
{
public:
VTKM_CONT void SetCartesianToSpherical() { CartesianToSpherical = true; }
VTKM_CONT void SetSphericalToCartesian() { CartesianToSpherical = false; }
private:
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
bool CartesianToSpherical = true;
};
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::SphericalCoordinateTransform.")
SphericalCoordinateTransform : public vtkm::filter::field_transform::SphericalCoordinateTransform
{
using field_transform::SphericalCoordinateTransform::SphericalCoordinateTransform;
};
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_field_transform_SphericalCoordinateTransform_h

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

@ -87,6 +87,11 @@ private:
vtkm::FloatDefault ScaleAmount;
};
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::WarpScalar.") WarpScalar
: public vtkm::filter::field_transform::WarpScalar
{
using field_transform::WarpScalar::WarpScalar;
};
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_field_transform_WarpScalar_h

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

@ -62,6 +62,11 @@ private:
vtkm::FloatDefault Scale;
};
} // namespace field_transform
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::field_transform::WarpVector.") WarpVector
: public vtkm::filter::field_transform::WarpVector
{
using field_transform::WarpVector::WarpVector;
};
} // namespace filter
} // namespace vtkm
#endif // vtk_m_filter_field_transform_WarpVector_h

3
vtkm/filter/field_transform/testing/UnitTestCoordinateSystemTransform.cxx
View File

@ -9,7 +9,8 @@
//============================================================================
#include <vtkm/cont/testing/Testing.h>
#include <vtkm/filter/field_transform/CoordinateSystemTransform.h>
#include <vtkm/filter/field_transform/CylindricalCoordinateTransform.h>
#include <vtkm/filter/field_transform/SphericalCoordinateTransform.h>
#include <vector>

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

@ -48,6 +48,12 @@ private:
vtkm::FloatDefault FeatureAngle = 30.0;
};
} // namespace geometry_refinement
class VTKM_DEPRECATED(1.8,
"Use vtkm::filter::geometry_refinement::SplitSharpEdges.") SplitSharpEdges
: public vtkm::filter::geometry_refinement::SplitSharpEdges
{
using geometry_refinement::SplitSharpEdges::SplitSharpEdges;
};
} // namespace filter
} // namespace vtkm

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

@ -25,6 +25,11 @@ class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Tetrahedralize : public vtkm::filte
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace geometry_refinement
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::geometry_refinement::Tetrahedralize.") Tetrahedralize
: public vtkm::filter::geometry_refinement::Tetrahedralize
{
using geometry_refinement::Tetrahedralize::Tetrahedralize;
};
} // namespace filter
} // namespace vtkm

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

@ -25,6 +25,11 @@ class VTKM_FILTER_GEOMETRY_REFINEMENT_EXPORT Triangulate : public vtkm::filter::
VTKM_CONT vtkm::cont::DataSet DoExecute(const vtkm::cont::DataSet& input) override;
};
} // namespace geometry_refinement
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::geometry_refinement::Triangulate.") Triangulate
: public vtkm::filter::geometry_refinement::Triangulate
{
using geometry_refinement::Triangulate::Triangulate;
};
} // namespace filter
} // namespace vtkm

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

@ -45,6 +45,11 @@ private:
bool Capping{};
};
} // namespace geometry_refinement
class VTKM_DEPRECATED(1.8, "Use vtkm::filter::geometry_refinement::Tube.") Tube
: public vtkm::filter::geometry_refinement::Tube
{
using geometry_refinement::Tube::Tube;
};
} // namespace filter
} // namespace vtkm

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