@kitware/vtk.js 20.1.4 → 20.2.3

package/Rendering/Core/CubeAxesActor.js

@@ -1,5 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import { mat4, vec3 } from 'gl-matrix';
+import * as d3 from 'd3-scale';
 import { K as nearestPowerOfTwo, L as normalize2D } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
@@ -9,9 +11,6 @@ import vtkMapper from './Mapper.js';
 import vtkPixelSpaceCallbackMapper from './PixelSpaceCallbackMapper.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTexture from './Texture.js';
-import { l as linear } from '../../vendor/d3-scale/src/linear.js';
-import { j as transpose, g as invert } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4, a as subtract, n as normalize, d as dot, b as scale, j as add } 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; }
 
@@ -70,7 +69,7 @@ function vtkCubeAxesActor(publicAPI, model) {
 
   publicAPI.computeFacesToDraw = function () {
     var cmat = model.camera.getViewMatrix();
-    transpose(cmat, cmat);
+    mat4.transpose(cmat, cmat);
     var changed = false;
     var length = vtkBoundingBox.getDiagonalLength(model.dataBounds);
     var faceDot = Math.sin(model.faceVisibilityAngle * Math.PI / 180.0);
@@ -86,17 +85,17 @@ function vtkCubeAxesActor(publicAPI, model) {
         ptv3[faceAxis] = model.dataBounds[f] - 0.1 * length * faceNormals[f][faceAxis];
         ptv3[otherAxis1] = 0.5 * (model.dataBounds[otherAxis1 * 2] + model.dataBounds[otherAxis1 * 2 + 1]);
         ptv3[otherAxis2] = 0.5 * (model.dataBounds[otherAxis2 * 2] + model.dataBounds[otherAxis2 * 2 + 1]);
-        transformMat4(tmpv3, ptv3, cmat);
+        vec3.transformMat4(tmpv3, ptv3, cmat);
         ptv3[faceAxis] = model.dataBounds[f];
-        transformMat4(tmp2v3, ptv3, cmat);
-        subtract(tmpv3, tmp2v3, tmpv3);
-        normalize(tmpv3, tmpv3); // tmpv3 now holds the face normal vector
+        vec3.transformMat4(tmp2v3, ptv3, cmat);
+        vec3.subtract(tmpv3, tmp2v3, tmpv3);
+        vec3.normalize(tmpv3, tmpv3); // tmpv3 now holds the face normal vector
 
         drawit = tmpv3[2] > faceDot; // for perspctive we need the view direction to the plane
 
         if (!model.camera.getParallelProjection()) {
-          normalize(tmp2v3, tmp2v3);
-          drawit = dot(tmp2v3, tmpv3) > faceDot;
+          vec3.normalize(tmp2v3, tmp2v3);
+          drawit = vec3.dot(tmp2v3, tmpv3) > faceDot;
         }
       }
 
@@ -327,7 +326,7 @@ function vtkCubeAxesActor(publicAPI, model) {
       var tickStrings = [];
 
       for (var _i = 0; _i < 3; _i++) {
-        var scale = linear().domain([model.dataBounds[_i * 2], model.dataBounds[_i * 2 + 1]]);
+        var scale = d3.scaleLinear().domain([model.dataBounds[_i * 2], model.dataBounds[_i * 2 + 1]]);
         ticks[_i] = scale.ticks(5);
         var format = scale.tickFormat(5);
         tickStrings[_i] = ticks[_i].map(format);
@@ -449,17 +448,17 @@ function vtkCubeAxesActor(publicAPI, model) {
     ptv3[0] = coords[pos * 3];
     ptv3[1] = coords[pos * 3 + 1];
     ptv3[2] = coords[pos * 3 + 2];
-    transformMat4(tmpv3, ptv3, cmat); // moving 0.1 in NDC
+    vec3.transformMat4(tmpv3, ptv3, cmat); // moving 0.1 in NDC
 
     tmpv3[0] += 0.1;
-    transformMat4(pt2v3, tmpv3, imat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
 
-    subtract(xDir, pt2v3, ptv3);
+    vec3.subtract(xDir, pt2v3, ptv3);
     tmpv3[0] -= 0.1;
     tmpv3[1] += 0.1;
-    transformMat4(pt2v3, tmpv3, imat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
 
-    subtract(yDir, pt2v3, ptv3);
+    vec3.subtract(yDir, pt2v3, ptv3);
 
     for (var i = 0; i < 3; i++) {
       xDir[i] /= 0.5 * 0.1 * size[0];
@@ -475,40 +474,40 @@ function vtkCubeAxesActor(publicAPI, model) {
     ptv3[2] = coords[pos * 3 + 2]; // horizontal left, right, or middle alignment based on dir[0]
 
     if (dir[0] < -0.5) {
-      scale(tmpv3, xDir, dir[0] * offset - value.width);
+      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width);
     } else if (dir[0] > 0.5) {
-      scale(tmpv3, xDir, dir[0] * offset);
+      vec3.scale(tmpv3, xDir, dir[0] * offset);
     } else {
-      scale(tmpv3, xDir, dir[0] * offset - value.width / 2.0);
+      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width / 2.0);
     }
 
-    add(ptv3, ptv3, tmpv3);
-    scale(tmpv3, yDir, dir[1] * offset - value.height / 2.0);
-    add(ptv3, ptv3, tmpv3);
+    vec3.add(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, yDir, dir[1] * offset - value.height / 2.0);
+    vec3.add(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[0];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[1];
     ptIdx++;
-    scale(tmpv3, xDir, value.width);
-    add(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, xDir, value.width);
+    vec3.add(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[2];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[3];
     ptIdx++;
-    scale(tmpv3, yDir, value.height);
-    add(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, yDir, value.height);
+    vec3.add(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
     results.tcoords[ptIdx * 2] = value.tcoords[4];
     results.tcoords[ptIdx * 2 + 1] = value.tcoords[5];
     ptIdx++;
-    scale(tmpv3, xDir, value.width);
-    subtract(ptv3, ptv3, tmpv3);
+    vec3.scale(tmpv3, xDir, value.width);
+    vec3.subtract(ptv3, ptv3, tmpv3);
     results.points[ptIdx * 3] = ptv3[0];
     results.points[ptIdx * 3 + 1] = ptv3[1];
     results.points[ptIdx * 3 + 2] = ptv3[2];
@@ -534,7 +533,7 @@ function vtkCubeAxesActor(publicAPI, model) {
 
   publicAPI.updateTexturePolyData = function () {
     var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    transpose(cmat, cmat); // update the polydata
+    mat4.transpose(cmat, cmat); // update the polydata
 
     var numLabels = model.textValues.length;
     var numPts = numLabels * 4;
@@ -542,7 +541,7 @@ function vtkCubeAxesActor(publicAPI, model) {
     var points = new Float64Array(numPts * 3);
     var polys = new Uint16Array(numTris * 4);
     var tcoords = new Float32Array(numPts * 2);
-    invert(invmat, cmat);
+    mat4.invert(invmat, cmat);
     var results = {
       ptIdx: 0,
       cellIdx: 0,
@@ -560,12 +559,12 @@ function vtkCubeAxesActor(publicAPI, model) {
       ptv3[0] = coords[ptIdx * 3];
       ptv3[1] = coords[ptIdx * 3 + 1];
       ptv3[2] = coords[ptIdx * 3 + 2];
-      transformMat4(tmpv3, ptv3, cmat);
+      vec3.transformMat4(tmpv3, ptv3, cmat);
       ptv3[0] = coords[ptIdx * 3 + 3];
       ptv3[1] = coords[ptIdx * 3 + 4];
       ptv3[2] = coords[ptIdx * 3 + 5];
-      transformMat4(tmp2v3, ptv3, cmat);
-      subtract(tmpv3, tmpv3, tmp2v3);
+      vec3.transformMat4(tmp2v3, ptv3, cmat);
+      vec3.subtract(tmpv3, tmpv3, tmp2v3);
       var dir = [tmpv3[0], tmpv3[1]];
       normalize2D(dir); // write the axis label
 
@@ -608,7 +607,11 @@ function vtkCubeAxesActor(publicAPI, model) {
     model.forceUpdate = true;
     publicAPI.update();
   });
-  publicAPI.setVisibility = macro.chain(publicAPI.setVisibility, model.pixelActor.setVisibility, model.tmActor.setVisibility);
+  var setVisibility = macro.chain(publicAPI.setVisibility, model.pixelActor.setVisibility, model.tmActor.setVisibility);
+
+  publicAPI.setVisibility = function () {
+    return setVisibility.apply(void 0, arguments).some(Boolean);
+  };
 
   publicAPI.setTickTextStyle = function (tickStyle) {
     model.tickTextStyle = _objectSpread(_objectSpread({}, model.tickTextStyle), tickStyle);

package/Rendering/Core/Follower.js

@@ -1,7 +1,6 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { i as identity, m as multiply, t as translate, s as scale, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { s as set, v as vec3, a as subtract, n as normalize, c as cross } from '../../vendor/gl-matrix/esm/vec3.js';
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 
@@ -31,43 +30,43 @@ function vtkFollower(publicAPI, model) {
   publicAPI.computeMatrix = function () {
     // check whether or not need to rebuild the matrix
     if (publicAPI.getMTime() > model.matrixMTime.getMTime()) {
-      identity(model.matrix);
+      mat4.identity(model.matrix);
 
       if (model.userMatrix) {
-        multiply(model.matrix, model.matrix, model.userMatrix);
+        mat4.multiply(model.matrix, model.matrix, model.userMatrix);
       }
 
-      translate(model.matrix, model.matrix, model.origin);
-      translate(model.matrix, model.matrix, model.position);
-      multiply(model.matrix, model.matrix, model.rotation);
-      scale(model.matrix, model.matrix, model.scale);
+      mat4.translate(model.matrix, model.matrix, model.origin);
+      mat4.translate(model.matrix, model.matrix, model.position);
+      mat4.multiply(model.matrix, model.matrix, model.rotation);
+      mat4.scale(model.matrix, model.matrix, model.scale);
 
       if (model.camera) {
         // first compute our target viewUp
         var vup = new Float64Array(model.viewUp);
 
         if (!model.useViewUp) {
-          set.apply(vec3, [vup].concat(_toConsumableArray(model.camera.getViewUp())));
+          vec3.set.apply(vec3, [vup].concat(_toConsumableArray(model.camera.getViewUp())));
         } // compute a vpn
 
 
         var vpn = new Float64Array(3);
 
         if (model.camera.getParallelProjection()) {
-          set(vpn, model.camera.getViewPlaneNormal());
+          vec3.set(vpn, model.camera.getViewPlaneNormal());
         } else {
-          set.apply(vec3, [vpn].concat(_toConsumableArray(model.position)));
-          subtract(vpn, model.camera.getPosition(), vpn);
-          normalize(vpn, vpn);
+          vec3.set.apply(vec3, [vpn].concat(_toConsumableArray(model.position)));
+          vec3.subtract(vpn, model.camera.getPosition(), vpn);
+          vec3.normalize(vpn, vpn);
         } // compute vright
 
 
         var vright = new Float64Array(3);
-        cross(vright, vup, vpn);
-        normalize(vright, vright); // now recompute the vpn so that it is orthogonal to vup
+        vec3.cross(vright, vup, vpn);
+        vec3.normalize(vright, vright); // now recompute the vpn so that it is orthogonal to vup
 
-        cross(vpn, vright, vup);
-        normalize(vpn, vpn);
+        vec3.cross(vpn, vright, vup);
+        vec3.normalize(vpn, vpn);
         model.followerMatrix[0] = vright[0];
         model.followerMatrix[1] = vright[1];
         model.followerMatrix[2] = vright[2];
@@ -77,11 +76,11 @@ function vtkFollower(publicAPI, model) {
         model.followerMatrix[8] = vpn[0];
         model.followerMatrix[9] = vpn[1];
         model.followerMatrix[10] = vpn[2];
-        multiply(model.matrix, model.followerMatrix, model.matrix);
+        mat4.multiply(model.matrix, model.followerMatrix, model.matrix);
       }
 
-      translate(model.matrix, model.matrix, [-model.origin[0], -model.origin[1], -model.origin[2]]);
-      transpose(model.matrix, model.matrix); // check for identity
+      mat4.translate(model.matrix, model.matrix, [-model.origin[0], -model.origin[1], -model.origin[2]]);
+      mat4.transpose(model.matrix, model.matrix); // check for identity
 
       model.isIdentity = false;
       model.matrixMTime.modified();
@@ -103,7 +102,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
   vtkActor.extend(publicAPI, model, initialValues);
-  model.followerMatrix = identity(new Float64Array(16)); // Build VTK API
+  model.followerMatrix = mat4.identity(new Float64Array(16)); // Build VTK API
 
   macro.setGet(publicAPI, model, ['useViewUp', 'camera']);
   macro.setGetArray(publicAPI, model, ['viewUp'], 3); // Object methods

package/Rendering/Core/Glyph3DMapper.js

@@ -1,13 +1,11 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { mat4, vec3, mat3 } from 'gl-matrix';
 import Constants from './Glyph3DMapper/Constants.js';
 import macro from '../../macros.js';
 import vtkMapper from './Mapper.js';
 import { M as createUninitializedBounds, n as norm } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { i as identity, t as translate, b as rotateY, r as rotate, c as rotateZ, a as rotateX, m as multiply, s as scale } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
-import { f as fromMat4, a as invert, t as transpose } from '../../vendor/gl-matrix/esm/mat3.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; }
 
@@ -141,9 +139,9 @@ function vtkGlyph3DMapper(publicAPI, model) {
       model.bounds[5] = vtkBoundingBox.INIT_BOUNDS[5];
       var tcorner = new Float64Array(3);
       var oArray = publicAPI.getOrientationArrayData();
-      var identity$1 = identity(new Float64Array(16));
+      var identity = mat4.identity(new Float64Array(16));
       var trans = [];
-      var scale$1 = [];
+      var scale = [];
       var numPts = pts.length / 3;
       model.matrixArray = new Float32Array(16 * numPts);
       var mbuff = model.matrixArray.buffer;
@@ -156,7 +154,7 @@ function vtkGlyph3DMapper(publicAPI, model) {
         trans[0] = pts[i * 3];
         trans[1] = pts[i * 3 + 1];
         trans[2] = pts[i * 3 + 2];
-        translate(z, identity$1, trans);
+        mat4.translate(z, identity, trans);
 
         if (oArray) {
           var orientation = [];
@@ -167,20 +165,20 @@ function vtkGlyph3DMapper(publicAPI, model) {
               {
                 // prettier-ignore
                 var rotMat4 = [].concat(_toConsumableArray(orientation.slice(0, 3)), [0], _toConsumableArray(orientation.slice(3, 6)), [0], _toConsumableArray(orientation.slice(6, 9)), [0, 0, 0, 0, 1]);
-                multiply(z, z, rotMat4);
+                mat4.multiply(z, z, rotMat4);
                 break;
               }
 
             case OrientationModes.ROTATION:
-              rotateZ(z, z, orientation[2]);
-              rotateX(z, z, orientation[0]);
-              rotateY(z, z, orientation[1]);
+              mat4.rotateZ(z, z, orientation[2]);
+              mat4.rotateX(z, z, orientation[0]);
+              mat4.rotateY(z, z, orientation[1]);
               break;
 
             case OrientationModes.DIRECTION:
               if (orientation[1] === 0.0 && orientation[2] === 0.0) {
                 if (orientation[0] < 0) {
-                  rotateY(z, z, 3.1415926);
+                  mat4.rotateY(z, z, 3.1415926);
                 }
               } else {
                 var vMag = norm(orientation);
@@ -188,7 +186,7 @@ function vtkGlyph3DMapper(publicAPI, model) {
                 vNew[0] = (orientation[0] + vMag) / 2.0;
                 vNew[1] = orientation[1] / 2.0;
                 vNew[2] = orientation[2] / 2.0;
-                rotate(z, z, 3.1415926, vNew);
+                mat4.rotate(z, z, 3.1415926, vNew);
               }
 
               break;
@@ -197,9 +195,9 @@ function vtkGlyph3DMapper(publicAPI, model) {
 
 
         if (model.scaling) {
-          scale$1[0] = model.scaleFactor;
-          scale$1[1] = model.scaleFactor;
-          scale$1[2] = model.scaleFactor; // Get the scalar and vector data
+          scale[0] = model.scaleFactor;
+          scale[1] = model.scaleFactor;
+          scale[2] = model.scaleFactor; // Get the scalar and vector data
 
           if (sArray) {
             switch (model.scaleMode) {
@@ -208,9 +206,9 @@ function vtkGlyph3DMapper(publicAPI, model) {
                   tuple[t] = sData[i * numSComp + t];
                 }
 
-                scale$1[0] *= norm(tuple, numSComp);
-                scale$1[1] = scale$1[0];
-                scale$1[2] = scale$1[0];
+                scale[0] *= norm(tuple, numSComp);
+                scale[1] = scale[0];
+                scale[2] = scale[0];
                 break;
 
               case ScaleModes.SCALE_BY_COMPONENTS:
@@ -218,33 +216,33 @@ function vtkGlyph3DMapper(publicAPI, model) {
                   tuple[_t] = sData[i * numSComp + _t];
                 }
 
-                scale$1[0] *= tuple[0];
-                scale$1[1] *= tuple[1];
-                scale$1[2] *= tuple[2];
+                scale[0] *= tuple[0];
+                scale[1] *= tuple[1];
+                scale[2] *= tuple[2];
                 break;
 
               case ScaleModes.SCALE_BY_CONSTANT:
             }
           }
 
-          if (scale$1[0] === 0.0) {
-            scale$1[0] = 1.0e-10;
+          if (scale[0] === 0.0) {
+            scale[0] = 1.0e-10;
           }
 
-          if (scale$1[1] === 0.0) {
-            scale$1[1] = 1.0e-10;
+          if (scale[1] === 0.0) {
+            scale[1] = 1.0e-10;
           }
 
-          if (scale$1[2] === 0.0) {
-            scale$1[2] = 1.0e-10;
+          if (scale[2] === 0.0) {
+            scale[2] = 1.0e-10;
           }
 
-          scale(z, z, scale$1);
+          mat4.scale(z, z, scale);
         } // update bounds
 
 
         for (var p = 0; p < 8; ++p) {
-          transformMat4(tcorner, corners[p], z);
+          vec3.transformMat4(tcorner, corners[p], z);
 
           if (tcorner[0] < model.bounds[0]) {
             model.bounds[0] = tcorner[0];
@@ -272,9 +270,9 @@ function vtkGlyph3DMapper(publicAPI, model) {
         }
 
         var n = new Float32Array(nbuff, i * 36, 9);
-        fromMat4(n, z);
-        invert(n, n);
-        transpose(n, n);
+        mat3.fromMat4(n, z);
+        mat3.invert(n, n);
+        mat3.transpose(n, n);
       } // map scalars as well
 
 

package/Rendering/Core/ImageMapper.js

@@ -5,7 +5,7 @@ import vtkAbstractMapper from './AbstractMapper.js';
 import { A as clampValue, N as multiply3x3_vect3, M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
-import { n as normalize } from '../../vendor/gl-matrix/esm/vec3.js';
+import { 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; }
 
@@ -368,7 +368,7 @@ function vtkImageMapper(publicAPI, model) {
     worldNormal[0] -= worldOrigin[0];
     worldNormal[1] -= worldOrigin[1];
     worldNormal[2] -= worldOrigin[2];
-    normalize(worldNormal, worldNormal);
+    vec3.normalize(worldNormal, worldNormal);
     var intersect = vtkPlane.intersectWithLine(p1, p2, worldOrigin, worldNormal);
 
     if (intersect.intersection) {

package/Rendering/Core/ImageSlice.js

@@ -1,9 +1,8 @@
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkImageProperty from './ImageProperty.js';
-import { j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro; // ----------------------------------------------------------------------------
 // vtkImageSlice methods
@@ -106,9 +105,9 @@ function vtkImageSlice(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 */
 
@@ -147,9 +146,9 @@ function vtkImageSlice(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);
     });
     var newBounds = [Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE, Number.MAX_VALUE, -Number.MAX_VALUE];
     newBounds = newBounds.map(function (d, i) {

package/Rendering/Core/Picker.d.ts

@@ -86,14 +86,14 @@ export interface vtkPicker extends vtkAbstractPicker {
 	setMapperPosition(x: number, y: number, z: number): boolean;
 
 	/**
-	 * 
-	 * @param {Vector3} mapperPosition 
+	 * Set position in mapper coordinates of pick point.
+	 * @param {Vector3} mapperPosition The mapper coordinates of pick point.
 	 */
 	setMapperPositionFrom(mapperPosition: Vector3): boolean;
 
 	/**
 	 * Specify tolerance for performing pick operation.
-	 * @param {Number} tolerance 
+	 * @param {Number} tolerance The tolerance value.
 	 */
 	setTolerance(tolerance: number): boolean;
 }
@@ -103,7 +103,7 @@ export interface vtkPicker extends vtkAbstractPicker {
  *
  * @param publicAPI object on which methods will be bounds (public)
  * @param model object on which data structure will be bounds (protected)
- * @param {IPickerInitialValues} initialValues 
+ * @param {IPickerInitialValues} [initialValues] 
  */
 export function extend(publicAPI: object, model: object, initialValues?: IPickerInitialValues): void;
 
@@ -111,7 +111,7 @@ export function extend(publicAPI: object, model: object, initialValues?: IPicker
  * Method use to create a new instance of vtkPicker with its focal point at the origin, 
  * and position=(0,0,1). The view up is along the y-axis, view angle is 30 degrees, 
  * and the clipping range is (.1,1000).
- * @param {IPickerInitialValues} initialValues for pre-setting some of its content
+ * @param {IPickerInitialValues} [initialValues] for pre-setting some of its content
  */
 export function newInstance(initialValues?: IPickerInitialValues): vtkPicker;
 

package/Rendering/Core/Picker.js

@@ -3,8 +3,7 @@ import macro from '../../macros.js';
 import vtkAbstractPicker from './AbstractPicker.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { d as dot, l as normalize, n as norm, f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
-import { j as transpose, g as invert } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec4.js';
+import { mat4, vec4 } 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; }
 
@@ -207,8 +206,8 @@ function vtkPicker(publicAPI, model) {
         model.transformMatrix = prop.getMatrix().slice(0); // Webgl need a transpose matrix but we need the untransposed one to project world points
         // into the right referential
 
-        transpose(model.transformMatrix, model.transformMatrix);
-        invert(model.transformMatrix, model.transformMatrix); // Extract scale
+        mat4.transpose(model.transformMatrix, model.transformMatrix);
+        mat4.invert(model.transformMatrix, model.transformMatrix); // Extract scale
 
         var col1 = [model.transformMatrix[0], model.transformMatrix[1], model.transformMatrix[2]];
         var col2 = [model.transformMatrix[4], model.transformMatrix[5], model.transformMatrix[6]];
@@ -216,8 +215,8 @@ function vtkPicker(publicAPI, model) {
         scale[0] = norm(col1);
         scale[1] = norm(col2);
         scale[2] = norm(col3);
-        transformMat4(p1Mapper, p1World, model.transformMatrix);
-        transformMat4(p2Mapper, p2World, model.transformMatrix);
+        vec4.transformMat4(p1Mapper, p1World, model.transformMatrix);
+        vec4.transformMat4(p2Mapper, p2World, model.transformMatrix);
         p1Mapper[0] /= p1Mapper[3];
         p1Mapper[1] /= p1Mapper[3];
         p1Mapper[2] /= p1Mapper[3];

package/Rendering/Core/PixelSpaceCallbackMapper.js

@@ -1,7 +1,6 @@
+import { mat4, vec3 } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkMapper from './Mapper.js';
-import { j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 // vtkPixelSpaceCallbackMapper methods
 // ----------------------------------------------------------------------------
@@ -19,7 +18,7 @@ function vtkPixelSpaceCallbackMapper(publicAPI, model) {
     }
 
     var matrix = camera.getCompositeProjectionMatrix(aspect, -1, 1);
-    transpose(matrix, matrix);
+    mat4.transpose(matrix, matrix);
     var dataPoints = dataset.getPoints();
     var result = new Float64Array(3);
     var width = windowSize.usize;
@@ -30,7 +29,7 @@ function vtkPixelSpaceCallbackMapper(publicAPI, model) {
 
     for (var pidx = 0; pidx < dataPoints.getNumberOfPoints(); pidx += 1) {
       var point = dataPoints.getPoint(pidx);
-      transformMat4(result, point, matrix);
+      vec3.transformMat4(result, point, matrix);
       var coord = [result[0] * hw + hw, result[1] * hh + hh, result[2], 0];
 
       if (depthValues) {