Remove Rover's volume renderer (#1544)

* Comment out all of the external rover volume rendering code

* Comment out all of the internal rover volume rendering code

* Add removal comment to external code

* Remove redundant setting of rover's render mode

* Fix nitpick

* Remove RenderMode since there is only one choice now

* More nitpicks

* Fix typo

Co-authored-by: Justin Privitera <[email protected]>

* Address feedback

---------

Co-authored-by: Justin Privitera <[email protected]>

Author: siramok

src/libs/ascent/runtimes/flow_filters/ascent_runtime_filters.cpp

@@ -154,7 +154,7 @@ register_builtin()
 
 
     AscentRuntime::register_filter_type<RoverXRay>("extracts", "xray");
-    AscentRuntime::register_filter_type<RoverVolume>("extracts", "volume");
+    // AscentRuntime::register_filter_type<RoverVolume>("extracts", "volume"); // removing volume renderer
 
     AscentRuntime::register_filter_type<AddPlot>();
     AscentRuntime::register_filter_type<CreatePlot>();

src/libs/ascent/runtimes/flow_filters/ascent_runtime_rover_filters.cpp

@@ -283,7 +283,6 @@ RoverXRay::execute()
   // Default render settings
   //
   RenderSettings render_settings;
-  render_settings.m_render_mode = rover::energy;
   render_settings.m_primary_field = absorption;
 
   // TODO: investigate how/why this is getting set, even if emission is not specified
@@ -383,6 +382,7 @@ RoverXRay::execute()
   }
 }
 
+#if 0 // removing volume renderer
 //-----------------------------------------------------------------------------
 RoverVolume::RoverVolume()
 :Filter()
@@ -560,6 +560,7 @@ RoverVolume::execute()
 
     tracer.save_png(filename);
 }
+#endif
 
 //-----------------------------------------------------------------------------
 };

src/libs/ascent/runtimes/flow_filters/ascent_runtime_rover_filters.hpp

@@ -55,6 +55,7 @@ class ASCENT_API RoverXRay: public ::flow::Filter
     virtual void   execute();
 };
 
+#if 0 // removing volume renderer
 class ASCENT_API RoverVolume : public ::flow::Filter
 {
 public:
@@ -66,7 +67,7 @@ class ASCENT_API RoverVolume : public ::flow::Filter
                                  conduit::Node &info);
     virtual void   execute();
 };
-
+#endif
 
 };
 //-----------------------------------------------------------------------------

src/libs/rover/CMakeLists.txt

@@ -63,11 +63,9 @@ set(rover_headers
       rover.hpp
       scheduler.hpp
       scheduler_base.hpp
-      static_scheduler.hpp
       # engines
       engine.hpp
       energy_engine.hpp
-      volume_engine.hpp
       # ray generators headers
       ray_generators/ray_generator.hpp
       ray_generators/camera_generator.hpp
@@ -89,7 +87,6 @@ set(rover_sources
       scheduler_base.cpp
       # engines
       energy_engine.cpp
-      volume_engine.cpp
       # ray generators
       ray_generators/ray_generator.cpp
       ray_generators/camera_generator.cpp

src/libs/rover/domain.cpp

@@ -10,14 +10,17 @@
 #include <rover_exceptions.hpp>
 #include <utils/rover_logging.hpp>
 
-namespace rover {
+namespace rover
+{
+
 Domain::Domain()
 {
-  m_engine = std::make_shared<VolumeEngine>();
+  m_engine = std::make_shared<EnergyEngine>();
 }
 
 Domain::~Domain()
 {
+
 }
 
 //
@@ -34,6 +37,7 @@ Domain::set_render_settings(const RenderSettings &settings)
 
   ROVER_INFO("Setting render settings");
 
+#if 0 // removing volume renderer
   if(m_render_settings.m_render_mode != volume &&
      settings.m_render_mode == volume)
   {
@@ -43,10 +47,14 @@ Domain::set_render_settings(const RenderSettings &settings)
   else if(m_render_settings.m_render_mode != energy &&
           settings.m_render_mode == energy)
   {
-    ROVER_INFO("Render mode = energy");
-    auto engine = std::make_shared<EnergyEngine>();
-    engine->set_unit_scalar(settings.m_energy_settings.m_unit_scalar);
-    m_engine = engine;
+#endif
+
+  ROVER_INFO("Render mode = energy");
+  auto engine = std::make_shared<EnergyEngine>();
+  engine->set_unit_scalar(settings.m_energy_settings.m_unit_scalar);
+  m_engine = engine;
+
+#if 0 // removing volume renderer
   }
   else if(m_render_settings.m_render_mode != surface &&
           settings.m_render_mode == surface)
@@ -58,13 +66,15 @@ Domain::set_render_settings(const RenderSettings &settings)
     //ROVER_ERROR("Unable to create the appropriate engine");
     //throw RoverException("Fatal Error: domain unable to create the apporpriate engine\n");
   }
+#endif
 
   m_render_settings = settings;
   m_render_settings.print();
 
   m_engine->set_data_set(m_data_set);
   set_engine_fields();
 
+#if 0 // removing volume renderer
   if(m_render_settings.m_render_mode == volume)
   {
     ROVER_INFO("outgoing render mode = volume");
@@ -74,6 +84,8 @@ Domain::set_render_settings(const RenderSettings &settings)
   {
     ROVER_INFO("outgoing render mode = energy");
   }
+#endif
+
 }
 
 int
@@ -97,6 +109,8 @@ Domain::set_engine_fields()
   ROVER_INFO("Primary field: " << m_render_settings.m_primary_field);
   ROVER_INFO("Secondary field: " << m_render_settings.m_secondary_field);
 
+  // TODO: This might be redundant, surely we catch this case in verify_params?
+  // (and should if we currently don't)
   if(m_render_settings.m_primary_field == "")
     throw RoverException("Fatal Error: primary field not set\n");
   m_engine->set_primary_field(m_render_settings.m_primary_field);
@@ -125,16 +139,14 @@ Domain::init_rays(Ray64 &rays)
 PartialVector32
 Domain::partial_trace(Ray32 &rays)
 {
-  m_engine->set_samples(m_global_bounds,
-                        m_render_settings.m_volume_settings.m_num_samples);
+  m_engine->set_samples(m_global_bounds, m_render_settings.m_num_samples);
   return m_engine->partial_trace(rays);
 }
 
 PartialVector64
 Domain::partial_trace(Ray64 &rays)
 {
-  m_engine->set_samples(m_global_bounds,
-                        m_render_settings.m_volume_settings.m_num_samples);
+  m_engine->set_samples(m_global_bounds, m_render_settings.m_num_samples);
   return m_engine->partial_trace(rays);
 }
 
@@ -153,6 +165,8 @@ Domain::set_composite_background(bool on)
 vtkmRange
 Domain::get_primary_range()
 {
+  // TODO: Redundant? Even if it's not, we can probably use something nicer
+  // than assert here
   assert(m_render_settings.m_primary_field != "");
   return m_engine->get_primary_range();
 }

src/libs/rover/domain.hpp

@@ -28,7 +28,7 @@ class Domain
   void init_rays(Ray32 &rays);
   void init_rays(Ray64 &rays);
   void set_data_set(vtkmDataSet &dataset);
-  void set_render_settings(const RenderSettings &setttings);
+  void set_render_settings(const RenderSettings &settings);
   void set_primary_range(const vtkmRange &range);
   void set_composite_background(bool on);
   vtkm::Bounds get_domain_bounds();

src/libs/rover/energy_engine.hpp

@@ -12,6 +12,8 @@
 #include <vtkm/rendering/ConnectivityProxy.h>
 namespace rover {
 
+// TODO: We only have one engine atp, so we can merge
+// Engine and EnergyEngine
 class EnergyEngine : public Engine
 {
 protected:

src/libs/rover/partial_image.hpp

@@ -14,7 +14,7 @@
 #include <vtkm/cont/ArrayHandle.h>
 #include <vtkh/compositing/AbsorptionPartial.hpp>
 #include <vtkh/compositing/EmissionPartial.hpp>
-#include <vtkh/compositing/VolumePartial.hpp>
+// #include <vtkh/compositing/VolumePartial.hpp> // removing volume renderer
 
 namespace rover
 {
@@ -25,7 +25,7 @@ struct PartialImage
   int                                      m_height;
   int                                      m_width;
   IdHandle                                 m_pixel_ids;
-  vtkmRayTracing::ChannelBuffer<FloatType> m_buffer;          // holds either color or absorption
+  vtkmRayTracing::ChannelBuffer<FloatType> m_buffer;          // holds the absorption
   vtkmRayTracing::ChannelBuffer<FloatType> m_intensities;     // holds the intensity emerging from each ray
   vtkm::cont::ArrayHandle<FloatType>       m_distances;
   std::vector<FloatType>                   m_source_sig;
@@ -49,6 +49,7 @@ struct PartialImage
 
   }
 
+#if 0 // removing volume renderer
   void extract_partials(std::vector<vtkh::VolumePartial<FloatType>> &partials)
   {
     auto id_portal = m_pixel_ids.ReadPortal();
@@ -72,6 +73,7 @@ struct PartialImage
       partials[i].m_alpha = static_cast<float>(buffer_portal.Get(i*4+3));
     }
   }
+#endif
 
   void extract_partials(std::vector<vtkh::AbsorptionPartial<FloatType>> &partials)
   {
@@ -105,10 +107,8 @@ struct PartialImage
     auto id_portal = m_pixel_ids.ReadPortal();
     auto buffer_portal = m_buffer.Buffer.ReadPortal();
     auto intensity_portal = m_intensities.Buffer.ReadPortal();
-
     auto depth_portal = m_distances.ReadPortal();
     const int size = static_cast<int>(m_pixel_ids.GetNumberOfValues());
-
     partials.resize(size);
 
 #ifdef ROVER_OPENMP_ENABLED
@@ -130,6 +130,7 @@ struct PartialImage
     }
   }
 
+#if 0 // removing volume renderer
   void store(std::vector<vtkh::VolumePartial<FloatType>> &partials,
              const std::vector<double> &background,
              const int width,
@@ -179,6 +180,7 @@ struct PartialImage
     }
 
   }
+#endif
 
   void store(std::vector<vtkh::AbsorptionPartial<FloatType>> &partials,
              const std::vector<double> &background,

src/libs/rover/rover.cpp

@@ -31,11 +31,6 @@ class Rover::InternalsType
   int                       m_num_ranks;
 #endif
 
-  void reset_render_mode(RenderMode render_mode)
-  {
-
-  }
-
 public:
   InternalsType()
   {
@@ -62,7 +57,7 @@ class Rover::InternalsType
     // logic to create the appropriate parallel scheduler
     //
     // ray tracing = dynamic scheduler, scattering | no_scattering
-    // volume/engery = scattering + local_scope -> dynamic scheduler
+    // energy = scattering + local_scope -> dynamic scheduler
     //                 non_scattering + global_scope ->static scheduler
     //
     // Note: I wanted to allow for the case of scattering + global scope. This could

src/libs/rover/rover_types.hpp

@@ -13,13 +13,15 @@
 
 namespace rover {
 
+#if 0 // removing volume renderer
 // this could be ray tracing(surface) / volume rendering / energy
 enum RenderMode
 {
   volume, // standard volume rendering (3d)
   energy, // radiography with enegry bins (3d)
   surface //
 };
+#endif
 
 enum ScatteringType
 {
@@ -36,6 +38,7 @@ enum RayScope
   local_rays    // rays only exist in a single domain at any given time
 };
 
+#if 0 // removing volume renderer
 //
 // Volume rendering specific settigns
 //
@@ -45,6 +48,7 @@ struct VolumeSettings
   vtkmRange m_scalar_range;
   VolumeSettings() : m_num_samples(400) {}
 };
+#endif
 
 //
 // Energy specific settings
@@ -58,22 +62,24 @@ struct EnergySettings
 
 struct RenderSettings
 {
-  RenderMode     m_render_mode;
+  // RenderMode     m_render_mode; // removing volume renderer
   ScatteringType m_scattering_type;
   RayScope       m_ray_scope;
   vtkmColorTable m_color_table;
   std::string    m_primary_field;
   std::string    m_secondary_field;
-  VolumeSettings m_volume_settings;
+  int            m_num_samples; // approximate number of samples per ray
+  // VolumeSettings m_volume_settings; // removing volume renderer
   EnergySettings m_energy_settings;
   //
   // Default settings
   //
   RenderSettings() : m_color_table("Cool to Warm")
   {
-    m_render_mode     = volume;
+    // m_render_mode     = energy; // removing volume renderer
     m_scattering_type = non_scattering;
     m_ray_scope       = global_rays;
+    m_num_samples     = 400;
   }
 
   void print()