@kitware/vtk.js 28.4.0 → 28.5.0

package/Rendering/Core/VolumeMapper.d.ts

@@ -68,6 +68,21 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	 */
 	getAutoAdjustSampleDistances(): boolean;
 
+	/**
+	 * Get at what scale the quality is reduced when interacting for the first time with the volume
+	 * It should should be set before any call to render for this volume
+	 * The higher the scale is, the lower the quality of rendering is during interaction
+	 * @default 16
+	 */
+	getInitialInteractionScale(): number;
+
+	/**
+	 * Get by how much the sample distance should be increased when interacting
+	 * This feature is only implemented in the OpenGL volume mapper
+	 * @default 4
+	 */
+	getInteractionSampleDistanceFactor(): number;
+
 	/**
 	 *
 	 */
@@ -188,6 +203,18 @@ export interface vtkVolumeMapper extends vtkAbstractMapper {
 	 */
 	setAutoAdjustSampleDistances(autoAdjustSampleDistances: boolean): boolean;
 
+	/**
+	 *
+	 * @param initialInteractionScale
+	 */
+	setInitialInteractionScale(initialInteractionScale: number): boolean;
+
+	/**
+	 *
+	 * @param interactionSampleDistanceFactor
+	 */
+	setInteractionSampleDistanceFactor(interactionSampleDistanceFactor: number): boolean;
+
 	/**
 	 * Set the normal computation to be dependent on the transfer function.
 	 * By default, the mapper relies on the scalar gradient for computing normals at sample locations

package/Rendering/Core/VolumeMapper.js

@@ -147,6 +147,8 @@ var DEFAULT_VALUES = {
   imageSampleDistance: 1.0,
   maximumSamplesPerRay: 1000,
   autoAdjustSampleDistances: true,
+  initialInteractionScale: 1.0,
+  interactionSampleDistanceFactor: 1.0,
   blendMode: BlendMode.COMPOSITE_BLEND,
   ipScalarRange: [-1000000.0, 1000000.0],
   filterMode: FilterMode.OFF,
@@ -169,7 +171,7 @@ function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkAbstractMapper.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
+  macro.setGet(publicAPI, model, ['sampleDistance', 'imageSampleDistance', 'maximumSamplesPerRay', 'autoAdjustSampleDistances', 'initialInteractionScale', 'interactionSampleDistanceFactor', 'blendMode', 'filterMode', 'preferSizeOverAccuracy', 'computeNormalFromOpacity', 'volumetricScatteringBlending', 'globalIlluminationReach', 'volumeShadowSamplingDistFactor', 'anisotropy', 'localAmbientOcclusion', 'LAOKernelSize', 'LAOKernelRadius']);
   macro.setGetArray(publicAPI, model, ['ipScalarRange'], 2);
   macro.event(publicAPI, model, 'lightingActivated'); // Object methods
 

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -377,24 +377,6 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 */
 	getSize(): Vector2;
 
-	/**
-	 *
-	 * @param {Vector2} size
-	 */
-	setVrResolution(size: Vector2): void;
-
-	/**
-	 *
-	 * @param {Number} x
-	 * @param {Number} y
-	 */
-	setVrResolution(x: number, y: number): void;
-
-	/**
-	 *
-	 */
-	getVrResolution(): Vector2;
-
 	/**
 	 * Scales the size of a browser CSS pixel to a rendered canvas pixel.  
 	 * `const renderedPixelWidth = cssPixelWidth * apiRenderWindow.getComputedDevicePixelRatio()`

package/Rendering/OpenGL/RenderWindow.js

@@ -93,9 +93,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
 
   model.canvas.addEventListener('webglcontextlost', _preventDefault, false);
-  model.canvas.addEventListener('webglcontextrestored', publicAPI.restoreContext, false); // Cache the value here as calling it on each frame is expensive
-
-  var isImmersiveVrSupported = navigator.xr !== undefined && navigator.xr.isSessionSupported('immersive-vr'); // Auto update style
+  model.canvas.addEventListener('webglcontextrestored', publicAPI.restoreContext, false); // Auto update style
 
   var previousSize = [0, 0];
 
@@ -233,12 +231,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
       alpha: true,
       powerPreference: 'high-performance'
     };
-    var result = null; // Do we have webxr support
-
-    if (isImmersiveVrSupported) {
-      publicAPI.invokeHaveVRDisplay();
-    }
-
+    var result = null;
     var webgl2Supported = typeof WebGL2RenderingContext !== 'undefined';
     model.webgl2 = false;
 
@@ -988,8 +981,7 @@ function extend(publicAPI, model) {
   model.shaderCache.setOpenGLRenderWindow(publicAPI); // setup default forward pass rendering
 
   model.renderPasses[0] = vtkForwardPass.newInstance();
-  macro.event(publicAPI, model, 'imageReady');
-  macro.event(publicAPI, model, 'haveVRDisplay'); // Build VTK API
+  macro.event(publicAPI, model, 'imageReady'); // Build VTK API
 
   macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage', 'xrSupported', 'activeFramebuffer']);
   macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen']);

package/Rendering/OpenGL/VolumeMapper.js

@@ -145,7 +145,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     var spc = model.currentInput.getSpacing();
     var vsize = new Float64Array(3);
     vec3.set(vsize, (ext[1] - ext[0]) * spc[0], (ext[3] - ext[2]) * spc[1], (ext[5] - ext[4]) * spc[2]);
-    var maxSamples = vec3.length(vsize) / model.renderable.getSampleDistance();
+    var maxSamples = vec3.length(vsize) / publicAPI.getCurrentSampleDistance(ren);
     FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::MaximumSamplesValue', "".concat(Math.ceil(maxSamples))).result; // set light complexity
 
     FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LightComplexity', "#define vtkLightComplexity ".concat(model.lastLightComplexity)).result; // set shadow blending flag
@@ -297,7 +297,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     var spc = model.currentInput.getSpacing();
     var vsize = new Float64Array(3);
     vec3.set(vsize, (ext[1] - ext[0]) * spc[0], (ext[3] - ext[2]) * spc[1], (ext[5] - ext[4]) * spc[2]);
-    var maxSamples = vec3.length(vsize) / model.renderable.getSampleDistance();
+    var maxSamples = vec3.length(vsize) / publicAPI.getCurrentSampleDistance(ren);
     var state = {
       interpolationType: actor.getProperty().getInterpolationType(),
       useLabelOutline: actor.getProperty().getUseLabelOutline(),
@@ -372,7 +372,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     }
 
     program.setUniformi('texture1', model.scalarTexture.getTextureUnit());
-    program.setUniformf('sampleDistance', model.renderable.getSampleDistance());
+    program.setUniformf('sampleDistance', publicAPI.getCurrentSampleDistance(ren));
     var volInfo = model.scalarTexture.getVolumeInfo();
     var ipScalarRange = model.renderable.getIpScalarRange();
     var minVals = [];
@@ -467,7 +467,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     mat4.multiply(model.idxToView, model.modelToView, i2wmat4);
     mat3.multiply(model.idxNormalMatrix, keyMats.normalMatrix, actMats.normalMatrix);
     mat3.multiply(model.idxNormalMatrix, model.idxNormalMatrix, model.currentInput.getDirectionByReference());
-    var maxSamples = vec3.length(vsize) / model.renderable.getSampleDistance();
+    var maxSamples = vec3.length(vsize) / publicAPI.getCurrentSampleDistance(ren);
 
     if (maxSamples > model.renderable.getMaximumSamplesPerRay()) {
       vtkWarningMacro("The number of steps required ".concat(Math.ceil(maxSamples), " is larger than the\n        specified maximum number of steps ").concat(model.renderable.getMaximumSamplesPerRay(), ".\n        Please either change the\n        volumeMapper sampleDistance or its maximum number of samples."));
@@ -817,8 +817,25 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     return [lowerLeftU, lowerLeftV];
   };
 
+  publicAPI.getCurrentSampleDistance = function (ren) {
+    var rwi = ren.getVTKWindow().getInteractor();
+    var baseSampleDistance = model.renderable.getSampleDistance();
+
+    if (rwi.isAnimating()) {
+      var factor = model.renderable.getInteractionSampleDistanceFactor();
+      return baseSampleDistance * factor;
+    }
+
+    return baseSampleDistance;
+  };
+
   publicAPI.renderPieceStart = function (ren, actor) {
     var rwi = ren.getVTKWindow().getInteractor();
+
+    if (!model._lastScale) {
+      model._lastScale = model.renderable.getInitialInteractionScale();
+    }
+
     model._useSmallViewport = false;
 
     if (rwi.isAnimating() && model._lastScale > 1.5) {
@@ -849,18 +866,16 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         } else {
           model._lastScale = model.renderable.getImageSampleDistance() * model.renderable.getImageSampleDistance();
         }
-
-        var size = model._openGLRenderWindow.getFramebufferSize();
-
-        model._smallViewportWidth = Math.ceil(size[0] / Math.sqrt(model._lastScale));
-        model._smallViewportHeight = Math.ceil(size[1] / Math.sqrt(model._lastScale));
       });
     } // use/create/resize framebuffer if needed
 
 
     if (model._useSmallViewport) {
-      var size = model._openGLRenderWindow.getFramebufferSize(); // adjust viewportSize to always be at most the dest fo size
+      var size = model._openGLRenderWindow.getFramebufferSize();
 
+      var scaleFactor = 1 / Math.sqrt(model._lastScale);
+      model._smallViewportWidth = Math.ceil(scaleFactor * size[0]);
+      model._smallViewportHeight = Math.ceil(scaleFactor * size[1]); // adjust viewportSize to always be at most the dest fo size
 
       if (model._smallViewportHeight > size[1]) {
         model._smallViewportHeight = size[1];
@@ -1063,7 +1078,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
 
       for (var c = 0; c < numIComps; ++c) {
         var ofun = vprop.getScalarOpacity(c);
-        var opacityFactor = model.renderable.getSampleDistance() / vprop.getScalarOpacityUnitDistance(c);
+        var opacityFactor = publicAPI.getCurrentSampleDistance(ren) / vprop.getScalarOpacityUnitDistance(c);
         var oRange = ofun.getRange();
         ofun.getTable(oRange[0], oRange[1], oWidth, tmpTable, 1); // adjust for sample distance etc
 
@@ -1251,8 +1266,7 @@ function extend(publicAPI, model) {
   model.idxNormalMatrix = mat3.identity(new Float64Array(9));
   model.modelToView = mat4.identity(new Float64Array(16));
   model.projectionToView = mat4.identity(new Float64Array(16));
-  model.projectionToWorld = mat4.identity(new Float64Array(16));
-  model._lastScale = 1.0; // Build VTK API
+  model.projectionToWorld = mat4.identity(new Float64Array(16)); // Build VTK API
 
   setGet(publicAPI, model, ['context']); // Object methods
 

package/Rendering/WebGPU/VolumePass.js

@@ -187,15 +187,16 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   }, publicAPI.delete);
 
   publicAPI.computeTiming = function (viewNode) {
-    model._useSmallViewport = false;
     var rwi = viewNode.getRenderable().getInteractor();
 
-    if (rwi.isAnimating() && model._lastScale > 1.5) {
-      if (!model._smallViewportHeight) {
-        model._smallViewportWidth = Math.ceil(viewNode.getCanvas().width / Math.sqrt(model._lastScale));
-        model._smallViewportHeight = Math.ceil(viewNode.getCanvas().height / Math.sqrt(model._lastScale));
-      }
+    if (model._lastScale == null) {
+      var firstMapper = model.volumes[0].getRenderable().getMapper();
+      model._lastScale = firstMapper.getInitialInteractionScale() || 1.0;
+    }
 
+    model._useSmallViewport = false;
+
+    if (rwi.isAnimating() && model._lastScale > 1.5) {
       model._useSmallViewport = true;
     }
 
@@ -222,9 +223,6 @@ function vtkWebGPUVolumePass(publicAPI, model) {
 
         if (model._lastScale < 1.5) {
           model._lastScale = 1.5;
-        } else {
-          model._smallViewportWidth = Math.ceil(viewNode.getCanvas().width / Math.sqrt(model._lastScale));
-          model._smallViewportHeight = Math.ceil(viewNode.getCanvas().height / Math.sqrt(model._lastScale));
         }
       });
     }
@@ -240,6 +238,10 @@ function vtkWebGPUVolumePass(publicAPI, model) {
     var height = model._colorTextureView.getTexture().getHeight();
 
     if (model._useSmallViewport) {
+      var canvas = viewNode.getCanvas();
+      var scaleFactor = 1 / Math.sqrt(model._lastScale);
+      model._smallViewportWidth = Math.ceil(scaleFactor * canvas.width);
+      model._smallViewportHeight = Math.ceil(scaleFactor * canvas.height);
       width = model._smallViewportWidth;
       height = model._smallViewportHeight;
     }
@@ -655,7 +657,6 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   vtkRenderPass.extend(publicAPI, model, initialValues);
-  model._lastScale = 2.0;
   model._mapper = vtkWebGPUSimpleMapper.newInstance();
 
   model._mapper.setFragmentShaderTemplate(DepthBoundsFS);

package/package.json

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