@kitware/vtk.js 22.1.4 → 22.1.8

package/Interaction/Manipulators/MouseBoxSelectorManipulator.js

@@ -56,9 +56,7 @@ function vtkMouseBoxSelectionManipulator(publicAPI, model) {
 
     var _container$getBoundin = container.getBoundingClientRect(),
         width = _container$getBoundin.width,
-        height = _container$getBoundin.height,
-        top = _container$getBoundin.top,
-        left = _container$getBoundin.left;
+        height = _container$getBoundin.height;
 
     var _getBounds = getBounds(),
         _getBounds2 = _slicedToArray(_getBounds, 4),
@@ -67,10 +65,8 @@ function vtkMouseBoxSelectionManipulator(publicAPI, model) {
         yMin = _getBounds2[2],
         yMax = _getBounds2[3];
 
-    var xShift = left + window.scrollX;
-    var yShift = top + window.scrollY;
-    div.style.left = "".concat(xShift + width * xMin / viewWidth, "px");
-    div.style.top = "".concat(yShift + height - height * yMax / viewHeight, "px");
+    div.style.left = "".concat(width * xMin / viewWidth, "px");
+    div.style.top = "".concat(height - height * yMax / viewHeight, "px");
     div.style.width = "".concat(width * (xMax - xMin) / viewWidth, "px");
     div.style.height = "".concat(height * (yMax - yMin) / viewHeight, "px");
   } //-------------------------------------------------------------------------
@@ -80,15 +76,21 @@ function vtkMouseBoxSelectionManipulator(publicAPI, model) {
     previousPosition = position;
 
     if (model.renderSelection) {
+      var _view;
+
       // Need window size and location to convert to style
       if (!view) {
         view = interactor.getView();
       }
 
-      if (!container && view) {
+      if (!container && (_view = view) !== null && _view !== void 0 && _view.getContainer) {
         container = view.getContainer();
       }
 
+      if (!container) {
+        container = model.container;
+      }
+
       if (!div) {
         div = document.createElement('div');
         applyStyle(div, model.selectionStyle);
@@ -155,6 +157,7 @@ function vtkMouseBoxSelectionManipulator(publicAPI, model) {
 
 function DEFAULT_VALUES(initialValues) {
   return _objectSpread(_objectSpread({
+    // container: null,
     renderSelection: true
   }, initialValues), {}, {
     selectionStyle: _objectSpread(_objectSpread({}, DEFAULT_STYLE), initialValues.selectionStyle)
@@ -172,7 +175,7 @@ function extend(publicAPI, model) {
 
   event(publicAPI, model, 'BoxSelectInput'); // Trigger while dragging
 
-  setGet(publicAPI, model, ['renderSelection', 'selectionStyle']); // Object specific methods
+  setGet(publicAPI, model, ['renderSelection', 'selectionStyle', 'container']); // Object specific methods
 
   vtkMouseBoxSelectionManipulator(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/Core/RenderWindowInteractor.js

@@ -328,8 +328,6 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     if (animationRequesters.size === 1 && !model.xrAnimation) {
       model._animationStartTime = Date.now();
       model._animationFrameCount = 0;
-      model.lastFrameTime = 0.1;
-      model.lastFrameStart = Date.now();
       model.animationRequest = requestAnimationFrame(publicAPI.handleAnimation);
       publicAPI.startAnimationEvent();
     }
@@ -375,7 +373,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     model.xrAnimation = false;
 
     if (animationRequesters.size !== 0) {
-      model.FrameTime = -1;
+      model.recentAnimationFrameRate = 10.0;
       model.animationRequest = requestAnimationFrame(publicAPI.handleAnimation);
     }
   };
@@ -456,19 +454,12 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
     if (currTime - model._animationStartTime > 1000.0 && model._animationFrameCount > 1) {
       model.recentAnimationFrameRate = 1000.0 * (model._animationFrameCount - 1) / (currTime - model._animationStartTime);
+      model.lastFrameTime = 1.0 / model.recentAnimationFrameRate;
       publicAPI.animationFrameRateUpdateEvent();
       model._animationStartTime = currTime;
       model._animationFrameCount = 1;
     }
 
-    if (model.FrameTime === -1.0) {
-      model.lastFrameTime = 0.1;
-    } else {
-      model.lastFrameTime = (currTime - model.lastFrameStart) / 1000.0;
-    }
-
-    model.lastFrameTime = Math.max(0.01, model.lastFrameTime);
-    model.lastFrameStart = currTime;
     publicAPI.animationEvent();
     forceRender();
     model.animationRequest = requestAnimationFrame(publicAPI.handleAnimation);
@@ -933,7 +924,6 @@ function vtkRenderWindowInteractor(publicAPI, model) {
   };
 
   publicAPI.handleVisibilityChange = function () {
-    model.lastFrameStart = Date.now();
     model._animationStartTime = Date.now();
     model._animationFrameCount = 0;
   };
@@ -957,7 +947,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
     superDelete();
   }; // Use the Page Visibility API to detect when we switch away from or back to
-  // this tab, and reset the lastFrameStart. When tabs are not active, browsers
+  // this tab, and reset the animationFrameStart. When tabs are not active, browsers
   // will stop calling requestAnimationFrame callbacks.
 
 

package/Rendering/OpenGL/VolumeMapper.js

@@ -1,5 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { newInstance as newInstance$1, obj, setGet, vtkWarningMacro as vtkWarningMacro$1, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
+import { newInstance as newInstance$1, obj, setGet, chain, vtkWarningMacro as vtkWarningMacro$1, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import { mat4, mat3, vec3 } from 'gl-matrix';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
@@ -672,90 +672,86 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       program.setUniform3fv("vClipPlaneNormals", clipPlaneNormals);
       program.setUniformfv("vClipPlaneDistances", clipPlaneDistances);
     }
-  };
+  }; // unsubscribe from our listeners
+
+
+  publicAPI.delete = chain(function () {
+    if (model._animationRateSubscription) {
+      model._animationRateSubscription.unsubscribe();
+
+      model._animationRateSubscription = null;
+    }
+  }, publicAPI.delete);
 
   publicAPI.getRenderTargetSize = function () {
-    if (model.lastXYF > 1.43) {
-      var sz = model.framebuffer.getSize();
-      return [model.fvp[0] * sz[0], model.fvp[1] * sz[1]];
+    if (model._useSmallViewport) {
+      return [model._smallViewportWidth, model._smallViewportHeight];
     }
 
     return model.openGLRenderWindow.getFramebufferSize();
   };
 
   publicAPI.renderPieceStart = function (ren, actor) {
-    if (model.renderable.getAutoAdjustSampleDistances()) {
-      var rwi = ren.getVTKWindow().getInteractor();
-      var rft = rwi.getLastFrameTime(); // console.log(`last frame time ${Math.floor(1.0 / rft)}`);
-      // frame time is typically for a couple frames prior
-      // which makes it messy, so keep long running averages
-      // of frame times and pixels rendered
-
-      model.avgFrameTime = 0.97 * model.avgFrameTime + 0.03 * rft;
-      model.avgWindowArea = 0.97 * model.avgWindowArea + 0.03 / (model.lastXYF * model.lastXYF);
-
-      if (ren.getVTKWindow().getInteractor().isAnimating()) {
-        // compute target xy factor
-        var txyf = Math.sqrt(model.avgFrameTime * rwi.getDesiredUpdateRate() / model.avgWindowArea); // limit subsampling to a factor of 10
-
-        if (txyf > 10.0) {
-          txyf = 10.0;
-        }
+    var rwi = ren.getVTKWindow().getInteractor();
+    model._useSmallViewport = false;
+
+    if (rwi.isAnimating() && model._lastScale > 1.5) {
+      model._useSmallViewport = true;
+    }
+
+    if (!model._animationRateSubscription) {
+      // when the animation frame rate changes recompute the scale factor
+      model._animationRateSubscription = rwi.onAnimationFrameRateUpdate(function () {
+        if (model.renderable.getAutoAdjustSampleDistances()) {
+          var frate = rwi.getRecentAnimationFrameRate();
+          var adjustment = rwi.getDesiredUpdateRate() / frate; // only change if we are off by 15%
+
+          if (adjustment > 1.15 || adjustment < 0.85) {
+            model._lastScale *= adjustment;
+          } // 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
 
-        model.targetXYF = txyf;
-      } else {
-        model.targetXYF = Math.sqrt(model.avgFrameTime * rwi.getStillUpdateRate() / model.avgWindowArea);
-      } // have some inertia to change states around 1.43
 
+          if (model._lastScale > 400) {
+            model._lastScale = 400;
+          }
+
+          if (model._lastScale < 1.5) {
+            model._lastScale = 1.5;
+          }
+        } 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.targetXYF < 1.53 && model.targetXYF > 1.33) {
-        model.targetXYF = model.lastXYF;
-      } // and add some inertia to change at all
 
+    if (model._useSmallViewport) {
+      var size = model.openGLRenderWindow.getFramebufferSize(); // adjust viewportSize to always be at most the dest fo size
 
-      if (Math.abs(1.0 - model.targetXYF / model.lastXYF) < 0.1) {
-        model.targetXYF = model.lastXYF;
+      if (model._smallViewportHeight > size[1]) {
+        model._smallViewportHeight = size[1];
       }
 
-      model.lastXYF = model.targetXYF;
-    } else {
-      model.lastXYF = model.renderable.getImageSampleDistance();
-    } // only use FBO beyond this value
-
-
-    if (model.lastXYF <= 1.43) {
-      model.lastXYF = 1.0;
-    } // console.log(`last target  ${model.lastXYF} ${model.targetXYF}`);
-    // console.log(`awin aft  ${model.avgWindowArea} ${model.avgFrameTime}`);
-
-
-    var xyf = model.lastXYF;
-    var size = model.openGLRenderWindow.getFramebufferSize(); // const newSize = [
-    //   Math.floor((size[0] / xyf) + 0.5),
-    //   Math.floor((size[1] / xyf) + 0.5)];
-    // const diag = vtkBoundingBox.getDiagonalLength(model.currentInput.getBounds());
-    // // so what is the resulting sample size roughly
-    // console.log(`sam size ${diag / newSize[0]} ${diag / newSize[1]} ${model.renderable.getImageSampleDistance()}`);
-    // // if the sample distance is getting far from the image sample dist
-    // if (2.0 * diag / (newSize[0] + newSize[1]) > 4 * model.renderable.getSampleDistance()) {
-    //   model.renderable.setSampleDistance(4.0 * model.renderable.getSampleDistance());
-    // }
-    // if (2.0 * diag / (newSize[0] + newSize[1]) < 0.25 * model.renderable.getSampleDistance()) {
-    //   model.renderable.setSampleDistance(0.25 * model.renderable.getSampleDistance());
-    // }
-    // create/resize framebuffer if needed
+      if (model._smallViewportWidth > size[0]) {
+        model._smallViewportWidth = size[0];
+      }
 
-    if (xyf > 1.43) {
       model.framebuffer.saveCurrentBindingsAndBuffers();
 
       if (model.framebuffer.getGLFramebuffer() === null) {
-        model.framebuffer.create(Math.floor(size[0] * 0.7), Math.floor(size[1] * 0.7));
+        model.framebuffer.create(size[0], size[1]);
         model.framebuffer.populateFramebuffer();
       } else {
         var fbSize = model.framebuffer.getSize();
 
-        if (fbSize[0] !== Math.floor(size[0] * 0.7) || fbSize[1] !== Math.floor(size[1] * 0.7)) {
-          model.framebuffer.create(Math.floor(size[0] * 0.7), Math.floor(size[1] * 0.7));
+        if (fbSize[0] !== size[0] || fbSize[1] !== size[1]) {
+          model.framebuffer.create(size[0], size[1]);
           model.framebuffer.populateFramebuffer();
         }
       }
@@ -765,8 +761,8 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       gl.clearColor(0.0, 0.0, 0.0, 0.0);
       gl.colorMask(true, true, true, true);
       gl.clear(gl.COLOR_BUFFER_BIT);
-      gl.viewport(0, 0, size[0] / xyf, size[1] / xyf);
-      model.fvp = [Math.floor(size[0] / xyf) / Math.floor(size[0] * 0.7), Math.floor(size[1] / xyf) / Math.floor(size[1] * 0.7)];
+      gl.viewport(0, 0, model._smallViewportWidth, model._smallViewportHeight);
+      model.fvp = [model._smallViewportWidth / size[0], model._smallViewportHeight / size[1]];
     }
 
     model.context.disable(model.context.DEPTH_TEST); // make sure the BOs are up to date
@@ -817,7 +813,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       model.zBufferTexture.deactivate();
     }
 
-    if (model.lastXYF > 1.43) {
+    if (model._useSmallViewport) {
       // now copy the framebuffer with the volume into the
       // regular buffer
       model.framebuffer.restorePreviousBindingsAndBuffers();
@@ -1006,8 +1002,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       var dims = image.getDimensions();
       model.scalarTexture.releaseGraphicsResources(model.openGLRenderWindow);
       model.scalarTexture.resetFormatAndType();
-      model.scalarTexture.create3DFilterableFromRaw(dims[0], dims[1], dims[2], numComp, scalars.getDataType(), scalars.getData(), model.renderable.getPreferSizeOverAccuracy()); // console.log(model.scalarTexture.get());
-
+      model.scalarTexture.create3DFilterableFromRaw(dims[0], dims[1], dims[2], numComp, scalars.getDataType(), scalars.getData(), model.renderable.getPreferSizeOverAccuracy());
       model.scalarTextureString = toString;
     }
 
@@ -1125,7 +1120,8 @@ 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)); // Build VTK API
+  model.projectionToWorld = mat4.identity(new Float64Array(16));
+  model._lastScale = 1.0; // Build VTK API
 
   setGet(publicAPI, model, ['context']); // Object methods
 

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.4",
+  "version": "22.1.8",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",