Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-10-05 01:49:02 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Combine ResultField + ResultDataSet into Result.

Browse Source
This commit is contained in:
Allison Vacanti 2017-08-10 13:56:19 -04:00
parent 1f451d538b
commit 565896cc49
94 changed files with 576 additions and 688 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -29,8 +29,8 @@ std::string fieldName = "pointvar";
// Create an isosurface filter
vtkm::filter::MarchingCubes filter;
filter.SetIsoValue(0, isovalue);
vtkm::filter::ResultDataSet result = filter.Execute( inputData,
inputData.GetField(fieldName) );
vtkm::filter::Result result = filter.Execute( inputData,
inputData.GetField(fieldName) );
filter.MapFieldOntoOutput(result, inputData.GetField(fieldName));
// compute the bounds and extends of the input data

2
examples/contour_tree/ContourTreeMesh2D.cxx
View File

@ -116,7 +116,7 @@ int main(int argc, char* argv[])
dsf.AddPointField(inDataSet, "values", values);
// Output data set is pairs of saddle and peak vertex IDs
vtkm::filter::ResultField result;
vtkm::filter::Result result;
// Convert 2D mesh of values into contour tree, pairs of vertex ids
vtkm::filter::ContourTreeMesh2D filter;

2
examples/contour_tree/ContourTreeMesh3D.cxx
View File

@ -117,7 +117,7 @@ int main(int argc, char* argv[])
dsf.AddPointField(inDataSet, "values", values);
// Output data set is pairs of saddle and peak vertex IDs
vtkm::filter::ResultField result;
vtkm::filter::Result result;
// Convert 3D mesh of values into contour tree, pairs of vertex ids
vtkm::filter::ContourTreeMesh3D filter;

2
examples/demo/Demo.cxx
View File

@ -119,7 +119,7 @@ int main(int argc, char* argv[])
filter.SetGenerateNormals(false);
filter.SetMergeDuplicatePoints(false);
filter.SetIsoValue(0, isovalue);
vtkm::filter::ResultDataSet result = filter.Execute(inputData, inputData.GetField(fieldName));
vtkm::filter::Result result = filter.Execute(inputData, inputData.GetField(fieldName));
filter.MapFieldOntoOutput(result, inputData.GetField(fieldName));
vtkm::cont::DataSet& outputData = result.GetDataSet();
// Render a separate image with the output isosurface

2
examples/isosurface/IsosurfaceUniformGrid.cxx
View File

@ -246,7 +246,7 @@ int main(int argc, char* argv[])
filter.SetGenerateNormals(true);
filter.SetMergeDuplicatePoints(false);
filter.SetIsoValue(0, 0.5);
vtkm::filter::ResultDataSet result = filter.Execute(dataSet, dataSet.GetField("nodevar"));
vtkm::filter::Result result = filter.Execute(dataSet, dataSet.GetField("nodevar"));
filter.MapFieldOntoOutput(result, dataSet.GetField("nodevar"));

2
examples/tetrahedra/TetrahedralizeExplicitGrid.cxx
View File

@ -302,7 +302,7 @@ int main(int argc, char* argv[])
// Convert cells to tetrahedra
vtkm::filter::Tetrahedralize tetrahedralize;
vtkm::filter::ResultDataSet result = tetrahedralize.Execute(inDataSet);
vtkm::filter::Result result = tetrahedralize.Execute(inDataSet);
outDataSet = result.GetDataSet();

2
examples/tetrahedra/TetrahedralizeUniformGrid.cxx
View File

@ -284,7 +284,7 @@ int main(int argc, char* argv[])
vtkm::cont::DataSet inDataSet = MakeTetrahedralizeTestDataSet(dims);
vtkm::filter::Tetrahedralize tetrahedralize;
vtkm::filter::ResultDataSet result = tetrahedralize.Execute(inDataSet);
vtkm::filter::Result result = tetrahedralize.Execute(inDataSet);
tetDataSet = result.GetDataSet();

2
examples/tetrahedra/TriangulateExplicitGrid.cxx
View File

@ -222,7 +222,7 @@ int main(int argc, char* argv[])
// Convert 2D explicit cells to triangles
vtkm::filter::Triangulate triangulate;
vtkm::filter::ResultDataSet result = triangulate.Execute(inDataSet);
vtkm::filter::Result result = triangulate.Execute(inDataSet);
outDataSet = result.GetDataSet();
// Render the output dataset of tets

2
examples/tetrahedra/TriangulateUniformGrid.cxx
View File

@ -189,7 +189,7 @@ int main(int argc, char* argv[])
// Convert uniform quad to triangle
vtkm::filter::Triangulate triangulate;
vtkm::filter::ResultDataSet result = triangulate.Execute(inDataSet);
vtkm::filter::Result result = triangulate.Execute(inDataSet);
triDataSet = result.GetDataSet();

2
examples/unified_memory/UnifiedMemory.cu
View File

@ -202,7 +202,7 @@ int main(int argc, char* argv[])
filter.SetGenerateNormals(true);
filter.SetMergeDuplicatePoints(false);
filter.SetIsoValue(0.5);
vtkm::filter::ResultDataSet result = filter.Execute(dataSet, dataSet.GetField("nodevar"));
vtkm::filter::Result result = filter.Execute(dataSet, dataSet.GetField("nodevar"));
filter.MapFieldOntoOutput(result, dataSet.GetField("nodevar"));

4
vtkm/filter/CMakeLists.txt
View File

@ -44,9 +44,7 @@ set(headers
PointElevation.h
PolicyBase.h
PolicyDefault.h
ResultBase.h
ResultDataSet.h
ResultField.h
Result.h
SurfaceNormals.h
Tetrahedralize.h
Threshold.h

11
vtkm/filter/CellAverage.h
View File

@ -42,12 +42,11 @@ public:
CellAverage();
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
private:
vtkm::worklet::CellAverage Worklet;

6
vtkm/filter/CellAverage.hxx
View File

@ -36,7 +36,7 @@ inline VTKM_CONT CellAverage::CellAverage()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultField CellAverage::DoExecute(
inline VTKM_CONT vtkm::filter::Result CellAverage::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
@ -45,7 +45,7 @@ inline VTKM_CONT vtkm::filter::ResultField CellAverage::DoExecute(
{
if (!fieldMetadata.IsPointField())
{
return vtkm::filter::ResultField();
return vtkm::filter::Result();
}
vtkm::cont::DynamicCellSet cellSet = input.GetCellSet(this->GetActiveCellSetIndex());
@ -66,7 +66,7 @@ inline VTKM_CONT vtkm::filter::ResultField CellAverage::DoExecute(
outputName = fieldMetadata.GetName();
}
return vtkm::filter::ResultField(
return vtkm::filter::Result(
input, outArray, outputName, vtkm::cont::Field::ASSOC_CELL_SET, cellSet.GetName());
}
}

8
vtkm/filter/CleanGrid.h
View File

@ -58,12 +58,12 @@ public:
void SetCompactPointFields(bool flag) { this->CompactPointFields = flag; }
template <typename Policy, typename Device>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device);
template <typename ValueType, typename Storage, typename Policy, typename Device>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<ValueType, Storage>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<Policy>,

9
vtkm/filter/CleanGrid.hxx
View File

@ -66,10 +66,9 @@ inline VTKM_CONT CleanGrid::CleanGrid()
}
template <typename Policy, typename Device>
inline VTKM_CONT vtkm::filter::ResultDataSet CleanGrid::DoExecute(
const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device)
inline VTKM_CONT vtkm::filter::Result CleanGrid::DoExecute(const vtkm::cont::DataSet& inData,
vtkm::filter::PolicyBase<Policy> policy,
Device)
{
VTKM_IS_DEVICE_ADAPTER_TAG(Device);
@ -144,7 +143,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet CleanGrid::DoExecute(
template <typename ValueType, typename Storage, typename Policy, typename Device>
inline VTKM_CONT bool CleanGrid::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<ValueType, Storage>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
vtkm::filter::PolicyBase<Policy>,

13
vtkm/filter/ClipWithField.h
View File

@ -47,17 +47,16 @@ public:
vtkm::Float64 GetClipValue() const { return this->ClipValue; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter.
//This call is only valid after Execute has been called.
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

8
vtkm/filter/ClipWithField.hxx
View File

@ -65,7 +65,7 @@ inline VTKM_CONT ClipWithField::ClipWithField()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet ClipWithField::DoExecute(
inline VTKM_CONT vtkm::filter::Result ClipWithField::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
@ -78,7 +78,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ClipWithField::DoExecute(
{
//todo: we need to mark this as a failure of input, not a failure
//of the algorithm
return vtkm::filter::ResultDataSet();
return vtkm::filter::Result();
}
//get the cells and coordinates of the dataset
@ -100,7 +100,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ClipWithField::DoExecute(
vtkm::filter::ApplyPolicy(inputCoords, policy).CastAndCall(pointMapper);
vtkm::cont::CoordinateSystem outputCoords(inputCoords.GetName(), outputCoordsArray);
output.AddCoordinateSystem(outputCoords);
vtkm::filter::ResultDataSet result(output);
vtkm::filter::Result result(output);
return result;
}
@ -108,7 +108,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ClipWithField::DoExecute(
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool ClipWithField::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

8
vtkm/filter/ClipWithImplicitFunction.h
View File

@ -56,14 +56,14 @@ public:
}
template <typename DerivedPolicy, typename DeviceAdapter>
vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter.
//This call is only valid after Execute has been called.
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
bool DoMapField(vtkm::filter::ResultDataSet& result,
bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

6
vtkm/filter/ClipWithImplicitFunction.hxx
View File

@ -65,7 +65,7 @@ inline void ClipWithImplicitFunction::SetImplicitFunction(
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline vtkm::filter::ResultDataSet ClipWithImplicitFunction::DoExecute(
inline vtkm::filter::Result ClipWithImplicitFunction::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
@ -92,14 +92,14 @@ inline vtkm::filter::ResultDataSet ClipWithImplicitFunction::DoExecute(
output.AddCellSet(outputCellSet);
output.AddCoordinateSystem(outputCoords);
vtkm::filter::ResultDataSet result(output);
vtkm::filter::Result result(output);
return result;
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline bool ClipWithImplicitFunction::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

22
vtkm/filter/ContourTreeUniform.h
View File

@ -88,12 +88,11 @@ public:
/// Output field
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
};
template <>
@ -117,12 +116,11 @@ public:
/// Output field "saddlePeak" which is pairs of vertex ids indicating saddle and peak of contour
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
};
template <>

28
vtkm/filter/ContourTreeUniform.hxx
View File

@ -79,7 +79,7 @@ ContourTreeMesh2D::ContourTreeMesh2D()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
vtkm::filter::ResultField ContourTreeMesh2D::DoExecute(
vtkm::filter::Result ContourTreeMesh2D::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
@ -89,7 +89,7 @@ vtkm::filter::ResultField ContourTreeMesh2D::DoExecute(
if (fieldMeta.IsPointField() == false)
{
std::cout << "ERROR: Point field expected" << std::endl;
return vtkm::filter::ResultField();
return vtkm::filter::Result();
}
// Collect sizing information from the dataset
@ -108,11 +108,11 @@ vtkm::filter::ResultField ContourTreeMesh2D::DoExecute(
vtkm::worklet::ContourTreeMesh2D worklet;
worklet.Run(field, nRows, nCols, saddlePeak, device);
return vtkm::filter::ResultField(input,
saddlePeak,
this->GetOutputFieldName(),
fieldMeta.GetAssociation(),
fieldMeta.GetCellSetName());
return vtkm::filter::Result(input,
saddlePeak,
this->GetOutputFieldName(),
fieldMeta.GetAssociation(),
fieldMeta.GetCellSetName());
}
//-----------------------------------------------------------------------------
ContourTreeMesh3D::ContourTreeMesh3D()
@ -122,7 +122,7 @@ ContourTreeMesh3D::ContourTreeMesh3D()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
vtkm::filter::ResultField ContourTreeMesh3D::DoExecute(
vtkm::filter::Result ContourTreeMesh3D::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
@ -132,7 +132,7 @@ vtkm::filter::ResultField ContourTreeMesh3D::DoExecute(
if (fieldMeta.IsPointField() == false)
{
std::cout << "ERROR: Point field expected" << std::endl;
return vtkm::filter::ResultField();
return vtkm::filter::Result();
}
// Collect sizing information from the dataset
@ -152,11 +152,11 @@ vtkm::filter::ResultField ContourTreeMesh3D::DoExecute(
vtkm::worklet::ContourTreeMesh3D worklet;
worklet.Run(field, nRows, nCols, nSlices, saddlePeak, device);
return vtkm::filter::ResultField(input,
saddlePeak,
this->GetOutputFieldName(),
fieldMeta.GetAssociation(),
fieldMeta.GetCellSetName());
return vtkm::filter::Result(input,
saddlePeak,
this->GetOutputFieldName(),
fieldMeta.GetAssociation(),
fieldMeta.GetCellSetName());
}
}
} // namespace vtkm::filter

11
vtkm/filter/Entropy.h
View File

@ -43,12 +43,11 @@ public:
void SetNumberOfBins(vtkm::Id count) { this->NumberOfBins = count; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
private:
vtkm::Id NumberOfBins;

39
vtkm/filter/Entropy.hxx
View File

@ -21,29 +21,26 @@
#include <vtkm/worklet/DispatcherMapField.h>
#include <vtkm/worklet/FieldEntropy.h>
namespace vtkm {
namespace filter {
namespace vtkm
{
namespace filter
{
//-----------------------------------------------------------------------------
inline VTKM_CONT
Entropy::Entropy():
NumberOfBins(10)
inline VTKM_CONT Entropy::Entropy()
: NumberOfBins(10)
{
this->SetOutputFieldName("entropy");
}
//-----------------------------------------------------------------------------
template<typename T,
typename StorageType,
typename DerivedPolicy,
typename DeviceAdapter>
inline VTKM_CONT
vtkm::filter::ResultField
Entropy::DoExecute(const vtkm::cont::DataSet &inDataSet,
const vtkm::cont::ArrayHandle<T,StorageType> &field,
const vtkm::filter::FieldMetadata &fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::Result Entropy::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
const vtkm::filter::PolicyBase<DerivedPolicy>&,
const DeviceAdapter& device)
{
vtkm::worklet::FieldEntropy worklet;
@ -54,11 +51,11 @@ Entropy::DoExecute(const vtkm::cont::DataSet &inDataSet,
entropy.Allocate(1);
entropy.GetPortalControl().Set(0, e);
return vtkm::filter::ResultField(inDataSet,
entropy,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
return vtkm::filter::Result(inDataSet,
entropy,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
}
}
} // namespace vtkm::filter

9
vtkm/filter/ExternalFaces.h
View File

@ -64,15 +64,14 @@ public:
}
template <typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

6
vtkm/filter/ExternalFaces.hxx
View File

@ -52,7 +52,7 @@ inline vtkm::filter::PolicyBase<CellSetExplicitPolicy<DerivedPolicy>> GetCellSet
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet ExternalFaces::DoExecute(
inline VTKM_CONT vtkm::filter::Result ExternalFaces::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
@ -107,14 +107,14 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ExternalFaces::DoExecute(
}
else
{
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool ExternalFaces::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

8
vtkm/filter/ExtractGeometry.h
View File

@ -95,13 +95,13 @@ public:
void ExtractOnlyBoundaryCellsOff() { this->ExtractOnlyBoundaryCells = false; }
template <typename DerivedPolicy, typename DeviceAdapter>
vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
bool DoMapField(vtkm::filter::ResultDataSet& result,
bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

4
vtkm/filter/ExtractGeometry.hxx
View File

@ -96,7 +96,7 @@ inline VTKM_CONT ExtractGeometry::ExtractGeometry()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet ExtractGeometry::DoExecute(
inline VTKM_CONT vtkm::filter::Result ExtractGeometry::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
@ -127,7 +127,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ExtractGeometry::DoExecute(
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool ExtractGeometry::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

8
vtkm/filter/ExtractPoints.h
View File

@ -79,13 +79,13 @@ public:
void ExtractInsideOff() { this->ExtractInside = false; }
template <typename DerivedPolicy, typename DeviceAdapter>
vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
bool DoMapField(vtkm::filter::ResultDataSet& result,
bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

6
vtkm/filter/ExtractPoints.hxx
View File

@ -63,7 +63,7 @@ inline VTKM_CONT ExtractPoints::ExtractPoints()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline vtkm::filter::ResultDataSet ExtractPoints::DoExecute(
inline vtkm::filter::Result ExtractPoints::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
@ -96,14 +96,14 @@ inline vtkm::filter::ResultDataSet ExtractPoints::DoExecute(
}
else
{
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool ExtractPoints::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

9
vtkm/filter/ExtractStructured.h
View File

@ -89,14 +89,13 @@ public:
void SetIncludeBoundary(bool value) { this->IncludeBoundary = value; }
template <typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
// Map new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

6
vtkm/filter/ExtractStructured.hxx
View File

@ -37,7 +37,7 @@ inline VTKM_CONT ExtractStructured::ExtractStructured()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet ExtractStructured::DoExecute(
inline VTKM_CONT vtkm::filter::Result ExtractStructured::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
@ -60,13 +60,13 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ExtractStructured::DoExecute(
vtkm::cont::DataSet output;
output.AddCellSet(vtkm::cont::DynamicCellSet(cellset));
output.AddCoordinateSystem(outputCoordinates);
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool ExtractStructured::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

17
vtkm/filter/FilterDataSet.h
View File

@ -28,7 +28,7 @@
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/filter/PolicyBase.h>
#include <vtkm/filter/ResultDataSet.h>
#include <vtkm/filter/Result.h>
namespace vtkm
{
@ -67,11 +67,11 @@ public:
const vtkm::cont::RuntimeDeviceTracker& GetRuntimeDeviceTracker() const { return this->Tracker; }
VTKM_CONT
ResultDataSet Execute(const vtkm::cont::DataSet& input);
Result Execute(const vtkm::cont::DataSet& input);
template <typename DerivedPolicy>
VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//From the field we can extract the association component
// ASSOC_ANY -> unable to map
@ -80,18 +80,17 @@ public:
// ASSOC_CELL_SET -> how do we map this?
// ASSOC_LOGICAL_DIM -> unable to map?
VTKM_CONT
bool MapFieldOntoOutput(ResultDataSet& result, const vtkm::cont::Field& field);
bool MapFieldOntoOutput(Result& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(ResultDataSet& result,
VTKM_CONT bool MapFieldOntoOutput(Result& result,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
template <typename DerivedPolicy>
VTKM_CONT ResultDataSet
PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
std::string OutputFieldName;
vtkm::Id CellSetIndex;

18
vtkm/filter/FilterDataSet.hxx
View File

@ -55,7 +55,7 @@ inline VTKM_CONT FilterDataSet<Derived>::~FilterDataSet()
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT ResultDataSet FilterDataSet<Derived>::Execute(const vtkm::cont::DataSet& input)
inline VTKM_CONT Result FilterDataSet<Derived>::Execute(const vtkm::cont::DataSet& input)
{
return this->Execute(input, vtkm::filter::PolicyDefault());
}
@ -63,7 +63,7 @@ inline VTKM_CONT ResultDataSet FilterDataSet<Derived>::Execute(const vtkm::cont:
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultDataSet
inline VTKM_CONT Result
FilterDataSet<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
@ -76,7 +76,7 @@ namespace detail
template <typename Derived, typename DerivedPolicy>
struct FilterDataSetPrepareForExecutionFunctor
{
vtkm::filter::ResultDataSet Result;
vtkm::filter::Result Result;
Derived* Self;
const vtkm::cont::DataSet& Input;
const vtkm::filter::PolicyBase<DerivedPolicy>& Policy;
@ -95,7 +95,7 @@ struct FilterDataSetPrepareForExecutionFunctor
VTKM_CONT bool operator()(Device)
{
this->Result = this->Self->DoExecute(this->Input, this->Policy, Device());
return this->Result.IsValid();
return this->Result.IsDataSetValid();
}
private:
@ -105,7 +105,7 @@ private:
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultDataSet
inline VTKM_CONT Result
FilterDataSet<Derived>::PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
@ -120,7 +120,7 @@ FilterDataSet<Derived>::PrepareForExecution(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT bool FilterDataSet<Derived>::MapFieldOntoOutput(ResultDataSet& result,
inline VTKM_CONT bool FilterDataSet<Derived>::MapFieldOntoOutput(Result& result,
const vtkm::cont::Field& field)
{
return this->MapFieldOntoOutput(result, field, vtkm::filter::PolicyDefault());
@ -130,12 +130,12 @@ inline VTKM_CONT bool FilterDataSet<Derived>::MapFieldOntoOutput(ResultDataSet&
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT bool FilterDataSet<Derived>::MapFieldOntoOutput(
ResultDataSet& result,
Result& result,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
bool valid = false;
if (result.IsValid())
if (result.IsDataSetValid())
{
vtkm::filter::FieldMetadata metaData(field);
typedef internal::ResolveFieldTypeAndMap<Derived, DerivedPolicy> FunctorType;
@ -148,7 +148,7 @@ inline VTKM_CONT bool FilterDataSet<Derived>::MapFieldOntoOutput(
//the bool valid will be modified by the map algorithm to hold if the
//mapping occurred or not. If the mapping was good a new field has been
//added to the ResultDataSet that was passed in.
//added to the Result that was passed in.
return valid;
}
}

45
vtkm/filter/FilterDataSetWithField.h
View File

@ -28,7 +28,7 @@
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/filter/PolicyBase.h>
#include <vtkm/filter/ResultDataSet.h>
#include <vtkm/filter/Result.h>
namespace vtkm
{
@ -67,29 +67,28 @@ public:
const vtkm::cont::RuntimeDeviceTracker& GetRuntimeDeviceTracker() const { return this->Tracker; }
VTKM_CONT
ResultDataSet Execute(const vtkm::cont::DataSet& input, const std::string& inFieldName);
Result Execute(const vtkm::cont::DataSet& input, const std::string& inFieldName);
VTKM_CONT
ResultDataSet Execute(const vtkm::cont::DataSet& input, const vtkm::cont::Field& field);
Result Execute(const vtkm::cont::DataSet& input, const vtkm::cont::Field& field);
VTKM_CONT
ResultDataSet Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field);
Result Execute(const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field);
template <typename DerivedPolicy>
VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
template <typename DerivedPolicy>
VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
template <typename DerivedPolicy>
VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//From the field we can extract the association component
// ASSOC_ANY -> unable to map
@ -98,26 +97,24 @@ public:
// ASSOC_CELL_SET -> how do we map this?
// ASSOC_LOGICAL_DIM -> unable to map?
VTKM_CONT
bool MapFieldOntoOutput(ResultDataSet& result, const vtkm::cont::Field& field);
bool MapFieldOntoOutput(Result& result, const vtkm::cont::Field& field);
template <typename DerivedPolicy>
VTKM_CONT bool MapFieldOntoOutput(ResultDataSet& result,
VTKM_CONT bool MapFieldOntoOutput(Result& result,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
template <typename DerivedPolicy>
VTKM_CONT ResultDataSet
PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
//How do we specify float/double coordinate types?
template <typename DerivedPolicy>
VTKM_CONT ResultDataSet
PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
std::string OutputFieldName;
vtkm::Id CellSetIndex;

38
vtkm/filter/FilterDataSetWithField.hxx
View File

@ -55,25 +55,23 @@ inline VTKM_CONT FilterDataSetWithField<Derived>::~FilterDataSetWithField()
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT ResultDataSet
FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName)
inline VTKM_CONT Result FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName)
{
return this->Execute(input, input.GetField(inFieldName), vtkm::filter::PolicyDefault());
}
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT ResultDataSet
FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field)
inline VTKM_CONT Result FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field)
{
return this->Execute(input, field, vtkm::filter::PolicyDefault());
}
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT ResultDataSet
inline VTKM_CONT Result
FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field)
{
@ -83,7 +81,7 @@ FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultDataSet
inline VTKM_CONT Result
FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -94,7 +92,7 @@ FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultDataSet
inline VTKM_CONT Result
FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -105,7 +103,7 @@ FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultDataSet
inline VTKM_CONT Result
FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -118,15 +116,15 @@ FilterDataSetWithField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultDataSet FilterDataSetWithField<Derived>::PrepareForExecution(
inline VTKM_CONT Result FilterDataSetWithField<Derived>::PrepareForExecution(
const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
vtkm::filter::FieldMetadata metaData(field);
ResultDataSet result;
Result result;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, ResultDataSet> FunctorType;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, Result> FunctorType;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, this->Tracker, result);
typedef vtkm::filter::FilterTraits<Derived> Traits;
@ -137,7 +135,7 @@ inline VTKM_CONT ResultDataSet FilterDataSetWithField<Derived>::PrepareForExecut
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultDataSet FilterDataSetWithField<Derived>::PrepareForExecution(
inline VTKM_CONT Result FilterDataSetWithField<Derived>::PrepareForExecution(
const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -147,8 +145,8 @@ inline VTKM_CONT ResultDataSet FilterDataSetWithField<Derived>::PrepareForExecut
vtkm::filter::FieldMetadata metaData(field);
//determine the field type first
ResultDataSet result;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, ResultDataSet> FunctorType;
Result result;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, Result> FunctorType;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, this->Tracker, result);
typedef vtkm::filter::FilterTraits<Derived> Traits;
@ -160,7 +158,7 @@ inline VTKM_CONT ResultDataSet FilterDataSetWithField<Derived>::PrepareForExecut
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT bool FilterDataSetWithField<Derived>::MapFieldOntoOutput(
ResultDataSet& result,
Result& result,
const vtkm::cont::Field& field)
{
return this->MapFieldOntoOutput(result, field, vtkm::filter::PolicyDefault());
@ -170,12 +168,12 @@ inline VTKM_CONT bool FilterDataSetWithField<Derived>::MapFieldOntoOutput(
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT bool FilterDataSetWithField<Derived>::MapFieldOntoOutput(
ResultDataSet& result,
Result& result,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
bool valid = false;
if (result.IsValid())
if (result.IsDataSetValid())
{
vtkm::filter::FieldMetadata metaData(field);
typedef internal::ResolveFieldTypeAndMap<Derived, DerivedPolicy> FunctorType;
@ -187,7 +185,7 @@ inline VTKM_CONT bool FilterDataSetWithField<Derived>::MapFieldOntoOutput(
//the bool valid will be modified by the map algorithm to hold if the
//mapping occurred or not. If the mapping was good a new field has been
//added to the ResultDataSet that was passed in.
//added to the Result that was passed in.
return valid;
}
}

38
vtkm/filter/FilterField.h
View File

@ -27,7 +27,7 @@
#include <vtkm/cont/RuntimeDeviceTracker.h>
#include <vtkm/filter/PolicyBase.h>
#include <vtkm/filter/ResultField.h>
#include <vtkm/filter/Result.h>
namespace vtkm
{
@ -60,39 +60,39 @@ public:
const vtkm::cont::RuntimeDeviceTracker& GetRuntimeDeviceTracker() const { return this->Tracker; }
VTKM_CONT
ResultField Execute(const vtkm::cont::DataSet& input, const std::string& inFieldName);
Result Execute(const vtkm::cont::DataSet& input, const std::string& inFieldName);
VTKM_CONT
ResultField Execute(const vtkm::cont::DataSet& input, const vtkm::cont::Field& field);
Result Execute(const vtkm::cont::DataSet& input, const vtkm::cont::Field& field);
VTKM_CONT
ResultField Execute(const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field);
Result Execute(const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field);
template <typename DerivedPolicy>
VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
template <typename DerivedPolicy>
VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
template <typename DerivedPolicy>
VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
private:
template <typename DerivedPolicy>
VTKM_CONT ResultField PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
template <typename DerivedPolicy>
VTKM_CONT ResultField PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
std::string OutputFieldName;
vtkm::cont::RuntimeDeviceTracker Tracker;

31
vtkm/filter/FilterField.hxx
View File

@ -51,25 +51,24 @@ inline VTKM_CONT FilterField<Derived>::~FilterField()
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT ResultField FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName)
inline VTKM_CONT Result FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName)
{
return this->Execute(input, input.GetField(inFieldName), vtkm::filter::PolicyDefault());
}
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT ResultField FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field)
inline VTKM_CONT Result FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field)
{
return this->Execute(input, field, vtkm::filter::PolicyDefault());
}
//-----------------------------------------------------------------------------
template <typename Derived>
inline VTKM_CONT ResultField
FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field)
inline VTKM_CONT Result FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field)
{
return this->Execute(input, field, vtkm::filter::PolicyDefault());
}
@ -77,7 +76,7 @@ FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultField
inline VTKM_CONT Result
FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const std::string& inFieldName,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -88,7 +87,7 @@ FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultField
inline VTKM_CONT Result
FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -99,7 +98,7 @@ FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultField
inline VTKM_CONT Result
FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -112,15 +111,15 @@ FilterField<Derived>::Execute(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultField
inline VTKM_CONT Result
FilterField<Derived>::PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::Field& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
vtkm::filter::FieldMetadata metaData(field);
ResultField result;
Result result;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, ResultField> FunctorType;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, Result> FunctorType;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, this->Tracker, result);
typedef vtkm::filter::FilterTraits<Derived> Traits;
@ -131,7 +130,7 @@ FilterField<Derived>::PrepareForExecution(const vtkm::cont::DataSet& input,
//-----------------------------------------------------------------------------
template <typename Derived>
template <typename DerivedPolicy>
inline VTKM_CONT ResultField
inline VTKM_CONT Result
FilterField<Derived>::PrepareForExecution(const vtkm::cont::DataSet& input,
const vtkm::cont::CoordinateSystem& field,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
@ -140,9 +139,9 @@ FilterField<Derived>::PrepareForExecution(const vtkm::cont::DataSet& input,
//the policy for the storage types and value types just for coordinate systems
vtkm::filter::FieldMetadata metaData(field);
ResultField result;
Result result;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, ResultField> FunctorType;
typedef internal::ResolveFieldTypeAndExecute<Derived, DerivedPolicy, Result> FunctorType;
FunctorType functor(static_cast<Derived*>(this), input, metaData, policy, this->Tracker, result);
typedef vtkm::filter::FilterTraits<Derived> Traits;

10
vtkm/filter/Gradient.h
View File

@ -98,11 +98,11 @@ public:
const std::string& GetQCriterionName() const { return this->QCriterionName; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
vtkm::filter::ResultField DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
private:
bool ComputePointGradient;

8
vtkm/filter/Gradient.hxx
View File

@ -25,7 +25,7 @@ namespace
{
//-----------------------------------------------------------------------------
template <typename HandleType>
inline void add_field(vtkm::filter::ResultField& result,
inline void add_field(vtkm::filter::Result& result,
const HandleType& handle,
const std::string name)
{
@ -80,7 +80,7 @@ Gradient::Gradient()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline vtkm::filter::ResultField Gradient::DoExecute(
inline vtkm::filter::Result Gradient::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
@ -92,7 +92,7 @@ inline vtkm::filter::ResultField Gradient::DoExecute(
//we currently only support point fields, as we need to write the
//worklet to efficiently map a cell field to the points of a cell
//without doing a memory explosion
return vtkm::filter::ResultField();
return vtkm::filter::Result();
}
const vtkm::cont::DynamicCellSet& cells = input.GetCellSet(this->GetActiveCellSetIndex());
@ -141,7 +141,7 @@ inline vtkm::filter::ResultField Gradient::DoExecute(
vtkm::cont::Field::AssociationEnum fieldAssociation(this->ComputePointGradient
? vtkm::cont::Field::ASSOC_POINTS
: vtkm::cont::Field::ASSOC_CELL_SET);
vtkm::filter::ResultField result(input, outArray, outputName, fieldAssociation, cells.GetName());
vtkm::filter::Result result(input, outArray, outputName, fieldAssociation, cells.GetName());
if (this->GetComputeDivergence() && isVector)
{

11
vtkm/filter/Histogram.h
View File

@ -54,12 +54,11 @@ public:
vtkm::Range GetDataRange() const { return this->DataRange; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
private:
vtkm::Id NumberOfBins;

12
vtkm/filter/Histogram.hxx
View File

@ -37,7 +37,7 @@ inline VTKM_CONT Histogram::Histogram()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultField Histogram::DoExecute(
inline VTKM_CONT vtkm::filter::Result Histogram::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
@ -51,11 +51,11 @@ inline VTKM_CONT vtkm::filter::ResultField Histogram::DoExecute(
worklet.Run(field, this->NumberOfBins, this->DataRange, delta, binArray, device);
this->BinDelta = static_cast<vtkm::Float64>(delta);
return vtkm::filter::ResultField(inDataSet,
binArray,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
return vtkm::filter::Result(inDataSet,
binArray,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
}
}
} // namespace vtkm::filter

13
vtkm/filter/MarchingCubes.h
View File

@ -106,17 +106,16 @@ public:
const std::string& GetNormalArrayName() const { return this->NormalArrayName; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

10
vtkm/filter/MarchingCubes.hxx
View File

@ -102,7 +102,7 @@ inline vtkm::Float64 MarchingCubes::GetIsoValue(vtkm::Id index) const
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet MarchingCubes::DoExecute(
inline VTKM_CONT vtkm::filter::Result MarchingCubes::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
@ -113,12 +113,12 @@ inline VTKM_CONT vtkm::filter::ResultDataSet MarchingCubes::DoExecute(
{
//todo: we need to mark this as a failure of input, not a failure
//of the algorithm
return vtkm::filter::ResultDataSet();
return vtkm::filter::Result();
}
if (this->IsoValues.size() == 0)
{
return vtkm::filter::ResultDataSet();
return vtkm::filter::Result();
}
// Check the fields of the dataset to see what kinds of fields are present so
@ -212,13 +212,13 @@ inline VTKM_CONT vtkm::filter::ResultDataSet MarchingCubes::DoExecute(
this->Worklet.ReleaseCellMapArrays();
}
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool MarchingCubes::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

9
vtkm/filter/Mask.h
View File

@ -52,14 +52,13 @@ public:
void SetStride(vtkm::Id& stride) { this->Stride = stride; }
template <typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

4
vtkm/filter/Mask.hxx
View File

@ -59,7 +59,7 @@ inline VTKM_CONT Mask::Mask()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet Mask::DoExecute(
inline VTKM_CONT vtkm::filter::Result Mask::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
@ -79,7 +79,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet Mask::DoExecute(
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool Mask::DoMapField(vtkm::filter::ResultDataSet& result,
inline VTKM_CONT bool Mask::DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

9
vtkm/filter/MaskPoints.h
View File

@ -52,14 +52,13 @@ public:
void SetStride(vtkm::Id stride) { this->Stride = stride; }
template <typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

8
vtkm/filter/MaskPoints.hxx
View File

@ -51,7 +51,7 @@ inline VTKM_CONT MaskPoints::MaskPoints()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet MaskPoints::DoExecute(
inline VTKM_CONT vtkm::filter::Result MaskPoints::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& device)
@ -74,19 +74,19 @@ inline VTKM_CONT vtkm::filter::ResultDataSet MaskPoints::DoExecute(
if (this->CompactPoints)
{
this->Compactor.SetCompactPointFields(true);
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
result = this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy), DeviceAdapter());
return result;
}
else
{
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool MaskPoints::DoMapField(vtkm::filter::ResultDataSet& result,
inline VTKM_CONT bool MaskPoints::DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

11
vtkm/filter/PointAverage.h
View File

@ -41,12 +41,11 @@ public:
PointAverage();
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
private:
vtkm::worklet::PointAverage Worklet;

6
vtkm/filter/PointAverage.hxx
View File

@ -36,7 +36,7 @@ inline VTKM_CONT PointAverage::PointAverage()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultField PointAverage::DoExecute(
inline VTKM_CONT vtkm::filter::Result PointAverage::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& inField,
const vtkm::filter::FieldMetadata& fieldMetadata,
@ -45,7 +45,7 @@ inline VTKM_CONT vtkm::filter::ResultField PointAverage::DoExecute(
{
if (!fieldMetadata.IsCellField())
{
return vtkm::filter::ResultField();
return vtkm::filter::Result();
}
vtkm::cont::DynamicCellSet cellSet = input.GetCellSet(this->GetActiveCellSetIndex());
@ -66,7 +66,7 @@ inline VTKM_CONT vtkm::filter::ResultField PointAverage::DoExecute(
outputName = fieldMetadata.GetName();
}
return vtkm::filter::ResultField(
return vtkm::filter::Result(
input, outArray, outputName, vtkm::cont::Field::ASSOC_POINTS, cellSet.GetName());
}
}

11
vtkm/filter/PointElevation.h
View File

@ -51,12 +51,11 @@ public:
void SetRange(vtkm::Float64 low, vtkm::Float64 high);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
private:
vtkm::worklet::PointElevation Worklet;

12
vtkm/filter/PointElevation.hxx
View File

@ -54,7 +54,7 @@ inline VTKM_CONT void PointElevation::SetRange(vtkm::Float64 low, vtkm::Float64
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultField PointElevation::DoExecute(
inline VTKM_CONT vtkm::filter::Result PointElevation::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
@ -69,11 +69,11 @@ inline VTKM_CONT vtkm::filter::ResultField PointElevation::DoExecute(
//that the dispatcher should do
dispatcher.Invoke(field, outArray);
return vtkm::filter::ResultField(inDataSet,
outArray,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
return vtkm::filter::Result(inDataSet,
outArray,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
}
}
} // namespace vtkm::filter

152
vtkm/filter/ResultField.h → vtkm/filter/Result.h
View File

@ -18,11 +18,11 @@
// this software.
//============================================================================
#ifndef vtk_m_filter_ResultField_h
#define vtk_m_filter_ResultField_h
#include <vtkm/filter/ResultBase.h>
#ifndef vtk_m_filter_Result_h
#define vtk_m_filter_Result_h
#include <vtkm/cont/DataSet.h>
#include <vtkm/cont/ErrorBadValue.h>
#include <vtkm/cont/Field.h>
namespace vtkm
@ -30,29 +30,49 @@ namespace vtkm
namespace filter
{
/// \brief Results for filters that create a field
/// \brief Storage for DataSet and/or Field results returned from a filter.
///
/// \c ResultField contains the results for a filter that generates a new
/// field. The geometry of the underlying data is a shallow copy of the
/// original input.
/// \c Result can store either a \c DataSet, or a \c DataSet and \c Field, depending
/// on the type of filter that produced it. Use \c IsDataSetValid() and
/// \c IsFieldValid() to identify what is stored in the \c Result.
///
/// This class also holds the field that has been added.
/// The \c DataSet and \c Field may be retrieved using \c GetDataSet() and
/// \c GetField() respectively. Attempts to retrieve an invalid result using
/// these methods will throw an \c vtkm::cont::ErrorValue exception.
///
class ResultField : public vtkm::filter::ResultBase
class Result
{
public:
VTKM_CONT
ResultField() {}
Result()
: DataSetValid(false)
, FieldValid(false)
, FieldAssociation(vtkm::cont::Field::ASSOC_ANY)
{
}
/// Use this constructor for DataSet filters (not Field filters).
///
VTKM_CONT
Result(const vtkm::cont::DataSet& dataSet)
: DataSetValid(true)
, Data(dataSet)
, FieldValid(false)
, FieldAssociation(vtkm::cont::Field::ASSOC_ANY)
{
}
/// Use this constructor if the field has already been added to the data set.
/// In this case, just tell us what the field name is (and optionally its
/// association).
///
VTKM_CONT
ResultField(const vtkm::cont::DataSet& dataSet,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation = vtkm::cont::Field::ASSOC_ANY)
: ResultBase(dataSet)
Result(const vtkm::cont::DataSet& dataSet,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation = vtkm::cont::Field::ASSOC_ANY)
: DataSetValid(true)
, Data(dataSet)
, FieldValid(true)
, FieldName(fieldName)
, FieldAssociation(fieldAssociation)
{
@ -60,21 +80,20 @@ public:
VTKM_ASSERT(dataSet.HasField(fieldName, fieldAssociation));
}
/// Use this constructor if you have build a \c Field object. An output
/// Use this constructor if you have built a \c Field object. An output
/// \c DataSet will be created by adding the field to the input.
///
VTKM_CONT
ResultField(const vtkm::cont::DataSet& inDataSet, const vtkm::cont::Field& field)
: FieldName(field.GetName())
Result(const vtkm::cont::DataSet& inDataSet, const vtkm::cont::Field& field)
: DataSetValid(true)
, Data(vtkm::cont::DataSet(inDataSet))
, FieldValid(true)
, FieldName(field.GetName())
, FieldAssociation(field.GetAssociation())
{
this->Data.AddField(field);
VTKM_ASSERT(this->FieldName != "");
vtkm::cont::DataSet outDataSet = inDataSet;
outDataSet.AddField(field);
this->SetDataSet(outDataSet);
// Sanity check.
VTKM_ASSERT(this->GetDataSet().HasField(this->FieldName, this->FieldAssociation));
}
@ -86,34 +105,33 @@ public:
/// for \c ASSOC_WHOLE_MESH and \c ASSOC_POINTS associations.
///
template <typename T, typename Storage>
VTKM_CONT ResultField(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, Storage>& fieldArray,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation,
const std::string& elementSetName = "")
: FieldName(fieldName)
VTKM_CONT Result(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, Storage>& fieldArray,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation,
const std::string& elementSetName = "")
: DataSetValid(true)
, Data(vtkm::cont::DataSet(inDataSet))
, FieldValid(true)
, FieldName(fieldName)
, FieldAssociation(fieldAssociation)
{
VTKM_ASSERT(fieldName != "");
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_ANY);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_LOGICAL_DIM);
vtkm::cont::DataSet outDataSet = inDataSet;
if ((fieldAssociation == vtkm::cont::Field::ASSOC_WHOLE_MESH) ||
(fieldAssociation == vtkm::cont::Field::ASSOC_POINTS))
{
vtkm::cont::Field field(fieldName, fieldAssociation, fieldArray);
outDataSet.AddField(field);
this->Data.AddField(field);
}
else
{
vtkm::cont::Field field(fieldName, fieldAssociation, elementSetName, fieldArray);
outDataSet.AddField(field);
this->Data.AddField(field);
}
this->SetDataSet(outDataSet);
// Sanity check.
VTKM_ASSERT(this->GetDataSet().HasField(this->FieldName, this->FieldAssociation));
}
@ -126,41 +144,73 @@ public:
/// for \c ASSOC_WHOLE_MESH and \c ASSOC_POINTS associations.
///
VTKM_CONT
ResultField(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::DynamicArrayHandle& fieldArray,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation,
const std::string& elementSetName = "")
: FieldName(fieldName)
Result(const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::DynamicArrayHandle& fieldArray,
const std::string& fieldName,
vtkm::cont::Field::AssociationEnum fieldAssociation,
const std::string& elementSetName = "")
: DataSetValid(true)
, Data(vtkm::cont::DataSet(inDataSet))
, FieldValid(true)
, FieldName(fieldName)
, FieldAssociation(fieldAssociation)
{
VTKM_ASSERT(fieldName != "");
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_ANY);
VTKM_ASSERT(fieldAssociation != vtkm::cont::Field::ASSOC_LOGICAL_DIM);
vtkm::cont::DataSet outDataSet = inDataSet;
if ((fieldAssociation == vtkm::cont::Field::ASSOC_WHOLE_MESH) ||
(fieldAssociation == vtkm::cont::Field::ASSOC_POINTS))
{
vtkm::cont::Field field(fieldName, fieldAssociation, fieldArray);
outDataSet.AddField(field);
this->Data.AddField(field);
}
else
{
vtkm::cont::Field field(fieldName, fieldAssociation, elementSetName, fieldArray);
outDataSet.AddField(field);
this->Data.AddField(field);
}
this->SetDataSet(outDataSet);
// Sanity check.
VTKM_ASSERT(this->GetDataSet().HasField(this->FieldName, this->FieldAssociation));
}
/// Returns true if these results are from a successful execution of a
/// filter.
///
VTKM_CONT
bool IsDataSetValid() const { return this->DataSetValid; }
/// Returns the results of the filter in terms of a \c DataSet.
///
VTKM_CONT
const vtkm::cont::DataSet& GetDataSet() const
{
if (!this->DataSetValid)
{
throw vtkm::cont::ErrorBadValue("Result object does not contain a result dataset.");
}
return this->Data;
}
/// Returns the results of the filter in terms of a writable \c DataSet.
VTKM_CONT
vtkm::cont::DataSet& GetDataSet() { return this->Data; }
VTKM_CONT
bool IsFieldValid() const { return this->FieldValid; }
VTKM_CONT
const vtkm::cont::Field& GetField() const
{
if (!this->FieldValid)
{
throw vtkm::cont::ErrorBadValue(
"Result object does not contain a result field, likely because it "
"came from a DataSet filter.");
}
return this->GetDataSet().GetField(this->FieldName, this->FieldAssociation);
}
@ -179,10 +229,14 @@ public:
}
private:
bool DataSetValid;
vtkm::cont::DataSet Data;
bool FieldValid;
std::string FieldName;
vtkm::cont::Field::AssociationEnum FieldAssociation;
};
}
} // namespace vtkm::filter
#endif //vtk_m_filter_ResultField_h
#endif //vtk_m_filter_Result_h

90
vtkm/filter/ResultBase.h
View File

@ -1,90 +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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_filter_ResultBase_h
#define vtk_m_filter_ResultBase_h
#include <vtkm/cont/DataSet.h>
namespace vtkm
{
namespace filter
{
/// \brief Base class for result returned from a filter.
///
/// \c ResultBase is the base class for the return value from any filter. It
/// contains a valid flag that signals whether the filter successfully
/// executed. Also, every filter produces some data on a data set. The
/// resulting data set is also available from this base clase.
///
/// Subclasses may define additional data (usually subparts of the data set)
/// specific to the type of operation.
///
class ResultBase
{
public:
/// Returns true if these results are from a successful execution of a
/// filter.
///
VTKM_CONT
bool IsValid() const { return this->Valid; }
/// Returns the results of the filter in terms of a \c DataSet.
///
VTKM_CONT
const vtkm::cont::DataSet& GetDataSet() const { return this->Data; }
/// Returns the results of the filter in terms of a writable \c DataSet.
VTKM_CONT
vtkm::cont::DataSet& GetDataSet() { return this->Data; }
protected:
VTKM_CONT
ResultBase()
: Valid(false)
{
}
VTKM_CONT
ResultBase(const vtkm::cont::DataSet& dataSet)
: Valid(true)
, Data(dataSet)
{
}
VTKM_CONT
void SetValid(bool valid) { this->Valid = valid; }
VTKM_CONT
void SetDataSet(const vtkm::cont::DataSet& dataSet)
{
this->Data = dataSet;
this->SetValid(true);
}
private:
bool Valid;
vtkm::cont::DataSet Data;
};
}
} // namespace vtkm::filter
#endif //vtk_m_filter_ResultBase_h

56
vtkm/filter/ResultDataSet.h
View File

@ -1,56 +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.
//
// Copyright 2016 Sandia Corporation.
// Copyright 2016 UT-Battelle, LLC.
// Copyright 2016 Los Alamos National Security.
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
#ifndef vtk_m_filter_ResultDataSet_h
#define vtk_m_filter_ResultDataSet_h
#include <vtkm/filter/ResultBase.h>
namespace vtkm
{
namespace filter
{
/// \brief Results for filters that generate new geometry
///
/// \c ResultDataSet contains the results for a filter that generates
/// a wholly new data set (new geometry). Typically little if any data
/// is shared between the filter input and this result.
///
/// Also, data set filters often have secondary operations on the resulting
/// data structure (such as interpolating fields). Thus, this class also
/// allows you to get modifiable versions of the data set.
///
class ResultDataSet : public vtkm::filter::ResultBase
{
public:
VTKM_CONT
ResultDataSet() {}
VTKM_CONT
ResultDataSet(const vtkm::cont::DataSet& dataSet)
: ResultBase(dataSet)
{
}
};
}
} // namespace vtkm::filter
#endif //vtk_m_filter_ResultDataSet_h

8
vtkm/filter/SurfaceNormals.h
View File

@ -66,15 +66,15 @@ public:
/// Execute the filter using the active coordinate system.
VTKM_CONT
vtkm::filter::ResultField Execute(const vtkm::cont::DataSet& input);
vtkm::filter::Result Execute(const vtkm::cont::DataSet& input);
/// Execute the filter using the active coordinate system.
template <typename DerivedPolicy>
VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
VTKM_CONT Result Execute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
vtkm::filter::ResultField DoExecute(
vtkm::filter::Result DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& points,
const vtkm::filter::FieldMetadata& fieldMeta,

28
vtkm/filter/SurfaceNormals.hxx
View File

@ -68,13 +68,13 @@ inline SurfaceNormals::SurfaceNormals()
{
}
inline vtkm::filter::ResultField SurfaceNormals::Execute(const vtkm::cont::DataSet& input)
inline vtkm::filter::Result SurfaceNormals::Execute(const vtkm::cont::DataSet& input)
{
return this->Execute(input, input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()));
}
template <typename DerivedPolicy>
inline vtkm::filter::ResultField SurfaceNormals::Execute(
inline vtkm::filter::Result SurfaceNormals::Execute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy)
{
@ -83,7 +83,7 @@ inline vtkm::filter::ResultField SurfaceNormals::Execute(
}
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline vtkm::filter::ResultField SurfaceNormals::DoExecute(
inline vtkm::filter::Result SurfaceNormals::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<vtkm::Vec<T, 3>, StorageType>& points,
const vtkm::filter::FieldMetadata& fieldMeta,
@ -94,7 +94,7 @@ inline vtkm::filter::ResultField SurfaceNormals::DoExecute(
if (!this->GenerateCellNormals && !this->GeneratePointNormals)
{
return vtkm::filter::ResultField();
return vtkm::filter::Result();
}
const auto& cellset = input.GetCellSet(this->GetActiveCellSetIndex());
@ -104,17 +104,17 @@ inline vtkm::filter::ResultField SurfaceNormals::DoExecute(
faceted.SetNormalize(this->NormalizeCellNormals);
faceted.Run(vtkm::filter::ApplyPolicy(cellset, policy), points, faceNormals, device);
vtkm::filter::ResultField result;
vtkm::filter::Result result;
if (this->GeneratePointNormals)
{
vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::FloatDefault, 3>> pointNormals;
vtkm::worklet::SmoothSurfaceNormals smooth;
smooth.Run(vtkm::filter::ApplyPolicy(cellset, policy), faceNormals, pointNormals, device);
result = vtkm::filter::ResultField(input,
pointNormals,
internal::ComputePointNormalsName(this),
vtkm::cont::Field::ASSOC_POINTS);
result = vtkm::filter::Result(input,
pointNormals,
internal::ComputePointNormalsName(this),
vtkm::cont::Field::ASSOC_POINTS);
if (this->GenerateCellNormals)
{
result.GetDataSet().AddField(vtkm::cont::Field(internal::ComputeCellNormalsName(this),
@ -125,11 +125,11 @@ inline vtkm::filter::ResultField SurfaceNormals::DoExecute(
}
else
{
result = vtkm::filter::ResultField(input,
faceNormals,
internal::ComputeCellNormalsName(this),
vtkm::cont::Field::ASSOC_CELL_SET,
cellset.GetName());
result = vtkm::filter::Result(input,
faceNormals,
internal::ComputeCellNormalsName(this),
vtkm::cont::Field::ASSOC_CELL_SET,
cellset.GetName());
}
return result;

9
vtkm/filter/Tetrahedralize.h
View File

@ -36,14 +36,13 @@ public:
Tetrahedralize();
template <typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
// Map new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

6
vtkm/filter/Tetrahedralize.hxx
View File

@ -58,7 +58,7 @@ inline VTKM_CONT Tetrahedralize::Tetrahedralize()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet Tetrahedralize::DoExecute(
inline VTKM_CONT vtkm::filter::Result Tetrahedralize::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
@ -75,13 +75,13 @@ inline VTKM_CONT vtkm::filter::ResultDataSet Tetrahedralize::DoExecute(
output.AddCellSet(outCellSet);
output.AddCoordinateSystem(input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()));
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool Tetrahedralize::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

13
vtkm/filter/Threshold.h
View File

@ -55,17 +55,16 @@ public:
vtkm::Float64 GetUpperThreshold() const { return this->UpperValue; }
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

4
vtkm/filter/Threshold.hxx
View File

@ -96,7 +96,7 @@ inline VTKM_CONT Threshold::Threshold()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet Threshold::DoExecute(
inline VTKM_CONT vtkm::filter::Result Threshold::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
@ -123,7 +123,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet Threshold::DoExecute(
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool Threshold::DoMapField(vtkm::filter::ResultDataSet& result,
inline VTKM_CONT bool Threshold::DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

13
vtkm/filter/ThresholdPoints.h
View File

@ -61,17 +61,16 @@ public:
void SetThresholdBetween(const vtkm::Float64 value1, const vtkm::Float64 value2);
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

10
vtkm/filter/ThresholdPoints.hxx
View File

@ -144,7 +144,7 @@ inline VTKM_CONT void ThresholdPoints::SetThresholdBetween(const vtkm::Float64 v
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet ThresholdPoints::DoExecute(
inline VTKM_CONT vtkm::filter::Result ThresholdPoints::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
@ -158,7 +158,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ThresholdPoints::DoExecute(
if (fieldMeta.IsPointField() == false)
{
//todo: we need to mark this as a failure of input, not a failure of the algorithm
return vtkm::filter::ResultDataSet();
return vtkm::filter::Result();
}
// run the worklet on the cell set and input field
@ -203,20 +203,20 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ThresholdPoints::DoExecute(
if (this->CompactPoints)
{
this->Compactor.SetCompactPointFields(true);
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
result = this->Compactor.DoExecute(output, GetCellSetSingleTypePolicy(policy), DeviceAdapter());
return result;
}
else
{
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool ThresholdPoints::DoMapField(
vtkm::filter::ResultDataSet& result,
vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

9
vtkm/filter/Triangulate.h
View File

@ -36,14 +36,13 @@ public:
Triangulate();
template <typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
// Map new field onto the resulting dataset after running the filter
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

6
vtkm/filter/Triangulate.hxx
View File

@ -58,7 +58,7 @@ inline VTKM_CONT Triangulate::Triangulate()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet Triangulate::DoExecute(
inline VTKM_CONT vtkm::filter::Result Triangulate::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter&)
@ -75,12 +75,12 @@ inline VTKM_CONT vtkm::filter::ResultDataSet Triangulate::DoExecute(
output.AddCellSet(outCellSet);
output.AddCoordinateSystem(input.GetCoordinateSystem(this->GetActiveCoordinateSystemIndex()));
return vtkm::filter::ResultDataSet(output);
return vtkm::filter::Result(output);
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool Triangulate::DoMapField(vtkm::filter::ResultDataSet& result,
inline VTKM_CONT bool Triangulate::DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

11
vtkm/filter/VectorMagnitude.h
View File

@ -36,12 +36,11 @@ public:
VectorMagnitude();
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultField DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
private:
vtkm::worklet::Magnitude Worklet;

12
vtkm/filter/VectorMagnitude.hxx
View File

@ -35,7 +35,7 @@ inline VTKM_CONT VectorMagnitude::VectorMagnitude()
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultField VectorMagnitude::DoExecute(
inline VTKM_CONT vtkm::filter::Result VectorMagnitude::DoExecute(
const vtkm::cont::DataSet& inDataSet,
const vtkm::cont::ArrayHandle<T, StorageType>& field,
const vtkm::filter::FieldMetadata& fieldMetadata,
@ -50,11 +50,11 @@ inline VTKM_CONT vtkm::filter::ResultField VectorMagnitude::DoExecute(
dispatcher.Invoke(field, outArray);
return vtkm::filter::ResultField(inDataSet,
outArray,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
return vtkm::filter::Result(inDataSet,
outArray,
this->GetOutputFieldName(),
fieldMetadata.GetAssociation(),
fieldMetadata.GetCellSetName());
}
}
} // namespace vtkm::filter

9
vtkm/filter/VertexClustering.h
View File

@ -70,15 +70,14 @@ public:
const vtkm::Id3& GetNumberOfDivisions() const { return this->NumberOfDivisions; }
template <typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT vtkm::filter::ResultDataSet DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag);
//Map a new field onto the resulting dataset after running the filter
//this call is only valid
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result,
VTKM_CONT bool DoMapField(vtkm::filter::Result& result,
const vtkm::cont::ArrayHandle<T, StorageType>& input,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,

6
vtkm/filter/VertexClustering.hxx
View File

@ -32,7 +32,7 @@ inline VTKM_CONT VertexClustering::VertexClustering()
//-----------------------------------------------------------------------------
template <typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT vtkm::filter::ResultDataSet VertexClustering::DoExecute(
inline VTKM_CONT vtkm::filter::Result VertexClustering::DoExecute(
const vtkm::cont::DataSet& input,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const DeviceAdapter& tag)
@ -52,12 +52,12 @@ inline VTKM_CONT vtkm::filter::ResultDataSet VertexClustering::DoExecute(
this->GetNumberOfDivisions(),
tag);
return vtkm::filter::ResultDataSet(outDataSet);
return vtkm::filter::Result(outDataSet);
}
//-----------------------------------------------------------------------------
template <typename T, typename StorageType, typename DerivedPolicy, typename DeviceAdapter>
inline VTKM_CONT bool VertexClustering::DoMapField(vtkm::filter::ResultDataSet&,
inline VTKM_CONT bool VertexClustering::DoMapField(vtkm::filter::Result&,
const vtkm::cont::ArrayHandle<T, StorageType>&,
const vtkm::filter::FieldMetadata&,
const vtkm::filter::PolicyBase<DerivedPolicy>&,

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

@ -81,7 +81,7 @@ private:
{
this->Instance.Result = this->Instance.DerivedClass->DoExecute(
this->Instance.InputData, this->Field, this->Instance.Metadata, this->Instance.Policy, tag);
return this->Instance.Result.IsValid();
return this->Instance.Result.IsFieldValid();
}
private:

6
vtkm/filter/internal/ResolveFieldTypeAndMap.h
View File

@ -33,7 +33,7 @@ namespace vtkm
{
namespace filter
{
class ResultDataSet;
class Result;
}
}
@ -50,14 +50,14 @@ struct ResolveFieldTypeAndMap
typedef ResolveFieldTypeAndMap<Derived, DerivedPolicy> Self;
Derived* DerivedClass;
vtkm::filter::ResultDataSet& InputResult;
vtkm::filter::Result& InputResult;
const vtkm::filter::FieldMetadata& Metadata;
const vtkm::filter::PolicyBase<DerivedPolicy>& Policy;
vtkm::cont::RuntimeDeviceTracker Tracker;
bool& RanProperly;
ResolveFieldTypeAndMap(Derived* derivedClass,
vtkm::filter::ResultDataSet& inResult,
vtkm::filter::Result& inResult,
const vtkm::filter::FieldMetadata& fieldMeta,
const vtkm::filter::PolicyBase<DerivedPolicy>& policy,
const vtkm::cont::RuntimeDeviceTracker& tracker,

12
vtkm/filter/testing/UnitTestCellAverageFilter.cxx
View File

@ -32,7 +32,7 @@ void TestCellAverageRegular3D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::CellAverage cellAverage;
cellAverage.SetOutputFieldName("avgvals");
@ -87,7 +87,7 @@ void TestCellAverageRegular2D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make2DUniformDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::CellAverage cellAverage;
result = cellAverage.Execute(dataSet, dataSet.GetField("pointvar"));
@ -96,11 +96,11 @@ void TestCellAverageRegular2D()
VTKM_TEST_ASSERT(result.GetField().GetName() == "pointvar", "Field was given the wrong name.");
VTKM_TEST_ASSERT(result.GetField().GetAssociation() == vtkm::cont::Field::ASSOC_CELL_SET,
"Field was given the wrong association.");
vtkm::cont::Field resultField = result.GetField();
vtkm::cont::Field Result = result.GetField();
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
resultField.GetData().CopyTo(resultArrayHandle);
Result.GetData().CopyTo(resultArrayHandle);
if (result.IsValid())
if (result.IsDataSetValid())
{
vtkm::Float32 expected[2] = { 30.1f, 40.1f };
for (int i = 0; i < 2; ++i)
@ -118,7 +118,7 @@ void TestCellAverageExplicit()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::CellAverage cellAverage;
result = cellAverage.Execute(dataSet, dataSet.GetField("pointvar"));

4
vtkm/filter/testing/UnitTestCleanGrid.cxx
View File

@ -34,8 +34,8 @@ void TestUniformGrid(vtkm::filter::CleanGrid clean)
vtkm::cont::DataSet inData = makeData.Make2DUniformDataSet0();
vtkm::filter::ResultDataSet result = clean.Execute(inData);
VTKM_TEST_ASSERT(result.IsValid(), "Filter failed to execute");
vtkm::filter::Result result = clean.Execute(inData);
VTKM_TEST_ASSERT(result.IsDataSetValid(), "Filter failed to execute");
bool success;
success = clean.MapFieldOntoOutput(result, inData.GetField("pointvar"));

2
vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx
View File

@ -66,7 +66,7 @@ void TestClipExplicit()
vtkm::cont::DataSet ds = MakeTestDatasetExplicit();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ClipWithField clip;
clip.SetClipValue(0.5);

2
vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx
View File

@ -62,7 +62,7 @@ void TestClipStructured()
vtkm::FloatDefault radius(0.5);
auto sphere = std::make_shared<vtkm::cont::Sphere>(center, radius);
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ClipWithImplicitFunction clip;
clip.SetImplicitFunction(sphere);

12
vtkm/filter/testing/UnitTestContourTreeUniformFilter.cxx
View File

@ -88,15 +88,15 @@ public:
vtkm::cont::DataSet inDataSet = MakeTestDataSet().Make2DUniformDataSet1();
// Output data set is pairs of saddle and peak vertex IDs
vtkm::filter::ResultField result;
vtkm::filter::Result result;
// Convert 2D mesh of values into contour tree, pairs of vertex ids
vtkm::filter::ContourTreeMesh2D contourTreeMesh2D;
result = contourTreeMesh2D.Execute(inDataSet, std::string("pointvar"));
vtkm::cont::Field resultField = result.GetField();
vtkm::cont::Field Result = result.GetField();
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
resultField.GetData().CopyTo(saddlePeak);
Result.GetData().CopyTo(saddlePeak);
VTKM_TEST_ASSERT(test_equal(saddlePeak.GetNumberOfValues(), 7),
"Wrong result for ContourTree filter");
@ -127,15 +127,15 @@ public:
vtkm::cont::DataSet inDataSet = MakeTestDataSet().Make3DUniformDataSet1();
// Output data set is pairs of saddle and peak vertex IDs
vtkm::filter::ResultField result;
vtkm::filter::Result result;
// Convert 2D mesh of values into contour tree, pairs of vertex ids
vtkm::filter::ContourTreeMesh3D contourTreeMesh3D;
result = contourTreeMesh3D.Execute(inDataSet, std::string("pointvar"));
vtkm::cont::Field resultField = result.GetField();
vtkm::cont::Field Result = result.GetField();
vtkm::cont::ArrayHandle<vtkm::Pair<vtkm::Id, vtkm::Id>> saddlePeak;
resultField.GetData().CopyTo(saddlePeak);
Result.GetData().CopyTo(saddlePeak);
VTKM_TEST_ASSERT(test_equal(saddlePeak.GetNumberOfValues(), 9),
"Wrong result for ContourTree filter");

70
vtkm/filter/testing/UnitTestEntropyFilter.cxx
View File

@ -24,7 +24,8 @@
#include <vtkm/cont/testing/Testing.h>
namespace {
namespace
{
///// dataset and field generator from "vtkm-m/vtkm/rendering/testing/UnitTestMapperVolume.cxx" /////
class TangleField : public vtkm::worklet::WorkletMapField
@ -39,25 +40,37 @@ public:
const vtkm::Id cellsPerLayer;
VTKM_CONT
TangleField(const vtkm::Id3 dims, const vtkm::Float32 mins[3], const vtkm::Float32 maxs[3]) : xdim(dims[0]), ydim(dims[1]), zdim(dims[2]),
xmin(mins[0]), ymin(mins[1]), zmin(mins[2]), xmax(maxs[0]), ymax(maxs[1]), zmax(maxs[2]), cellsPerLayer((xdim) * (ydim)) { };
TangleField(const vtkm::Id3 dims, const vtkm::Float32 mins[3], const vtkm::Float32 maxs[3])
: xdim(dims[0])
, ydim(dims[1])
, zdim(dims[2])
, xmin(mins[0])
, ymin(mins[1])
, zmin(mins[2])
, xmax(maxs[0])
, ymax(maxs[1])
, zmax(maxs[2])
, cellsPerLayer((xdim) * (ydim)){};
VTKM_EXEC
void operator()(const vtkm::Id &vertexId, vtkm::Float32 &v) const
void operator()(const vtkm::Id& vertexId, vtkm::Float32& v) const
{
const vtkm::Id x = vertexId % (xdim);
const vtkm::Id y = (vertexId / (xdim)) % (ydim);
const vtkm::Id z = vertexId / cellsPerLayer;
const vtkm::Float32 fx = static_cast<vtkm::Float32>(x) / static_cast<vtkm::Float32>(xdim-1);
const vtkm::Float32 fy = static_cast<vtkm::Float32>(y) / static_cast<vtkm::Float32>(xdim-1);
const vtkm::Float32 fz = static_cast<vtkm::Float32>(z) / static_cast<vtkm::Float32>(xdim-1);
const vtkm::Float32 fx = static_cast<vtkm::Float32>(x) / static_cast<vtkm::Float32>(xdim - 1);
const vtkm::Float32 fy = static_cast<vtkm::Float32>(y) / static_cast<vtkm::Float32>(xdim - 1);
const vtkm::Float32 fz = static_cast<vtkm::Float32>(z) / static_cast<vtkm::Float32>(xdim - 1);
const vtkm::Float32 xx = 3.0f*(xmin+(xmax-xmin)*(fx));
const vtkm::Float32 yy = 3.0f*(ymin+(ymax-ymin)*(fy));
const vtkm::Float32 zz = 3.0f*(zmin+(zmax-zmin)*(fz));
const vtkm::Float32 xx = 3.0f * (xmin + (xmax - xmin) * (fx));
const vtkm::Float32 yy = 3.0f * (ymin + (ymax - ymin) * (fy));
const vtkm::Float32 zz = 3.0f * (zmin + (zmax - zmin) * (fz));
v = (xx*xx*xx*xx - 5.0f*xx*xx + yy*yy*yy*yy - 5.0f*yy*yy + zz*zz*zz*zz - 5.0f*zz*zz + 11.8f) * 0.2f + 0.5f;
v = (xx * xx * xx * xx - 5.0f * xx * xx + yy * yy * yy * yy - 5.0f * yy * yy +
zz * zz * zz * zz - 5.0f * zz * zz + 11.8f) *
0.2f +
0.5f;
}
};
@ -69,24 +82,23 @@ vtkm::cont::DataSet MakeIsosurfaceTestDataSet(vtkm::Id3 dims)
const vtkm::Id3 vdims(dims[0] + 1, dims[1] + 1, dims[2] + 1);
vtkm::Float32 mins[3] = {-1.0f, -1.0f, -1.0f};
vtkm::Float32 maxs[3] = {1.0f, 1.0f, 1.0f};
vtkm::Float32 mins[3] = { -1.0f, -1.0f, -1.0f };
vtkm::Float32 maxs[3] = { 1.0f, 1.0f, 1.0f };
vtkm::cont::ArrayHandle<vtkm::Float32> fieldArray;
vtkm::cont::ArrayHandleCounting<vtkm::Id> vertexCountImplicitArray(0, 1, vdims[0]*vdims[1]*vdims[2]);
vtkm::worklet::DispatcherMapField<TangleField> tangleFieldDispatcher(TangleField(vdims, mins, maxs));
vtkm::cont::ArrayHandleCounting<vtkm::Id> vertexCountImplicitArray(
0, 1, vdims[0] * vdims[1] * vdims[2]);
vtkm::worklet::DispatcherMapField<TangleField> tangleFieldDispatcher(
TangleField(vdims, mins, maxs));
tangleFieldDispatcher.Invoke(vertexCountImplicitArray, fieldArray);
vtkm::Vec<vtkm::FloatDefault,3> origin(0.0f, 0.0f, 0.0f);
vtkm::Vec<vtkm::FloatDefault,3> spacing(
1.0f/static_cast<vtkm::FloatDefault>(dims[0]),
1.0f/static_cast<vtkm::FloatDefault>(dims[2]),
1.0f/static_cast<vtkm::FloatDefault>(dims[1]));
vtkm::Vec<vtkm::FloatDefault, 3> origin(0.0f, 0.0f, 0.0f);
vtkm::Vec<vtkm::FloatDefault, 3> spacing(1.0f / static_cast<vtkm::FloatDefault>(dims[0]),
1.0f / static_cast<vtkm::FloatDefault>(dims[2]),
1.0f / static_cast<vtkm::FloatDefault>(dims[1]));
vtkm::cont::ArrayHandleUniformPointCoordinates
coordinates(vdims, origin, spacing);
dataSet.AddCoordinateSystem(
vtkm::cont::CoordinateSystem("coordinates", coordinates));
vtkm::cont::ArrayHandleUniformPointCoordinates coordinates(vdims, origin, spacing);
dataSet.AddCoordinateSystem(vtkm::cont::CoordinateSystem("coordinates", coordinates));
dataSet.AddField(vtkm::cont::Field("nodevar", vtkm::cont::Field::ASSOC_POINTS, fieldArray));
@ -104,26 +116,26 @@ void TestEntropy()
vtkm::Id3 dims(32, 32, 32);
vtkm::cont::DataSet dataSet = MakeIsosurfaceTestDataSet(dims);
vtkm::filter::ResultField resultEntropy;
vtkm::filter::Result resultEntropy;
vtkm::filter::Entropy entropyFilter;
///// calculate entropy of "nodevar" field of the data set /////
entropyFilter.SetNumberOfBins(50);//set number of bins
entropyFilter.SetNumberOfBins(50); //set number of bins
resultEntropy = entropyFilter.Execute(dataSet, "nodevar");
///// get entropy from resultEntropy /////
vtkm::cont::ArrayHandle<vtkm::Float64> entropy;
resultEntropy.FieldAs(entropy);
vtkm::cont::ArrayHandle<vtkm::Float64>::PortalConstControl portal = entropy.GetPortalConstControl();
vtkm::cont::ArrayHandle<vtkm::Float64>::PortalConstControl portal =
entropy.GetPortalConstControl();
vtkm::Float64 entropyFromFilter = portal.Get(0);
/////// check if calculating entopry is close enough to ground truth value /////
VTKM_TEST_ASSERT(fabs(entropyFromFilter - 4.59093) < 0.001, "Entropy calculation is incorrect");
} // TestFieldEntropy
}
int UnitTestEntropyFilter(int, char *[])
int UnitTestEntropyFilter(int, char* [])
{
return vtkm::cont::testing::Testing::Run(TestEntropy);
}

6
vtkm/filter/testing/UnitTestExternalFacesFilter.cxx
View File

@ -35,7 +35,7 @@ vtkm::cont::DataSet MakeDataTestSet1()
vtkm::cont::DataSet ds = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::CleanGrid clean;
vtkm::filter::ResultDataSet result = clean.Execute(ds);
vtkm::filter::Result result = clean.Execute(ds);
for (vtkm::IdComponent i = 0; i < ds.GetNumberOfFields(); ++i)
{
clean.MapFieldOntoOutput(result, ds.GetField(i));
@ -74,9 +74,9 @@ void TestExternalFacesExplicitGrid(const vtkm::cont::DataSet& ds,
vtkm::filter::ExternalFaces externalFaces;
externalFaces.SetCompactPoints(compactPoints);
externalFaces.SetPassPolyData(passPolyData);
vtkm::filter::ResultDataSet result = externalFaces.Execute(ds);
vtkm::filter::Result result = externalFaces.Execute(ds);
VTKM_TEST_ASSERT(result.IsValid(), "Results should be valid");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "Results should be valid");
// map fields
for (vtkm::IdComponent i = 0; i < ds.GetNumberOfFields(); ++i)

8
vtkm/filter/testing/UnitTestExtractGeometryFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing extract geometry with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(1.f, 1.f, 1.f);
@ -71,7 +71,7 @@ public:
{
std::cout << "Testing extract geometry with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(1.f, 1.f, 1.f);
@ -107,7 +107,7 @@ public:
{
std::cout << "Testing extract geometry with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(0.5f, 0.5f, 0.5f);
@ -142,7 +142,7 @@ public:
{
std::cout << "Testing extract geometry with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(0.5f, 0.5f, 0.5f);

10
vtkm/filter/testing/UnitTestExtractPointsFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing extract points with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(1.f, 1.f, 1.f);
@ -77,7 +77,7 @@ public:
{
std::cout << "Testing extract points with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(1.f, 1.f, 1.f);
@ -120,7 +120,7 @@ public:
{
std::cout << "Testing extract points with implicit function (sphere):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> center(2.f, 2.f, 2.f);
@ -149,7 +149,7 @@ public:
{
std::cout << "Testing extract points with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(0.f, 0.f, 0.f);
@ -178,7 +178,7 @@ public:
{
std::cout << "Testing extract points with implicit function (box):" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Implicit function
vtkm::Vec<vtkm::FloatDefault, 3> minPoint(0.f, 0.f, 0.f);

24
vtkm/filter/testing/UnitTestExtractStructuredFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::RangeId3 range(1, 4, 1, 4, 0, 1);
vtkm::Id3 sample(1, 1, 1);
@ -81,7 +81,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -126,7 +126,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -173,7 +173,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -219,7 +219,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -266,7 +266,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -313,7 +313,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -359,7 +359,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -405,7 +405,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -450,7 +450,7 @@ public:
{
std::cout << "Testing extract structured uniform" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -499,7 +499,7 @@ public:
{
std::cout << "Testing extract structured rectilinear" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DRectilinearDataSet0();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;
@ -543,7 +543,7 @@ public:
{
std::cout << "Testing extract structured rectilinear" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DRectilinearDataSet0();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ExtractStructured extract;

10
vtkm/filter/testing/UnitTestGradient.cxx
View File

@ -33,7 +33,7 @@ void TestCellGradientUniform3D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::Gradient gradient;
gradient.SetOutputFieldName("Gradient");
@ -89,7 +89,7 @@ void TestCellGradientUniform3DWithVectorField()
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec_pointvar", input);
//we need to add Vec3 array to the dataset
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::Gradient gradient;
gradient.SetOutputFieldName("vec_gradient");
gradient.SetComputeVorticity(true);
@ -141,7 +141,7 @@ void TestCellGradientExplicit()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::Gradient gradient;
gradient.SetOutputFieldName("gradient");
@ -183,7 +183,7 @@ void TestPointGradientUniform3DWithVectorField()
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "vec_pointvar", input);
//we need to add Vec3 array to the dataset
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::Gradient gradient;
gradient.SetComputePointGradient(true);
gradient.SetOutputFieldName("vec_gradient");
@ -227,7 +227,7 @@ void TestPointGradientExplicit()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::Gradient gradient;
gradient.SetComputePointGradient(true);
gradient.SetOutputFieldName("gradient");

6
vtkm/filter/testing/UnitTestHistogramFilter.cxx
View File

@ -257,13 +257,13 @@ vtkm::cont::DataSet MakeTestDataSet()
//
// Verify the histogram result and tally
//
void VerifyHistogram(const vtkm::filter::ResultField& result,
void VerifyHistogram(const vtkm::filter::Result& result,
vtkm::Id numberOfBins,
const vtkm::Range& range,
vtkm::Float64 delta,
bool output = true)
{
VTKM_TEST_ASSERT(result.IsValid(), "result should be valid");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "result should be valid");
VTKM_TEST_ASSERT(result.GetField().GetName() == "histogram", "Output field has wrong name.");
vtkm::cont::ArrayHandle<vtkm::Id> bins;
@ -299,7 +299,7 @@ void TestHistogram()
// Data attached is the poisson distribution
vtkm::cont::DataSet ds = MakeTestDataSet();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::Histogram histogram;
// Run data

4
vtkm/filter/testing/UnitTestMarchingCubesFilter.cxx
View File

@ -300,7 +300,7 @@ void TestMarchingCubesUniformGrid()
vtkm::Id3 dims(4, 4, 4);
vtkm::cont::DataSet dataSet = MakeIsosurfaceTestDataSet(dims);
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::MarchingCubes mc;
mc.SetGenerateNormals(true);
@ -369,7 +369,7 @@ void TestMarchingCubesCustomPolicy()
vtkm::cont::Field contourField = dataSet.GetField("distanceToOrigin");
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::MarchingCubes mc;
mc.SetGenerateNormals(false);

6
vtkm/filter/testing/UnitTestMaskFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing mask cells uniform grid :" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Setup and run filter to extract by stride
vtkm::filter::Mask mask;
@ -67,7 +67,7 @@ public:
{
std::cout << "Testing mask cells uniform grid :" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Setup and run filter to extract by stride
vtkm::filter::Mask mask;
@ -98,7 +98,7 @@ public:
{
std::cout << "Testing mask cells explicit:" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
// Setup and run filter to extract by stride
vtkm::filter::Mask mask;

6
vtkm/filter/testing/UnitTestMaskPointsFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing mask points on 2D regular dataset" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::MaskPoints maskPoints;
maskPoints.SetStride(2);
@ -54,7 +54,7 @@ public:
{
std::cout << "Testing mask points on 3D regular dataset" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::MaskPoints maskPoints;
maskPoints.SetStride(5);
@ -73,7 +73,7 @@ public:
{
std::cout << "Testing mask points on 3D explicit dataset" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::MaskPoints maskPoints;
maskPoints.SetStride(3);

14
vtkm/filter/testing/UnitTestPointAverageFilter.cxx
View File

@ -32,7 +32,7 @@ void TestPointAverageUniform3D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DUniformDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::PointAverage pointAverage;
pointAverage.SetOutputFieldName("avgvals");
@ -64,7 +64,7 @@ void TestPointAverageRegular3D()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DRectilinearDataSet0();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::PointAverage pointAverage;
result = pointAverage.Execute(dataSet, dataSet.GetField("cellvar"));
@ -73,11 +73,11 @@ void TestPointAverageRegular3D()
VTKM_TEST_ASSERT(result.GetField().GetName() == "cellvar", "Field was given the wrong name.");
VTKM_TEST_ASSERT(result.GetField().GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Field was given the wrong association.");
vtkm::cont::Field resultField = result.GetField();
vtkm::cont::Field Result = result.GetField();
vtkm::cont::ArrayHandle<vtkm::Float32> resultArrayHandle;
resultField.GetData().CopyTo(resultArrayHandle);
Result.GetData().CopyTo(resultArrayHandle);
if (result.IsValid())
if (result.IsDataSetValid())
{
vtkm::Float32 expected[18] = { 0.f, 0.5f, 1.f, 0.f, 0.5f, 1.f, 1.f, 1.5f, 2.f,
1.f, 1.5f, 2.f, 2.f, 2.5f, 3.f, 2.f, 2.5f, 3.f };
@ -96,7 +96,7 @@ void TestPointAverageExplicit1()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet1();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::PointAverage pointAverage;
result = pointAverage.Execute(dataSet, dataSet.GetField("cellvar"));
@ -126,7 +126,7 @@ void TestPointAverageExplicit2()
vtkm::cont::testing::MakeTestDataSet testDataSet;
vtkm::cont::DataSet dataSet = testDataSet.Make3DExplicitDataSet5();
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::PointAverage pointAverage;
result = pointAverage.Execute(dataSet, dataSet.GetField("cellvar"));

8
vtkm/filter/testing/UnitTestPointElevationFilter.cxx
View File

@ -77,11 +77,11 @@ void TestPointElevationNoPolicy()
filter.SetRange(0.0, 2.0);
filter.SetOutputFieldName("height");
vtkm::filter::ResultField result;
vtkm::filter::Result result;
result = filter.Execute(inputData, inputData.GetCoordinateSystem());
//verify the result
VTKM_TEST_ASSERT(result.IsValid(), "result should be valid");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "result should be valid");
VTKM_TEST_ASSERT(result.GetField().GetName() == "height", "Output field has wrong name.");
VTKM_TEST_ASSERT(result.GetField().GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Output field has wrong association");
@ -115,13 +115,13 @@ void TestPointElevationWithPolicy()
filter.SetHighPoint(0.0, 1.0, 0.0);
filter.SetRange(0.0, 2.0);
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::PolicyDefault p;
result = filter.Execute(inputData, inputData.GetCoordinateSystem(), p);
//verify the result
VTKM_TEST_ASSERT(result.IsValid(), "result should be valid");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "result should be valid");
VTKM_TEST_ASSERT(result.GetField().GetName() == "elevation", "Output field has wrong name.");
VTKM_TEST_ASSERT(result.GetField().GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Output field has wrong association");

2
vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx
View File

@ -71,7 +71,7 @@ void TestSurfaceNormals()
vtkm::cont::DataSet ds = vtkm::cont::testing::MakeTestDataSet().Make3DExplicitDataSetPolygonal();
vtkm::filter::SurfaceNormals filter;
vtkm::filter::ResultField result;
vtkm::filter::Result result;
std::cout << "testing default output (generate only point normals):\n";
result = filter.Execute(ds);

4
vtkm/filter/testing/UnitTestTetrahedralizeFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing tetrahedralize structured" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet0();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::Tetrahedralize tetrahedralize;
@ -64,7 +64,7 @@ public:
{
std::cout << "Testing tetrahedralize explicit" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::Tetrahedralize tetrahedralize;

10
vtkm/filter/testing/UnitTestThresholdFilter.cxx
View File

@ -38,7 +38,7 @@ public:
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DUniformDataSet0();
vtkm::filter::Threshold threshold;
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
threshold.SetLowerThreshold(60.1);
threshold.SetUpperThreshold(60.1);
@ -64,7 +64,7 @@ public:
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet0();
vtkm::filter::Threshold threshold;
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
threshold.SetLowerThreshold(20.1);
threshold.SetUpperThreshold(20.1);
@ -91,7 +91,7 @@ public:
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet1();
vtkm::filter::Threshold threshold;
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
threshold.SetLowerThreshold(20.1);
threshold.SetUpperThreshold(20.1);
@ -118,13 +118,13 @@ public:
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet1();
vtkm::filter::Threshold threshold;
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
threshold.SetLowerThreshold(500.1);
threshold.SetUpperThreshold(500.1);
result = threshold.Execute(dataset, std::string("pointvar"));
VTKM_TEST_ASSERT(result.IsValid(), "threshold algorithm should return true");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "threshold algorithm should return true");
threshold.MapFieldOntoOutput(result, dataset.GetField("cellvar"));

10
vtkm/filter/testing/UnitTestThresholdPointsFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing threshold points on 2D regular dataset" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ThresholdPoints thresholdPoints;
thresholdPoints.SetThresholdBetween(40.0f, 71.0f);
@ -61,7 +61,7 @@ public:
{
std::cout << "Testing threshold points on 3D regular dataset" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ThresholdPoints thresholdPoints;
thresholdPoints.SetThresholdAbove(1.0f);
@ -88,7 +88,7 @@ public:
{
std::cout << "Testing threshold points on 3D explicit dataset" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet5();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::ThresholdPoints thresholdPoints;
thresholdPoints.SetThresholdBelow(50.0);
@ -117,12 +117,12 @@ public:
vtkm::cont::DataSet dataset = MakeTestDataSet().Make3DExplicitDataSet1();
vtkm::filter::ThresholdPoints thresholdPoints;
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
thresholdPoints.SetThresholdBetween(500.0, 600.0);
result = thresholdPoints.Execute(dataset, std::string("pointvar"));
VTKM_TEST_ASSERT(result.IsValid(), "threshold algorithm should return true");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "threshold algorithm should return true");
thresholdPoints.MapFieldOntoOutput(result, dataset.GetField("pointvar"));

4
vtkm/filter/testing/UnitTestTriangulateFilter.cxx
View File

@ -35,7 +35,7 @@ public:
{
std::cout << "Testing triangulate structured" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DUniformDataSet1();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::Triangulate triangulate;
@ -63,7 +63,7 @@ public:
{
std::cout << "Testing triangulate explicit" << std::endl;
vtkm::cont::DataSet dataset = MakeTestDataSet().Make2DExplicitDataSet0();
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
vtkm::filter::Triangulate triangulate;

4
vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx
View File

@ -47,12 +47,12 @@ void TestVectorMagnitude()
vtkm::cont::DataSetFieldAdd::AddPointField(dataSet, "double_vec_pointvar", finput);
vtkm::filter::ResultField result;
vtkm::filter::Result result;
vtkm::filter::VectorMagnitude vm;
result = vm.Execute(dataSet, dataSet.GetField("double_vec_pointvar"));
VTKM_TEST_ASSERT(result.IsValid(), "result should be valid");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "result should be valid");
VTKM_TEST_ASSERT(result.GetField().GetName() == "magnitude", "Output field has wrong name.");
VTKM_TEST_ASSERT(result.GetField().GetAssociation() == vtkm::cont::Field::ASSOC_POINTS,
"Output field has wrong association");

4
vtkm/filter/testing/UnitTestVertexClusteringFilter.cxx
View File

@ -35,12 +35,12 @@ void TestVertexClustering()
vtkm::cont::DataSet dataSet = maker.Make3DExplicitDataSetCowNose();
vtkm::filter::VertexClustering clustering;
vtkm::filter::ResultDataSet result;
vtkm::filter::Result result;
clustering.SetNumberOfDivisions(vtkm::Id3(3, 3, 3));
result = clustering.Execute(dataSet);
VTKM_TEST_ASSERT(result.IsValid(), "results should be valid");
VTKM_TEST_ASSERT(result.IsDataSetValid(), "results should be valid");
vtkm::cont::DataSet output = result.GetDataSet();
VTKM_TEST_ASSERT(output.GetNumberOfCoordinateSystems() == 1,