Documentation/release/dev/addSurfaceProbeVolumeMapper.md

+## Add SurfaceProbeVolumeMapper
+
+vtkOpenGLSurfaceProbeVolumeMapper is a PolyDataMapper colored with probed volume data.
+The mapper accepts three inputs: the Input, the Source and an optional ProbeInput.
+The Source data defines the vtkImageData from which scalar values are interpolated.
+The Input data defines the rendered surface.
+The ProbeInput defines the geometry used to interpolate the source data.
+If the ProbeInput is not specified, the Input is used both for probing and rendering.
+Projecting the scalar values from the ProbeInput to the Input is done thanks to texture
+coordinates. Both inputs must provide texture coordinates in the [0, 1] range.

Rendering/VolumeOpenGL2/CMakeLists.txt

@@ -4,6 +4,7 @@ set(classes
   vtkOpenGLGPUVolumeRayCastMapper
   vtkOpenGLProjectedTetrahedraMapper
   vtkOpenGLRayCastImageDisplayHelper
+  vtkOpenGLSurfaceProbeVolumeMapper
   vtkSmartVolumeMapper
   vtkVolumeTexture)
 

Rendering/VolumeOpenGL2/Testing/Cxx/CMakeLists.txt

@@ -19,6 +19,7 @@ set (VolumeOpenGL2CxxTests
   TestGPURayCastToggleJittering.cxx
   TestGPURayCastUserShader.cxx
   TestGPURayCastUserShader2.cxx
+  TestSurfaceProbeVolumeMapper.cxx
   )
 
 # everyone gets these tests

Rendering/VolumeOpenGL2/Testing/Cxx/TestSurfaceProbeVolumeMapper.cxx

+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+
+#include "vtkActor.h"
+#include "vtkCamera.h"
+#include "vtkCellArray.h"
+#include "vtkColorTransferFunction.h"
+#include "vtkDoubleArray.h"
+#include "vtkImageData.h"
+#include "vtkLinearExtrusionFilter.h"
+#include "vtkNew.h"
+#include "vtkOpenGLGPUVolumeRayCastMapper.h"
+#include "vtkOpenGLSurfaceProbeVolumeMapper.h"
+#include "vtkPiecewiseFunction.h"
+#include "vtkPlaneSource.h"
+#include "vtkPointData.h"
+#include "vtkPoints.h"
+#include "vtkPolyData.h"
+#include "vtkPolyDataMapper.h"
+#include "vtkPolyDataNormals.h"
+#include "vtkPolyLine.h"
+#include "vtkRegressionTestImage.h"
+#include "vtkRenderWindow.h"
+#include "vtkRenderWindowInteractor.h"
+#include "vtkRenderer.h"
+#include "vtkSplineFilter.h"
+#include "vtkTestUtilities.h"
+#include "vtkTransform.h"
+#include "vtkVolume.h"
+#include "vtkVolume16Reader.h"
+#include "vtkVolumeProperty.h"
+
+namespace
+{
+
+vtkSmartPointer<vtkPolyData> CreateCurvedPlane(double planeWidth, double& curveLength)
+{
+  // Create centerline polydata
+  vtkNew<vtkPoints> linePoints;
+  linePoints->InsertNextPoint(70.0, 105.0, 70.0);
+  linePoints->InsertNextPoint(95.0, 165.0, 70.0);
+  linePoints->InsertNextPoint(125.0, 105.0, 70.0);
+
+  vtkNew<vtkPolyLine> line;
+  line->GetPointIds()->SetNumberOfIds(linePoints->GetNumberOfPoints());
+  for (int i = 0; i < linePoints->GetNumberOfPoints(); i++)
+  {
+    line->GetPointIds()->SetId(i, i);
+  }
+
+  vtkNew<vtkCellArray> lines;
+  lines->InsertNextCell(line);
+
+  vtkNew<vtkPolyData> linePolydata;
+  linePolydata->SetPoints(linePoints);
+  linePolydata->SetLines(lines);
+
+  // Create spline from centerline polydata
+  vtkNew<vtkSplineFilter> spline;
+  spline->SetNumberOfSubdivisions(50);
+  spline->SetInputData(linePolydata);
+  spline->Update();
+
+  vtkPolyData* splinePolydata = spline->GetOutput();
+
+  // Extrude spline to create a curved plane
+  vtkNew<vtkLinearExtrusionFilter> lineExtrusion;
+  lineExtrusion->SetInputData(splinePolydata);
+  lineExtrusion->SetExtrusionTypeToVectorExtrusion();
+  lineExtrusion->SetVector(0, 0, planeWidth);
+
+  // Compute normals for blend mode
+  vtkNew<vtkPolyDataNormals> normalsFilter;
+  normalsFilter->SetInputConnection(lineExtrusion->GetOutputPort());
+  normalsFilter->ConsistencyOn();
+  normalsFilter->SplittingOff();
+
+  normalsFilter->Update();
+  vtkSmartPointer<vtkPolyData> probeSurface = normalsFilter->GetOutput();
+
+  curveLength = 0.0;
+  // Compute centerline length for texture coordinates
+  for (int i = 0; i < splinePolydata->GetNumberOfPoints(); i++)
+  {
+    double p1[3] = {};
+    double p2[3] = {};
+    splinePolydata->GetPoint(i, p1);
+    splinePolydata->GetPoint(i > 0 ? i - 1 : i, p2);
+
+    curveLength += std::sqrt(vtkMath::Distance2BetweenPoints(p1, p2));
+  }
+
+  // Compute texture coordinates
+  vtkNew<vtkDoubleArray> tcoords;
+  tcoords->SetNumberOfComponents(2);
+  tcoords->SetNumberOfTuples(2 * probeSurface->GetNumberOfPoints());
+
+  double currentLineDistance = 0.0;
+  for (int i = 0; i < splinePolydata->GetNumberOfPoints(); i++)
+  {
+    double p1[3] = {};
+    double p2[3] = {};
+    splinePolydata->GetPoint(i, p1);
+    splinePolydata->GetPoint(i > 0 ? i - 1 : i, p2);
+
+    currentLineDistance += std::sqrt(vtkMath::Distance2BetweenPoints(p1, p2));
+
+    double xCoord = currentLineDistance / curveLength;
+
+    tcoords->SetTuple2(i, xCoord, 1.0);
+    tcoords->SetTuple2(i + splinePolydata->GetNumberOfPoints(), xCoord, 0.0);
+  }
+  probeSurface->GetPointData()->SetTCoords(tcoords);
+
+  return probeSurface;
+}
+
+}
+
+//------------------------------------------------------------------------------
+int TestSurfaceProbeVolumeMapper(int argc, char* argv[])
+{
+  // Load image
+  char* fname = vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/headsq/quarter");
+
+  vtkNew<vtkVolume16Reader> volumeReader;
+  volumeReader->SetDataDimensions(64, 64);
+  volumeReader->SetDataByteOrderToLittleEndian();
+  volumeReader->SetImageRange(1, 93);
+  volumeReader->SetDataSpacing(3.2, 3.2, 1.5);
+  volumeReader->SetFilePrefix(fname);
+  volumeReader->Update();
+  delete[] fname;
+  vtkImageData* volumeData = volumeReader->GetOutput();
+
+  vtkNew<vtkRenderWindow> renderWindow;
+  vtkNew<vtkRenderWindowInteractor> interactor;
+  interactor->SetRenderWindow(renderWindow);
+
+  vtkNew<vtkRenderer> renderer;
+  renderWindow->AddRenderer(renderer);
+  renderer->SetBackground(1, 1, 1);
+  renderer->SetViewport(0, 0.3, 1, 1);
+
+  vtkNew<vtkRenderer> renderer2;
+  renderWindow->AddRenderer(renderer2);
+  renderer2->SetBackground(1, 1, 1);
+  renderer2->SetViewport(0, 0, 1, 0.3);
+
+  // Test mixing surface probe mapper with volume rendering
+  vtkNew<vtkOpenGLGPUVolumeRayCastMapper> volumeMapper;
+  volumeMapper->SetInputData(volumeData);
+
+  vtkNew<vtkVolume> volume;
+  volume->SetMapper(volumeMapper);
+
+  vtkNew<vtkColorTransferFunction> colorFunction;
+  colorFunction->AddRGBPoint(0, 0.0, 0.0, 0.0);
+  colorFunction->AddRGBPoint(3900, 1.0, 1.0, 1.0);
+  vtkNew<vtkPiecewiseFunction> scalarOpacityFunction;
+  scalarOpacityFunction->AddPoint(1000, 0.0);
+  scalarOpacityFunction->AddPoint(3900, 0.15);
+  volume->GetProperty()->SetScalarOpacity(scalarOpacityFunction);
+  volume->GetProperty()->SetColor(colorFunction);
+  volume->GetProperty()->SetInterpolationTypeToLinear();
+
+  renderer->AddVolume(volume);
+
+  // Create probe surface
+  double planeWidth = 30.0;
+  double lineDistance = 0.0;
+  vtkSmartPointer<vtkPolyData> probeSurface = CreateCurvedPlane(planeWidth, lineDistance);
+
+  // Test probe mapper without probe input. The input data is used for probing and rendering.
+  vtkNew<vtkOpenGLSurfaceProbeVolumeMapper> probeMapper;
+  probeMapper->SetInputData(probeSurface);
+  probeMapper->SetSourceData(volumeData);
+  probeMapper->SetBlendModeToAverageIntensity();
+  probeMapper->SetBlendWidth(10);
+  probeMapper->SetWindow(2000);
+  probeMapper->SetLevel(2000);
+
+  vtkNew<vtkActor> probeActor;
+  probeActor->SetMapper(probeMapper);
+
+  // Test transforms applied to probe surface
+  double* c = probeActor->GetCenter();
+  vtkNew<vtkTransform> transform;
+  transform->Translate(c);
+  transform->RotateX(30);
+  transform->Translate(-c[0], -c[1], -c[2]);
+
+  probeActor->SetUserTransform(transform);
+
+  renderer->AddActor(probeActor);
+
+  renderer->ResetCamera();
+  renderer->GetActiveCamera()->Elevation(70);
+  renderer->GetActiveCamera()->Dolly(1.5);
+  renderer->ResetCameraClippingRange();
+
+  // Test probe mapper on straightened plane.
+  // The probe input is projected on the input data
+  vtkNew<vtkPlaneSource> planeSource;
+  planeSource->SetOrigin(0, 0, 0);
+  planeSource->SetPoint1(0, lineDistance, 0);
+  planeSource->SetPoint2(planeWidth, 0, 0);
+
+  vtkNew<vtkOpenGLSurfaceProbeVolumeMapper> probeMapper2;
+  probeMapper2->SetInputConnection(planeSource->GetOutputPort());
+  probeMapper2->SetProbeInputData(probeSurface);
+  probeMapper2->SetSourceData(volumeData);
+  probeMapper2->SetBlendModeToAverageIntensity();
+  probeMapper2->SetBlendWidth(10);
+  probeMapper2->SetWindow(2000);
+  probeMapper2->SetLevel(2000);
+
+  vtkNew<vtkActor> probeActor2;
+  probeActor2->SetMapper(probeMapper2);
+  probeActor2->SetUserTransform(transform);
+
+  renderer2->AddActor(probeActor2);
+
+  renderer2->GetActiveCamera()->SetViewUp(1, 0, 0);
+  renderer2->GetActiveCamera()->Yaw(210);
+  renderer2->ResetCamera();
+  renderer2->GetActiveCamera()->Dolly(3);
+  renderer2->ResetCameraClippingRange();
+
+  renderWindow->Render();
+
+  int retVal = vtkRegressionTestImage(renderWindow);
+  if (retVal == vtkRegressionTester::DO_INTERACTOR)
+  {
+    interactor->Start();
+  }
+
+  return !retVal;
+}

Rendering/VolumeOpenGL2/Testing/Data/Baseline/TestSurfaceProbeVolumeMapper.png.sha512

+c1629c99a7f048c0da3cc2e62861db29f06feecf1a55f5673aa52fc67ae84d3a960b4bca292cc45337922b36a8339dfac02a338d1cdfb8022d1164b99e16c27e

Rendering/VolumeOpenGL2/vtkOpenGLSurfaceProbeVolumeMapper.h

+// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
+// SPDX-License-Identifier: BSD-3-Clause
+/**
+ * @class   vtkOpenGLSurfaceProbeVolumeMapper
+ * @brief   PolyDataMapper colored with probed volume data.
+ *
+ * PolyDataMapper that probes volume data at the points positions specified in its input data.
+ * The rendered surface is colored using the scalar values that were probed in the source volume.
+ * The mapper accepts three inputs: the Input, the Source and an optional ProbeInput.
+ * The Source data defines the vtkImageData from which scalar values are interpolated.
+ * The Input data defines the rendered surface.
+ * The ProbeInput defines the geometry used to interpolate the source data.
+ * If the ProbeInput is not specified, the Input is used both for probing and rendering.
+ *
+ * Projecting the scalar values from the ProbeInput to the Input is done thanks to texture
+ * coordinates. Both inputs must provide texture coordinates in the [0, 1] range.
+ *
+ * The sampled scalar values can be computed with different blending strategy that use surface
+ * normals to perform thick probing of the Source data.
+ *
+ * @note The following features are not supported yet but should be considered in the future.
+ *
+ * - The volume texture is always uploaded using linear interpolation.
+ *   The public API could provide a setter to use nearest neighbor interpolation instead.
+ *
+ * - If the source is rendered by a volume mapper, any transform applied to the volume
+ *   is ignored as there is no interface to pass this information.
+ *
+ * - Only the first scalar component is used for rendering and rescaled with Window/Level.
+ *   Consider supporting RGB volumes without W/L mapping, and independent component.
+ *   Consider supporting Color and opacity transfer function to replace W/L mapping.
+ *
+ * Passing a vtkVolumeProperty to this mapper should be considered to address the above points.
+ *
+ * - A background value of (0, 0, 0, 0) is used when probing outside the volume, but this
+ *   parameters could be exposed in the public API
+ *
+ * - A step value corresponding to the half of the minimum spacing value of the source is used for
+ *   blend modes, but it could be configured from the public API.
+ */
+
+#ifndef vtkOpenGLSurfaceProbeVolumeMapper_h
+#define vtkOpenGLSurfaceProbeVolumeMapper_h
+
+#include "vtkNew.h" // For vtkNew
+#include "vtkOpenGLPolyDataMapper.h"
+#include "vtkRenderingVolumeOpenGL2Module.h" // For export macro
+
+VTK_ABI_NAMESPACE_BEGIN
+class vtkOpenGLFramebufferObject;
+class vtkOpenGLRenderWindow;
+class vtkTextureObject;
+class vtkVolumeTexture;
+
+class VTKRENDERINGVOLUMEOPENGL2_EXPORT vtkOpenGLSurfaceProbeVolumeMapper
+  : public vtkOpenGLPolyDataMapper
+{
+public:
+  static vtkOpenGLSurfaceProbeVolumeMapper* New();
+  vtkTypeMacro(vtkOpenGLSurfaceProbeVolumeMapper, vtkOpenGLPolyDataMapper);
+
+  ///@{
+  /**
+   * Specify the input data used for probing (optional).
+   * If no probe data is specified, the input is used.
+   */
+  void SetProbeInputData(vtkPolyData* in);
+  vtkPolyData* GetProbeInput();
+  void SetProbeInputConnection(vtkAlgorithmOutput* algOutput);
+  ///@}
+
+  ///@{
+  /**
+   * Specify the input data to be probed.
+   */
+  void SetSourceData(vtkImageData* in);
+  vtkImageData* GetSource();
+  void SetSourceConnection(vtkAlgorithmOutput* algOutput);
+  ///@}
+
+  ///@{
+  /**
+   * Set/Get the current window and level values used for scalar coloring.
+   */
+  vtkGetMacro(Window, double);
+  vtkSetMacro(Window, double);
+
+  vtkGetMacro(Level, double);
+  vtkSetMacro(Level, double);
+  ///@}
+
+  ///@{
+  /**
+   * Set/Get the blend mode.
+   * Default is none.
+   *
+   * \sa vtkVolumeMapper::GetBlendMode()
+   */
+  enum class BlendModes : unsigned int
+  {
+    NONE = 0,
+    MAX,
+    MIN,
+    AVERAGE
+  };
+
+  vtkGetEnumMacro(BlendMode, BlendModes);
+  vtkSetEnumMacro(BlendMode, BlendModes);
+  void SetBlendModeToNone() { this->SetBlendMode(BlendModes::NONE); }
+  void SetBlendModeToMaximumIntensity() { this->SetBlendMode(BlendModes::MAX); }
+  void SetBlendModeToMinimumIntensity() { this->SetBlendMode(BlendModes::MIN); }
+  void SetBlendModeToAverageIntensity() { this->SetBlendMode(BlendModes::AVERAGE); }
+  ///@}
+
+  ///@{
+  /**
+   * Set/Get the blend width in world coordinates.
+   */
+  vtkGetMacro(BlendWidth, double);
+  vtkSetMacro(BlendWidth, double);
+  ///@}
+
+  void RenderPiece(vtkRenderer* ren, vtkActor* act) override;
+
+  void UpdateShaders(vtkOpenGLHelper& cellBO, vtkRenderer* ren, vtkActor* act) override;
+
+protected:
+  int FillInputPortInformation(int port, vtkInformation* info) override;
+
+  virtual void ReplaceShaderPositionPass(vtkActor* act);
+  virtual void ReplaceShaderProbePass(vtkActor* act);
+  virtual void UpdateShadersProbePass(vtkOpenGLHelper& cellBO, vtkRenderer* ren);
+
+private:
+  vtkOpenGLSurfaceProbeVolumeMapper();
+  ~vtkOpenGLSurfaceProbeVolumeMapper() override = default;
+
+  void CreateTexture(vtkTextureObject*, vtkOpenGLRenderWindow*);
+  void ReplaceActiveFBO(vtkRenderer*);
+  void RestoreActiveFBO(vtkRenderer*);
+
+  vtkNew<vtkOpenGLFramebufferObject> FBO;
+
+  vtkNew<vtkTextureObject> PositionsTextureObject;
+  vtkNew<vtkTextureObject> NormalsTextureObject;
+  vtkNew<vtkVolumeTexture> VolumeTexture;
+
+  vtkNew<vtkImageData> TransformedSource;
+
+  // Internal pass type used for shader updates
+  enum class PassTypes : unsigned int
+  {
+    DEFAULT = 0,
+    POSITION_TEXTURE,
+    PROBE
+  };
+  PassTypes CurrentPass = PassTypes::DEFAULT;
+
+  // Window / level
+  double Window = 1.0;
+  double Level = 0.0;
+
+  // Blend mode
+  BlendModes BlendMode = BlendModes::NONE;
+  double BlendWidth = 1.0;
+
+  // Saved state
+  bool SavedScissorTestState = false;
+  bool SavedBlendState = false;
+  int SavedViewport[4] = {};
+};
+
+VTK_ABI_NAMESPACE_END
+#endif