update to support new vtk-m (#229)

* Updating threshold to match new vtkm

* try vtk-m 1.7.0 rc

* heal

* adjust for new vtk-m

* Fixing DataSetWriter warning.

* retest release branch

* remove patch

* Add calls to text and line annotation batching vtk-m API

VTK-m introduced new APIs to batch text and line annotation rendering.
This speeds up the rendering of the annotations, but requires calling:
 - `Canvas::BeginTextRenderingBatch()` and `Canvas::EndTextRenderingBatch()`
  for batched text rendering.
 - `WorldAnnotator::BeginLineRenderingBatch()` and
 `WorldAnnotator::EndLineRenderingBatch()` for batched line rendering

* update to new vtk-m hash

* add vtkh init function

* build using released 1.7.0 vtk-m

* fix typo and use newer configs

* add missing include

* update hashes to point to vtk-m 1.7.0

Co-authored-by: James <[email protected]>
Co-authored-by: Manish Mathai <[email protected]>

Author: 3 people

hashes.txt

@@ -1,2 +1,2 @@
 blt  branch='develop' commit='86a7d6b5ee93d8b7b3233a3e54a4f06f8d8308d3'
-vtkm branch='master' commit='d2d1c854adc8c0518802f153b48afd17646b6252'
+vtkm branch='release' commit='d5143ad7ed2e55025cec2f49fb3f0ab46045a8e2'

scripts/uberenv_configs/packages/vtk-m/disable_flying_edges.patch

@@ -0,0 +1,14 @@
+diff --git a/vtkm/worklet/Contour.h b/vtkm/worklet/Contour.h
+index c28c5ec09..70737777f 100644
+--- a/vtkm/worklet/Contour.h
++++ b/vtkm/worklet/Contour.h
+@@ -46,7 +46,8 @@ struct DeduceCoordType
+                   vtkm::cont::CellSetSingleType<>& result,
+                   Args&&... args) const
+   {
+-    result = flying_edges::execute(cells, coords, std::forward<Args>(args)...);
++    result = marching_cells::execute(cells, coords, std::forward<Args>(args)...);
++    //result = flying_edges::execute(cells, coords, std::forward<Args>(args)...);
+   }
+ };
+ 

scripts/uberenv_configs/packages/vtk-m/package.py

@@ -0,0 +1,12 @@
+diff --git a/vtkm/thirdparty/diy/vtkmdiy/CMakeLists.txt b/vtkm/thirdparty/diy/vtkmdiy/CMakeLists.txt
+index 5211330..3e991f3 100644
+--- a/vtkm/thirdparty/diy/vtkmdiy/CMakeLists.txt
++++ b/vtkm/thirdparty/diy/vtkmdiy/CMakeLists.txt
+@@ -139,6 +139,7 @@ function(add_diy_mpi_library use_mpi)
+     endif()
+ 
+     add_library(${lib_name} ${sources})
++    set_property(TARGET ${lib_name} PROPERTY POSITION_INDEPENDENT_CODE ON)
+     target_compile_features(${lib_name} PRIVATE cxx_std_11)
+     target_compile_definitions(${lib_name}
+         PRIVATE -DVTKMDIY_HAS_MPI=${has_mpi_val}

scripts/uberenv_configs/packages/vtk-m/vtkmdiy_fpic.patch

@@ -10,7 +10,7 @@
 #include <vtkh/DataSet.hpp>
 #include <vtkh/filters/ParticleAdvection.hpp>
 #include <vtkh/filters/Streamline.hpp>
-#include <vtkm/io/writer/VTKDataSetWriter.h>
+#include <vtkm/io/VTKDataSetWriter.h>
 #include <vtkm/cont/DataSet.h>
 #include <vtkm/cont/DataSetFieldAdd.h>
 #include <vtkm/cont/CellSetSingleType.h>
@@ -52,7 +52,7 @@ void writeDataSet(vtkh::DataSet *data, std::string fName, int rank)
   {
     char fileNm[128];
     sprintf(fileNm, "%s.rank%d.domain%d.vtk", fName.c_str(), rank, i);
-    vtkm::io::writer::VTKDataSetWriter write(fileNm);
+    vtkm::io::VTKDataSetWriter write(fileNm);
     write.WriteDataSet(data->GetDomain(i));
   }
 }

scripts/uberenv_configs/spack_configs

@@ -38,6 +38,12 @@ Threshold::SetField(const std::string &field_name)
   m_field_name = field_name;
 }
 
+void
+Threshold::SetAllInRange(const bool &value)
+{
+  m_return_all_in_range = value;
+}
+
 double
 Threshold::GetUpperThreshold() const
 {
@@ -50,6 +56,12 @@ Threshold::GetLowerThreshold() const
   return m_range.Min;
 }
 
+bool
+Threshold::GetAllInRange() const
+{
+  return m_return_all_in_range;
+}
+
 std::string
 Threshold::GetField() const
 {
@@ -89,7 +101,8 @@ void Threshold::DoExecute()
                                     m_field_name,
                                     m_range.Min,
                                     m_range.Max,
-                                    this->GetFieldSelection());
+                                    this->GetFieldSelection(),
+                                    m_return_all_in_range);
 
     temp_data.AddDomain(data_set, domain_id);
   }

src/tests/vtkh/t_vtk-h_particle_advection_par.cpp

@@ -21,16 +21,19 @@ class VTKH_API Threshold: public Filter
   void SetUpperThreshold(const double &value);
   void SetLowerThreshold(const double &value);
   void SetField(const std::string &field_name);
+  void SetAllInRange(const bool &value);
 
   double GetUpperThreshold() const;
   double GetLowerThreshold() const;
+  bool GetAllInRange() const;
   std::string GetField() const;
 protected:
   void PreExecute() override;
   void PostExecute() override;
   void DoExecute() override;
   vtkm::Range m_range;
   std::string m_field_name;
+  bool m_return_all_in_range = false;
 };
 
 } //namespace vtkh

src/vtkh/filters/Threshold.cpp

@@ -37,6 +37,8 @@ Annotator::RenderScreenAnnotations(const std::vector<std::string> &field_names,
   m_canvas.SetViewToScreenSpace(m_camera, true);
   // currently we only support 4 color bars, so grab the first 4
   int num_bars = std::min(int(field_names.size()),4);
+  m_canvas.BeginTextRenderingBatch();
+  m_world_annotator->BeginLineRenderingBatch();
   for(int i = 0; i < num_bars; ++i)
   {
     this->m_color_bar_annotation.SetRange(ranges[i], 5);
@@ -45,19 +47,24 @@ Annotator::RenderScreenAnnotations(const std::vector<std::string> &field_names,
     this->m_color_bar_annotation.SetColorTable(color_tables[i]);
     this->m_color_bar_annotation.Render(m_camera, *m_world_annotator, m_canvas);
   }
+  m_world_annotator->EndLineRenderingBatch();
+  m_canvas.EndTextRenderingBatch();
 }
 
 void Annotator::RenderWorldAnnotations(vtkm::Vec<float,3> axis_scale)
 {
   if(!m_is_3d) return;
   m_canvas.SetViewToWorldSpace(m_camera, false);
+
+  m_canvas.BeginTextRenderingBatch();
   vtkm::Float64 xmin = m_bounds.X.Min, xmax = m_bounds.X.Max;
   vtkm::Float64 ymin = m_bounds.Y.Min, ymax = m_bounds.Y.Max;
   vtkm::Float64 zmin = m_bounds.Z.Min, zmax = m_bounds.Z.Max;
   vtkm::Float64 dx = xmax - xmin, dy = ymax - ymin, dz = zmax - zmin;
   vtkm::Float64 size = vtkm::Sqrt(dx * dx + dy * dy + dz * dz);
 
   //TODO: get forground color
+  m_world_annotator->BeginLineRenderingBatch();
   this->m_box_annotation.SetColor(m_canvas.GetForegroundColor());
   this->m_box_annotation.SetExtents(m_bounds);
   this->m_box_annotation.Render(m_camera, *m_world_annotator);
@@ -66,6 +73,7 @@ void Annotator::RenderWorldAnnotations(vtkm::Vec<float,3> axis_scale)
   bool xtest = lookAt[0] > position[0];
   bool ytest = lookAt[1] > position[1];
   bool ztest = lookAt[2] > position[2];
+  m_world_annotator->EndLineRenderingBatch();
 
   const bool outsideedges = true; // if false, do closesttriad
   if (outsideedges)
@@ -79,6 +87,8 @@ void Annotator::RenderWorldAnnotations(vtkm::Vec<float,3> axis_scale)
   vtkm::Float64 zrel = vtkm::Abs(dz) / size;
   float major_tick_size = size / 40.f;
   float minor_tick_size = size / 80.f;
+
+  m_world_annotator->BeginLineRenderingBatch();
   this->m_x_axis_annotation.SetAxis(0);
   this->m_x_axis_annotation.SetColor(m_canvas.GetForegroundColor());
   this->m_x_axis_annotation.SetTickInvert(xtest, ytest, ztest);
@@ -117,7 +127,9 @@ void Annotator::RenderWorldAnnotations(vtkm::Vec<float,3> axis_scale)
   //this->m_z_axis_annotation.SetMoreOrLessTickAdjustment(zrel < .3 ? -1 : 0);
   this->m_z_axis_annotation.SetMoreOrLessTickAdjustment(-1);
   this->m_z_axis_annotation.Render(m_camera, *m_world_annotator, m_canvas);
+  m_world_annotator->EndLineRenderingBatch();
 
+  m_canvas.EndTextRenderingBatch();
 }
 
 } //namespace vtkh

src/vtkh/filters/Threshold.hpp

@@ -2,9 +2,10 @@
 #include "Error.hpp"
 #include <vtkh/Logger.hpp>
 
+#include <vtkm/cont/Initialize.h>
 #include <vtkm/cont/RuntimeDeviceInformation.h>
 #include <vtkm/cont/RuntimeDeviceTracker.h>
-#include <vtkm/cont/DeviceAdapterListTag.h>
+
 
 #ifdef VTKM_CUDA
 #include <cuda.h>
@@ -19,7 +20,8 @@
 namespace vtkh
 {
 
-static int g_mpi_comm_id = -1;
+static int  g_mpi_comm_id = -1;
+static bool g_vtkm_inited = false;
 
 
 //---------------------------------------------------------------------------//
@@ -133,6 +135,18 @@ GetMPISize()
 #endif
 //---------------------------------------------------------------------------//
 
+//---------------------------------------------------------------------------//
+void
+Initialize()
+{
+    // call vtk-m init, if we haven't already
+    if(!g_vtkm_inited)
+    {
+        vtkm::cont::Initialize();
+        g_vtkm_inited = true;
+    }
+}
+
 //---------------------------------------------------------------------------//
 bool
 IsMPIEnabled()