Add SSAO support to the VTK renderer

Author: Vinicius [C] Guimaraes

bindings/pydrake/geometry/geometry_py_render.cc

@@ -27,6 +27,7 @@ using geometry::render::DepthRenderCamera;
 using geometry::render::LightParameter;
 using geometry::render::LightType;
 using geometry::render::RenderEngine;
+using geometry::render::SsaoParameter;
 using math::RigidTransformd;
 using systems::sensors::CameraInfo;
 using systems::sensors::Image;
@@ -414,6 +415,17 @@ void DoScalarIndependentDefinitions(py::module m) {
     DefCopyAndDeepCopy(&cls);
   }
 
+  {
+    using Class = geometry::render::SsaoParameter;
+    constexpr auto& cls_doc = doc.SsaoParameter;
+    py::class_<Class> cls(m, "SsaoParameter", cls_doc.doc);
+    cls  // BR
+        .def(ParamInit<Class>());
+    DefAttributesUsingSerialize(&cls);
+    DefReprUsingSerialize(&cls);
+    DefCopyAndDeepCopy(&cls);
+  }
+
   {
     using Class = RenderEngineVtkParams;
     constexpr auto& cls_doc = doc_geometry.RenderEngineVtkParams;

geometry/render_vtk/BUILD.bazel

@@ -150,6 +150,7 @@ drake_cc_googletest(
     timeout = "moderate",
     data = [
         ":test/multi_material_mesh.png",
+        ":test/whole_image_custom_and_SSAO_color.png",
         ":test/whole_image_custom_color.png",
         ":test/whole_image_custom_depth.png",
         ":test/whole_image_custom_label.png",

geometry/render_vtk/internal_render_engine_vtk.cc

@@ -30,6 +30,7 @@
 #include <vtkPointData.h>                // vtkCommonDataModel
 #include <vtkProperty.h>                 // vtkRenderingCore
 #include <vtkRenderPassCollection.h>     // vtkRenderingOpenGL2
+#include <vtkSSAOPass.h>                 // vtkRenderingOpenGL2
 #include <vtkSequencePass.h>             // vtkRenderingOpenGL2
 #include <vtkShadowMapBakerPass.h>       // vtkRenderingOpenGL2
 #include <vtkShadowMapPass.h>            // vtkRenderingOpenGL2
@@ -962,7 +963,27 @@ void RenderEngineVtk::InitializePipelines() {
   vtkNew<vtkSequencePass> full_seq;
   vtkNew<vtkRenderPassCollection> full_passes;
   full_passes->AddItem(vtkNew<vtkLightsPass>());
-  full_passes->AddItem(vtkNew<vtkOpaquePass>());
+  if (parameters_.ssao_params.has_value()) {
+    vtkNew<vtkCameraPass> ssao_camera_pass;
+    vtkNew<vtkOpaquePass> opaque_pass;
+    ssao_camera_pass->SetDelegatePass(opaque_pass);
+
+    vtkNew<vtkSSAOPass> ssao_pass;
+    const auto& ssao_parameter = parameters_.ssao_params.value();
+    ssao_pass->SetDelegatePass(ssao_camera_pass);
+    ssao_pass->SetRadius(ssao_parameter.radius);  // comparison radius
+    ssao_pass->SetBias(ssao_parameter.bias);      // comparison bias
+    ssao_pass->SetKernelSize(
+        ssao_parameter.kernel_size);  // number of samples used
+    ssao_pass->SetIntensityScale(ssao_parameter.intensity_scale);
+    ssao_pass->SetIntensityShift(ssao_parameter.intensity_shift);
+    if (!ssao_parameter.blur) {
+      ssao_pass->BlurOff();  // do not blur occlusion
+    }
+    full_passes->AddItem(ssao_pass);
+  } else {
+    full_passes->AddItem(vtkNew<vtkOpaquePass>());
+  }
   full_passes->AddItem(vtkNew<vtkTranslucentPass>());
   full_seq->SetPasses(full_passes);
 

geometry/render_vtk/render_engine_vtk_params.h

@@ -14,6 +14,30 @@
 namespace drake {
 namespace geometry {
 
+namespace render {
+/** SSAO parameter for supporting SSAO feature in VTK rendering. */
+struct SsaoParameter {
+  /** Passes this object to an Archive.
+   Refer to @ref yaml_serialization "YAML Serialization" for background. */
+  template <typename Archive>
+  void Serialize(Archive* a) {
+    a->Visit(DRAKE_NVP(radius));
+    a->Visit(DRAKE_NVP(bias));
+    a->Visit(DRAKE_NVP(kernel_size));
+    a->Visit(DRAKE_NVP(intensity_scale));
+    a->Visit(DRAKE_NVP(intensity_shift));
+    a->Visit(DRAKE_NVP(blur));
+  }
+
+  double radius{0.5};
+  double bias{0.01};
+  int kernel_size{32};
+  double intensity_scale{1.0};
+  double intensity_shift{0.0};
+  bool blur{false};
+};
+}  // namespace render
+
 // TODO(SeanCurtis-TRI): When CubeMap is implemented, replace NullTexture with
 // CubeMap.
 
@@ -101,6 +125,7 @@ struct RenderEngineVtkParams {
     a->Visit(DRAKE_NVP(lights));
     a->Visit(DRAKE_NVP(environment_map));
     a->Visit(DRAKE_NVP(exposure));
+    a->Visit(DRAKE_NVP(ssao_params));
     a->Visit(DRAKE_NVP(cast_shadows));
     a->Visit(DRAKE_NVP(shadow_map_size));
     a->Visit(DRAKE_NVP(force_to_pbr));
@@ -174,6 +199,21 @@ struct RenderEngineVtkParams {
    */
   std::optional<double> exposure{};
 
+  /** An optional SSAO (screen-space ambient occlusion) parameters set. When
+   * specified, VTK will use the parameters provided for SSAO and simulate the
+   * ambient occlusion on surfaces where light is obstructed by the surrounding
+   * geometry, producing images with better qualities and higher fidelity.
+   * See https://www.kitware.com/ssao/ for details.
+   * Non-specified parameters will use default values:
+   * radius: 0.5
+   * bias: 0.01
+   * kernel size: 32
+   * intensity_scale: 1.0
+   * intensity_shift: 0.0
+   * blur: false
+   */
+  std::optional<render::SsaoParameter> ssao_params{};
+
   /** If `true`, *all* lights that are *able* to cast shadows will do so.
 
    Several important notes when designing your lighting:

geometry/render_vtk/test/internal_render_engine_vtk_test.cc

@@ -3097,6 +3097,87 @@ TEST_F(RenderEngineVtkTest, WholeImageCustomParams) {
   }
 }
 
+// Like WholeImageCustomParams, except we introduce the SSAO pass to the render
+// engine parameters to detect differences.
+TEST_F(RenderEngineVtkTest, WholeImageCustomParamsAndSSAO) {
+  const double last_x =
+      AddShapeRows(nullptr, {.gltf_mesh = true, .no_half_space = true});
+  const RigidTransformd X_WR(RotationMatrixd::MakeXRotation(-3.2 * M_PI / 4),
+                             Vector3d(last_x / 2, -0.75, 1.1));
+
+  // Use default SSAO values
+  const drake::geometry::render::SsaoParameter ssaoParams{};
+  vector<LightParameter> lights_W{{.type = "point",
+                                   .color = Rgba(1.0, 0.75, 0.75),
+                                   .attenuation_values = {0, 0, 1},
+                                   .position = Vector3d(0, 0, 0.3),
+                                   .frame = "world",
+                                   .intensity = 0.5},
+                                  {.type = "spot",
+                                   .color = Rgba(0.75, 1.0, 0.75),
+                                   .position = Vector3d(0, -0.1, 2),
+                                   .frame = "world",
+                                   .intensity = 1,
+                                   .direction = Vector3d(-0.5, 0, -1),
+                                   .cone_angle = 10},
+                                  {.type = "directional",
+                                   .color = Rgba(1, 1, 1),
+                                   .frame = "world",
+                                   .intensity = 1,
+                                   .direction = Vector3d(0.02, -0.05, -1)}};
+  // We should get the same images whether the lights are expressed in the
+  // world frame or the camera frame.
+  // TODO(SeanCurtis-TRI): When we can edit the lights after instantiation,
+  // simplify this so we don't re-instantiate the engine.
+  for (const vector<LightParameter>& lights :
+       {lights_W, TransformLightsToCamera(lights_W, X_WR)}) {
+    const RenderEngineVtkParams params{
+        .default_diffuse = Eigen::Vector4d(0.1, 0.2, 0.4, 1.0),
+        .default_clear_color = Vector3d(0.25, 0.25, 0.25),
+        .lights = lights,
+        .environment_map = {},
+        .exposure = 0.75,
+        .ssao_params = ssaoParams,
+        .cast_shadows = true,
+        .shadow_map_size = 1024,
+        .backend = FLAGS_backend,
+    };
+    RenderEngineVtk engine(params);
+
+    // We'll use the same camera as the default camera for the tests, but shrink
+    // the image size so they're not as big in the repository.
+    const int w = 480;
+    const int h = 360;
+    const CameraInfo& source_intrinsics = depth_camera_.core().intrinsics();
+    const CameraInfo intrinsics(w, h, source_intrinsics.fov_y());
+    const DepthRenderCamera camera(
+        {"unused", intrinsics, depth_camera_.core().clipping(),
+         depth_camera_.core().sensor_pose_in_camera_body()},
+        depth_camera_.depth_range());
+
+    // The value we used to define the camera pose better match.
+    DRAKE_DEMAND(AddShapeRows(&engine, {.gltf_mesh = true,
+                                        .no_half_space = true}) == last_x);
+
+    // Now make the rendering.
+    engine.UpdateViewpoint(X_WR);
+
+    ImageRgba8U color(w, h);
+    ImageDepth32F depth(w, h);
+    ImageLabel16I label(w, h);
+    this->Render(fmt::format("whole_image_custom_color_{}", lights[0].frame),
+                 &engine, &camera, &color, &depth, &label);
+
+    {
+      SCOPED_TRACE(fmt::format("Color image - {}", lights[0].frame));
+      CompareImages(color,
+                    "drake/geometry/render_vtk/test/"
+                    "whole_image_custom_and_SSAO_color.png",
+                    /* tolerance = */ 25);
+    }
+  }
+}
+
 // To work around a bug in VTK, when shadows are enabled, we have to render into
 // a square window, and then crop the image back out. The WholeImageCustomParams
 // implicitly handles non-square images with a *horizontal* aspect ratio. This