@kitware/vtk.js 20.1.2 → 20.2.1

package/Imaging/Core/ImageReslice.js

@@ -1,4 +1,5 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4, vec4 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
@@ -9,8 +10,6 @@ import vtkImagePointDataIterator from './ImagePointDataIterator.js';
 import { InterpolationMode, ImageBorderMode } from './AbstractImageInterpolator/Constants.js';
 import { vtkInterpolationMathRound, vtkInterpolationMathClamp, vtkInterpolationMathFloor } from './AbstractImageInterpolator/InterpolationInfo.js';
 import Constants from './ImageReslice/Constants.js';
-import { i as identity, h as exactEquals, d as copy, g as invert, m as multiply } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec4.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -100,11 +99,11 @@ function vtkImageReslice(publicAPI, model) {
 
   publicAPI.setResliceAxes = function (resliceAxes) {
     if (!model.resliceAxes) {
-      model.resliceAxes = identity(new Float64Array(16));
+      model.resliceAxes = mat4.identity(new Float64Array(16));
     }
 
-    if (!exactEquals(model.resliceAxes, resliceAxes)) {
-      copy(model.resliceAxes, resliceAxes);
+    if (!mat4.exactEquals(model.resliceAxes, resliceAxes)) {
+      mat4.copy(model.resliceAxes, resliceAxes);
       publicAPI.modified();
       return true;
     }
@@ -137,11 +136,11 @@ function vtkImageReslice(publicAPI, model) {
     if (model.resliceAxes) {
       matrix = model.resliceAxes;
     } else {
-      matrix = identity(new Float64Array(16));
+      matrix = mat4.identity(new Float64Array(16));
     }
 
     var imatrix = new Float64Array(16);
-    invert(imatrix, matrix);
+    mat4.invert(imatrix, matrix);
     var inCenter = [origin[0] + 0.5 * (inWholeExt[0] + inWholeExt[1]) * inSpacing[0], origin[1] + 0.5 * (inWholeExt[2] + inWholeExt[3]) * inSpacing[1], origin[2] + 0.5 * (inWholeExt[4] + inWholeExt[5]) * inSpacing[2]];
     var maxBounds = null;
 
@@ -582,19 +581,19 @@ function vtkImageReslice(publicAPI, model) {
   publicAPI.getIndexMatrix = function (input, output) {
     // first verify that we have to update the matrix
     if (indexMatrix === null) {
-      indexMatrix = identity(new Float64Array(16));
+      indexMatrix = mat4.identity(new Float64Array(16));
     }
 
     var inOrigin = input.getOrigin();
     var inSpacing = input.getSpacing();
     var outOrigin = output.getOrigin();
     var outSpacing = output.getSpacing();
-    var transform = identity(new Float64Array(16));
-    var inMatrix = identity(new Float64Array(16));
-    var outMatrix = identity(new Float64Array(16));
+    var transform = mat4.identity(new Float64Array(16));
+    var inMatrix = mat4.identity(new Float64Array(16));
+    var outMatrix = mat4.identity(new Float64Array(16));
 
     if (model.resliceAxes) {
-      copy(transform, model.resliceAxes);
+      mat4.copy(transform, model.resliceAxes);
     }
 
     if (model.resliceTransform) ; // check to see if we have an identity matrix
@@ -617,17 +616,17 @@ function vtkImageReslice(publicAPI, model) {
     if (!isIdentity) {
       // transform.PreMultiply();
       // transform.Concatenate(outMatrix);
-      multiply(transform, transform, outMatrix); // the optimizedTransform requires data coords, not
+      mat4.multiply(transform, transform, outMatrix); // the optimizedTransform requires data coords, not
       // index coords, as its input
 
       {
         // transform->PostMultiply();
         // transform->Concatenate(inMatrix);
-        multiply(transform, inMatrix, transform);
+        mat4.multiply(transform, inMatrix, transform);
       }
     }
 
-    copy(indexMatrix, transform);
+    mat4.copy(indexMatrix, transform);
     return indexMatrix;
   };
 
@@ -639,9 +638,9 @@ function vtkImageReslice(publicAPI, model) {
     var matrix = new Float64Array(16);
 
     if (model.resliceAxes) {
-      invert(matrix, model.resliceAxes);
+      mat4.invert(matrix, model.resliceAxes);
     } else {
-      identity(matrix);
+      mat4.identity(matrix);
     }
 
     var bounds = [Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE];
@@ -655,7 +654,7 @@ function vtkImageReslice(publicAPI, model) {
 
       if (model.resliceTransform) ;
 
-      transformMat4(point, point, matrix);
+      vec4.transformMat4(point, point, matrix);
       var f = 1.0 / point[3];
       point[0] *= f;
       point[1] *= f;
@@ -837,7 +836,7 @@ function vtkImageReslice(publicAPI, model) {
 
   publicAPI.applyTransform = function (newTrans, inPoint, inOrigin, inInvSpacing) {
     inPoint[3] = 1;
-    transformMat4(inPoint, inPoint, newTrans);
+    vec4.transformMat4(inPoint, inPoint, newTrans);
     inPoint[0] -= inOrigin[0];
     inPoint[1] -= inOrigin[1];
     inPoint[2] -= inOrigin[2];

package/Interaction/Manipulators/MouseCameraAxisRotateManipulator.js

@@ -1,11 +1,10 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4, a as subtract, n as normalize, d as dot, h as distance, e as scaleAndAdd, c as cross$1, l as length } from '../../vendor/gl-matrix/esm/vec3.js';
 
 // vtkMouseCameraAxisRotateManipulator methods
 // ----------------------------------------------------------------------------
@@ -36,34 +35,34 @@ function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
     var cameraFp = camera.getFocalPoint();
     var cameraViewUp = camera.getViewUp();
     var cameraDirection = camera.getDirectionOfProjection();
-    identity(trans);
+    mat4.identity(trans);
     var center = model.center,
         rotationFactor = model.rotationFactor,
         rotationAxis = model.rotationAxis; // Translate to center
 
-    translate(trans, trans, center);
+    mat4.translate(trans, trans, center);
     var dx = model.previousPosition.x - position.x;
     var dy = model.previousPosition.y - position.y;
     var size = interactor.getView().getSize(); // Azimuth
 
-    rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), rotationAxis); // Elevation
+    mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), rotationAxis); // Elevation
 
     cross(cameraDirection, cameraViewUp, v2);
-    rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
+    mat4.rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
 
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
     centerNeg[2] = -center[2];
-    translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
 
-    transformMat4(newCamPos, cameraPos, trans);
-    transformMat4(newFp, cameraFp, trans); // what is the current direction from the fp
+    vec3.transformMat4(newCamPos, cameraPos, trans);
+    vec3.transformMat4(newFp, cameraFp, trans); // what is the current direction from the fp
     // to the camera
 
-    subtract(fpDirection, newCamPos, newFp);
-    normalize(fpDirection, fpDirection); // make the top sticky to avoid accidental flips
+    vec3.subtract(fpDirection, newCamPos, newFp);
+    vec3.normalize(fpDirection, fpDirection); // make the top sticky to avoid accidental flips
 
-    if (Math.abs(dot(fpDirection, rotationAxis)) > 0.95) {
+    if (Math.abs(vec3.dot(fpDirection, rotationAxis)) > 0.95) {
       // this can be smarter where it still allows Azimuth here
       // but prevents the elevation part
       model.previousPosition = position;
@@ -72,41 +71,41 @@ function vtkMouseCameraAxisRotateManipulator(publicAPI, model) {
 
     if (model.useHalfAxis) {
       // what is the current distance from pos to center of rotation
-      var distance$1 = distance(newCamPos, center); // what is the current direction from the center of rotation
+      var distance = vec3.distance(newCamPos, center); // what is the current direction from the center of rotation
       // to the camera
 
-      subtract(direction, newCamPos, center);
-      normalize(direction, direction); // project the rotation axis onto the direction
+      vec3.subtract(direction, newCamPos, center);
+      vec3.normalize(direction, direction); // project the rotation axis onto the direction
       // so we know how much below the half plane we are
 
-      var dotP = dot(rotationAxis, direction);
+      var dotP = vec3.dot(rotationAxis, direction);
 
       if (dotP < 0) {
         // adjust the new camera position to bring it up to the half plane
-        scaleAndAdd(newCamPos, newCamPos, rotationAxis, -dotP * distance$1); // the above step will change the distance which might feel odd
+        vec3.scaleAndAdd(newCamPos, newCamPos, rotationAxis, -dotP * distance); // the above step will change the distance which might feel odd
         // so the next couple lines restore the distance to the center
         // what is the new direction from the center of rotation
         // to the camera
 
-        subtract(direction, newCamPos, center);
-        normalize(direction, direction);
-        scaleAndAdd(newCamPos, center, direction, distance$1); // compute original cam direction to center
+        vec3.subtract(direction, newCamPos, center);
+        vec3.normalize(direction, direction);
+        vec3.scaleAndAdd(newCamPos, center, direction, distance); // compute original cam direction to center
 
-        subtract(v2, cameraPos, center);
-        normalize(v2, v2); // const rAngle = 0.0;
+        vec3.subtract(v2, cameraPos, center);
+        vec3.normalize(v2, v2); // const rAngle = 0.0;
 
-        var acosR = Math.min(1.0, Math.max(-1.0, dot(direction, v2)));
+        var acosR = Math.min(1.0, Math.max(-1.0, vec3.dot(direction, v2)));
         var rAngle = Math.acos(acosR); // 0 to pi
 
-        cross$1(v2, v2, direction);
-        normalize(v2, v2);
-        subtract(newFp, cameraFp, center);
-        var fpDist = length(newFp); // Note it normalizes the vector to be rotated
+        vec3.cross(v2, v2, direction);
+        vec3.normalize(v2, v2);
+        vec3.subtract(newFp, cameraFp, center);
+        var fpDist = vec3.length(newFp); // Note it normalizes the vector to be rotated
 
         var result = _toConsumableArray(newFp);
 
         vtkMatrixBuilder.buildFromRadian().rotate(rAngle, v2).apply(result);
-        scaleAndAdd(newFp, center, result, fpDist);
+        vec3.scaleAndAdd(newFp, center, result, fpDist);
       }
     }
 

package/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -1,9 +1,8 @@
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { r as radiansFromDegrees, y as degreesFromRadians } from '../../Common/Core/Math/index.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 // vtkMouseCameraTrackballRollManipulator methods
 // ----------------------------------------------------------------------------
@@ -52,23 +51,23 @@ function vtkMouseCameraTrackballRollManipulator(publicAPI, model) {
 
     var angle = degreesFromRadians((x1 * y2 - y1 * x2) / (Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2)));
     var center = model.center;
-    identity(transform);
+    mat4.identity(transform);
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
     centerNeg[2] = -center[2]; // Translate to center
 
-    translate(transform, transform, center); // roll
+    mat4.translate(transform, transform, center); // roll
 
-    rotate(transform, transform, radiansFromDegrees(angle), axis); // Translate back
+    mat4.rotate(transform, transform, radiansFromDegrees(angle), axis); // Translate back
 
-    translate(transform, transform, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(transform, transform, centerNeg); // Apply transformation to camera position, focal point, and view up
 
-    transformMat4(newCamPos, cameraPos, transform);
-    transformMat4(newFp, cameraFp, transform);
+    vec3.transformMat4(newCamPos, cameraPos, transform);
+    vec3.transformMat4(newFp, cameraFp, transform);
     direction[0] = viewUp[0] + cameraPos[0];
     direction[1] = viewUp[1] + cameraPos[1];
     direction[2] = viewUp[2] + cameraPos[2];
-    transformMat4(newViewUp, direction, transform);
+    vec3.transformMat4(newViewUp, direction, transform);
     camera.setPosition(newCamPos[0], newCamPos[1], newCamPos[2]);
     camera.setFocalPoint(newFp[0], newFp[1], newFp[2]);
     camera.setViewUp(newViewUp[0] - newCamPos[0], newViewUp[1] - newCamPos[1], newViewUp[2] - newCamPos[2]);

package/Interaction/Manipulators/MouseCameraTrackballRotateManipulator.js

@@ -1,9 +1,8 @@
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
 import { t as multiplyScalar, d as dot, k as add, r as radiansFromDegrees, j as cross } from '../../Common/Core/Math/index.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { i as copy, t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 // vtkMouseCameraTrackballRotateManipulator methods
 // ----------------------------------------------------------------------------
@@ -31,7 +30,7 @@ function vtkMouseCameraTrackballRotateManipulator(publicAPI, model) {
     var camera = renderer.getActiveCamera();
     var cameraPos = camera.getPosition();
     var cameraFp = camera.getFocalPoint();
-    identity(trans);
+    mat4.identity(trans);
     var center = model.center,
         rotationFactor = model.rotationFactor;
 
@@ -49,38 +48,38 @@ function vtkMouseCameraTrackballRotateManipulator(publicAPI, model) {
 
     if (model.useWorldUpVec) {
       var centerOfRotation = new Float64Array(3);
-      copy(centerOfRotation, model.worldUpVec); // Compute projection of cameraPos onto worldUpVec
+      vec3.copy(centerOfRotation, model.worldUpVec); // Compute projection of cameraPos onto worldUpVec
 
       multiplyScalar(centerOfRotation, dot(cameraPos, model.worldUpVec) / dot(model.worldUpVec, model.worldUpVec));
       add(center, centerOfRotation, centerOfRotation);
-      translate(trans, trans, centerOfRotation);
-      rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), model.worldUpVec); // Translate back
+      mat4.translate(trans, trans, centerOfRotation);
+      mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), model.worldUpVec); // Translate back
 
       centerOfRotation[0] = -centerOfRotation[0];
       centerOfRotation[1] = -centerOfRotation[1];
       centerOfRotation[2] = -centerOfRotation[2];
-      translate(trans, trans, centerOfRotation);
-      translate(trans, trans, center);
+      mat4.translate(trans, trans, centerOfRotation);
+      mat4.translate(trans, trans, center);
     } else {
-      translate(trans, trans, center);
-      rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), viewUp);
+      mat4.translate(trans, trans, center);
+      mat4.rotate(trans, trans, radiansFromDegrees(360.0 * dx / size[0] * rotationFactor), viewUp);
     } // Elevation
 
 
     cross(camera.getDirectionOfProjection(), viewUp, v2);
-    rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
+    mat4.rotate(trans, trans, radiansFromDegrees(-360.0 * dy / size[1] * rotationFactor), v2); // Translate back
 
     centerNeg[0] = -center[0];
     centerNeg[1] = -center[1];
     centerNeg[2] = -center[2];
-    translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
+    mat4.translate(trans, trans, centerNeg); // Apply transformation to camera position, focal point, and view up
 
-    transformMat4(newCamPos, cameraPos, trans);
-    transformMat4(newFp, cameraFp, trans);
+    vec3.transformMat4(newCamPos, cameraPos, trans);
+    vec3.transformMat4(newFp, cameraFp, trans);
     direction[0] = viewUp[0] + cameraPos[0];
     direction[1] = viewUp[1] + cameraPos[1];
     direction[2] = viewUp[2] + cameraPos[2];
-    transformMat4(newViewUp, direction, trans);
+    vec3.transformMat4(newViewUp, direction, trans);
     camera.setPosition(newCamPos[0], newCamPos[1], newCamPos[2]);
     camera.setFocalPoint(newFp[0], newFp[1], newFp[2]);
     camera.setViewUp(newViewUp[0] - newCamPos[0], newViewUp[1] - newCamPos[1], newViewUp[2] - newCamPos[2]);

package/Interaction/Manipulators/MouseCameraUnicamRotateManipulator.js

@@ -8,10 +8,9 @@ import vtkMapper from '../../Rendering/Core/Mapper.js';
 import vtkPointPicker from '../../Rendering/Core/PointPicker.js';
 import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
 import { FieldAssociations } from '../../Common/DataModel/DataSet/Constants.js';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import { z as areEquals, l as normalize, d as dot, A as clampValue, g as subtract, j as cross, t as multiplyScalar, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import { i as identity, t as translate, r as rotate } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var States = vtkInteractorStyleConstants.States; // ----------------------------------------------------------------------------
 // vtkMouseCameraUnicamRotateManipulator methods
@@ -79,25 +78,25 @@ function vtkMouseCameraUnicamRotateManipulator(publicAPI, model) {
     cameraPosition[3] = 1.0;
     cameraFocalPoint[3] = 1.0;
     cameraViewUp[3] = 0.0;
-    var transform = identity(new Float64Array(16));
-    translate(transform, transform, [cx, cy, cz]);
-    rotate(transform, transform, angle, [ax, ay, az]);
-    translate(transform, transform, [-cx, -cy, -cz]);
+    var transform = mat4.identity(new Float64Array(16));
+    mat4.translate(transform, transform, [cx, cy, cz]);
+    mat4.rotate(transform, transform, angle, [ax, ay, az]);
+    mat4.translate(transform, transform, [-cx, -cy, -cz]);
     var newCameraPosition = [];
     var newCameraFocalPoint = [];
-    transformMat4(newCameraPosition, cameraPosition, transform);
-    transformMat4(newCameraFocalPoint, cameraFocalPoint, transform);
-    identity(transform);
-    rotate(transform, transform, angle, [ax, ay, az]);
+    vec3.transformMat4(newCameraPosition, cameraPosition, transform);
+    vec3.transformMat4(newCameraFocalPoint, cameraFocalPoint, transform);
+    mat4.identity(transform);
+    mat4.rotate(transform, transform, angle, [ax, ay, az]);
     var newCameraViewUp = [];
-    transformMat4(newCameraViewUp, cameraViewUp, transform);
+    vec3.transformMat4(newCameraViewUp, cameraViewUp, transform);
     camera.setPosition.apply(camera, newCameraPosition);
     camera.setFocalPoint.apply(camera, newCameraFocalPoint);
     camera.setViewUp.apply(camera, newCameraViewUp);
   }; //----------------------------------------------------------------------------
 
 
-  var rotate$1 = function rotate(interactor, position) {
+  var rotate = function rotate(interactor, position) {
     var _interactor$getView;
 
     var renderer = interactor.findPokedRenderer();
@@ -300,7 +299,7 @@ function vtkMouseCameraUnicamRotateManipulator(publicAPI, model) {
     }
 
     model.state = States.IS_ROTATE;
-    rotate$1(interactor, position);
+    rotate(interactor, position);
     model.previousPosition = position;
   }; //--------------------------------------------------------------------------
 

package/Interaction/Widgets/ImageCroppingRegionsWidget.js

@@ -6,8 +6,7 @@ import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkAbstractWidget from './AbstractWidget.js';
 import vtkImageCroppingRegionsRepresentation from './ImageCroppingRegionsRepresentation.js';
 import Constants from './ImageCroppingRegionsWidget/Constants.js';
-import { i as identity } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
+import { mat4, vec3 } from 'gl-matrix';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -42,8 +41,8 @@ function vtkImageCroppingRegionsWidget(publicAPI, model) {
   model.classHierarchy.push('vtkImageCroppingRegionsWidget'); // camera subscription
 
   var cameraSub = null;
-  model.indexToWorld = identity(new Float64Array(16));
-  model.worldToIndex = identity(new Float64Array(16));
+  model.indexToWorld = mat4.identity(new Float64Array(16));
+  model.worldToIndex = mat4.identity(new Float64Array(16));
   var handlesCache = null;
   model.widgetState = {
     activeHandleIndex: -1,
@@ -54,13 +53,13 @@ function vtkImageCroppingRegionsWidget(publicAPI, model) {
 
   function worldToIndex(ain) {
     var vout = [];
-    transformMat4(vout, ain, model.worldToIndex);
+    vec3.transformMat4(vout, ain, model.worldToIndex);
     return vout;
   }
 
   function indexToWorld(ain) {
     var vout = [];
-    transformMat4(vout, ain, model.indexToWorld);
+    vec3.transformMat4(vout, ain, model.indexToWorld);
     return vout;
   } // Overridden method
 

package/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js

@@ -1,4 +1,4 @@
-import { r as registerWebworker } from '../../../vendor/webworker-promise/lib/register.js';
+import registerWebworker from 'webworker-promise/lib/register';
 
 /* eslint-disable */
 // prettier-ignore

package/Interaction/Widgets/PiecewiseGaussianWidget.js

@@ -3,7 +3,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import { C as arrayRange } from '../../Common/Core/Math/index.js';
-import { s as src } from '../../vendor/webworker-promise/src/index.js';
+import WebworkerPromise from 'webworker-promise';
 import { W as WorkerFactory } from '../../_virtual/rollup-plugin-worker-loader__module_Sources/Interaction/Widgets/PiecewiseGaussianWidget/ComputeHistogram.worker.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
@@ -522,7 +522,7 @@ function vtkPiecewiseGaussianWidget(publicAPI, model) {
     while (arrayIndex < array.length) {
       var worker = new WorkerFactory();
       workers.push(worker);
-      var workerPromise = new src(worker);
+      var workerPromise = new WebworkerPromise(worker);
       var arrayStart = arrayIndex;
       var arrayEnd = Math.min(arrayIndex + arrayStride, array.length - 1);
       var subArray = new array.constructor(array.slice(arrayStart, arrayEnd + 1));

package/Interaction/Widgets/ResliceCursor/ResliceCursorRepresentation.js

@@ -1,5 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../../macros.js';
+import { mat4, vec4 } from 'gl-matrix';
 import vtkImageMapper from '../../../Rendering/Core/ImageMapper.js';
 import vtkImageReslice from '../../../Imaging/Core/ImageReslice.js';
 import vtkImageSlice from '../../../Rendering/Core/ImageSlice.js';
@@ -7,8 +8,6 @@ import { k as add, g as subtract, l as normalize } from '../../../Common/Core/Ma
 import vtkPlaneSource from '../../../Filters/Sources/PlaneSource.js';
 import vtkWidgetRepresentation from '../WidgetRepresentation.js';
 import { transformPlane, boundPlane } from '../../../Widgets/Widgets3D/ResliceCursorWidget/helpers.js';
-import { i as identity, j as transpose } from '../../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../../vendor/gl-matrix/esm/vec4.js';
 
 var vtkErrorMacro = macro.vtkErrorMacro;
 var VTK_INT_MAX = 2147483647; // ----------------------------------------------------------------------------
@@ -156,7 +155,7 @@ function vtkResliceCursorRepresentation(publicAPI, model) {
     var planeSizeX = normalize(planeAxis1);
     var planeSizeY = normalize(planeAxis2);
     var normal = model.planeSource.getNormal();
-    identity(model.newResliceAxes);
+    mat4.identity(model.newResliceAxes);
 
     for (var i = 0; i < 3; i++) {
       model.newResliceAxes[4 * i + 0] = planeAxis1[i];
@@ -169,9 +168,9 @@ function vtkResliceCursorRepresentation(publicAPI, model) {
     var planeOrigin = [].concat(_toConsumableArray(model.planeSource.getOrigin()), [1.0]);
     var originXYZW = [];
     var newOriginXYZW = [];
-    transformMat4(originXYZW, planeOrigin, model.newResliceAxes);
-    transpose(model.newResliceAxes, model.newResliceAxes);
-    transformMat4(newOriginXYZW, originXYZW, model.newResliceAxes);
+    vec4.transformMat4(originXYZW, planeOrigin, model.newResliceAxes);
+    mat4.transpose(model.newResliceAxes, model.newResliceAxes);
+    vec4.transformMat4(newOriginXYZW, originXYZW, model.newResliceAxes);
     model.newResliceAxes[4 * 3 + 0] = newOriginXYZW[0];
     model.newResliceAxes[4 * 3 + 1] = newOriginXYZW[1];
     model.newResliceAxes[4 * 3 + 2] = newOriginXYZW[2]; // Compute a new set of resliced extents
@@ -250,7 +249,7 @@ function vtkResliceCursorRepresentation(publicAPI, model) {
   publicAPI.computeOrigin = function (matrix) {
     var center = publicAPI.getResliceCursor().getCenter();
     var centerTransformed = [];
-    transformMat4(centerTransformed, center, matrix);
+    vec4.transformMat4(centerTransformed, center, matrix);
 
     for (var i = 0; i < 3; i++) {
       matrix[4 * 3 + i] = matrix[4 * 3 + i] + center[i] - centerTransformed[i];
@@ -346,8 +345,8 @@ function extend(publicAPI, model) {
   vtkWidgetRepresentation.extend(publicAPI, model, initialValues);
   model.reslice = null;
   model.planeSource = vtkPlaneSource.newInstance();
-  model.resliceAxes = identity(new Float64Array(16));
-  model.newResliceAxes = identity(new Float64Array(16));
+  model.resliceAxes = mat4.identity(new Float64Array(16));
+  model.newResliceAxes = mat4.identity(new Float64Array(16));
   model.imageActor = vtkImageSlice.newInstance();
   model.imageMapper = vtkImageMapper.newInstance();
   model.imageMapper.setResolveCoincidentTopologyToPolygonOffset();

package/Rendering/Core/Actor.js

@@ -1,10 +1,9 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkProperty from './Property.js';
-import { j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -105,9 +104,9 @@ function vtkActor(publicAPI, model) {
       vtkBoundingBox.getCorners(bds, bbox);
       publicAPI.computeMatrix();
       var tmp4 = new Float64Array(16);
-      transpose(tmp4, model.matrix);
+      mat4.transpose(tmp4, model.matrix);
       bbox.forEach(function (pt) {
-        return transformMat4(pt, pt, tmp4);
+        return vec3.transformMat4(pt, pt, tmp4);
       });
       /* eslint-disable no-multi-assign */