adding mesh quality (#218)

* adding mesh quality

* make it explicit

Co-authored-by: Cyrus Harrison <cyrush@llnl.gov>

Author: mclarsen

src/tests/vtkh/CMakeLists.txt

@@ -68,6 +68,7 @@ set(BASIC_TESTS t_vtk-h_smoke
                 t_vtk-h_threshold
                 t_vtk-h_point_transform
                 t_vtk-h_mesh_renderer
+                t_vtk-h_mesh_quality
                 t_vtk-h_multi_render
                 t_vtk-h_point_renderer
                 t_vtk-h_raytracer

src/tests/vtkh/t_vtk-h_mesh_quality.cpp

@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------------
+///
+/// file: t_vtk-h_dataset.cpp
+///
+//-----------------------------------------------------------------------------
+
+#include "gtest/gtest.h"
+
+#include <vtkh/vtkh.hpp>
+#include <vtkh/DataSet.hpp>
+#include <vtkh/filters/MeshQuality.hpp>
+#include <vtkh/rendering/RayTracer.hpp>
+#include <vtkh/rendering/Scene.hpp>
+#include <vtkm/cont/testing/MakeTestDataSet.h>
+
+
+#include <iostream>
+
+
+
+//----------------------------------------------------------------------------
+TEST(vtkh_mesh_quality, vtkh_volume)
+{
+  vtkh::DataSet data_set;
+
+  const int base_size = 32;
+  const int num_blocks = 2;
+
+  vtkm::cont::testing::MakeTestDataSet maker;
+  data_set.AddDomain(maker.Make3DExplicitDataSet5(),0);
+
+  vtkh::MeshQuality quali;
+  quali.SetInput(&data_set);
+  quali.AddMapField("point_data_Float64");
+  quali.AddMapField("cell_data_Float64");
+  quali.Update();
+
+  vtkh::DataSet *q_output = quali.GetOutput();
+
+  vtkm::Bounds bounds = q_output->GetGlobalBounds();
+  float bg_color[4] = { 0.f, 0.f, 0.f, 1.f};
+  vtkm::rendering::Camera camera;
+  camera.ResetToBounds(bounds);
+  vtkh::Render render = vtkh::MakeRender(512,
+                                         512,
+                                         camera,
+                                         *q_output,
+                                         "mesh_volume",
+                                          bg_color);
+  vtkh::RayTracer tracer;
+  tracer.SetInput(q_output);
+  tracer.SetField("volume");
+
+  vtkh::Scene scene;
+  scene.AddRenderer(&tracer);
+  scene.AddRender(render);
+  scene.Render();
+
+  delete q_output;
+}
+
+//----------------------------------------------------------------------------
+TEST(vtkh_mesh_quality, vtkh_not_supported)
+{
+  vtkh::DataSet data_set;
+
+  const int base_size = 32;
+  const int num_blocks = 2;
+
+  vtkm::cont::testing::MakeTestDataSet maker;
+  data_set.AddDomain(maker.Make3DExplicitDataSet5(),0);
+  data_set.AddDomain(maker.Make3DUniformDataSet0(),1);
+
+  vtkh::MeshQuality quali;
+  quali.SetInput(&data_set);
+  quali.AddMapField("point_data_Float64");
+  quali.AddMapField("cell_data_Float64");
+  bool threw = false;
+  try
+  {
+    quali.Update();
+  }
+  catch(...)
+  {
+    threw = true;
+  }
+  EXPECT_TRUE(threw);
+}

src/vtkh/DataSet.cpp

@@ -560,6 +560,30 @@ DataSet::IsPointMesh() const
   return is_points;
 }
 
+bool
+DataSet::IsUnstructured() const
+{
+  bool is_unstructured = true;
+  const size_t num_domains = m_domains.size();
+  for(size_t i = 0; i < num_domains; ++i)
+  {
+    const vtkm::cont::DataSet &dom = m_domains[i];
+    int dims;
+    is_unstructured = !VTKMDataSetInfo::IsStructured(dom, dims) && is_unstructured;
+
+    (void) dims;
+
+    if(!is_unstructured)
+    {
+      break;
+    }
+  }
+
+  is_unstructured = detail::GlobalAgreement(is_unstructured);
+
+  return is_unstructured;
+}
+
 bool
 DataSet::IsStructured(int &topological_dims) const
 {

src/vtkh/DataSet.hpp

@@ -100,6 +100,9 @@ class VTKH_API DataSet
    */
   bool IsStructured(int &topological_dims) const;
 
+  // returns true if every single domain is unstructrued
+  bool IsUnstructured() const;
+
   bool IsPointMesh() const;
 
   void PrintSummary(std::ostream &stream) const;

src/vtkh/filters/CMakeLists.txt

@@ -18,6 +18,7 @@ set(vtkh_filters_headers
   NoOp.hpp
   Lagrangian.hpp
   MarchingCubes.hpp
+  MeshQuality.hpp
   ParticleAdvection.hpp
   ParticleMerging.hpp
   PointAverage.hpp
@@ -53,6 +54,7 @@ set(vtkh_filters_sources
   NoOp.cpp
   Lagrangian.cpp
   MarchingCubes.cpp
+  MeshQuality.cpp
   ParticleAdvection.cpp
   ParticleMerging.cpp
   PointAverage.cpp

src/vtkh/filters/MeshQuality.cpp

@@ -0,0 +1,67 @@
+#include <vtkh/filters/MeshQuality.hpp>
+#include <vtkh/vtkm_filters/vtkmMeshQuality.hpp>
+#include <vtkh/vtkm_filters/vtkmCleanGrid.hpp>
+#include <vtkh/Error.hpp>
+
+namespace vtkh
+{
+
+MeshQuality::MeshQuality()
+  : m_metric(vtkm::filter::CellMetric::VOLUME)
+{
+
+}
+
+MeshQuality::~MeshQuality()
+{
+
+}
+
+void MeshQuality::cell_metric(vtkm::filter::CellMetric metric)
+{
+  m_metric = metric;
+}
+
+void MeshQuality::PreExecute()
+{
+  Filter::PreExecute();
+  if(!m_input->IsUnstructured())
+  {
+    throw Error("Mesh quality requires that meshes be completely unstructured");
+  }
+}
+
+void MeshQuality::PostExecute()
+{
+  Filter::PostExecute();
+}
+
+void MeshQuality::DoExecute()
+{
+  this->m_output = new DataSet();
+  const int num_domains = this->m_input->GetNumberOfDomains();
+
+  for(int i = 0; i < num_domains; ++i)
+  {
+    vtkm::Id domain_id;
+    vtkm::cont::DataSet dom;
+    this->m_input->GetDomain(i, dom, domain_id);
+
+    // force this to an fully explicit data set because
+    // old vtkm was not handling this
+    vtkh::vtkmCleanGrid cleaner;
+    auto dataset = cleaner.Run(dom, this->GetFieldSelection());
+
+    vtkmMeshQuality quali;
+    vtkm::cont::DataSet res = quali.Run(dataset, m_metric, this->GetFieldSelection());
+    m_output->AddDomain(res, domain_id);
+  }
+}
+
+std::string
+MeshQuality::GetName() const
+{
+  return "vtkh::MeshQuality";
+}
+
+} //  namespace vtkh

src/vtkh/filters/MeshQuality.hpp

@@ -0,0 +1,30 @@
+#ifndef VTK_H_MESH_QUALITY_HPP
+#define VTK_H_MESH_QUALITY_HPP
+
+#include <vtkh/vtkh_exports.h>
+#include <vtkh/vtkh.hpp>
+#include <vtkh/filters/Filter.hpp>
+#include <vtkh/DataSet.hpp>
+#include <vtkm/filter/MeshQuality.h>
+
+namespace vtkh
+{
+
+class VTKH_API MeshQuality: public Filter
+{
+public:
+  MeshQuality();
+  virtual ~MeshQuality();
+  std::string GetName() const override;
+
+  void cell_metric(vtkm::filter::CellMetric metric);
+
+protected:
+  void PreExecute() override;
+  void PostExecute() override;
+  void DoExecute() override;
+  vtkm::filter::CellMetric m_metric;
+};
+
+} //namespace vtkh
+#endif

src/vtkh/vtkm_filters/CMakeLists.txt

@@ -11,6 +11,7 @@ set(vtkm_filters_headers
   vtkmGradient.hpp
   vtkmLagrangian.hpp
   vtkmMarchingCubes.hpp
+  vtkmMeshQuality.hpp
   vtkmPointAverage.hpp
   vtkmPointTransform.hpp
   vtkmTetrahedralize.hpp
@@ -29,6 +30,7 @@ set(vtkm_filters_sources
   vtkmGradient.cpp
   vtkmLagrangian.cpp
   vtkmMarchingCubes.cpp
+  vtkmMeshQuality.cpp
   vtkmPointAverage.cpp
   vtkmPointTransform.cpp
   vtkmTetrahedralize.cpp

src/vtkh/vtkm_filters/vtkmMeshQuality.cpp

@@ -0,0 +1,17 @@
+#include "vtkmMeshQuality.hpp"
+
+namespace vtkh
+{
+
+vtkm::cont::DataSet vtkmMeshQuality::Run(vtkm::cont::DataSet &input,
+                                         vtkm::filter::CellMetric metric,
+                                         vtkm::filter::FieldSelection map_fields)
+
+{
+  vtkm::filter::MeshQuality quali(metric);
+  quali.SetFieldsToPass(map_fields);
+  auto output = quali.Execute(input);
+  return output;
+}
+
+} // namespace vtkh

src/vtkh/vtkm_filters/vtkmMeshQuality.hpp

@@ -0,0 +1,19 @@
+#ifndef VTK_H_VTKM_MESH_QUALITY_HPP
+#define VTK_H_VTKM_MESH_QUALITY_HPP
+
+#include <vtkm/cont/DataSet.h>
+#include <vtkm/filter/FieldSelection.h>
+#include <vtkm/filter/MeshQuality.h>
+
+namespace vtkh
+{
+
+class vtkmMeshQuality
+{
+public:
+  vtkm::cont::DataSet Run(vtkm::cont::DataSet &input,
+                          vtkm::filter::CellMetric metric,
+                          vtkm::filter::FieldSelection map_fields);
+};
+}
+#endif