feat(cpr): Add stretched and projected CPR

Tweaking the settings of the mapper makes it possible to use the mapper in
straightened, stretched or projected mode.

Author: bruyeret

Sources/Common/DataModel/PolyLine/index.d.ts

@@ -1,5 +1,5 @@
-import { quat } from 'gl-matrix';
-import { Vector2, Vector3 } from '../../../types';
+import { quat, vec3 } from 'gl-matrix';
+import { Nullable, Vector2, Vector3 } from '../../../types';
 import vtkCell, { ICellInitialValues } from '../Cell';
 import { IIntersectWithLine } from '../Line';
 
@@ -67,6 +67,31 @@ export interface vtkPolyLine extends vtkCell {
    * @param distance The distance from the first point of the polyline
    */
   findPointIdAtDistanceFromFirstPoint(distance: number): number;
+
+  /**
+   * An array of quaternions used to orient the polyline at each of its point
+   * The length of the array has to be the same size as the number of points
+   * Defaults to null.
+   */
+  getOrientations(): Nullable<quat[]>;
+
+  /**
+   * @see getOrientations
+   * @param orientations
+   */
+  setOrientations(orientations: Nullable<quat[]>): boolean;
+
+  /**
+   * The function used in getDistancesToFirstPoint and in findPointIdAtDistanceFromFirstPoint
+   * Defaults to vec3.dist of gl-matrix
+   */
+  getDistanceFunction(): (a: vec3, b: vec3) => number;
+
+  /**
+   * @see getDistanceFunction
+   * @param f
+   */
+  setDistanceFunction(f: (a: vec3, b: vec3) => number): boolean;
 }
 
 /**

Sources/Common/DataModel/PolyLine/index.js

@@ -81,7 +81,8 @@ function vtkPolyLine(publicAPI, model) {
   };
 
   publicAPI.getDistancesToFirstPoint = () => {
-    if (model.distancesTime.getMTime() < model.points.getMTime()) {
+    const dTime = model.distancesTime.getMTime();
+    if (dTime < model.points.getMTime() || dTime < publicAPI.getMTime()) {
       const numPoints = publicAPI.getNumberOfPoints();
       if (!model.distances) {
         model.distances = new Array(numPoints);
@@ -96,7 +97,7 @@ function vtkPolyLine(publicAPI, model) {
         model.points.getPoint(0, previousPoint);
         for (let i = 1; i < numPoints; ++i) {
           model.points.getPoint(i, currentPoint);
-          totalDistance += vec3.dist(previousPoint, currentPoint);
+          totalDistance += model.distanceFunction(previousPoint, currentPoint);
           model.distances[i] = totalDistance;
           vec3.copy(previousPoint, currentPoint);
         }
@@ -140,6 +141,7 @@ function vtkPolyLine(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   orientations: null, // an array of quat or null
+  distanceFunction: vec3.dist,
 };
 
 // ----------------------------------------------------------------------------
@@ -149,7 +151,7 @@ export function extend(publicAPI, model, initialValues = {}) {
 
   vtkCell.extend(publicAPI, model, initialValues);
 
-  macro.setGet(publicAPI, model, ['orientations']);
+  macro.setGet(publicAPI, model, ['orientations', 'distanceFunction']);
 
   model.distancesTime = {};
   macro.obj(model.distancesTime, { mtime: 0 });

Sources/Rendering/Core/ImageCPRMapper/index.d.ts

@@ -62,6 +62,21 @@ export interface vtkImageCPRMapper extends vtkAbstractMapper3D {
 	 */
 	setUseUniformOrientation(useUniformOrientation: boolean): boolean;
 
+	/**
+	 * A point used to offset each line of pixel in the rendering
+	 * The line of pixel is offseted such as the center of the line is as close as possible to the center point
+	 * This can be used in combination with @see getUseUniformOrientation and a custom distance function for @see getOrientedCenterline to visualize a CPR in projected mode or stretched mode
+	 * Defaults to null.
+	 * @returns the center point
+	 */
+	getCenterPoint(): Nullable<vec3>;
+	
+	/**
+	 * @see getCenterPoint
+	 * @param point
+	 */
+	setCenterPoint(point: Nullable<vec3>): boolean;
+
 	/**
 	 * This flag indicates wether the GPU should use half float or not
 	 * When true, will use half float
@@ -346,7 +361,10 @@ export function newInstance(initialValues?: IImageCPRMapperInitialValues): vtkIm
 
 /**
  * CPR in vtkImageCPRMapper stands for Curved Planar Reformation. This mapper
- * can be used to visualize tubular structures such as blood vessels.
+ * can be used to visualize tubular structures such as blood vessels. It can be
+ * used in projected mode, stretched mode or straightened mode depending on the
+ * settings @see getUseUniformOrientation , @see getCenterPoint and the distance
+ * function of @see getOrientedCenterline .
  * 
  * This specialised mapper takes as input a vtkImageData representing a volume
  * ( @see setImageData ) and a vtkPolyData representing a centerline

Sources/Rendering/Core/ImageCPRMapper/index.js

@@ -297,6 +297,7 @@ const DEFAULT_VALUES = {
   width: 10,
   uniformOrientation: [0, 0, 0, 1],
   useUniformOrientation: false,
+  centerPoint: null,
   preferSizeOverAccuracy: false,
   orientationArrayName: null,
   tangentDirection: [1, 0, 0],
@@ -323,6 +324,7 @@ export function extend(publicAPI, model, initialValues = {}) {
     'width',
     'uniformOrientation',
     'useUniformOrientation',
+    'centerPoint',
     'preferSizeOverAccuracy',
     'orientationArrayName',
     'tangentDirection',

Sources/Rendering/OpenGL/ImageCPRMapper/index.js

@@ -504,20 +504,28 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
   publicAPI.getNeedToRebuildShaders = (cellBO, ren, actor) => {
     // has something changed that would require us to recreate the shader?
     // candidates are
+    // presence of centerPoint
+    // value of useUniformOrientation
     // property modified (representation interpolation and lighting)
     // input modified
     // light complexity changed
     // render pass shader replacement changed
 
     const tNumComp = model.volumeTexture.getComponents();
     const iComp = actor.getProperty().getIndependentComponents();
+    const useCenterPoint = !!model.renderable.getCenterPoint();
+    const useUniformOrientation = model.renderable.getUseUniformOrientation();
 
     if (
-      model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest ||
       cellBO.getProgram() === 0 ||
+      model.lastUseCenterPoint !== useCenterPoint ||
+      model.lastUseUniformOrientation !== useUniformOrientation ||
+      model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest ||
       model.lastTextureComponents !== tNumComp ||
       model.lastIndependentComponents !== iComp
     ) {
+      model.lastUseCenterPoint = useCenterPoint;
+      model.lastUseUniformOrientation = useUniformOrientation;
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -653,6 +661,10 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         'in float centerlineAngleVSOutput;'
       );
     }
+    const centerPoint = model.renderable.getCenterPoint();
+    if (centerPoint) {
+      tcoordFSDec.push('uniform vec3 globalCenterPoint;');
+    }
     if (iComps) {
       for (let comp = 1; comp < tNumComp; comp++) {
         tcoordFSDec = tcoordFSDec.concat([
@@ -740,8 +752,16 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         'interpolatedCenterlineDir = normalize(interpolatedCenterlineDir);'
       );
     }
+    if (centerPoint) {
+      tcoordFSImpl.push(
+        'float baseOffset = dot(interpolatedCenterlineDir, globalCenterPoint - centerlinePosVSOutput);',
+        'float horizontalOffset = quadOffsetVSOutput.x + baseOffset;'
+      );
+    } else {
+      tcoordFSImpl.push('float horizontalOffset = quadOffsetVSOutput.x;');
+    }
     tcoordFSImpl.push(
-      'vec3 volumePosMC = centerlinePosVSOutput + quadOffsetVSOutput.x * interpolatedCenterlineDir;',
+      'vec3 volumePosMC = centerlinePosVSOutput + horizontalOffset * interpolatedCenterlineDir;',
       'vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;',
       'if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))',
       '{',
@@ -972,6 +992,10 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         .getProgram()
         .setUniform3fArray('centerlineDirection', uniformDirection);
     }
+    if (cellBO.getProgram().isUniformUsed('globalCenterPoint')) {
+      const centerPoint = model.renderable.getCenterPoint();
+      cellBO.getProgram().setUniform3fArray('globalCenterPoint', centerPoint);
+    }
 
     // Model coordinates to image space
     // getWorldToIndex is badly named and is in fact modelToIndex