@kitware/vtk.js 22.1.1 → 22.1.5

package/Common/DataModel/ITKHelper.js

@@ -92,7 +92,7 @@ function convertItkToVtkImage(itkImage) {
   imageData.getPointData().setScalars(pointData); // Associate the point data that are 3D vectors / tensors
   // Refer to itk-js/src/PixelTypes.js for numerical values
 
-  switch (ITKPixelTypes[itkImage.imageType.pixelType]) {
+  switch (isITKWasm ? ITKPixelTypes[itkImage.imageType.pixelType] : itkImage.imageType.pixelType) {
     case ITKPixelTypes.Scalar:
       break;
 

package/Filters/Sources/Arrow2DSource.js

@@ -139,7 +139,7 @@ function defaultValues(initialValues) {
     center: [0, 0, 0],
     height: 1.0,
     direction: [1, 0, 0],
-    pointType: 'Float32Array',
+    pointType: 'Float64Array',
     thickness: 0,
     width: 1.0
   }, initialValues);

package/Filters/Sources/ArrowSource.js

@@ -72,7 +72,7 @@ var DEFAULT_VALUES = {
   shaftRadius: 0.03,
   invert: false,
   direction: [1.0, 0.0, 0.0],
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/CircleSource.js

@@ -73,7 +73,7 @@ function defaultValues(initialValues) {
     center: [0, 0, 0],
     lines: false,
     direction: [1, 0, 0],
-    pointType: 'Float32Array',
+    pointType: 'Float64Array',
     radius: 1.0,
     resolution: 6
   }, initialValues);

package/Filters/Sources/ConcentricCylinderSource.js

@@ -386,7 +386,7 @@ var DEFAULT_VALUES = {
   skipInnerFaces: true,
   mask: null,
   // If present, array to know if a layer should be skipped(=true)
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/ConeSource.js

@@ -81,7 +81,7 @@ var DEFAULT_VALUES = {
   center: [0, 0, 0],
   direction: [1.0, 0.0, 0.0],
   capping: true,
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/CubeSource.js

@@ -178,7 +178,7 @@ function vtkCubeSource(publicAPI, model) {
     (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).apply(points); // Define quads
 
 
-    var polys = macro.newTypedArray(model.pointType, numberOfPolys * 5);
+    var polys = new Uint16Array(numberOfPolys * 5);
     polyData.getPolys().setData(polys, 1);
     var polyIndex = 0;
     polys[polyIndex++] = 4;
@@ -247,7 +247,7 @@ var DEFAULT_VALUES = {
   zLength: 1.0,
   center: [0.0, 0.0, 0.0],
   rotations: [0.0, 0.0, 0.0],
-  pointType: 'Float32Array',
+  pointType: 'Float64Array',
   generate3DTextureCoordinates: false
 }; // ----------------------------------------------------------------------------
 

package/Filters/Sources/CylinderSource.js

@@ -180,7 +180,7 @@ var DEFAULT_VALUES = {
   center: [0, 0, 0],
   direction: [0.0, 1.0, 0.0],
   capping: true,
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/LineSource.js

@@ -17,9 +17,9 @@ function vtkLineSource(publicAPI, model) {
 
     var dataset = outData[0]; // Check input
 
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : 'Float32Array';
+    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
     var pd = vtkPolyData.newInstance();
-    var v21 = new Float32Array(3);
+    var v21 = [];
     subtract(model.point2, model.point1, v21);
 
     if (norm(v21) <= 0.0) {
@@ -68,7 +68,7 @@ var DEFAULT_VALUES = {
   resolution: 10,
   point1: [-1, 0, 0],
   point2: [1, 0, 0],
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/PlaneSource.js

@@ -22,10 +22,10 @@ function vtkPlaneSource(publicAPI, model) {
 
     var dataset = outData[0]; // Check input
 
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : 'Float32Array';
+    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
     var pd = vtkPolyData.newInstance();
-    var v10 = new Float32Array(3);
-    var v20 = new Float32Array(3);
+    var v10 = [];
+    var v20 = [];
     subtract(model.point1, model.origin, v10);
     subtract(model.point2, model.origin, v20);
 
@@ -242,7 +242,7 @@ var DEFAULT_VALUES = {
   origin: [0, 0, 0],
   point1: [1, 0, 0],
   point2: [0, 1, 0],
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/PointSource.js

@@ -16,7 +16,7 @@ function vtkPointSource(publicAPI, model) {
 
     var dataset = outData[0]; // Check input
 
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : 'Float32Array';
+    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
     var pd = vtkPolyData.newInstance(); // hand create a point cloud
 
     var numPts = model.numberOfPoints; // Points
@@ -63,7 +63,7 @@ var DEFAULT_VALUES = {
   numberOfPoints: 10,
   center: [0, 0, 0],
   radius: 0.5,
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/SLICSource.js

@@ -7,7 +7,7 @@ import vtkDataArray from '../../Common/Core/DataArray.js';
 // ----------------------------------------------------------------------------
 
 function generateCoordinates(origin, dimensions, spacing) {
-  var coordinates = new Float32Array(dimensions[0] * dimensions[1] * dimensions[2] * 3);
+  var coordinates = new Float64Array(dimensions[0] * dimensions[1] * dimensions[2] * 3);
   var offset = 0;
 
   for (var k = 0; k < dimensions[2]; k++) {
@@ -37,7 +37,7 @@ function vtkSLICSource(publicAPI, model) {
 
   publicAPI.addCluster = function (centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz) {
     var id = model.clusters.length;
-    model.clusters.push(new Float32Array([centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz]));
+    model.clusters.push(new Float64Array([centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz]));
     publicAPI.modified();
     return id;
   };
@@ -54,7 +54,7 @@ function vtkSLICSource(publicAPI, model) {
 
   publicAPI.updateCluster = function (id, centerX, centerY, centerZ, fnConst, fnDfDx, fnDfDy, fnDfDz) {
     if (!model.clusters[id]) {
-      model.clusters[id] = new Float32Array(7);
+      model.clusters[id] = new Float64Array(7);
     }
 
     model.clusters[id][0] = centerX;

package/Filters/Sources/SphereSource.js

@@ -15,7 +15,7 @@ function vtkSphereSource(publicAPI, model) {
     }
 
     var dataset = outData[0];
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : 'Float32Array';
+    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
     dataset = vtkPolyData.newInstance(); // ----------------------------------------------------------------------
 
     var numPoles = 0; // Check data, determine increments, and convert to radians
@@ -180,7 +180,7 @@ var DEFAULT_VALUES = {
   startPhi: 0.0,
   endPhi: 180.0,
   center: [0, 0, 0],
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Filters/Sources/ViewFinderSource.js

@@ -75,7 +75,7 @@ var DEFAULT_VALUES = {
   radius: 1,
   spacing: 2,
   width: 4,
-  pointType: 'Float32Array'
+  pointType: 'Float64Array'
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Rendering/WebGPU/VolumePass.js

@@ -8,6 +8,7 @@ import vtkWebGPUMapperHelper from './MapperHelper.js';
 import vtkWebGPURenderEncoder from './RenderEncoder.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUTexture from './Texture.js';
+import vtkWebGPUUniformBuffer from './UniformBuffer.js';
 import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
 import vtkWebGPUVolumePassFSQ from './VolumePassFSQ.js';
 import { f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
@@ -33,7 +34,7 @@ var BufferUsage = vtkWebGPUBufferManager.BufferUsage,
 
 var cubeFaceTriangles = [[0, 4, 6], [0, 6, 2], [1, 3, 7], [1, 7, 5], [0, 5, 4], [0, 1, 5], [2, 6, 7], [2, 7, 3], [0, 3, 1], [0, 2, 3], [4, 5, 7], [4, 7, 6]];
 var DepthBoundsFS = "\n//VTK::Renderer::Dec\n\n//VTK::Select::Dec\n\n//VTK::VolumePass::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : fragmentOutput;\n\n  //VTK::Select::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::VolumePass::Impl\n\n  // use the maximum (closest) of the current value and the zbuffer\n  // the blend func will then take the min to find the farthest stop value\n  var stopval: f32 = max(input.fragPos.z, textureLoad(opaquePassDepthTexture, vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y)), 0));\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
-var volumeCopyFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = textureSample(volumePassSmallColorTexture,\n    volumePassSmallColorTextureSampler, input.tcoordVS);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
+var volumeCopyFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = textureSample(volumePassSmallColorTexture,\n    volumePassSmallColorTextureSampler, mapperUBO.tscale*input.tcoordVS);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
 /* eslint-disable no-undef */
 
 /* eslint-disable no-bitwise */
@@ -44,14 +45,14 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   model.classHierarchy.push('vtkWebGPUVolumePass'); // create the required textures, encoders, FSQ etc
 
   publicAPI.initialize = function (viewNode) {
-    if (!model._mergeEncoder) {
-      publicAPI.createMergeEncoder(viewNode);
-    }
-
     if (!model._clearEncoder) {
       publicAPI.createClearEncoder(viewNode);
     }
 
+    if (!model._mergeEncoder) {
+      publicAPI.createMergeEncoder(viewNode);
+    }
+
     if (!model._copyEncoder) {
       publicAPI.createCopyEncoder(viewNode);
     }
@@ -74,6 +75,16 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       model._volumeCopyQuad.setDevice(viewNode.getDevice());
 
       model._volumeCopyQuad.setFragmentShaderTemplate(volumeCopyFragTemplate);
+
+      model._copyUBO = vtkWebGPUUniformBuffer.newInstance();
+
+      model._copyUBO.setName('mapperUBO');
+
+      model._copyUBO.addEntry('tscale', 'vec2<f32>');
+
+      model._volumeCopyQuad.setUBO(model._copyUBO);
+
+      model._volumeCopyQuad.setTextureViews([model._colorTextureView]);
     }
   };
 
@@ -136,13 +147,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       // if not rendering in chunks then just draw all of them at once
       publicAPI.rayCastPass(viewNode, renNode, model.volumes);
     } // copy back to the original color buffer
-
-
-    if (model.small) {
-      model._volumeCopyQuad.setTextureViews([model._smallColorTextureView]);
-    } else {
-      model._volumeCopyQuad.setTextureViews([model._largeColorTextureView]);
-    } // final composite
+    // final composite
 
 
     model._copyEncoder.setColorTextureView(0, model.colorTextureView);
@@ -157,6 +162,18 @@ function vtkWebGPUVolumePass(publicAPI, model) {
 
     model._volumeCopyQuad.setWebGPURenderer(renNode);
 
+    if (model._useSmallViewport) {
+      var width = model._colorTextureView.getTexture().getWidth();
+
+      var height = model._colorTextureView.getTexture().getHeight();
+
+      model._copyUBO.setArray('tscale', [model._smallViewportWidth / width, model._smallViewportHeight / height]);
+    } else {
+      model._copyUBO.setArray('tscale', [1.0, 1.0]);
+    }
+
+    model._copyUBO.sendIfNeeded(device);
+
     model._volumeCopyQuad.render(model._copyEncoder, viewNode.getDevice());
 
     model._copyEncoder.end();
@@ -172,47 +189,38 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   }, publicAPI.delete);
 
   publicAPI.computeTiming = function (viewNode) {
-    model.small = false;
+    model._useSmallViewport = false;
     var rwi = viewNode.getRenderable().getInteractor();
 
     if (rwi.isAnimating() && model._lastScale > 1.5) {
-      model.small = true;
-    }
-
-    if (model.small) {
-      model._activeColorTextureView = model._smallColorTextureView;
-    } else {
-      model._largeColorTexture.resize(viewNode.getCanvas().width, viewNode.getCanvas().height);
+      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));
+      }
 
-      model._activeColorTextureView = model._largeColorTextureView;
+      model._useSmallViewport = true;
     }
 
+    model._colorTexture.resize(viewNode.getCanvas().width, viewNode.getCanvas().height);
+
     if (!model._animationRateSubscription) {
       // when the animation frame rate changes recompute the scale factor
       model._animationRateSubscription = rwi.onAnimationFrameRateUpdate(function () {
         var frate = rwi.getRecentAnimationFrameRate();
-        var targetScale = model._lastScale * rwi.getDesiredUpdateRate() / frate; // Do we need a resize? The values below are to provide some stickyness
-        // so that we are not changing texture size every second. Instead the targhet scale
-        // has to be a certain amount larger or smaller than the current value to force a
-        // change in texture size
-
-        if (targetScale > 1.4 * model._lastScale || targetScale < 0.7 * model._lastScale) {
-          model._lastScale = targetScale; // clamp scale to some reasonable values.
-          // Below 1.5 we will just be using full resolution as that is close enough
-          // Above 400 seems like a lot so we limit to that 1/20th per axis
-
-          if (model._lastScale > 400) {
-            model._lastScale = 400;
-          }
+        var targetScale = model._lastScale * rwi.getDesiredUpdateRate() / frate;
+        model._lastScale = targetScale; // clamp scale to some reasonable values.
+        // Below 1.5 we will just be using full resolution as that is close enough
+        // Above 400 seems like a lot so we limit to that 1/20th per axis
 
-          if (model._lastScale < 1.5) {
-            model._lastScale = 1.5;
-          } else {
-            var targetSmallWidth = 64 * Math.ceil(viewNode.getCanvas().width / (Math.sqrt(model._lastScale) * 64));
-            var targetSmallHeight = Math.ceil(targetSmallWidth * viewNode.getCanvas().height / viewNode.getCanvas().width);
+        if (model._lastScale > 400) {
+          model._lastScale = 400;
+        }
 
-            model._smallColorTexture.resize(targetSmallWidth, targetSmallHeight);
-          }
+        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));
         }
       });
     }
@@ -220,14 +228,18 @@ function vtkWebGPUVolumePass(publicAPI, model) {
 
   publicAPI.rayCastPass = function (viewNode, renNode, volumes) {
     var encoder = model._firstGroup ? model._clearEncoder : model._mergeEncoder;
-    encoder.setColorTextureView(0, model._activeColorTextureView);
     encoder.attachTextureViews();
     renNode.setRenderEncoder(encoder);
     encoder.begin(viewNode.getCommandEncoder());
 
-    var width = model._activeColorTextureView.getTexture().getWidth();
+    var width = model._colorTextureView.getTexture().getWidth();
+
+    var height = model._colorTextureView.getTexture().getHeight();
 
-    var height = model._activeColorTextureView.getTexture().getHeight();
+    if (model._useSmallViewport) {
+      width = model._smallViewportWidth;
+      height = model._smallViewportHeight;
+    }
 
     encoder.getHandle().setViewport(0, 0, width, height, 0.0, 1.0); // set scissor
 
@@ -453,35 +465,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   };
 
   publicAPI.createClearEncoder = function (viewNode) {
-    model._smallColorTexture = vtkWebGPUTexture.newInstance(); // multiple of 64 pixels to help with texture alignment/size issues
-    // as webgpu textures have to be multiples of 256 bytes wide
-    // for data transfers (just in case)
+    model._colorTexture = vtkWebGPUTexture.newInstance();
 
-    var targetSmallWidth = 64 * Math.ceil(0.7 * viewNode.getCanvas().width / 64);
-
-    model._smallColorTexture.create(viewNode.getDevice(), {
-      width: targetSmallWidth,
-      height: Math.ceil(targetSmallWidth * viewNode.getCanvas().height / viewNode.getCanvas().width),
-      format: 'bgra8unorm',
-
-      /* eslint-disable no-undef */
-
-      /* eslint-disable no-bitwise */
-      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
-    });
-
-    model._smallColorTextureView = model._smallColorTexture.createView();
-
-    model._smallColorTextureView.setName('volumePassSmallColorTexture');
-
-    model._smallColorTextureView.addSampler(viewNode.getDevice(), {
-      minFilter: 'linear',
-      magFilter: 'linear'
-    });
-
-    model._largeColorTexture = vtkWebGPUTexture.newInstance();
-
-    model._largeColorTexture.create(viewNode.getDevice(), {
+    model._colorTexture.create(viewNode.getDevice(), {
       width: viewNode.getCanvas().width,
       height: viewNode.getCanvas().height,
       format: 'bgra8unorm',
@@ -492,17 +478,19 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
     });
 
-    model._largeColorTextureView = model._largeColorTexture.createView();
+    model._colorTextureView = model._colorTexture.createView();
 
-    model._largeColorTextureView.setName('volumePassSmallColorTexture');
+    model._colorTextureView.setName('volumePassSmallColorTexture');
 
-    model._largeColorTextureView.addSampler(viewNode.getDevice(), {
+    model._colorTextureView.addSampler(viewNode.getDevice(), {
       minFilter: 'linear',
       magFilter: 'linear'
     });
 
     model._clearEncoder = vtkWebGPURenderEncoder.newInstance();
 
+    model._clearEncoder.setColorTextureView(0, model._colorTextureView);
+
     model._clearEncoder.setDescription({
       colorAttachments: [{
         view: null,
@@ -573,6 +561,8 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   publicAPI.createMergeEncoder = function (viewNode) {
     model._mergeEncoder = vtkWebGPURenderEncoder.newInstance();
 
+    model._mergeEncoder.setColorTextureView(0, model._colorTextureView);
+
     model._mergeEncoder.setDescription({
       colorAttachments: [{
         view: null,

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -3,11 +3,11 @@ import vtkBoundingBox, { STATIC } from '../../../Common/DataModel/BoundingBox.js
 import vtkCubeSource from '../../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
-import { g as subtract, l as normalize, j as cross, Q as multiplyAccumulate, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { g as subtract, l as normalize, j as cross, t as multiplyScalar, Q as multiplyAccumulate, S as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { ViewTypes } from '../../Core/WidgetManager/Constants.js';
 
-var EPSILON = 0.00001;
+var EPSILON = 10e-7;
 /**
  * Fit the plane defined by origin, p1, p2 onto the bounds.
  * Plane is untouched if does not intersect bounds.
@@ -15,6 +15,7 @@ var EPSILON = 0.00001;
  * @param {Array} origin
  * @param {Array} p1
  * @param {Array} p2
+ * @return {Boolean} false if no bounds have been found, else true
  */
 
 function boundPlane(bounds, origin, p1, p2) {
@@ -26,19 +27,26 @@ function boundPlane(bounds, origin, p1, p2) {
   normalize(v2);
   var n = [0, 0, 1];
   cross(v1, v2, n);
-  normalize(n);
+  normalize(n); // Inflate bounds in order to avoid precision error when cutting cubesource
+
+  var inflatedBounds = _toConsumableArray(bounds);
+
+  var eps = [].concat(n);
+  multiplyScalar(eps, EPSILON);
+  vtkBoundingBox.addBounds(inflatedBounds, bounds[0] + eps[0], bounds[1] + eps[0], bounds[2] + eps[1], bounds[3] + eps[1], bounds[4] + eps[2], bounds[5] + eps[2]);
+  vtkBoundingBox.addBounds(inflatedBounds, bounds[0] - eps[0], bounds[1] - eps[0], bounds[2] - eps[1], bounds[3] - eps[1], bounds[4] - eps[2], bounds[5] - eps[2]);
   var plane = vtkPlane.newInstance();
   plane.setOrigin.apply(plane, _toConsumableArray(origin));
   plane.setNormal.apply(plane, n);
   var cubeSource = vtkCubeSource.newInstance();
-  cubeSource.setBounds(bounds);
+  cubeSource.setBounds(inflatedBounds);
   var cutter = vtkCutter.newInstance();
   cutter.setCutFunction(plane);
   cutter.setInputConnection(cubeSource.getOutputPort());
   var cutBounds = cutter.getOutputData();
 
   if (cutBounds.getNumberOfPoints() === 0) {
-    return;
+    return false;
   }
 
   var localBounds = STATIC.computeLocalBounds(cutBounds.getPoints(), v1, v2, n);
@@ -48,6 +56,8 @@ function boundPlane(bounds, origin, p1, p2) {
     p1[i] = localBounds[1] * v1[i] + localBounds[2] * v2[i] + localBounds[4] * n[i];
     p2[i] = localBounds[0] * v1[i] + localBounds[3] * v2[i] + localBounds[4] * n[i];
   }
+
+  return true;
 } // Project point (inPoint) to the bounds of the image according to a plane
 // defined by two vectors (v1, v2)
 

package/package.json

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