@kitware/vtk.js 29.7.2 → 29.8.0

package/IO/Core/HttpDataSetReader.js

@@ -185,8 +185,10 @@ function vtkHttpDataSetReader(publicAPI, model) {
       // cacheArrays[arrayId] can be a promise or value
       Promise.resolve(cachedArraysAndPromises[arrayId]).then(cachedArray => {
         if (array !== cachedArray) {
-          //  Update last access for cache retention rules
-          cachedArraysMetaData[arrayId].lastAccess = new Date();
+          //  Update last access for cache retention rules (if caching is enabled)
+          if (model.maxCacheSize) {
+            cachedArraysMetaData[arrayId].lastAccess = new Date();
+          }
 
           // Assign cached array as result
           Object.assign(array, cachedArray);

package/Rendering/Core/ImageCPRMapper/Constants.d.ts

@@ -0,0 +1,10 @@
+export declare enum ProjectionMode {
+	MAX = 0,
+	MIN = 1,
+	AVERAGE = 2,
+}
+
+declare const _default: {
+	ProjectionMode: typeof ProjectionMode;
+};
+export default _default;

package/Rendering/Core/ImageCPRMapper/Constants.js

@@ -0,0 +1,10 @@
+const ProjectionMode = {
+  MAX: 0,
+  MIN: 1,
+  AVERAGE: 2
+};
+var Constants = {
+  ProjectionMode
+};
+
+export { ProjectionMode, Constants as default };

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -6,6 +6,7 @@ import vtkDataArray from './../../Common/Core/DataArray';
 import vtkImageData from './../../Common/DataModel/ImageData';
 import vtkPolyData from './../../Common/DataModel/PolyData';
 import vtkPolyLine from './../../Common/DataModel/PolyLine';
+import { ProjectionMode } from './ImageCPRMapper/Constants';
 
 interface ICoincidentTopology {
 	factor: number;
@@ -157,6 +158,51 @@ export interface vtkImageCPRMapper extends vtkAbstractMapper3D {
 	 */
 	setDirectionMatrix(mat: mat3): boolean;
 
+	/**
+	 * Thickness of the projection slab in image coordinates (NOT in voxels)
+	 * Usually in millimeters if the spacing of the input image is set from a DICOM
+	 */
+	getProjectionSlabThickness(): number;
+
+	/**
+	 * @see getProjectionSlabThickness
+	 * @param projectionSlabThickness
+	 */
+	setProjectionSlabThickness(ProjectionSlabThickness: number): boolean;
+
+	/**
+	 * Total number of samples of the volume done by the projection mode
+	 * If this number is equal or less than 1, projection is disabled
+	 * Using an odd number is advised
+	 * If this number is even, the center of the slab will not be sampled
+	 */
+	getProjectionSlabNumberOfSamples(): number;
+
+	/**
+	 * @see getProjectionSlabNumberOfSamples
+	 * @param projectionSlabNumberOfSamples
+	 */
+	setProjectionSlabNumberOfSamples(projectionSlabNumberOfSamples: number): boolean;
+
+	/**
+	 * Returns wether projection is enabled
+	 * It is based on the number of samples
+	 * @see getProjectionSlabNumberOfSamples
+	 */
+	isProjectionEnabled(): boolean;
+
+	/**
+	 * The different modes of projection
+	 * Available modes include MIP, MinIP and AverageIP
+	 */
+	getProjectionMode(): ProjectionMode;
+
+	/**
+	 * @see getProjectionMode
+	 * @param projectionMode
+	 */
+	setProjectionMode(projectionMode: ProjectionMode): boolean;
+
 	/**
 	 * Find the data array to use for orientation in the input polydata ( @see getOrientationArrayName )
 	 */

package/Rendering/Core/ImageCPRMapper.js

@@ -4,6 +4,7 @@ import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { m as macro } from '../../macros2.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyLine from '../../Common/DataModel/PolyLine.js';
+import { ProjectionMode } from './ImageCPRMapper/Constants.js';
 
 const {
   vtkErrorMacro
@@ -88,7 +89,10 @@ function vtkImageCPRMapper(publicAPI, model) {
     const numComps = model.useUniformOrientation ? model.uniformOrientation.length : orientationDataArray.getNumberOfComponents();
     switch (numComps) {
       case 16:
-        convert = mat4.getRotation;
+        convert = (outQuat, inMat) => {
+          mat4.getRotation(outQuat, inMat);
+          quat.normalize(outQuat, outQuat);
+        };
         break;
       case 9:
         convert = (outQuat, inMat) => {
@@ -250,6 +254,7 @@ function vtkImageCPRMapper(publicAPI, model) {
       return Math.sqrt(d2 - x * x);
     });
   };
+  publicAPI.isProjectionEnabled = () => model.projectionSlabNumberOfSamples > 1;
   publicAPI.setCenterlineData = centerlineData => publicAPI.setInputData(centerlineData, 1);
   publicAPI.setCenterlineConnection = centerlineConnection => publicAPI.setInputConnection(centerlineConnection, 1);
   publicAPI.setImageData = imageData => publicAPI.setInputData(imageData, 0);
@@ -274,7 +279,10 @@ const DEFAULT_VALUES = {
   orientationArrayName: null,
   tangentDirection: [1, 0, 0],
   bitangentDirection: [0, 1, 0],
-  normalDirection: [0, 0, 1]
+  normalDirection: [0, 0, 1],
+  projectionSlabThickness: 1,
+  projectionSlabNumberOfSamples: 1,
+  projectionMode: ProjectionMode.MAX
 };
 
 // ----------------------------------------------------------------------------
@@ -294,7 +302,7 @@ function extend(publicAPI, model) {
   });
 
   // Setters and getters
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/OpenGL/Framebuffer.js

@@ -148,12 +148,8 @@ function vtkFramebuffer(publicAPI, model) {
     }
   };
   publicAPI.getSize = () => {
-    const size = [0, 0];
-    if (model.glFramebuffer !== null) {
-      size[0] = model.glFramebuffer.width;
-      size[1] = model.glFramebuffer.height;
-    }
-    return size;
+    if (model.glFramebuffer == null) return null;
+    return [model.glFramebuffer.width, model.glFramebuffer.height];
   };
   publicAPI.populateFramebuffer = () => {
     if (!model.context) {

package/Rendering/OpenGL/HardwareSelector.js

@@ -241,7 +241,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
       model.framebuffer.setOpenGLRenderWindow(model._openGLRenderWindow);
       model.framebuffer.saveCurrentBindingsAndBuffers();
       const fbSize = model.framebuffer.getSize();
-      if (fbSize[0] !== size[0] || fbSize[1] !== size[1]) {
+      if (!fbSize || fbSize[0] !== size[0] || fbSize[1] !== size[1]) {
         model.framebuffer.create(size[0], size[1]);
         // this calls model.framebuffer.bind()
         model.framebuffer.populateFramebuffer();

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -1,15 +1,16 @@
 import { m as macro } from '../../macros2.js';
 import { mat4, vec3 } from 'gl-matrix';
-import vtkViewNode from '../SceneGraph/ViewNode.js';
+import { Filter } from './Texture/Constants.js';
+import { InterpolationType } from '../Core/ImageProperty/Constants.js';
+import { ProjectionMode } from '../Core/ImageCPRMapper/Constants.js';
+import { Representation } from '../Core/Property/Constants.js';
+import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkHelper from './Helper.js';
+import vtkOpenGLTexture from './Texture.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
-import vtkOpenGLTexture from './Texture.js';
-import vtkDataArray from '../../Common/Core/DataArray.js';
-import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
-import { Representation } from '../Core/Property/Constants.js';
-import { Filter } from './Texture/Constants.js';
-import { InterpolationType } from '../Core/ImageProperty/Constants.js';
+import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import { registerOverride } from './ViewNodeFactory.js';
@@ -364,40 +365,35 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
       });
       const customAttributes = [centerlinePosition, quadIndex];
       if (!model.renderable.getUseUniformOrientation()) {
-        // For each {quad / centerline segment}, two vectors in directionDataArray give the orientation of the centerline
-        // Send these two vectors to each vertex and use flat interpolation to get them as is in the fragment shader
-        // The interpolation will occur in the fragment shader (slerp)
-        const directions = model.renderable.getCenterlineTangentDirections();
-        const centerlineTopDirectionArray = new Float32Array(3 * nPts);
-        const centerlineBotDirectionArray = new Float32Array(3 * nPts);
-        for (let lineIdx = 0, offset = 0; lineIdx < nLines; ++lineIdx) {
-          const baseDirectionIdx = 3 * lineIdx;
-
-          // Every vertex of each quad/segment have the same topDir and botDir
-          // Top left, Top right, Bottom right, Bottom left
-          for (let i = 0; i < 4; ++i) {
-            // Top array
-            centerlineTopDirectionArray[offset + 0] = directions[baseDirectionIdx + 0];
-            centerlineTopDirectionArray[offset + 1] = directions[baseDirectionIdx + 1];
-            centerlineTopDirectionArray[offset + 2] = directions[baseDirectionIdx + 2];
-            // Bot array
-            centerlineBotDirectionArray[offset + 0] = directions[baseDirectionIdx + 3];
-            centerlineBotDirectionArray[offset + 1] = directions[baseDirectionIdx + 4];
-            centerlineBotDirectionArray[offset + 2] = directions[baseDirectionIdx + 5];
-            offset += 3;
+        // For each quad (i.e. centerline segment), a top and bottom quaternion give the orientation
+        // Send both quaternions to each vertex and use flat interpolation to get them "as is" in the fragment shader
+        // The interpolation of the quaternions will occur in the fragment shader (slerp)
+        const orientationQuats = model.renderable.getOrientedCenterline().getOrientations() ?? [];
+        const centerlineTopOrientationArray = new Float32Array(4 * nPts);
+        const centerlineBotOrientationArray = new Float32Array(4 * nPts);
+        for (let quadIdx = 0; quadIdx < nLines; ++quadIdx) {
+          // All vertices of a given quad have the same topDir and botDir
+          // Polyline goes from top to bottom
+          const topQuat = orientationQuats[quadIdx];
+          const botQuat = orientationQuats[quadIdx + 1];
+          for (let pointInQuadIdx = 0; pointInQuadIdx < 4; ++pointInQuadIdx) {
+            const pointIdx = pointInQuadIdx + 4 * quadIdx;
+            const quaternionArrayOffset = 4 * pointIdx;
+            centerlineTopOrientationArray.set(topQuat, quaternionArrayOffset);
+            centerlineBotOrientationArray.set(botQuat, quaternionArrayOffset);
           }
         }
-        const centerlineTopDirection = vtkDataArray.newInstance({
-          numberOfComponents: 3,
-          values: centerlineTopDirectionArray,
-          name: 'centerlineTopDirection'
+        const centerlineTopOrientation = vtkDataArray.newInstance({
+          numberOfComponents: 4,
+          values: centerlineTopOrientationArray,
+          name: 'centerlineTopOrientation'
         });
-        const centerlineBotDirection = vtkDataArray.newInstance({
-          numberOfComponents: 3,
-          values: centerlineBotDirectionArray,
-          name: 'centerlineBotDirection'
+        const centerlineBotOrientation = vtkDataArray.newInstance({
+          numberOfComponents: 4,
+          values: centerlineBotOrientationArray,
+          name: 'centerlineBotOrientation'
         });
-        customAttributes.push(centerlineTopDirection, centerlineBotDirection);
+        customAttributes.push(centerlineTopOrientation, centerlineBotOrientation);
       }
       model.tris.getCABO().createVBO(cells, 'polys', Representation.SURFACE, {
         points,
@@ -420,9 +416,11 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const iComp = actor.getProperty().getIndependentComponents();
     const useCenterPoint = !!model.renderable.getCenterPoint();
     const useUniformOrientation = model.renderable.getUseUniformOrientation();
-    if (cellBO.getProgram() === 0 || model.lastUseCenterPoint !== useCenterPoint || model.lastUseUniformOrientation !== useUniformOrientation || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    const projectionMode = model.renderable.isProjectionEnabled() && model.renderable.getProjectionMode();
+    if (cellBO.getProgram() === 0 || model.lastUseCenterPoint !== useCenterPoint || model.lastUseUniformOrientation !== useUniformOrientation || model.lastProjectionMode !== projectionMode || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
       model.lastUseCenterPoint = useCenterPoint;
       model.lastUseUniformOrientation = useUniformOrientation;
+      model.lastProjectionMode = projectionMode;
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -438,15 +436,22 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     let VSSource = shaders.Vertex;
     let FSSource = shaders.Fragment;
 
+    // https://glmatrix.net/docs/vec3.js.html#line522
+    const applyQuaternionToVecShaderFunction = ['vec3 applyQuaternionToVec(vec4 q, vec3 v) {', '  float uvx = q.y * v.z - q.z * v.y;', '  float uvy = q.z * v.x - q.x * v.z;', '  float uvz = q.x * v.y - q.y * v.x;', '  float uuvx = q.y * uvz - q.z * uvy;', '  float uuvy = q.z * uvx - q.x * uvz;', '  float uuvz = q.x * uvy - q.y * uvx;', '  float w2 = q.w * 2.0;', '  uvx *= w2;', '  uvy *= w2;', '  uvz *= w2;', '  uuvx *= 2.0;', '  uuvy *= 2.0;', '  uuvz *= 2.0;', '  return vec3(v.x + uvx + uuvx, v.y + uvy + uuvy, v.z + uvz + uuvz);', '}'];
+
     // Vertex shader main replacements
     VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Camera::Dec', ['uniform mat4 MCPCMatrix;']).result;
     VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['  gl_Position = MCPCMatrix * vertexMC;']).result;
     const vsColorDec = ['attribute vec3 centerlinePosition;', 'attribute float quadIndex;', 'uniform float width;', 'out vec2 quadOffsetVSOutput;', 'out vec3 centerlinePosVSOutput;'];
+    const useProjection = model.renderable.isProjectionEnabled();
     const isDirectionUniform = model.renderable.getUseUniformOrientation();
     if (isDirectionUniform) {
-      vsColorDec.push('out vec3 centerlineDirVSOutput;', 'uniform vec3 centerlineDirection;');
+      vsColorDec.push('out vec3 samplingDirVSOutput;', 'uniform vec4 centerlineOrientation;', 'uniform vec3 tangentDirection;', ...applyQuaternionToVecShaderFunction);
+      if (useProjection) {
+        vsColorDec.push('out vec3 projectionDirVSOutput;', 'uniform vec3 bitangentDirection;');
+      }
     } else {
-      vsColorDec.push('out vec3 centerlineTopDirVSOutput;', 'out vec3 centerlineBotDirVSOutput;', 'out float centerlineAngleVSOutput;', 'attribute vec3 centerlineTopDirection;', 'attribute vec3 centerlineBotDirection;');
+      vsColorDec.push('out vec4 centerlineTopOrientationVSOutput;', 'out vec4 centerlineBotOrientationVSOutput;', 'attribute vec4 centerlineTopOrientation;', 'attribute vec4 centerlineBotOrientation;');
     }
     VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Dec', vsColorDec).result;
     const vsColorImpl = [
@@ -454,15 +459,12 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     // quadOffsetVSOutput.y: bottom = 0.0; top = 1.0;
     'quadOffsetVSOutput = vec2(width * (mod(quadIndex, 2.0) == 0.0 ? -0.5 : 0.5), quadIndex > 1.0 ? 0.0 : 1.0);', 'centerlinePosVSOutput = centerlinePosition;'];
     if (isDirectionUniform) {
-      vsColorImpl.push('centerlineDirVSOutput = centerlineDirection;');
+      vsColorImpl.push('samplingDirVSOutput = applyQuaternionToVec(centerlineOrientation, tangentDirection);');
+      if (useProjection) {
+        vsColorImpl.push('projectionDirVSOutput = applyQuaternionToVec(centerlineOrientation, bitangentDirection);');
+      }
     } else {
-      vsColorImpl.push(
-      // When u and v are unit vectors: uvAngle = 2 * atan2(|| u - v ||, || u + v ||)
-      // When u != -v: || u + v || > 0
-      // When x > 0: atan2(y, x) = atan(y/x)
-      // Thus: dirAngle = 2 * atan(|| topDir - botDir || / || topDir + botDir ||)
-      // This is more stable and should not be to slow compared to acos(dot(u, v))
-      'vec3 sumVec = centerlineTopDirection + centerlineBotDirection;', 'float sumLen2 = dot(sumVec, sumVec);', 'float diffLen2 = 4.0 - sumLen2;', 'if (diffLen2 < 0.001) {', '  // vectors are too close to each other, use lerp', '  centerlineAngleVSOutput = -1.0; // use negative angle as a flag for lerp', '  centerlineTopDirVSOutput = centerlineTopDirection;', '  centerlineBotDirVSOutput = centerlineBotDirection;', '} else if (sumLen2 == 0.0) {', "  // vector are opposite to each other, don't make a choice for the user", '  // use slerp without direction, it will display the centerline color on each row of pixel', '  centerlineAngleVSOutput = 0.0;', '  centerlineTopDirVSOutput = vec3(0.0);', '  centerlineBotDirVSOutput = vec3(0.0);', '} else {', '  // use slerp', '  centerlineAngleVSOutput = 2.0 * atan(sqrt(diffLen2/sumLen2));', '  float sinAngle = sin(centerlineAngleVSOutput);', '  centerlineTopDirVSOutput = centerlineTopDirection / sinAngle;', '  centerlineBotDirVSOutput = centerlineBotDirection / sinAngle;', '}');
+      vsColorImpl.push('centerlineTopOrientationVSOutput = centerlineTopOrientation;', 'centerlineBotOrientationVSOutput = centerlineBotOrientation;');
     }
     VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Impl', vsColorImpl).result;
 
@@ -484,10 +486,19 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     `uniform float cshift0;`, `uniform float cscale0;`,
     // weighting shift and scale
     `uniform float pwfshift0;`, `uniform float pwfscale0;`];
+    if (useProjection) {
+      tcoordFSDec.push('uniform vec3 spacing;', 'uniform int projectionSlabNumberOfSamples;', 'uniform float projectionConstantOffset;', 'uniform float projectionStepLength;');
+    }
     if (isDirectionUniform) {
-      tcoordFSDec.push('in vec3 centerlineDirVSOutput;');
+      tcoordFSDec.push('in vec3 samplingDirVSOutput;');
+      if (useProjection) {
+        tcoordFSDec.push('in vec3 projectionDirVSOutput;');
+      }
     } else {
-      tcoordFSDec.push('in vec3 centerlineTopDirVSOutput;', 'in vec3 centerlineBotDirVSOutput;', 'in float centerlineAngleVSOutput;');
+      tcoordFSDec.push('uniform vec3 tangentDirection;', 'in vec4 centerlineTopOrientationVSOutput;', 'in vec4 centerlineBotOrientationVSOutput;', ...applyQuaternionToVecShaderFunction);
+      if (useProjection) {
+        tcoordFSDec.push('uniform vec3 bitangentDirection;');
+      }
     }
     const centerPoint = model.renderable.getCenterPoint();
     if (centerPoint) {
@@ -526,18 +537,62 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Dec', tcoordFSDec).result;
     let tcoordFSImpl = [];
     if (isDirectionUniform) {
-      tcoordFSImpl.push('vec3 interpolatedCenterlineDir = centerlineDirVSOutput;');
+      tcoordFSImpl.push('vec3 samplingDirection = samplingDirVSOutput;');
+      if (useProjection) {
+        tcoordFSImpl.push('vec3 projectionDirection = projectionDirVSOutput;');
+      }
     } else {
       // Slerp or lerp between centerlineTopDirVSOutput and centerlineBotDirVSOutput
       // We use quadOffsetVSOutput.y: bottom = 0.0; top = 1.0;
-      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(
+      // Slerp / Lerp
+      'vec4 q0 = centerlineBotOrientationVSOutput;', 'vec4 q1 = centerlineTopOrientationVSOutput;', 'float qCosAngle = dot(q0, q1);', 'vec4 interpolatedOrientation;', 'if (qCosAngle > 0.999 || qCosAngle < -0.999) {', '  // Use LERP instead of SLERP when the two quaternions are close or opposite', '  interpolatedOrientation = normalize(mix(q0, q1, quadOffsetVSOutput.y));', '} else {', '  float omega = acos(qCosAngle);', '  interpolatedOrientation = normalize(sin((1.0 - quadOffsetVSOutput.y) * omega) * q0 + sin(quadOffsetVSOutput.y * omega) * q1);', '}', 'vec3 samplingDirection = applyQuaternionToVec(interpolatedOrientation, tangentDirection);');
+      if (useProjection) {
+        tcoordFSImpl.push('vec3 projectionDirection = applyQuaternionToVec(interpolatedOrientation, bitangentDirection);');
+      }
     }
     if (centerPoint) {
-      tcoordFSImpl.push('float baseOffset = dot(interpolatedCenterlineDir, globalCenterPoint - centerlinePosVSOutput);', 'float horizontalOffset = quadOffsetVSOutput.x + baseOffset;');
+      tcoordFSImpl.push('float baseOffset = dot(samplingDirection, 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);');
+    tcoordFSImpl.push('vec3 volumePosMC = centerlinePosVSOutput + horizontalOffset * samplingDirection;', '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;', '}');
+    if (useProjection) {
+      const projectionMode = model.renderable.getProjectionMode();
+      switch (projectionMode) {
+        case ProjectionMode.MIN:
+          tcoordFSImpl.push('const vec4 initialProjectionTextureValue = vec4(1.0);');
+          break;
+        case ProjectionMode.MAX:
+        case ProjectionMode.AVERAGE:
+        default:
+          tcoordFSImpl.push('const vec4 initialProjectionTextureValue = vec4(0.0);');
+          break;
+      }
+
+      // Loop on all the samples of the projection
+      tcoordFSImpl.push('vec3 projectionScaledDirection = projectionDirection / spacing;', 'vec3 projectionStep = projectionStepLength * projectionScaledDirection;', 'vec3 projectionStartPosition = volumePosTC + projectionConstantOffset * projectionScaledDirection;', 'vec4 tvalue = initialProjectionTextureValue;', 'for (int projectionSampleIdx = 0; projectionSampleIdx < projectionSlabNumberOfSamples; ++projectionSampleIdx) {', '  vec3 projectionSamplePosition = projectionStartPosition + float(projectionSampleIdx) * projectionStep;', '  vec4 sampledTextureValue = texture(volumeTexture, projectionSamplePosition);');
+      switch (projectionMode) {
+        case ProjectionMode.MAX:
+          tcoordFSImpl.push('  tvalue = max(tvalue, sampledTextureValue);');
+          break;
+        case ProjectionMode.MIN:
+          tcoordFSImpl.push('  tvalue = min(tvalue, sampledTextureValue);');
+          break;
+        case ProjectionMode.AVERAGE:
+        default:
+          tcoordFSImpl.push('  tvalue = tvalue + sampledTextureValue;');
+          break;
+      }
+      tcoordFSImpl.push('}');
+
+      // Process the total if needed
+      if (projectionMode === ProjectionMode.AVERAGE) {
+        tcoordFSImpl.push('tvalue = tvalue / float(projectionSlabNumberOfSamples);');
+      }
+    } else {
+      tcoordFSImpl.push('vec4 tvalue = texture(volumeTexture, volumePosTC);');
+    }
     if (iComps) {
       const rgba = ['r', 'g', 'b', 'a'];
       for (let comp = 0; comp < tNumComp; ++comp) {
@@ -610,32 +665,55 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     shaders.Geometry = '';
   };
   publicAPI.setMapperShaderParameters = (cellBO, ren, actor) => {
-    if (cellBO.getCABO().getElementCount() && (model.VBOBuildTime.getMTime() > cellBO.getAttributeUpdateTime().getMTime() || cellBO.getShaderSourceTime().getMTime() > cellBO.getAttributeUpdateTime().getMTime())) {
-      if (cellBO.getProgram().isAttributeUsed('vertexMC')) {
-        if (!cellBO.getVAO().addAttributeArray(cellBO.getProgram(), cellBO.getCABO(), 'vertexMC', cellBO.getCABO().getVertexOffset(), cellBO.getCABO().getStride(), model.context.FLOAT, 3, model.context.FALSE)) {
+    const program = cellBO.getProgram();
+    const cellArrayBufferObject = cellBO.getCABO();
+    if (cellArrayBufferObject.getElementCount() && (model.VBOBuildTime.getMTime() > cellBO.getAttributeUpdateTime().getMTime() || cellBO.getShaderSourceTime().getMTime() > cellBO.getAttributeUpdateTime().getMTime())) {
+      if (program.isAttributeUsed('vertexMC')) {
+        if (!cellBO.getVAO().addAttributeArray(program, cellArrayBufferObject, 'vertexMC', cellArrayBufferObject.getVertexOffset(), cellArrayBufferObject.getStride(), model.context.FLOAT, 3, model.context.FALSE)) {
           vtkErrorMacro('Error setting vertexMC in shader VAO.');
         }
       }
       // Custom data of the CABO (centerlinePosition, centerlineTopDirection,
       // centerlineBotDirection, quadIndex and user defined custom data)
       cellBO.getCABO().getCustomData().forEach(data => {
-        if (data && cellBO.getProgram().isAttributeUsed(data.name) && !cellBO.getVAO().addAttributeArray(cellBO.getProgram(), cellBO.getCABO(), data.name, data.offset, cellBO.getCABO().getStride(), model.context.FLOAT, data.components, model.context.FALSE)) {
+        if (data && program.isAttributeUsed(data.name) && !cellBO.getVAO().addAttributeArray(program, cellArrayBufferObject, data.name, data.offset, cellArrayBufferObject.getStride(), model.context.FLOAT, data.components, model.context.FALSE)) {
           vtkErrorMacro(`Error setting ${data.name} in shader VAO.`);
         }
       });
       cellBO.getAttributeUpdateTime().modified();
     }
     const texUnit = model.volumeTexture.getTextureUnit();
-    cellBO.getProgram().setUniformi('volumeTexture', texUnit);
-    cellBO.getProgram().setUniformf('width', model.renderable.getWidth());
-    cellBO.getProgram().setUniform4f('backgroundColor', ...model.renderable.getBackgroundColor());
-    if (cellBO.getProgram().isUniformUsed('centerlineDirection')) {
-      const uniformDirection = model.renderable.getUniformDirection();
-      cellBO.getProgram().setUniform3fArray('centerlineDirection', uniformDirection);
-    }
-    if (cellBO.getProgram().isUniformUsed('globalCenterPoint')) {
+    program.setUniformi('volumeTexture', texUnit);
+    program.setUniformf('width', model.renderable.getWidth());
+    cellBO.getProgram().setUniform4fv('backgroundColor', model.renderable.getBackgroundColor());
+    if (program.isUniformUsed('tangentDirection')) {
+      const tangentDirection = model.renderable.getTangentDirection();
+      cellBO.getProgram().setUniform3fArray('tangentDirection', tangentDirection);
+    }
+    if (program.isUniformUsed('bitangentDirection')) {
+      const bitangentDirection = model.renderable.getBitangentDirection();
+      cellBO.getProgram().setUniform3fArray('bitangentDirection', bitangentDirection);
+    }
+    if (program.isUniformUsed('centerlineOrientation')) {
+      const uniformOrientation = model.renderable.getUniformOrientation();
+      cellBO.getProgram().setUniform4fv('centerlineOrientation', uniformOrientation);
+    }
+    if (program.isUniformUsed('globalCenterPoint')) {
       const centerPoint = model.renderable.getCenterPoint();
-      cellBO.getProgram().setUniform3fArray('globalCenterPoint', centerPoint);
+      program.setUniform3fArray('globalCenterPoint', centerPoint);
+    }
+    // Projection uniforms
+    if (model.renderable.isProjectionEnabled()) {
+      const image = model.currentImageDataInput;
+      const spacing = image.getSpacing();
+      const projectionSlabThickness = model.renderable.getProjectionSlabThickness();
+      const projectionSlabNumberOfSamples = model.renderable.getProjectionSlabNumberOfSamples();
+      program.setUniform3fArray('spacing', spacing);
+      program.setUniformi('projectionSlabNumberOfSamples', projectionSlabNumberOfSamples);
+      const constantOffset = -0.5 * projectionSlabThickness;
+      program.setUniformf('projectionConstantOffset', constantOffset);
+      const stepLength = projectionSlabThickness / (projectionSlabNumberOfSamples - 1);
+      program.setUniformf('projectionStepLength', stepLength);
     }
 
     // Model coordinates to image space
@@ -646,7 +724,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     const MCICMatrix = image.getWorldToIndex();
     const ICTCMatrix = mat4.fromScaling(new Float32Array(16), vec3.inverse([], image.getDimensions()));
     const MCTCMatrix = mat4.mul(ICTCMatrix, ICTCMatrix, MCICMatrix);
-    cellBO.getProgram().setUniformMatrix('MCTCMatrix', MCTCMatrix);
+    program.setUniformMatrix('MCTCMatrix', MCTCMatrix);
     if (model.haveSeenDepthRequest) {
       cellBO.getProgram().setUniformi('depthRequest', model.renderDepth ? 1 : 0);
     }
@@ -657,8 +735,8 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
         macro.vtkErrorMacro('OpenGL has a limit of 6 clipping planes');
         numClipPlanes = 6;
       }
-      const shiftScaleEnabled = cellBO.getCABO().getCoordShiftAndScaleEnabled();
-      const inverseShiftScaleMatrix = shiftScaleEnabled ? cellBO.getCABO().getInverseShiftAndScaleMatrix() : null;
+      const shiftScaleEnabled = cellArrayBufferObject.getCoordShiftAndScaleEnabled();
+      const inverseShiftScaleMatrix = shiftScaleEnabled ? cellArrayBufferObject.getInverseShiftAndScaleMatrix() : null;
       const mat = inverseShiftScaleMatrix ? mat4.copy(model.imagematinv, actor.getMatrix()) : actor.getMatrix();
       if (inverseShiftScaleMatrix) {
         mat4.transpose(mat, mat);
@@ -677,17 +755,17 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
           planeEquations.push(planeEquation[j]);
         }
       }
-      cellBO.getProgram().setUniformi('numClipPlanes', numClipPlanes);
-      cellBO.getProgram().setUniform4fv('clipPlanes', planeEquations);
+      program.setUniformi('numClipPlanes', numClipPlanes);
+      program.setUniform4fv('clipPlanes', planeEquations);
     }
 
     // handle coincident
-    if (cellBO.getProgram().isUniformUsed('coffset')) {
+    if (program.isUniformUsed('coffset')) {
       const cp = publicAPI.getCoincidentParameters(ren, actor);
-      cellBO.getProgram().setUniformf('coffset', cp.offset);
+      program.setUniformf('coffset', cp.offset);
       // cfactor isn't always used when coffset is.
-      if (cellBO.getProgram().isUniformUsed('cfactor')) {
-        cellBO.getProgram().setUniformf('cfactor', cp.factor);
+      if (program.isUniformUsed('cfactor')) {
+        program.setUniformf('cfactor', cp.factor);
       }
     }
   };

package/Rendering/OpenGL/RenderWindow.js

@@ -184,10 +184,8 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     return model.containerSize || model.size;
   };
   publicAPI.getFramebufferSize = () => {
-    if (model.activeFramebuffer) {
-      return model.activeFramebuffer.getSize();
-    }
-    return model.size;
+    const fbSize = model.activeFramebuffer?.getSize();
+    return fbSize || model.size;
   };
   publicAPI.getPixelData = (x1, y1, x2, y2) => {
     const pixels = new Uint8Array((x2 - x1 + 1) * (y2 - y1 + 1) * 4);

package/Rendering/OpenGL/SurfaceLIC/LineIntegralConvolution2D.js

@@ -133,7 +133,8 @@ function vtkLineIntegralConvolution2D(publicAPI, model) {
     }
     const gl = model.context;
     let fb = model.framebuffer;
-    if (!fb || size[0] !== fb.getSize()[0] || size[1] !== fb.getSize()[1]) {
+    const fbSize = fb.getSize();
+    if (!fb || !fbSize || size[0] !== fbSize || size[1] !== fbSize) {
       fb = vtkOpenGLFramebuffer.newInstance();
       fb.setOpenGLRenderWindow(model._openGLRenderWindow);
       fb.saveCurrentBindingsAndBuffers();

package/Rendering/OpenGL/VolumeMapper.js

@@ -813,7 +813,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         model.framebuffer.populateFramebuffer();
       } else {
         const fbSize = model.framebuffer.getSize();
-        if (fbSize[0] !== size[0] || fbSize[1] !== size[1]) {
+        if (!fbSize || fbSize[0] !== size[0] || fbSize[1] !== size[1]) {
           model.framebuffer.create(size[0], size[1]);
           model.framebuffer.populateFramebuffer();
         }

package/index.d.ts

@@ -160,6 +160,7 @@
 /// <reference path="./Rendering/Core/Glyph3DMapper.d.ts" />
 /// <reference path="./Rendering/Core/HardwareSelector.d.ts" />
 /// <reference path="./Rendering/Core/ImageArrayMapper.d.ts" />
+/// <reference path="./Rendering/Core/ImageCPRMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ImageCPRMapper.d.ts" />
 /// <reference path="./Rendering/Core/ImageMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ImageMapper.d.ts" />

package/package.json

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