From 565896cc493227eae9fe843612902faecad639d6 Mon Sep 17 00:00:00 2001 From: Allison Vacanti Date: Thu, 10 Aug 2017 13:56:19 -0400 Subject: [PATCH] Combine ResultField + ResultDataSet into Result. --- README.md | 4 +- examples/contour_tree/ContourTreeMesh2D.cxx | 2 +- examples/contour_tree/ContourTreeMesh3D.cxx | 2 +- examples/demo/Demo.cxx | 2 +- examples/isosurface/IsosurfaceUniformGrid.cxx | 2 +- .../tetrahedra/TetrahedralizeExplicitGrid.cxx | 2 +- .../tetrahedra/TetrahedralizeUniformGrid.cxx | 2 +- .../tetrahedra/TriangulateExplicitGrid.cxx | 2 +- .../tetrahedra/TriangulateUniformGrid.cxx | 2 +- examples/unified_memory/UnifiedMemory.cu | 2 +- vtkm/filter/CMakeLists.txt | 4 +- vtkm/filter/CellAverage.h | 11 +- vtkm/filter/CellAverage.hxx | 6 +- vtkm/filter/CleanGrid.h | 8 +- vtkm/filter/CleanGrid.hxx | 9 +- vtkm/filter/ClipWithField.h | 13 +- vtkm/filter/ClipWithField.hxx | 8 +- vtkm/filter/ClipWithImplicitFunction.h | 8 +- vtkm/filter/ClipWithImplicitFunction.hxx | 6 +- vtkm/filter/ContourTreeUniform.h | 22 ++- vtkm/filter/ContourTreeUniform.hxx | 28 ++-- vtkm/filter/Entropy.h | 11 +- vtkm/filter/Entropy.hxx | 39 +++-- vtkm/filter/ExternalFaces.h | 9 +- vtkm/filter/ExternalFaces.hxx | 6 +- vtkm/filter/ExtractGeometry.h | 8 +- vtkm/filter/ExtractGeometry.hxx | 4 +- vtkm/filter/ExtractPoints.h | 8 +- vtkm/filter/ExtractPoints.hxx | 6 +- vtkm/filter/ExtractStructured.h | 9 +- vtkm/filter/ExtractStructured.hxx | 6 +- vtkm/filter/FilterDataSet.h | 17 +- vtkm/filter/FilterDataSet.hxx | 18 +-- vtkm/filter/FilterDataSetWithField.h | 45 +++--- vtkm/filter/FilterDataSetWithField.hxx | 38 +++-- vtkm/filter/FilterField.h | 38 ++--- vtkm/filter/FilterField.hxx | 31 ++-- vtkm/filter/Gradient.h | 10 +- vtkm/filter/Gradient.hxx | 8 +- vtkm/filter/Histogram.h | 11 +- vtkm/filter/Histogram.hxx | 12 +- vtkm/filter/MarchingCubes.h | 13 +- vtkm/filter/MarchingCubes.hxx | 10 +- vtkm/filter/Mask.h | 9 +- vtkm/filter/Mask.hxx | 4 +- vtkm/filter/MaskPoints.h | 9 +- vtkm/filter/MaskPoints.hxx | 8 +- vtkm/filter/PointAverage.h | 11 +- vtkm/filter/PointAverage.hxx | 6 +- vtkm/filter/PointElevation.h | 11 +- vtkm/filter/PointElevation.hxx | 12 +- vtkm/filter/{ResultField.h => Result.h} | 152 ++++++++++++------ vtkm/filter/ResultBase.h | 90 ----------- vtkm/filter/ResultDataSet.h | 56 ------- vtkm/filter/SurfaceNormals.h | 8 +- vtkm/filter/SurfaceNormals.hxx | 28 ++-- vtkm/filter/Tetrahedralize.h | 9 +- vtkm/filter/Tetrahedralize.hxx | 6 +- vtkm/filter/Threshold.h | 13 +- vtkm/filter/Threshold.hxx | 4 +- vtkm/filter/ThresholdPoints.h | 13 +- vtkm/filter/ThresholdPoints.hxx | 10 +- vtkm/filter/Triangulate.h | 9 +- vtkm/filter/Triangulate.hxx | 6 +- vtkm/filter/VectorMagnitude.h | 11 +- vtkm/filter/VectorMagnitude.hxx | 12 +- vtkm/filter/VertexClustering.h | 9 +- vtkm/filter/VertexClustering.hxx | 6 +- .../internal/ResolveFieldTypeAndExecute.h | 2 +- vtkm/filter/internal/ResolveFieldTypeAndMap.h | 6 +- .../testing/UnitTestCellAverageFilter.cxx | 12 +- vtkm/filter/testing/UnitTestCleanGrid.cxx | 4 +- .../testing/UnitTestClipWithFieldFilter.cxx | 2 +- ...UnitTestClipWithImplicitFunctionFilter.cxx | 2 +- .../UnitTestContourTreeUniformFilter.cxx | 12 +- vtkm/filter/testing/UnitTestEntropyFilter.cxx | 70 ++++---- .../testing/UnitTestExternalFacesFilter.cxx | 6 +- .../testing/UnitTestExtractGeometryFilter.cxx | 8 +- .../testing/UnitTestExtractPointsFilter.cxx | 10 +- .../UnitTestExtractStructuredFilter.cxx | 24 +-- vtkm/filter/testing/UnitTestGradient.cxx | 10 +- .../testing/UnitTestHistogramFilter.cxx | 6 +- .../testing/UnitTestMarchingCubesFilter.cxx | 4 +- vtkm/filter/testing/UnitTestMaskFilter.cxx | 6 +- .../testing/UnitTestMaskPointsFilter.cxx | 6 +- .../testing/UnitTestPointAverageFilter.cxx | 14 +- .../testing/UnitTestPointElevationFilter.cxx | 8 +- .../testing/UnitTestSurfaceNormalsFilter.cxx | 2 +- .../testing/UnitTestTetrahedralizeFilter.cxx | 4 +- .../testing/UnitTestThresholdFilter.cxx | 10 +- .../testing/UnitTestThresholdPointsFilter.cxx | 10 +- .../testing/UnitTestTriangulateFilter.cxx | 4 +- .../testing/UnitTestVectorMagnitudeFilter.cxx | 4 +- .../UnitTestVertexClusteringFilter.cxx | 4 +- 94 files changed, 576 insertions(+), 688 deletions(-) rename vtkm/filter/{ResultField.h => Result.h} (56%) delete mode 100644 vtkm/filter/ResultBase.h delete mode 100644 vtkm/filter/ResultDataSet.h diff --git a/README.md b/README.md index b13dc70cf..9227a7309 100644 --- a/README.md +++ b/README.md @@ -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 diff --git a/examples/contour_tree/ContourTreeMesh2D.cxx b/examples/contour_tree/ContourTreeMesh2D.cxx index ecd8ac9ca..5fa2104d9 100644 --- a/examples/contour_tree/ContourTreeMesh2D.cxx +++ b/examples/contour_tree/ContourTreeMesh2D.cxx @@ -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; diff --git a/examples/contour_tree/ContourTreeMesh3D.cxx b/examples/contour_tree/ContourTreeMesh3D.cxx index f21d587e3..6d03a5bb9 100644 --- a/examples/contour_tree/ContourTreeMesh3D.cxx +++ b/examples/contour_tree/ContourTreeMesh3D.cxx @@ -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; diff --git a/examples/demo/Demo.cxx b/examples/demo/Demo.cxx index 4d4045971..86a1f6c3e 100644 --- a/examples/demo/Demo.cxx +++ b/examples/demo/Demo.cxx @@ -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 diff --git a/examples/isosurface/IsosurfaceUniformGrid.cxx b/examples/isosurface/IsosurfaceUniformGrid.cxx index 52c505b7f..a563c4d33 100644 --- a/examples/isosurface/IsosurfaceUniformGrid.cxx +++ b/examples/isosurface/IsosurfaceUniformGrid.cxx @@ -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")); diff --git a/examples/tetrahedra/TetrahedralizeExplicitGrid.cxx b/examples/tetrahedra/TetrahedralizeExplicitGrid.cxx index 82dbe19b2..b4bb2d1da 100644 --- a/examples/tetrahedra/TetrahedralizeExplicitGrid.cxx +++ b/examples/tetrahedra/TetrahedralizeExplicitGrid.cxx @@ -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(); diff --git a/examples/tetrahedra/TetrahedralizeUniformGrid.cxx b/examples/tetrahedra/TetrahedralizeUniformGrid.cxx index 35335e062..21da1c32f 100644 --- a/examples/tetrahedra/TetrahedralizeUniformGrid.cxx +++ b/examples/tetrahedra/TetrahedralizeUniformGrid.cxx @@ -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(); diff --git a/examples/tetrahedra/TriangulateExplicitGrid.cxx b/examples/tetrahedra/TriangulateExplicitGrid.cxx index 1c6ad9b93..2e4425411 100644 --- a/examples/tetrahedra/TriangulateExplicitGrid.cxx +++ b/examples/tetrahedra/TriangulateExplicitGrid.cxx @@ -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 diff --git a/examples/tetrahedra/TriangulateUniformGrid.cxx b/examples/tetrahedra/TriangulateUniformGrid.cxx index 73ad1ccd5..893e55655 100644 --- a/examples/tetrahedra/TriangulateUniformGrid.cxx +++ b/examples/tetrahedra/TriangulateUniformGrid.cxx @@ -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(); diff --git a/examples/unified_memory/UnifiedMemory.cu b/examples/unified_memory/UnifiedMemory.cu index bff9c4789..9acef878f 100644 --- a/examples/unified_memory/UnifiedMemory.cu +++ b/examples/unified_memory/UnifiedMemory.cu @@ -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")); diff --git a/vtkm/filter/CMakeLists.txt b/vtkm/filter/CMakeLists.txt index 09009f216..c30206e66 100644 --- a/vtkm/filter/CMakeLists.txt +++ b/vtkm/filter/CMakeLists.txt @@ -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 diff --git a/vtkm/filter/CellAverage.h b/vtkm/filter/CellAverage.h index 4c2eeaf81..b53184c9a 100644 --- a/vtkm/filter/CellAverage.h +++ b/vtkm/filter/CellAverage.h @@ -42,12 +42,11 @@ public: CellAverage(); template - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); private: vtkm::worklet::CellAverage Worklet; diff --git a/vtkm/filter/CellAverage.hxx b/vtkm/filter/CellAverage.hxx index dd47aa7ed..987d505f3 100644 --- a/vtkm/filter/CellAverage.hxx +++ b/vtkm/filter/CellAverage.hxx @@ -36,7 +36,7 @@ inline VTKM_CONT CellAverage::CellAverage() //----------------------------------------------------------------------------- template -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& 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()); } } diff --git a/vtkm/filter/CleanGrid.h b/vtkm/filter/CleanGrid.h index b99744775..dea2779f8 100644 --- a/vtkm/filter/CleanGrid.h +++ b/vtkm/filter/CleanGrid.h @@ -58,12 +58,12 @@ public: void SetCompactPointFields(bool flag) { this->CompactPointFields = flag; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& inData, - vtkm::filter::PolicyBase policy, - Device); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& inData, + vtkm::filter::PolicyBase policy, + Device); template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, vtkm::filter::PolicyBase, diff --git a/vtkm/filter/CleanGrid.hxx b/vtkm/filter/CleanGrid.hxx index 56004a8f9..f291fee8d 100644 --- a/vtkm/filter/CleanGrid.hxx +++ b/vtkm/filter/CleanGrid.hxx @@ -66,10 +66,9 @@ inline VTKM_CONT CleanGrid::CleanGrid() } template -inline VTKM_CONT vtkm::filter::ResultDataSet CleanGrid::DoExecute( - const vtkm::cont::DataSet& inData, - vtkm::filter::PolicyBase policy, - Device) +inline VTKM_CONT vtkm::filter::Result CleanGrid::DoExecute(const vtkm::cont::DataSet& inData, + vtkm::filter::PolicyBase policy, + Device) { VTKM_IS_DEVICE_ADAPTER_TAG(Device); @@ -144,7 +143,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet CleanGrid::DoExecute( template inline VTKM_CONT bool CleanGrid::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, vtkm::filter::PolicyBase, diff --git a/vtkm/filter/ClipWithField.h b/vtkm/filter/ClipWithField.h index 2fd0187f4..003dd515e 100644 --- a/vtkm/filter/ClipWithField.h +++ b/vtkm/filter/ClipWithField.h @@ -47,17 +47,16 @@ public: vtkm::Float64 GetClipValue() const { return this->ClipValue; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& 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 - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ClipWithField.hxx b/vtkm/filter/ClipWithField.hxx index 0884073f2..a5afc48ee 100644 --- a/vtkm/filter/ClipWithField.hxx +++ b/vtkm/filter/ClipWithField.hxx @@ -65,7 +65,7 @@ inline VTKM_CONT ClipWithField::ClipWithField() //----------------------------------------------------------------------------- template -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& 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 inline VTKM_CONT bool ClipWithField::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/ClipWithImplicitFunction.h b/vtkm/filter/ClipWithImplicitFunction.h index 8b96d409b..90ab3de53 100644 --- a/vtkm/filter/ClipWithImplicitFunction.h +++ b/vtkm/filter/ClipWithImplicitFunction.h @@ -56,14 +56,14 @@ public: } template - vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& 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 - bool DoMapField(vtkm::filter::ResultDataSet& result, + bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ClipWithImplicitFunction.hxx b/vtkm/filter/ClipWithImplicitFunction.hxx index b9348bdff..4369a3827 100644 --- a/vtkm/filter/ClipWithImplicitFunction.hxx +++ b/vtkm/filter/ClipWithImplicitFunction.hxx @@ -65,7 +65,7 @@ inline void ClipWithImplicitFunction::SetImplicitFunction( //----------------------------------------------------------------------------- template -inline vtkm::filter::ResultDataSet ClipWithImplicitFunction::DoExecute( +inline vtkm::filter::Result ClipWithImplicitFunction::DoExecute( const vtkm::cont::DataSet& input, const vtkm::filter::PolicyBase& 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 inline bool ClipWithImplicitFunction::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/ContourTreeUniform.h b/vtkm/filter/ContourTreeUniform.h index 4306c0e5c..25521a5c5 100644 --- a/vtkm/filter/ContourTreeUniform.h +++ b/vtkm/filter/ContourTreeUniform.h @@ -88,12 +88,11 @@ public: /// Output field template - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& 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 - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); }; template <> diff --git a/vtkm/filter/ContourTreeUniform.hxx b/vtkm/filter/ContourTreeUniform.hxx index f9fd0f3d2..c86043430 100644 --- a/vtkm/filter/ContourTreeUniform.hxx +++ b/vtkm/filter/ContourTreeUniform.hxx @@ -79,7 +79,7 @@ ContourTreeMesh2D::ContourTreeMesh2D() //----------------------------------------------------------------------------- template -vtkm::filter::ResultField ContourTreeMesh2D::DoExecute( +vtkm::filter::Result ContourTreeMesh2D::DoExecute( const vtkm::cont::DataSet& input, const vtkm::cont::ArrayHandle& 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 -vtkm::filter::ResultField ContourTreeMesh3D::DoExecute( +vtkm::filter::Result ContourTreeMesh3D::DoExecute( const vtkm::cont::DataSet& input, const vtkm::cont::ArrayHandle& 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 diff --git a/vtkm/filter/Entropy.h b/vtkm/filter/Entropy.h index 741560c6c..9d24a1416 100644 --- a/vtkm/filter/Entropy.h +++ b/vtkm/filter/Entropy.h @@ -43,12 +43,11 @@ public: void SetNumberOfBins(vtkm::Id count) { this->NumberOfBins = count; } template - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); private: vtkm::Id NumberOfBins; diff --git a/vtkm/filter/Entropy.hxx b/vtkm/filter/Entropy.hxx index 90c83a89c..ffc96ace0 100644 --- a/vtkm/filter/Entropy.hxx +++ b/vtkm/filter/Entropy.hxx @@ -21,29 +21,26 @@ #include #include -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 -inline VTKM_CONT -vtkm::filter::ResultField -Entropy::DoExecute(const vtkm::cont::DataSet &inDataSet, - const vtkm::cont::ArrayHandle &field, - const vtkm::filter::FieldMetadata &fieldMetadata, - const vtkm::filter::PolicyBase&, - const DeviceAdapter& device) +template +inline VTKM_CONT vtkm::filter::Result Entropy::DoExecute( + const vtkm::cont::DataSet& inDataSet, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMetadata, + const vtkm::filter::PolicyBase&, + 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 diff --git a/vtkm/filter/ExternalFaces.h b/vtkm/filter/ExternalFaces.h index 1f8ba76ed..04c189b04 100644 --- a/vtkm/filter/ExternalFaces.h +++ b/vtkm/filter/ExternalFaces.h @@ -64,15 +64,14 @@ public: } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter //this call is only valid template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ExternalFaces.hxx b/vtkm/filter/ExternalFaces.hxx index 3f135bc83..86585fd34 100644 --- a/vtkm/filter/ExternalFaces.hxx +++ b/vtkm/filter/ExternalFaces.hxx @@ -52,7 +52,7 @@ inline vtkm::filter::PolicyBase> GetCellSet //----------------------------------------------------------------------------- template -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& 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 inline VTKM_CONT bool ExternalFaces::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ExtractGeometry.h b/vtkm/filter/ExtractGeometry.h index 5ebeb8605..078758737 100644 --- a/vtkm/filter/ExtractGeometry.h +++ b/vtkm/filter/ExtractGeometry.h @@ -95,13 +95,13 @@ public: void ExtractOnlyBoundaryCellsOff() { this->ExtractOnlyBoundaryCells = false; } template - vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter template - bool DoMapField(vtkm::filter::ResultDataSet& result, + bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ExtractGeometry.hxx b/vtkm/filter/ExtractGeometry.hxx index a93f51791..d9f9f87b6 100644 --- a/vtkm/filter/ExtractGeometry.hxx +++ b/vtkm/filter/ExtractGeometry.hxx @@ -96,7 +96,7 @@ inline VTKM_CONT ExtractGeometry::ExtractGeometry() //----------------------------------------------------------------------------- template -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& policy, const DeviceAdapter&) @@ -127,7 +127,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet ExtractGeometry::DoExecute( //----------------------------------------------------------------------------- template inline VTKM_CONT bool ExtractGeometry::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/ExtractPoints.h b/vtkm/filter/ExtractPoints.h index 481e86f27..89f0fe72b 100644 --- a/vtkm/filter/ExtractPoints.h +++ b/vtkm/filter/ExtractPoints.h @@ -79,13 +79,13 @@ public: void ExtractInsideOff() { this->ExtractInside = false; } template - vtkm::filter::ResultDataSet DoExecute(const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter template - bool DoMapField(vtkm::filter::ResultDataSet& result, + bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ExtractPoints.hxx b/vtkm/filter/ExtractPoints.hxx index 3ba9b3de6..ab9963668 100644 --- a/vtkm/filter/ExtractPoints.hxx +++ b/vtkm/filter/ExtractPoints.hxx @@ -63,7 +63,7 @@ inline VTKM_CONT ExtractPoints::ExtractPoints() //----------------------------------------------------------------------------- template -inline vtkm::filter::ResultDataSet ExtractPoints::DoExecute( +inline vtkm::filter::Result ExtractPoints::DoExecute( const vtkm::cont::DataSet& input, const vtkm::filter::PolicyBase& 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 inline VTKM_CONT bool ExtractPoints::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ExtractStructured.h b/vtkm/filter/ExtractStructured.h index 7a837956d..e181dc3ed 100644 --- a/vtkm/filter/ExtractStructured.h +++ b/vtkm/filter/ExtractStructured.h @@ -89,14 +89,13 @@ public: void SetIncludeBoundary(bool value) { this->IncludeBoundary = value; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); // Map new field onto the resulting dataset after running the filter template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ExtractStructured.hxx b/vtkm/filter/ExtractStructured.hxx index 22d5e8833..0633a6ebb 100644 --- a/vtkm/filter/ExtractStructured.hxx +++ b/vtkm/filter/ExtractStructured.hxx @@ -37,7 +37,7 @@ inline VTKM_CONT ExtractStructured::ExtractStructured() //----------------------------------------------------------------------------- template -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& 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 inline VTKM_CONT bool ExtractStructured::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/FilterDataSet.h b/vtkm/filter/FilterDataSet.h index 5c844dbe4..7420e1b63 100644 --- a/vtkm/filter/FilterDataSet.h +++ b/vtkm/filter/FilterDataSet.h @@ -28,7 +28,7 @@ #include #include -#include +#include 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 - VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& 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 - VTKM_CONT bool MapFieldOntoOutput(ResultDataSet& result, + VTKM_CONT bool MapFieldOntoOutput(Result& result, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy); private: template - VTKM_CONT ResultDataSet - PrepareForExecution(const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy); std::string OutputFieldName; vtkm::Id CellSetIndex; diff --git a/vtkm/filter/FilterDataSet.hxx b/vtkm/filter/FilterDataSet.hxx index 348a03ffb..092aca56e 100644 --- a/vtkm/filter/FilterDataSet.hxx +++ b/vtkm/filter/FilterDataSet.hxx @@ -55,7 +55,7 @@ inline VTKM_CONT FilterDataSet::~FilterDataSet() //----------------------------------------------------------------------------- template -inline VTKM_CONT ResultDataSet FilterDataSet::Execute(const vtkm::cont::DataSet& input) +inline VTKM_CONT Result FilterDataSet::Execute(const vtkm::cont::DataSet& input) { return this->Execute(input, vtkm::filter::PolicyDefault()); } @@ -63,7 +63,7 @@ inline VTKM_CONT ResultDataSet FilterDataSet::Execute(const vtkm::cont: //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultDataSet +inline VTKM_CONT Result FilterDataSet::Execute(const vtkm::cont::DataSet& input, const vtkm::filter::PolicyBase& policy) { @@ -76,7 +76,7 @@ namespace detail template struct FilterDataSetPrepareForExecutionFunctor { - vtkm::filter::ResultDataSet Result; + vtkm::filter::Result Result; Derived* Self; const vtkm::cont::DataSet& Input; const vtkm::filter::PolicyBase& 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 template -inline VTKM_CONT ResultDataSet +inline VTKM_CONT Result FilterDataSet::PrepareForExecution(const vtkm::cont::DataSet& input, const vtkm::filter::PolicyBase& policy) { @@ -120,7 +120,7 @@ FilterDataSet::PrepareForExecution(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template -inline VTKM_CONT bool FilterDataSet::MapFieldOntoOutput(ResultDataSet& result, +inline VTKM_CONT bool FilterDataSet::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::MapFieldOntoOutput(ResultDataSet& template template inline VTKM_CONT bool FilterDataSet::MapFieldOntoOutput( - ResultDataSet& result, + Result& result, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy) { bool valid = false; - if (result.IsValid()) + if (result.IsDataSetValid()) { vtkm::filter::FieldMetadata metaData(field); typedef internal::ResolveFieldTypeAndMap FunctorType; @@ -148,7 +148,7 @@ inline VTKM_CONT bool FilterDataSet::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; } } diff --git a/vtkm/filter/FilterDataSetWithField.h b/vtkm/filter/FilterDataSetWithField.h index 5f6b3fac8..077eb4754 100644 --- a/vtkm/filter/FilterDataSetWithField.h +++ b/vtkm/filter/FilterDataSetWithField.h @@ -28,7 +28,7 @@ #include #include -#include +#include 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 - VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input, - const std::string& inFieldName, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const std::string& inFieldName, + const vtkm::filter::PolicyBase& policy); template - VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input, - const vtkm::cont::Field& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const vtkm::cont::Field& field, + const vtkm::filter::PolicyBase& policy); template - VTKM_CONT ResultDataSet Execute(const vtkm::cont::DataSet& input, - const vtkm::cont::CoordinateSystem& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const vtkm::cont::CoordinateSystem& field, + const vtkm::filter::PolicyBase& 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 - VTKM_CONT bool MapFieldOntoOutput(ResultDataSet& result, + VTKM_CONT bool MapFieldOntoOutput(Result& result, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy); private: template - VTKM_CONT ResultDataSet - PrepareForExecution(const vtkm::cont::DataSet& input, - const vtkm::cont::Field& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input, + const vtkm::cont::Field& field, + const vtkm::filter::PolicyBase& policy); //How do we specify float/double coordinate types? template - VTKM_CONT ResultDataSet - PrepareForExecution(const vtkm::cont::DataSet& input, - const vtkm::cont::CoordinateSystem& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input, + const vtkm::cont::CoordinateSystem& field, + const vtkm::filter::PolicyBase& policy); std::string OutputFieldName; vtkm::Id CellSetIndex; diff --git a/vtkm/filter/FilterDataSetWithField.hxx b/vtkm/filter/FilterDataSetWithField.hxx index ad3c0d4e7..403c6daf7 100644 --- a/vtkm/filter/FilterDataSetWithField.hxx +++ b/vtkm/filter/FilterDataSetWithField.hxx @@ -55,25 +55,23 @@ inline VTKM_CONT FilterDataSetWithField::~FilterDataSetWithField() //----------------------------------------------------------------------------- template -inline VTKM_CONT ResultDataSet -FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, - const std::string& inFieldName) +inline VTKM_CONT Result FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, + const std::string& inFieldName) { return this->Execute(input, input.GetField(inFieldName), vtkm::filter::PolicyDefault()); } //----------------------------------------------------------------------------- template -inline VTKM_CONT ResultDataSet -FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, - const vtkm::cont::Field& field) +inline VTKM_CONT Result FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, + const vtkm::cont::Field& field) { return this->Execute(input, field, vtkm::filter::PolicyDefault()); } //----------------------------------------------------------------------------- template -inline VTKM_CONT ResultDataSet +inline VTKM_CONT Result FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field) { @@ -83,7 +81,7 @@ FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultDataSet +inline VTKM_CONT Result FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, const std::string& inFieldName, const vtkm::filter::PolicyBase& policy) @@ -94,7 +92,7 @@ FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultDataSet +inline VTKM_CONT Result FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy) @@ -105,7 +103,7 @@ FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultDataSet +inline VTKM_CONT Result FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field, const vtkm::filter::PolicyBase& policy) @@ -118,15 +116,15 @@ FilterDataSetWithField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultDataSet FilterDataSetWithField::PrepareForExecution( +inline VTKM_CONT Result FilterDataSetWithField::PrepareForExecution( const vtkm::cont::DataSet& input, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy) { vtkm::filter::FieldMetadata metaData(field); - ResultDataSet result; + Result result; - typedef internal::ResolveFieldTypeAndExecute FunctorType; + typedef internal::ResolveFieldTypeAndExecute FunctorType; FunctorType functor(static_cast(this), input, metaData, policy, this->Tracker, result); typedef vtkm::filter::FilterTraits Traits; @@ -137,7 +135,7 @@ inline VTKM_CONT ResultDataSet FilterDataSetWithField::PrepareForExecut //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultDataSet FilterDataSetWithField::PrepareForExecution( +inline VTKM_CONT Result FilterDataSetWithField::PrepareForExecution( const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field, const vtkm::filter::PolicyBase& policy) @@ -147,8 +145,8 @@ inline VTKM_CONT ResultDataSet FilterDataSetWithField::PrepareForExecut vtkm::filter::FieldMetadata metaData(field); //determine the field type first - ResultDataSet result; - typedef internal::ResolveFieldTypeAndExecute FunctorType; + Result result; + typedef internal::ResolveFieldTypeAndExecute FunctorType; FunctorType functor(static_cast(this), input, metaData, policy, this->Tracker, result); typedef vtkm::filter::FilterTraits Traits; @@ -160,7 +158,7 @@ inline VTKM_CONT ResultDataSet FilterDataSetWithField::PrepareForExecut //----------------------------------------------------------------------------- template inline VTKM_CONT bool FilterDataSetWithField::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::MapFieldOntoOutput( template template inline VTKM_CONT bool FilterDataSetWithField::MapFieldOntoOutput( - ResultDataSet& result, + Result& result, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy) { bool valid = false; - if (result.IsValid()) + if (result.IsDataSetValid()) { vtkm::filter::FieldMetadata metaData(field); typedef internal::ResolveFieldTypeAndMap FunctorType; @@ -187,7 +185,7 @@ inline VTKM_CONT bool FilterDataSetWithField::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; } } diff --git a/vtkm/filter/FilterField.h b/vtkm/filter/FilterField.h index b28a63e89..243ebaf74 100644 --- a/vtkm/filter/FilterField.h +++ b/vtkm/filter/FilterField.h @@ -27,7 +27,7 @@ #include #include -#include +#include 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 - VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input, - const std::string& inFieldName, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const std::string& inFieldName, + const vtkm::filter::PolicyBase& policy); template - VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input, - const vtkm::cont::Field& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const vtkm::cont::Field& field, + const vtkm::filter::PolicyBase& policy); template - VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input, - const vtkm::cont::CoordinateSystem& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const vtkm::cont::CoordinateSystem& field, + const vtkm::filter::PolicyBase& policy); private: template - VTKM_CONT ResultField PrepareForExecution(const vtkm::cont::DataSet& input, - const vtkm::cont::Field& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input, + const vtkm::cont::Field& field, + const vtkm::filter::PolicyBase& policy); template - VTKM_CONT ResultField PrepareForExecution(const vtkm::cont::DataSet& input, - const vtkm::cont::CoordinateSystem& field, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result PrepareForExecution(const vtkm::cont::DataSet& input, + const vtkm::cont::CoordinateSystem& field, + const vtkm::filter::PolicyBase& policy); std::string OutputFieldName; vtkm::cont::RuntimeDeviceTracker Tracker; diff --git a/vtkm/filter/FilterField.hxx b/vtkm/filter/FilterField.hxx index 60e15dcaa..29278541c 100644 --- a/vtkm/filter/FilterField.hxx +++ b/vtkm/filter/FilterField.hxx @@ -51,25 +51,24 @@ inline VTKM_CONT FilterField::~FilterField() //----------------------------------------------------------------------------- template -inline VTKM_CONT ResultField FilterField::Execute(const vtkm::cont::DataSet& input, - const std::string& inFieldName) +inline VTKM_CONT Result FilterField::Execute(const vtkm::cont::DataSet& input, + const std::string& inFieldName) { return this->Execute(input, input.GetField(inFieldName), vtkm::filter::PolicyDefault()); } //----------------------------------------------------------------------------- template -inline VTKM_CONT ResultField FilterField::Execute(const vtkm::cont::DataSet& input, - const vtkm::cont::Field& field) +inline VTKM_CONT Result FilterField::Execute(const vtkm::cont::DataSet& input, + const vtkm::cont::Field& field) { return this->Execute(input, field, vtkm::filter::PolicyDefault()); } //----------------------------------------------------------------------------- template -inline VTKM_CONT ResultField -FilterField::Execute(const vtkm::cont::DataSet& input, - const vtkm::cont::CoordinateSystem& field) +inline VTKM_CONT Result FilterField::Execute(const vtkm::cont::DataSet& input, + const vtkm::cont::CoordinateSystem& field) { return this->Execute(input, field, vtkm::filter::PolicyDefault()); } @@ -77,7 +76,7 @@ FilterField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultField +inline VTKM_CONT Result FilterField::Execute(const vtkm::cont::DataSet& input, const std::string& inFieldName, const vtkm::filter::PolicyBase& policy) @@ -88,7 +87,7 @@ FilterField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultField +inline VTKM_CONT Result FilterField::Execute(const vtkm::cont::DataSet& input, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy) @@ -99,7 +98,7 @@ FilterField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultField +inline VTKM_CONT Result FilterField::Execute(const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field, const vtkm::filter::PolicyBase& policy) @@ -112,15 +111,15 @@ FilterField::Execute(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultField +inline VTKM_CONT Result FilterField::PrepareForExecution(const vtkm::cont::DataSet& input, const vtkm::cont::Field& field, const vtkm::filter::PolicyBase& policy) { vtkm::filter::FieldMetadata metaData(field); - ResultField result; + Result result; - typedef internal::ResolveFieldTypeAndExecute FunctorType; + typedef internal::ResolveFieldTypeAndExecute FunctorType; FunctorType functor(static_cast(this), input, metaData, policy, this->Tracker, result); typedef vtkm::filter::FilterTraits Traits; @@ -131,7 +130,7 @@ FilterField::PrepareForExecution(const vtkm::cont::DataSet& input, //----------------------------------------------------------------------------- template template -inline VTKM_CONT ResultField +inline VTKM_CONT Result FilterField::PrepareForExecution(const vtkm::cont::DataSet& input, const vtkm::cont::CoordinateSystem& field, const vtkm::filter::PolicyBase& policy) @@ -140,9 +139,9 @@ FilterField::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 FunctorType; + typedef internal::ResolveFieldTypeAndExecute FunctorType; FunctorType functor(static_cast(this), input, metaData, policy, this->Tracker, result); typedef vtkm::filter::FilterTraits Traits; diff --git a/vtkm/filter/Gradient.h b/vtkm/filter/Gradient.h index 70006e76e..66aa81fe9 100644 --- a/vtkm/filter/Gradient.h +++ b/vtkm/filter/Gradient.h @@ -98,11 +98,11 @@ public: const std::string& GetQCriterionName() const { return this->QCriterionName; } template - vtkm::filter::ResultField DoExecute(const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); private: bool ComputePointGradient; diff --git a/vtkm/filter/Gradient.hxx b/vtkm/filter/Gradient.hxx index fa055122a..e2c643284 100644 --- a/vtkm/filter/Gradient.hxx +++ b/vtkm/filter/Gradient.hxx @@ -25,7 +25,7 @@ namespace { //----------------------------------------------------------------------------- template -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 -inline vtkm::filter::ResultField Gradient::DoExecute( +inline vtkm::filter::Result Gradient::DoExecute( const vtkm::cont::DataSet& input, const vtkm::cont::ArrayHandle& 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) { diff --git a/vtkm/filter/Histogram.h b/vtkm/filter/Histogram.h index 206c35f91..7ec499171 100644 --- a/vtkm/filter/Histogram.h +++ b/vtkm/filter/Histogram.h @@ -54,12 +54,11 @@ public: vtkm::Range GetDataRange() const { return this->DataRange; } template - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); private: vtkm::Id NumberOfBins; diff --git a/vtkm/filter/Histogram.hxx b/vtkm/filter/Histogram.hxx index 00c1fc529..67e419ccd 100644 --- a/vtkm/filter/Histogram.hxx +++ b/vtkm/filter/Histogram.hxx @@ -37,7 +37,7 @@ inline VTKM_CONT Histogram::Histogram() //----------------------------------------------------------------------------- template -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& 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(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 diff --git a/vtkm/filter/MarchingCubes.h b/vtkm/filter/MarchingCubes.h index 257782984..59584fee0 100644 --- a/vtkm/filter/MarchingCubes.h +++ b/vtkm/filter/MarchingCubes.h @@ -106,17 +106,16 @@ public: const std::string& GetNormalArrayName() const { return this->NormalArrayName; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter //this call is only valid template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/MarchingCubes.hxx b/vtkm/filter/MarchingCubes.hxx index b901f9935..d6938ab89 100644 --- a/vtkm/filter/MarchingCubes.hxx +++ b/vtkm/filter/MarchingCubes.hxx @@ -102,7 +102,7 @@ inline vtkm::Float64 MarchingCubes::GetIsoValue(vtkm::Id index) const //----------------------------------------------------------------------------- template -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& 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 inline VTKM_CONT bool MarchingCubes::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/Mask.h b/vtkm/filter/Mask.h index a13c54095..b938863c1 100644 --- a/vtkm/filter/Mask.h +++ b/vtkm/filter/Mask.h @@ -52,14 +52,13 @@ public: void SetStride(vtkm::Id& stride) { this->Stride = stride; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/Mask.hxx b/vtkm/filter/Mask.hxx index 640f66ac1..f25e99fcd 100644 --- a/vtkm/filter/Mask.hxx +++ b/vtkm/filter/Mask.hxx @@ -59,7 +59,7 @@ inline VTKM_CONT Mask::Mask() //----------------------------------------------------------------------------- template -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& policy, const DeviceAdapter&) @@ -79,7 +79,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet Mask::DoExecute( //----------------------------------------------------------------------------- template -inline VTKM_CONT bool Mask::DoMapField(vtkm::filter::ResultDataSet& result, +inline VTKM_CONT bool Mask::DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/MaskPoints.h b/vtkm/filter/MaskPoints.h index 1b12999f8..69fe0510c 100644 --- a/vtkm/filter/MaskPoints.h +++ b/vtkm/filter/MaskPoints.h @@ -52,14 +52,13 @@ public: void SetStride(vtkm::Id stride) { this->Stride = stride; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/MaskPoints.hxx b/vtkm/filter/MaskPoints.hxx index 350ff80c8..25be71b09 100644 --- a/vtkm/filter/MaskPoints.hxx +++ b/vtkm/filter/MaskPoints.hxx @@ -51,7 +51,7 @@ inline VTKM_CONT MaskPoints::MaskPoints() //----------------------------------------------------------------------------- template -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& 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 -inline VTKM_CONT bool MaskPoints::DoMapField(vtkm::filter::ResultDataSet& result, +inline VTKM_CONT bool MaskPoints::DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/PointAverage.h b/vtkm/filter/PointAverage.h index 1262fbfa0..72e833941 100644 --- a/vtkm/filter/PointAverage.h +++ b/vtkm/filter/PointAverage.h @@ -41,12 +41,11 @@ public: PointAverage(); template - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); private: vtkm::worklet::PointAverage Worklet; diff --git a/vtkm/filter/PointAverage.hxx b/vtkm/filter/PointAverage.hxx index 67ce420a3..daa2f19ec 100644 --- a/vtkm/filter/PointAverage.hxx +++ b/vtkm/filter/PointAverage.hxx @@ -36,7 +36,7 @@ inline VTKM_CONT PointAverage::PointAverage() //----------------------------------------------------------------------------- template -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& 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()); } } diff --git a/vtkm/filter/PointElevation.h b/vtkm/filter/PointElevation.h index 5dc46c88b..c5e835347 100644 --- a/vtkm/filter/PointElevation.h +++ b/vtkm/filter/PointElevation.h @@ -51,12 +51,11 @@ public: void SetRange(vtkm::Float64 low, vtkm::Float64 high); template - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); private: vtkm::worklet::PointElevation Worklet; diff --git a/vtkm/filter/PointElevation.hxx b/vtkm/filter/PointElevation.hxx index f5dcab8f4..e43eba5e0 100644 --- a/vtkm/filter/PointElevation.hxx +++ b/vtkm/filter/PointElevation.hxx @@ -54,7 +54,7 @@ inline VTKM_CONT void PointElevation::SetRange(vtkm::Float64 low, vtkm::Float64 //----------------------------------------------------------------------------- template -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& 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 diff --git a/vtkm/filter/ResultField.h b/vtkm/filter/Result.h similarity index 56% rename from vtkm/filter/ResultField.h rename to vtkm/filter/Result.h index a92736826..8a69be473 100644 --- a/vtkm/filter/ResultField.h +++ b/vtkm/filter/Result.h @@ -18,11 +18,11 @@ // this software. //============================================================================ -#ifndef vtk_m_filter_ResultField_h -#define vtk_m_filter_ResultField_h - -#include +#ifndef vtk_m_filter_Result_h +#define vtk_m_filter_Result_h +#include +#include #include 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 - VTKM_CONT ResultField(const vtkm::cont::DataSet& inDataSet, - const vtkm::cont::ArrayHandle& 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& 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 diff --git a/vtkm/filter/ResultBase.h b/vtkm/filter/ResultBase.h deleted file mode 100644 index 0d12f0559..000000000 --- a/vtkm/filter/ResultBase.h +++ /dev/null @@ -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 - -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 diff --git a/vtkm/filter/ResultDataSet.h b/vtkm/filter/ResultDataSet.h deleted file mode 100644 index a0be89203..000000000 --- a/vtkm/filter/ResultDataSet.h +++ /dev/null @@ -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 - -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 diff --git a/vtkm/filter/SurfaceNormals.h b/vtkm/filter/SurfaceNormals.h index 36b7f157b..c24c3b761 100644 --- a/vtkm/filter/SurfaceNormals.h +++ b/vtkm/filter/SurfaceNormals.h @@ -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 - VTKM_CONT ResultField Execute(const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy); + VTKM_CONT Result Execute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy); template - vtkm::filter::ResultField DoExecute( + vtkm::filter::Result DoExecute( const vtkm::cont::DataSet& input, const vtkm::cont::ArrayHandle, StorageType>& points, const vtkm::filter::FieldMetadata& fieldMeta, diff --git a/vtkm/filter/SurfaceNormals.hxx b/vtkm/filter/SurfaceNormals.hxx index 407921c96..f5610ee9e 100644 --- a/vtkm/filter/SurfaceNormals.hxx +++ b/vtkm/filter/SurfaceNormals.hxx @@ -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 -inline vtkm::filter::ResultField SurfaceNormals::Execute( +inline vtkm::filter::Result SurfaceNormals::Execute( const vtkm::cont::DataSet& input, const vtkm::filter::PolicyBase& policy) { @@ -83,7 +83,7 @@ inline vtkm::filter::ResultField SurfaceNormals::Execute( } template -inline vtkm::filter::ResultField SurfaceNormals::DoExecute( +inline vtkm::filter::Result SurfaceNormals::DoExecute( const vtkm::cont::DataSet& input, const vtkm::cont::ArrayHandle, 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> 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; diff --git a/vtkm/filter/Tetrahedralize.h b/vtkm/filter/Tetrahedralize.h index 8eed88db0..30c68e1fd 100644 --- a/vtkm/filter/Tetrahedralize.h +++ b/vtkm/filter/Tetrahedralize.h @@ -36,14 +36,13 @@ public: Tetrahedralize(); template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); // Map new field onto the resulting dataset after running the filter template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/Tetrahedralize.hxx b/vtkm/filter/Tetrahedralize.hxx index 73ac88ec0..e82fba577 100644 --- a/vtkm/filter/Tetrahedralize.hxx +++ b/vtkm/filter/Tetrahedralize.hxx @@ -58,7 +58,7 @@ inline VTKM_CONT Tetrahedralize::Tetrahedralize() //----------------------------------------------------------------------------- template -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& 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 inline VTKM_CONT bool Tetrahedralize::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/Threshold.h b/vtkm/filter/Threshold.h index c3fc105b3..e4875cf6c 100644 --- a/vtkm/filter/Threshold.h +++ b/vtkm/filter/Threshold.h @@ -55,17 +55,16 @@ public: vtkm::Float64 GetUpperThreshold() const { return this->UpperValue; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter //this call is only valid template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/Threshold.hxx b/vtkm/filter/Threshold.hxx index d82fc975b..4dafc9569 100644 --- a/vtkm/filter/Threshold.hxx +++ b/vtkm/filter/Threshold.hxx @@ -96,7 +96,7 @@ inline VTKM_CONT Threshold::Threshold() //----------------------------------------------------------------------------- template -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& field, const vtkm::filter::FieldMetadata& fieldMeta, @@ -123,7 +123,7 @@ inline VTKM_CONT vtkm::filter::ResultDataSet Threshold::DoExecute( //----------------------------------------------------------------------------- template -inline VTKM_CONT bool Threshold::DoMapField(vtkm::filter::ResultDataSet& result, +inline VTKM_CONT bool Threshold::DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/ThresholdPoints.h b/vtkm/filter/ThresholdPoints.h index a60e17b91..d88f96d55 100644 --- a/vtkm/filter/ThresholdPoints.h +++ b/vtkm/filter/ThresholdPoints.h @@ -61,17 +61,16 @@ public: void SetThresholdBetween(const vtkm::Float64 value1, const vtkm::Float64 value2); template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter //this call is only valid template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/ThresholdPoints.hxx b/vtkm/filter/ThresholdPoints.hxx index 1c52ba190..1be19a9c7 100644 --- a/vtkm/filter/ThresholdPoints.hxx +++ b/vtkm/filter/ThresholdPoints.hxx @@ -144,7 +144,7 @@ inline VTKM_CONT void ThresholdPoints::SetThresholdBetween(const vtkm::Float64 v //----------------------------------------------------------------------------- template -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& 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 inline VTKM_CONT bool ThresholdPoints::DoMapField( - vtkm::filter::ResultDataSet& result, + vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/Triangulate.h b/vtkm/filter/Triangulate.h index 297e5adbe..f61ef29e4 100644 --- a/vtkm/filter/Triangulate.h +++ b/vtkm/filter/Triangulate.h @@ -36,14 +36,13 @@ public: Triangulate(); template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); // Map new field onto the resulting dataset after running the filter template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/Triangulate.hxx b/vtkm/filter/Triangulate.hxx index 3ee540bd0..4c3cb5705 100644 --- a/vtkm/filter/Triangulate.hxx +++ b/vtkm/filter/Triangulate.hxx @@ -58,7 +58,7 @@ inline VTKM_CONT Triangulate::Triangulate() //----------------------------------------------------------------------------- template -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& 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 -inline VTKM_CONT bool Triangulate::DoMapField(vtkm::filter::ResultDataSet& result, +inline VTKM_CONT bool Triangulate::DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/VectorMagnitude.h b/vtkm/filter/VectorMagnitude.h index f7b37057c..918c463db 100644 --- a/vtkm/filter/VectorMagnitude.h +++ b/vtkm/filter/VectorMagnitude.h @@ -36,12 +36,11 @@ public: VectorMagnitude(); template - VTKM_CONT vtkm::filter::ResultField DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::cont::ArrayHandle& field, - const vtkm::filter::FieldMetadata& fieldMeta, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::cont::ArrayHandle& field, + const vtkm::filter::FieldMetadata& fieldMeta, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); private: vtkm::worklet::Magnitude Worklet; diff --git a/vtkm/filter/VectorMagnitude.hxx b/vtkm/filter/VectorMagnitude.hxx index 62489ce70..3847614fc 100644 --- a/vtkm/filter/VectorMagnitude.hxx +++ b/vtkm/filter/VectorMagnitude.hxx @@ -35,7 +35,7 @@ inline VTKM_CONT VectorMagnitude::VectorMagnitude() //----------------------------------------------------------------------------- template -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& 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 diff --git a/vtkm/filter/VertexClustering.h b/vtkm/filter/VertexClustering.h index 38f5e54e0..7db398b19 100644 --- a/vtkm/filter/VertexClustering.h +++ b/vtkm/filter/VertexClustering.h @@ -70,15 +70,14 @@ public: const vtkm::Id3& GetNumberOfDivisions() const { return this->NumberOfDivisions; } template - VTKM_CONT vtkm::filter::ResultDataSet DoExecute( - const vtkm::cont::DataSet& input, - const vtkm::filter::PolicyBase& policy, - const DeviceAdapter& tag); + VTKM_CONT vtkm::filter::Result DoExecute(const vtkm::cont::DataSet& input, + const vtkm::filter::PolicyBase& policy, + const DeviceAdapter& tag); //Map a new field onto the resulting dataset after running the filter //this call is only valid template - VTKM_CONT bool DoMapField(vtkm::filter::ResultDataSet& result, + VTKM_CONT bool DoMapField(vtkm::filter::Result& result, const vtkm::cont::ArrayHandle& input, const vtkm::filter::FieldMetadata& fieldMeta, const vtkm::filter::PolicyBase& policy, diff --git a/vtkm/filter/VertexClustering.hxx b/vtkm/filter/VertexClustering.hxx index 9db5e64b5..9d2eddb97 100644 --- a/vtkm/filter/VertexClustering.hxx +++ b/vtkm/filter/VertexClustering.hxx @@ -32,7 +32,7 @@ inline VTKM_CONT VertexClustering::VertexClustering() //----------------------------------------------------------------------------- template -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& 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 -inline VTKM_CONT bool VertexClustering::DoMapField(vtkm::filter::ResultDataSet&, +inline VTKM_CONT bool VertexClustering::DoMapField(vtkm::filter::Result&, const vtkm::cont::ArrayHandle&, const vtkm::filter::FieldMetadata&, const vtkm::filter::PolicyBase&, diff --git a/vtkm/filter/internal/ResolveFieldTypeAndExecute.h b/vtkm/filter/internal/ResolveFieldTypeAndExecute.h index 94cffa1d8..0b3ee1886 100644 --- a/vtkm/filter/internal/ResolveFieldTypeAndExecute.h +++ b/vtkm/filter/internal/ResolveFieldTypeAndExecute.h @@ -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: diff --git a/vtkm/filter/internal/ResolveFieldTypeAndMap.h b/vtkm/filter/internal/ResolveFieldTypeAndMap.h index a5c2c85e0..060f2a3e3 100644 --- a/vtkm/filter/internal/ResolveFieldTypeAndMap.h +++ b/vtkm/filter/internal/ResolveFieldTypeAndMap.h @@ -33,7 +33,7 @@ namespace vtkm { namespace filter { -class ResultDataSet; +class Result; } } @@ -50,14 +50,14 @@ struct ResolveFieldTypeAndMap typedef ResolveFieldTypeAndMap Self; Derived* DerivedClass; - vtkm::filter::ResultDataSet& InputResult; + vtkm::filter::Result& InputResult; const vtkm::filter::FieldMetadata& Metadata; const vtkm::filter::PolicyBase& 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& policy, const vtkm::cont::RuntimeDeviceTracker& tracker, diff --git a/vtkm/filter/testing/UnitTestCellAverageFilter.cxx b/vtkm/filter/testing/UnitTestCellAverageFilter.cxx index 4b4cc351d..2d683cdcf 100644 --- a/vtkm/filter/testing/UnitTestCellAverageFilter.cxx +++ b/vtkm/filter/testing/UnitTestCellAverageFilter.cxx @@ -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 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")); diff --git a/vtkm/filter/testing/UnitTestCleanGrid.cxx b/vtkm/filter/testing/UnitTestCleanGrid.cxx index 2a5ab34ff..250ceadb9 100644 --- a/vtkm/filter/testing/UnitTestCleanGrid.cxx +++ b/vtkm/filter/testing/UnitTestCleanGrid.cxx @@ -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")); diff --git a/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx b/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx index 3796e98d2..e091e1c64 100644 --- a/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx +++ b/vtkm/filter/testing/UnitTestClipWithFieldFilter.cxx @@ -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); diff --git a/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx b/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx index b2e5d3c4f..27a0e74b1 100644 --- a/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx +++ b/vtkm/filter/testing/UnitTestClipWithImplicitFunctionFilter.cxx @@ -62,7 +62,7 @@ void TestClipStructured() vtkm::FloatDefault radius(0.5); auto sphere = std::make_shared(center, radius); - vtkm::filter::ResultDataSet result; + vtkm::filter::Result result; vtkm::filter::ClipWithImplicitFunction clip; clip.SetImplicitFunction(sphere); diff --git a/vtkm/filter/testing/UnitTestContourTreeUniformFilter.cxx b/vtkm/filter/testing/UnitTestContourTreeUniformFilter.cxx index ac21e5024..e39bae52b 100644 --- a/vtkm/filter/testing/UnitTestContourTreeUniformFilter.cxx +++ b/vtkm/filter/testing/UnitTestContourTreeUniformFilter.cxx @@ -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> 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> saddlePeak; - resultField.GetData().CopyTo(saddlePeak); + Result.GetData().CopyTo(saddlePeak); VTKM_TEST_ASSERT(test_equal(saddlePeak.GetNumberOfValues(), 9), "Wrong result for ContourTree filter"); diff --git a/vtkm/filter/testing/UnitTestEntropyFilter.cxx b/vtkm/filter/testing/UnitTestEntropyFilter.cxx index 17b10b7aa..503c348df 100644 --- a/vtkm/filter/testing/UnitTestEntropyFilter.cxx +++ b/vtkm/filter/testing/UnitTestEntropyFilter.cxx @@ -24,7 +24,8 @@ #include -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(x) / static_cast(xdim-1); - const vtkm::Float32 fy = static_cast(y) / static_cast(xdim-1); - const vtkm::Float32 fz = static_cast(z) / static_cast(xdim-1); + const vtkm::Float32 fx = static_cast(x) / static_cast(xdim - 1); + const vtkm::Float32 fy = static_cast(y) / static_cast(xdim - 1); + const vtkm::Float32 fz = static_cast(z) / static_cast(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 fieldArray; - vtkm::cont::ArrayHandleCounting vertexCountImplicitArray(0, 1, vdims[0]*vdims[1]*vdims[2]); - vtkm::worklet::DispatcherMapField tangleFieldDispatcher(TangleField(vdims, mins, maxs)); + vtkm::cont::ArrayHandleCounting vertexCountImplicitArray( + 0, 1, vdims[0] * vdims[1] * vdims[2]); + vtkm::worklet::DispatcherMapField tangleFieldDispatcher( + TangleField(vdims, mins, maxs)); tangleFieldDispatcher.Invoke(vertexCountImplicitArray, fieldArray); - vtkm::Vec origin(0.0f, 0.0f, 0.0f); - vtkm::Vec spacing( - 1.0f/static_cast(dims[0]), - 1.0f/static_cast(dims[2]), - 1.0f/static_cast(dims[1])); + vtkm::Vec origin(0.0f, 0.0f, 0.0f); + vtkm::Vec spacing(1.0f / static_cast(dims[0]), + 1.0f / static_cast(dims[2]), + 1.0f / static_cast(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 entropy; resultEntropy.FieldAs(entropy); - vtkm::cont::ArrayHandle::PortalConstControl portal = entropy.GetPortalConstControl(); + vtkm::cont::ArrayHandle::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); } diff --git a/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx b/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx index 6f2041865..485076de0 100644 --- a/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx +++ b/vtkm/filter/testing/UnitTestExternalFacesFilter.cxx @@ -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) diff --git a/vtkm/filter/testing/UnitTestExtractGeometryFilter.cxx b/vtkm/filter/testing/UnitTestExtractGeometryFilter.cxx index 5e7d28df4..c2721951e 100644 --- a/vtkm/filter/testing/UnitTestExtractGeometryFilter.cxx +++ b/vtkm/filter/testing/UnitTestExtractGeometryFilter.cxx @@ -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 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 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 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 minPoint(0.5f, 0.5f, 0.5f); diff --git a/vtkm/filter/testing/UnitTestExtractPointsFilter.cxx b/vtkm/filter/testing/UnitTestExtractPointsFilter.cxx index f40a2c771..6d104405c 100644 --- a/vtkm/filter/testing/UnitTestExtractPointsFilter.cxx +++ b/vtkm/filter/testing/UnitTestExtractPointsFilter.cxx @@ -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 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 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 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 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 minPoint(0.f, 0.f, 0.f); diff --git a/vtkm/filter/testing/UnitTestExtractStructuredFilter.cxx b/vtkm/filter/testing/UnitTestExtractStructuredFilter.cxx index 4a3473d9e..93adad304 100644 --- a/vtkm/filter/testing/UnitTestExtractStructuredFilter.cxx +++ b/vtkm/filter/testing/UnitTestExtractStructuredFilter.cxx @@ -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; diff --git a/vtkm/filter/testing/UnitTestGradient.cxx b/vtkm/filter/testing/UnitTestGradient.cxx index 370bfc2ac..b03cabf91 100644 --- a/vtkm/filter/testing/UnitTestGradient.cxx +++ b/vtkm/filter/testing/UnitTestGradient.cxx @@ -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"); diff --git a/vtkm/filter/testing/UnitTestHistogramFilter.cxx b/vtkm/filter/testing/UnitTestHistogramFilter.cxx index e913f35fa..54f4df9f2 100644 --- a/vtkm/filter/testing/UnitTestHistogramFilter.cxx +++ b/vtkm/filter/testing/UnitTestHistogramFilter.cxx @@ -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 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 diff --git a/vtkm/filter/testing/UnitTestMarchingCubesFilter.cxx b/vtkm/filter/testing/UnitTestMarchingCubesFilter.cxx index 5ad513615..78de4c33a 100644 --- a/vtkm/filter/testing/UnitTestMarchingCubesFilter.cxx +++ b/vtkm/filter/testing/UnitTestMarchingCubesFilter.cxx @@ -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); diff --git a/vtkm/filter/testing/UnitTestMaskFilter.cxx b/vtkm/filter/testing/UnitTestMaskFilter.cxx index ca4defa22..749184644 100644 --- a/vtkm/filter/testing/UnitTestMaskFilter.cxx +++ b/vtkm/filter/testing/UnitTestMaskFilter.cxx @@ -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; diff --git a/vtkm/filter/testing/UnitTestMaskPointsFilter.cxx b/vtkm/filter/testing/UnitTestMaskPointsFilter.cxx index 09da35abd..8592e719c 100644 --- a/vtkm/filter/testing/UnitTestMaskPointsFilter.cxx +++ b/vtkm/filter/testing/UnitTestMaskPointsFilter.cxx @@ -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); diff --git a/vtkm/filter/testing/UnitTestPointAverageFilter.cxx b/vtkm/filter/testing/UnitTestPointAverageFilter.cxx index 72ebd9e41..8759f9d5e 100644 --- a/vtkm/filter/testing/UnitTestPointAverageFilter.cxx +++ b/vtkm/filter/testing/UnitTestPointAverageFilter.cxx @@ -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 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")); diff --git a/vtkm/filter/testing/UnitTestPointElevationFilter.cxx b/vtkm/filter/testing/UnitTestPointElevationFilter.cxx index 32d5040ac..6e751b124 100644 --- a/vtkm/filter/testing/UnitTestPointElevationFilter.cxx +++ b/vtkm/filter/testing/UnitTestPointElevationFilter.cxx @@ -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"); diff --git a/vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx b/vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx index 91e729348..a129e79c3 100644 --- a/vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx +++ b/vtkm/filter/testing/UnitTestSurfaceNormalsFilter.cxx @@ -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); diff --git a/vtkm/filter/testing/UnitTestTetrahedralizeFilter.cxx b/vtkm/filter/testing/UnitTestTetrahedralizeFilter.cxx index 47580e29a..932f582bc 100644 --- a/vtkm/filter/testing/UnitTestTetrahedralizeFilter.cxx +++ b/vtkm/filter/testing/UnitTestTetrahedralizeFilter.cxx @@ -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; diff --git a/vtkm/filter/testing/UnitTestThresholdFilter.cxx b/vtkm/filter/testing/UnitTestThresholdFilter.cxx index 1e6c853df..da2e3d69f 100644 --- a/vtkm/filter/testing/UnitTestThresholdFilter.cxx +++ b/vtkm/filter/testing/UnitTestThresholdFilter.cxx @@ -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")); diff --git a/vtkm/filter/testing/UnitTestThresholdPointsFilter.cxx b/vtkm/filter/testing/UnitTestThresholdPointsFilter.cxx index e51be601d..f962054a9 100644 --- a/vtkm/filter/testing/UnitTestThresholdPointsFilter.cxx +++ b/vtkm/filter/testing/UnitTestThresholdPointsFilter.cxx @@ -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")); diff --git a/vtkm/filter/testing/UnitTestTriangulateFilter.cxx b/vtkm/filter/testing/UnitTestTriangulateFilter.cxx index 0e2a5a889..6419d6dc3 100644 --- a/vtkm/filter/testing/UnitTestTriangulateFilter.cxx +++ b/vtkm/filter/testing/UnitTestTriangulateFilter.cxx @@ -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; diff --git a/vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx b/vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx index d9e9ae0be..ed23c8be5 100644 --- a/vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx +++ b/vtkm/filter/testing/UnitTestVectorMagnitudeFilter.cxx @@ -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"); diff --git a/vtkm/filter/testing/UnitTestVertexClusteringFilter.cxx b/vtkm/filter/testing/UnitTestVertexClusteringFilter.cxx index 72c9c1c4a..3a8546834 100644 --- a/vtkm/filter/testing/UnitTestVertexClusteringFilter.cxx +++ b/vtkm/filter/testing/UnitTestVertexClusteringFilter.cxx @@ -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,