Display depth image

application/F3DOptionsTools.cxx

@@ -188,7 +188,8 @@ static inline const std::array<CLIGroup, 8> CLIOptions = {{
       {"anti-aliasing", "a", R"(Select anti-aliasing method ("none", "fxaa", "ssaa" or "taa"))", "<string>", "fxaa"},
       {"anti-aliasing-mode", "", R"(Select anti-aliasing method ("fxaa", "ssaa" or "taa") (deprecated))", "<string>", "fxaa"},
       {"tone-mapping", "t", "Enable Tone Mapping, providing balanced coloring", "<bool>", "1"},
-      {"final-shader", "", "Execute the final shader at the end of the rendering pipeline", "<GLSL code>", ""} } },
+      {"final-shader", "", "Execute the final shader at the end of the rendering pipeline", "<GLSL code>", ""},
+      {"display-depth", "", "Display depth buffer as grayscale image", "<bool>", "1"} } },
   {"Testing",
     { {"reference", "", "Reference", "<png file>", ""},
       {"reference-threshold", "", "Testing threshold", "<threshold>", ""},

application/F3DOptionsTools.h

@@ -141,6 +141,7 @@ static inline const std::map<std::string_view, std::string_view> LibOptionsNames
   { "ambient-occlusion", "render.effect.ambient_occlusion" },
   { "tone-mapping", "render.effect.tone_mapping" },
   { "final-shader", "render.effect.final_shader" },
+  { "display-depth", "render.effect.display_depth" },
   { "textures-transform", "model.textures_transform" },
 };
 

library/options.json

@@ -130,6 +130,10 @@
       },
       "final_shader": {
         "type": "string"
+      },
+      "display_depth": {
+        "type": "bool",
+        "default_value": "false"
       }
     },
     "hdri": {

library/src/window_impl.cxx

@@ -568,6 +568,8 @@ void window_impl::UpdateDynamicOptions()
   renderer->SetUseSSAOPass(opt.render.effect.ambient_occlusion);
   renderer->SetAntiAliasingMode(aaMode);
   renderer->SetUseToneMappingPass(opt.render.effect.tone_mapping);
+  renderer->SetDisplayDepth(opt.render.effect.display_depth);
+  renderer->SetDisplayDepthScalarColoring(opt.model.scivis.enable);
   renderer->SetBlendingMode(blendMode);
   renderer->SetBackfaceType(opt.render.backface_type);
   renderer->SetFinalShader(opt.render.effect.final_shader);

vtkext/private/module/CMakeLists.txt

@@ -81,6 +81,7 @@ set(classes
   vtkF3DUIActor
   vtkF3DUserRenderPass
   vtkF3DTAAResolvePass
+  vtkF3DDisplayDepthRenderPass
   )
 
 if (F3D_MODULE_UI)

vtkext/private/module/vtkF3DDisplayDepthRenderPass.cxx

@@ -0,0 +1,184 @@
+#include "vtkF3DDisplayDepthRenderPass.h"
+
+#include "vtkObjectFactory.h"
+#include "vtkOpenGLError.h"
+#include "vtkOpenGLFramebufferObject.h"
+#include "vtkOpenGLQuadHelper.h"
+#include "vtkOpenGLRenderUtilities.h"
+#include "vtkOpenGLRenderWindow.h"
+#include "vtkOpenGLShaderCache.h"
+#include "vtkOpenGLState.h"
+#include "vtkRenderState.h"
+#include "vtkRenderer.h"
+#include "vtkShaderProgram.h"
+#include "vtkTextureObject.h"
+#include <vtkOpenGLRenderer.h>
+
+vtkStandardNewMacro(vtkF3DDisplayDepthRenderPass);
+
+//------------------------------------------------------------------------------
+void vtkF3DDisplayDepthRenderPass::Render(const vtkRenderState* state)
+{
+  vtkOpenGLClearErrorMacro();
+  this->NumberOfRenderedProps = 0;
+
+  vtkRenderer* renderer = state->GetRenderer();
+  vtkOpenGLRenderWindow* renWin = vtkOpenGLRenderWindow::SafeDownCast(renderer->GetRenderWindow());
+  vtkOpenGLState* ostate = renWin->GetState();
+
+  vtkOpenGLState::ScopedglEnableDisable bsaver(ostate, GL_BLEND);
+  vtkOpenGLState::ScopedglEnableDisable dsaver(ostate, GL_DEPTH_TEST);
+
+  assert(this->DelegatePass != nullptr);
+
+  int pos[2];
+  int size[2];
+  renderer->GetTiledSizeAndOrigin(&size[0], &size[1], &pos[0], &pos[1]);
+
+  // initialize resources
+  if (this->DepthTexture == nullptr)
+  {
+    this->DepthTexture = vtkSmartPointer<vtkTextureObject>::New();
+    this->DepthTexture->SetContext(renWin);
+    this->DepthTexture->SetFormat(GL_RGBA);
+    this->DepthTexture->SetInternalFormat(GL_RGBA16F);
+    this->DepthTexture->SetDataType(GL_HALF_FLOAT);
+    this->DepthTexture->SetMinificationFilter(vtkTextureObject::Linear);
+    this->DepthTexture->SetMagnificationFilter(vtkTextureObject::Linear);
+    this->DepthTexture->SetWrapS(vtkTextureObject::ClampToEdge);
+    this->DepthTexture->SetWrapT(vtkTextureObject::ClampToEdge);
+    this->DepthTexture->Allocate2D(size[0], size[1], 4, VTK_FLOAT);
+  }
+  this->DepthTexture->Resize(size[0], size[1]);
+
+  if (this->ColorMapTexture == nullptr)
+  {
+    this->ColorMapTexture = vtkSmartPointer<vtkTextureObject>::New();
+    this->ColorMapTexture->SetContext(renWin);
+    this->ColorMapTexture->Allocate1D(256, 3, VTK_FLOAT);
+    this->ColorMapTexture->SetWrapS(vtkTextureObject::ClampToEdge);
+    this->ColorMapTexture->SetWrapT(vtkTextureObject::ClampToEdge);
+    this->ColorMapTexture->SetMinificationFilter(vtkTextureObject::Linear);
+    this->ColorMapTexture->SetMagnificationFilter(vtkTextureObject::Linear);
+
+    this->ColorMapTexture->SetFormat(GL_RGB);
+    this->ColorMapTexture->SetInternalFormat(GL_RGB16F);
+    this->ColorMapTexture->SetDataType(GL_FLOAT);
+
+    if (ColorMapDirty && this->ColorMap)
+    {
+      int tableSize = 256;
+      this->ColorMap->SetNumberOfValues(tableSize);
+      this->ColorMap->Build();
+      double range[2];
+      this->ColorMap->GetRange(range);
+
+      std::vector<float> table(tableSize * 3);
+      this->ColorMap->GetTable(range[0], range[1], tableSize, table.data());
+
+      this->ColorMapTexture->Create1DFromRaw(tableSize, 3, VTK_FLOAT, table.data());
+      ColorMapDirty = false;
+    }
+  }
+
+  if (this->FrameBufferObject == nullptr)
+  {
+    this->FrameBufferObject = vtkSmartPointer<vtkOpenGLFramebufferObject>::New();
+    this->FrameBufferObject->SetContext(renWin);
+  }
+
+  // render to texture
+  this->PreRender(state);
+  renWin->GetState()->PushFramebufferBindings();
+  this->RenderDelegate(
+    state, size[0], size[1], size[0], size[1], this->FrameBufferObject, this->DepthTexture);
+  renWin->GetState()->PopFramebufferBindings();
+  this->PostRender(state);
+
+  // depth displaying pass
+  if (!this->QuadHelper)
+  {
+    std::string depthDisplayingFS =
+      vtkOpenGLRenderUtilities::GetFullScreenQuadFragmentShaderTemplate();
+    vtkShaderProgram::Substitute(depthDisplayingFS, "//VTK::FSQ::Decl",
+      "uniform sampler2D depthTexture;\n"
+      "uniform bool useColorMap;\n"
+      "uniform sampler1D colorMapTexture;\n"
+      "//VTK::FSQ::Decl");
+
+    vtkShaderProgram::Substitute(depthDisplayingFS, "//VTK::FSQ::Impl",
+      "float depth = texture2D(depthTexture, texCoord).r;\n"
+      "if (useColorMap)\n"
+      "{\n"
+      "  vec4 colorMapped = texture1D(colorMapTexture, depth);\n"
+      "  gl_FragData[0] = vec4(colorMapped.rgb, 1.0);\n"
+      "  return;\n"
+      "}\n"
+      "else {"
+      "if (depth <= 1e-6) depth = 1.0;\n"
+      "}"
+      "gl_FragData[0] = vec4(depth, depth, depth, 1.0);\n"
+      "//VTK::FSQ::Impl");
+    this->QuadHelper =
+      std::make_shared<vtkOpenGLQuadHelper>(renWin, nullptr, depthDisplayingFS.c_str(), nullptr);
+    this->QuadHelper->ShaderChangeValue = this->GetMTime();
+  }
+  else
+  {
+    renWin->GetShaderCache()->ReadyShaderProgram(this->QuadHelper->Program);
+  }
+
+  assert(this->QuadHelper->Program && this->QuadHelper->Program->GetCompiled());
+
+  this->DepthTexture->Activate();
+  this->ColorMapTexture->Activate();
+
+  this->QuadHelper->Program->SetUniformi("depthTexture", this->DepthTexture->GetTextureUnit());
+  this->QuadHelper->Program->SetUniformi("useColorMap", this->ColorMap != nullptr ? 1 : 0);
+  this->QuadHelper->Program->SetUniformi(
+    "colorMapTexture", this->ColorMapTexture->GetTextureUnit());
+
+  ostate->vtkglDisable(GL_BLEND);
+  ostate->vtkglDisable(GL_DEPTH_TEST);
+  ostate->vtkglViewport(pos[0], pos[1], size[0], size[1]);
+  ostate->vtkglScissor(pos[0], pos[1], size[0], size[1]);
+
+  this->QuadHelper->Render();
+
+  this->DepthTexture->Deactivate();
+  this->ColorMapTexture->Deactivate();
+  vtkOpenGLCheckErrorMacro("failed after Render");
+}
+
+void vtkF3DDisplayDepthRenderPass::ReleaseGraphicsResources(vtkWindow* window)
+{
+  this->Superclass::ReleaseGraphicsResources(window);
+
+  if (this->FrameBufferObject)
+  {
+    this->FrameBufferObject->ReleaseGraphicsResources(window);
+  }
+  if (this->DepthTexture)
+  {
+    this->DepthTexture->ReleaseGraphicsResources(window);
+  }
+  if (this->ColorMapTexture)
+  {
+    this->ColorMapTexture->ReleaseGraphicsResources(window);
+  }
+}
+
+bool vtkF3DDisplayDepthRenderPass::PreReplaceShaderValues(std::string& vertexShader,
+  std::string& geometryShader, std::string& fragmentShader, vtkAbstractMapper* mapper,
+  vtkProp* prop)
+{
+  vtkShaderProgram::Substitute(
+    fragmentShader, "//VTK::Light::Impl", "  gl_FragData[0] = vec4(vec3(gl_FragCoord.z), 1.0);\n");
+  return true;
+}
+
+void vtkF3DDisplayDepthRenderPass::SetColorMap(vtkDiscretizableColorTransferFunction* colorMap)
+{
+  this->ColorMap = colorMap;
+  ColorMapDirty = true;
+}

vtkext/private/module/vtkF3DDisplayDepthRenderPass.h

@@ -0,0 +1,38 @@
+#ifndef vtkF3DDepthRenderPass_h
+#define vtkF3DDepthRenderPass_h
+
+#include "vtkImageProcessingPass.h"
+
+#include <vtkDiscretizableColorTransferFunction.h>
+#include <vtkSmartPointer.h>
+
+#include <memory>
+
+class vtkOpenGLFramebufferObject;
+class vtkOpenGLQuadHelper;
+class vtkTextureObject;
+
+class vtkF3DDisplayDepthRenderPass : public vtkImageProcessingPass
+{
+public:
+  static vtkF3DDisplayDepthRenderPass* New();
+  vtkTypeMacro(vtkF3DDisplayDepthRenderPass, vtkImageProcessingPass);
+  void Render(const vtkRenderState* state) override;
+  void ReleaseGraphicsResources(vtkWindow* window) override;
+  bool PreReplaceShaderValues(std::string& vertexShader, std::string& geometryShader,
+    std::string& fragmentShader, vtkAbstractMapper* mapper, vtkProp* prop) override;
+  void SetColorMap(vtkDiscretizableColorTransferFunction* colorMap);
+
+private:
+  vtkF3DDisplayDepthRenderPass() = default;
+  ~vtkF3DDisplayDepthRenderPass() override = default;
+
+  vtkDiscretizableColorTransferFunction* ColorMap = nullptr;
+  bool ColorMapDirty = true;
+
+  vtkSmartPointer<vtkTextureObject> DepthTexture;
+  vtkSmartPointer<vtkTextureObject> ColorMapTexture;
+  vtkSmartPointer<vtkOpenGLFramebufferObject> FrameBufferObject;
+  std::shared_ptr<vtkOpenGLQuadHelper> QuadHelper;
+};
+#endif

vtkext/private/module/vtkF3DRenderer.cxx

@@ -5,6 +5,7 @@
 #include "F3DLog.h"
 #include "vtkF3DCachedLUTTexture.h"
 #include "vtkF3DCachedSpecularTexture.h"
+#include "vtkF3DDisplayDepthRenderPass.h"
 #include "vtkF3DInteractorStyle.h"
 #include "vtkF3DOpenGLGridMapper.h"
 #include "vtkF3DOverlayRenderPass.h"
@@ -481,6 +482,18 @@ void vtkF3DRenderer::ConfigureRenderPasses()
   // Image post processing passes
   vtkSmartPointer<vtkRenderPass> renderingPass = newPass;
 
+  if (this->DisplayDepth)
+  {
+    vtkNew<vtkF3DDisplayDepthRenderPass> depthP;
+    depthP->SetDelegatePass(renderingPass);
+    if (this->DisplayDepthScalarColoring)
+    {
+      this->ConfigureColoring();
+      depthP->SetColorMap(this->ColorTransferFunction);
+    }
+    renderingPass = depthP;
+  }
+
   if (this->AntiAliasingModeEnabled == vtkF3DRenderer::AntiAliasingMode::SSAA)
   {
     vtkNew<vtkSSAAPass> ssaaP;
@@ -1730,6 +1743,28 @@ void vtkF3DRenderer::SetUseToneMappingPass(bool use)
   }
 }
 
+//----------------------------------------------------------------------------
+void vtkF3DRenderer::SetDisplayDepth(bool use)
+{
+  if (this->DisplayDepth != use)
+  {
+    this->DisplayDepth = use;
+    this->RenderPassesConfigured = false;
+    this->CheatSheetConfigured = false;
+  }
+}
+
+//----------------------------------------------------------------------------
+void vtkF3DRenderer::SetDisplayDepthScalarColoring(bool use)
+{
+  if (this->DisplayDepthScalarColoring != use)
+  {
+    this->DisplayDepthScalarColoring = use;
+    this->RenderPassesConfigured = false;
+    this->CheatSheetConfigured = false;
+  }
+}
+
 //----------------------------------------------------------------------------
 void vtkF3DRenderer::SetUseRaytracing(bool use)
 {
@@ -2836,7 +2871,8 @@ void vtkF3DRenderer::ConfigureColoring()
   assert(this->Importer);
 
   // Recover coloring information and update handler
-  bool enableColoring = this->EnableColoring || (!this->UseRaytracing && this->UseVolume);
+  bool enableColoring = this->EnableColoring || (!this->UseRaytracing && this->UseVolume) ||
+    (this->DisplayDepth && this->DisplayDepthScalarColoring);
   F3DColoringInfoHandler& coloringHandler = this->Importer->GetColoringInfoHandler();
   auto info = coloringHandler.SetCurrentColoring(
     enableColoring, this->UseCellColoring, this->ArrayNameForColoring, false);

vtkext/private/module/vtkF3DRenderer.h

@@ -139,6 +139,8 @@ class vtkF3DRenderer : public vtkOpenGLRenderer
   void SetUseSSAOPass(bool use);
   void SetAntiAliasingMode(AntiAliasingMode mode);
   void SetUseToneMappingPass(bool use);
+  void SetDisplayDepth(bool use);
+  void SetDisplayDepthScalarColoring(bool use);
   void SetUseBlurBackground(bool use);
   void SetBlurCircleOfConfusionRadius(double radius);
   void SetRaytracingSamples(int samples);
@@ -689,6 +691,8 @@ class vtkF3DRenderer : public vtkOpenGLRenderer
   BlendingMode BlendingModeEnabled = BlendingMode::NONE;
   bool UseSSAOPass = false;
   bool UseToneMappingPass = false;
+  bool DisplayDepth = false;
+  bool DisplayDepthScalarColoring = false;
   bool UseBlurBackground = false;
   std::optional<bool> UseOrthographicProjection = false;
   bool UseTrackball = false;