@kitware/vtk.js 28.7.0 → 28.8.0

package/Common/DataModel/PolyLine.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;
 }
 
 /**

package/Common/DataModel/PolyLine.js

@@ -58,7 +58,9 @@ function vtkPolyLine(publicAPI, model) {
   };
 
   publicAPI.getDistancesToFirstPoint = function () {
-    if (model.distancesTime.getMTime() < model.points.getMTime()) {
+    var dTime = model.distancesTime.getMTime();
+
+    if (dTime < model.points.getMTime() || dTime < publicAPI.getMTime()) {
       var numPoints = publicAPI.getNumberOfPoints();
 
       if (!model.distances) {
@@ -76,7 +78,7 @@ function vtkPolyLine(publicAPI, model) {
 
         for (var 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);
         }
@@ -121,15 +123,16 @@ function vtkPolyLine(publicAPI, model) {
 
 
 var DEFAULT_VALUES = {
-  orientations: null // an array of quat or null
-
+  orientations: null,
+  // an array of quat or null
+  distanceFunction: vec3.dist
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, 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

package/Rendering/Core/ImageCPRMapper.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
@@ -191,6 +206,17 @@ export interface vtkImageCPRMapper extends vtkAbstractMapper3D {
 	 */
 	preRenderCheck(): boolean;
 
+	/**
+	 * Configure the mapper and the centerline to be in straightened CPR mode
+	 */
+	useStraightenedMode(): void;
+
+	/**
+	 * Configure the mapper and the centerline to be in strectched CPR mode
+	 * @param centerPoint The center point, optional, default to the first point of the centerline or [0, 0, 0]
+	 */
+	useStretchedMode(centerPoint?: Nullable<vec3>): void;
+
 	/**
 	 * Set the polydata used as a centerline
 	 * You can also use `publicAPI.setInputData(centerlineData, 1);`
@@ -346,7 +372,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

package/Rendering/Core/ImageCPRMapper.js

@@ -293,6 +293,36 @@ function vtkImageCPRMapper(publicAPI, model) {
     return true;
   };
 
+  publicAPI.useStraightenedMode = function () {
+    publicAPI.setCenterPoint(null);
+    publicAPI.setUseUniformOrientation(false);
+    publicAPI.getOrientedCenterline().setDistanceFunction(vec3.dist);
+  };
+
+  publicAPI.useStretchedMode = function (centerPoint) {
+    var centerline = publicAPI.getOrientedCenterline(); // Set center point
+
+    if (!centerPoint) {
+      // Get the first point of the centerline if there is one
+      var centerlinePoints = centerline.getPoints();
+      var newCenterPoint = centerlinePoints.getNumberOfTuples() > 0 ? centerlinePoints.getPoint(0) : [0, 0, 0];
+      publicAPI.setCenterPoint(newCenterPoint);
+    } else {
+      publicAPI.setCenterPoint(centerPoint);
+    } // Enable uniform orientation
+
+
+    publicAPI.setUseUniformOrientation(true); // Change distance function
+
+    centerline.setDistanceFunction(function (a, b) {
+      var direction = publicAPI.getUniformDirection();
+      var vec = vec3.subtract([], a, b);
+      var d2 = vec3.squaredLength(vec);
+      var x = vec3.dot(direction, vec);
+      return Math.sqrt(d2 - x * x);
+    });
+  };
+
   publicAPI.setCenterlineData = function (centerlineData) {
     return publicAPI.setInputData(centerlineData, 1);
   };
@@ -326,6 +356,7 @@ var DEFAULT_VALUES = {
   width: 10,
   uniformOrientation: [0, 0, 0, 1],
   useUniformOrientation: false,
+  centerPoint: null,
   preferSizeOverAccuracy: false,
   orientationArrayName: null,
   tangentDirection: [1, 0, 0],
@@ -345,7 +376,7 @@ function extend(publicAPI, model) {
     mtime: 0
   }); // Setters and getters
 
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model); // Object methods
 
   vtkImageCPRMapper(publicAPI, model);

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -449,14 +449,20 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
   publicAPI.getNeedToRebuildShaders = function (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
     var tNumComp = model.volumeTexture.getComponents();
     var iComp = actor.getProperty().getIndependentComponents();
+    var useCenterPoint = !!model.renderable.getCenterPoint();
+    var useUniformOrientation = model.renderable.getUseUniformOrientation();
 
-    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    if (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;
@@ -521,6 +527,12 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       tcoordFSDec.push('in vec3 centerlineTopDirVSOutput;', 'in vec3 centerlineBotDirVSOutput;', 'in float centerlineAngleVSOutput;');
     }
 
+    var centerPoint = model.renderable.getCenterPoint();
+
+    if (centerPoint) {
+      tcoordFSDec.push('uniform vec3 globalCenterPoint;');
+    }
+
     if (iComps) {
       for (var comp = 1; comp < tNumComp; comp++) {
         tcoordFSDec = tcoordFSDec.concat([// color shift and scale
@@ -566,7 +578,13 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       tcoordFSImpl.push('vec3 interpolatedCenterlineDir;', 'if (centerlineAngleVSOutput < 0.0) {', '  // Lerp', '  interpolatedCenterlineDir = quadOffsetVSOutput.y * centerlineTopDirVSOutput + (1.0 - quadOffsetVSOutput.y) * centerlineBotDirVSOutput;', '} else {', '  // Slerp', '  float topInterpolationAngle = quadOffsetVSOutput.y * centerlineAngleVSOutput;', '  float botInterpolationAngle = centerlineAngleVSOutput - topInterpolationAngle;', '  interpolatedCenterlineDir = sin(topInterpolationAngle) * centerlineTopDirVSOutput + sin(botInterpolationAngle) * centerlineBotDirVSOutput;', '}', '// Slerp should give a normalized vector but when sin(angle) is small, rounding error occurs', '// Normalize for both lerp and slerp', 'interpolatedCenterlineDir = normalize(interpolatedCenterlineDir);');
     }
 
-    tcoordFSImpl.push('vec3 volumePosMC = centerlinePosVSOutput + quadOffsetVSOutput.x * interpolatedCenterlineDir;', 'vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;', 'if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(volumeTexture, volumePosTC);');
+    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 + horizontalOffset * interpolatedCenterlineDir;', 'vec3 volumePosTC = (MCTCMatrix * vec4(volumePosMC, 1.0)).xyz;', 'if (any(lessThan(volumePosTC, vec3(0.0))) || any(greaterThan(volumePosTC, vec3(1.0))))', '{', '  // set the background color and exit', '  gl_FragData[0] = backgroundColor;', '  return;', '}', 'vec4 tvalue = texture(volumeTexture, volumePosTC);');
 
     if (iComps) {
       var rgba = ['r', 'g', 'b', 'a'];
@@ -685,6 +703,11 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (cellBO.getProgram().isUniformUsed('centerlineDirection')) {
       var uniformDirection = model.renderable.getUniformDirection();
       cellBO.getProgram().setUniform3fArray('centerlineDirection', uniformDirection);
+    }
+
+    if (cellBO.getProgram().isUniformUsed('globalCenterPoint')) {
+      var centerPoint = model.renderable.getCenterPoint();
+      cellBO.getProgram().setUniform3fArray('globalCenterPoint', centerPoint);
     } // Model coordinates to image space
     // getWorldToIndex is badly named and is in fact modelToIndex
     // MCIC -> Model coordinates to index coordinates

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -365,6 +365,10 @@ function widgetBehavior(publicAPI, model) {
     var _manipulator$handleEv3 = manipulator.handleEvent(calldata, model._apiSpecificRenderWindow),
         worldCoords = _manipulator$handleEv3.worldCoords;
 
+    if (!worldCoords || !worldCoords.length) {
+      return;
+    }
+
     var center = model.widgetState.getCenter();
     var currentVectorToOrigin = [0, 0, 0];
     subtract(worldCoords, center, currentVectorToOrigin);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "28.7.0",
+  "version": "28.8.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",