@kitware/vtk.js 20.1.2 → 20.2.1

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.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) {

package/Rendering/Core/Prop3D.js

@@ -1,9 +1,8 @@
+import { mat4, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import { y as degreesFromRadians, r as radiansFromDegrees } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
-import { i as identity, n as getRotation, a as rotateX, b as rotateY, c as rotateZ, k as fromQuat, m as multiply, d as copy, t as translate, s as scale, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { c as create, g as getAxisAngle, s as setAxisAngle } from '../../vendor/gl-matrix/esm/quat.js';
 
 // vtkProp3D methods
 // ----------------------------------------------------------------------------
@@ -20,10 +19,10 @@ function vtkProp3D(publicAPI, model) {
   };
 
   publicAPI.getOrientationWXYZ = function () {
-    var q = create();
-    getRotation(q, model.rotation);
+    var q = quat.create();
+    mat4.getRotation(q, model.rotation);
     var oaxis = new Float64Array(3);
-    var w = getAxisAngle(oaxis, q);
+    var w = quat.getAxisAngle(oaxis, q);
     return [degreesFromRadians(w), oaxis[0], oaxis[1], oaxis[2]];
   };
 
@@ -32,7 +31,7 @@ function vtkProp3D(publicAPI, model) {
       return;
     }
 
-    rotateX(model.rotation, model.rotation, radiansFromDegrees(val));
+    mat4.rotateX(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
 
@@ -41,7 +40,7 @@ function vtkProp3D(publicAPI, model) {
       return;
     }
 
-    rotateY(model.rotation, model.rotation, radiansFromDegrees(val));
+    mat4.rotateY(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
 
@@ -50,7 +49,7 @@ function vtkProp3D(publicAPI, model) {
       return;
     }
 
-    rotateZ(model.rotation, model.rotation, radiansFromDegrees(val));
+    mat4.rotateZ(model.rotation, model.rotation, radiansFromDegrees(val));
     publicAPI.modified();
   };
 
@@ -61,11 +60,11 @@ function vtkProp3D(publicAPI, model) {
 
 
     var angle = radiansFromDegrees(degrees);
-    var q = create();
-    setAxisAngle(q, [x, y, z], angle);
+    var q = quat.create();
+    quat.setAxisAngle(q, [x, y, z], angle);
     var quatMat = new Float64Array(16);
-    fromQuat(quatMat, q);
-    multiply(model.rotation, model.rotation, quatMat);
+    mat4.fromQuat(quatMat, q);
+    mat4.multiply(model.rotation, model.rotation, quatMat);
     publicAPI.modified();
   };
 
@@ -75,7 +74,7 @@ function vtkProp3D(publicAPI, model) {
     }
 
     model.orientation = [x, y, z];
-    identity(model.rotation);
+    mat4.identity(model.rotation);
     publicAPI.rotateZ(z);
     publicAPI.rotateX(x);
     publicAPI.rotateY(y);
@@ -84,7 +83,7 @@ function vtkProp3D(publicAPI, model) {
   };
 
   publicAPI.setUserMatrix = function (matrix) {
-    copy(model.userMatrix, matrix);
+    mat4.copy(model.userMatrix, matrix);
     publicAPI.modified();
   };
 
@@ -96,18 +95,18 @@ function vtkProp3D(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);
-      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);
+      mat4.translate(model.matrix, model.matrix, model.position);
+      mat4.multiply(model.matrix, model.matrix, model.rotation);
+      mat4.scale(model.matrix, model.matrix, model.scale);
+      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 = true;
 
@@ -183,9 +182,9 @@ function extend(publicAPI, model) {
   macro.getArray(publicAPI, model, ['orientation']);
   macro.setGetArray(publicAPI, model, ['origin', 'position', 'scale'], 3); // Object internal instance
 
-  model.matrix = identity(new Float64Array(16));
-  model.rotation = identity(new Float64Array(16));
-  model.userMatrix = identity(new Float64Array(16));
+  model.matrix = mat4.identity(new Float64Array(16));
+  model.rotation = mat4.identity(new Float64Array(16));
+  model.userMatrix = mat4.identity(new Float64Array(16));
   model.transform = null; // FIXME
   // Object methods
 

package/Rendering/Core/Renderer.js

@@ -1,11 +1,10 @@
+import { mat4, vec3 } from 'gl-matrix';
 import { newInstance as newInstance$1, get, setGet, getArray, setGetArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
 import { O as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, M as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { g as invert, j as transpose } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
 
 var vtkDebugMacro = vtkDebugMacro$1,
     vtkErrorMacro = vtkErrorMacro$1,
@@ -266,11 +265,11 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getViewMatrix();
-    invert(matrix, matrix);
-    transpose(matrix, matrix); // Transform point to world coordinates
+    mat4.invert(matrix, matrix);
+    mat4.transpose(matrix, matrix); // Transform point to world coordinates
 
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   };
 
@@ -282,11 +281,11 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getProjectionMatrix(aspect, -1.0, 1.0);
-    invert(matrix, matrix);
-    transpose(matrix, matrix); // Transform point to world coordinates
+    mat4.invert(matrix, matrix);
+    mat4.transpose(matrix, matrix); // Transform point to world coordinates
 
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   }; // Convert world point coordinates to view coordinates.
 
@@ -299,9 +298,9 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getViewMatrix();
-    transpose(matrix, matrix);
+    mat4.transpose(matrix, matrix);
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   }; // Convert world point coordinates to view coordinates.
   // requires the aspect ratio of the viewport as X/Y
@@ -315,9 +314,9 @@ function vtkRenderer(publicAPI, model) {
 
 
     var matrix = model.activeCamera.getProjectionMatrix(aspect, -1.0, 1.0);
-    transpose(matrix, matrix);
+    mat4.transpose(matrix, matrix);
     var result = new Float64Array([x, y, z]);
-    transformMat4(result, result, matrix);
+    vec3.transformMat4(result, result, matrix);
     return result;
   };
 

package/Rendering/Core/ScalarBarActor.js

@@ -1,5 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { vec3, mat4 } from 'gl-matrix';
+import * as d3 from 'd3-scale';
 import { K as nearestPowerOfTwo } 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 { b as scale, j as add, a as subtract, t as transformMat4 } from '../../vendor/gl-matrix/esm/vec3.js';
-import { j as transpose, g as invert } from '../../vendor/gl-matrix/esm/mat4.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; }
 
@@ -130,7 +129,7 @@ function vtkScalarBarActor(publicAPI, model) {
       model.lastTickBounds = _toConsumableArray(range);
       model.barMapper.setScalarRange(model.lastTickBounds); // compute tick marks for axes (update for log scale)
 
-      var scale = linear().domain([model.lastTickBounds[0], model.lastTickBounds[1]]);
+      var scale = d3.scaleLinear().domain([model.lastTickBounds[0], model.lastTickBounds[1]]);
       model.ticks = scale.ticks(5);
       var format = scale.tickFormat(5);
       model.tickStrings = model.ticks.map(format);
@@ -378,40 +377,40 @@ function vtkScalarBarActor(publicAPI, model) {
     ptv3[2] = pos[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];
@@ -437,25 +436,25 @@ function vtkScalarBarActor(publicAPI, model) {
 
   publicAPI.updatePolyDataForLabels = function () {
     var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    transpose(cmat, cmat);
-    invert(invmat, cmat);
+    mat4.transpose(cmat, cmat);
+    mat4.invert(invmat, cmat);
     var size = model.lastSize; // compute pixel to distance factors
 
     tmpv3[0] = 0.0;
     tmpv3[1] = 0.0;
     tmpv3[2] = -0.99; // near plane
 
-    transformMat4(ptv3, tmpv3, invmat); // moving 0.1 in NDC
+    vec3.transformMat4(ptv3, tmpv3, invmat); // moving 0.1 in NDC
 
     tmpv3[0] += 0.1;
-    transformMat4(pt2v3, tmpv3, invmat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, invmat); // 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, invmat); // results in WC move of
+    vec3.transformMat4(pt2v3, tmpv3, invmat); // 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];
@@ -486,24 +485,24 @@ function vtkScalarBarActor(publicAPI, model) {
       if (model.topTitle) {
         tmpv3[0] = model.boxPosition[0] + 0.5 * model.boxSize[0];
         tmpv3[1] = model.barPosition[1] + model.barSize[1];
-        transformMat4(ptv3, tmpv3, invmat); // write the axis label
+        vec3.transformMat4(ptv3, tmpv3, invmat); // write the axis label
 
         publicAPI.createPolyDataForOneLabel(model.axisLabel, ptv3, xDir, yDir, [0, 1], model.axisTitlePixelOffset, results);
       } else {
         tmpv3[0] = model.barPosition[0] + model.barSize[0];
         tmpv3[1] = model.barPosition[1] + 0.5 * model.barSize[1];
-        transformMat4(ptv3, tmpv3, invmat); // write the axis label
+        vec3.transformMat4(ptv3, tmpv3, invmat); // write the axis label
 
-        scale(xDir, xDir, -1);
+        vec3.scale(xDir, xDir, -1);
         publicAPI.createPolyDataForOneLabel(model.axisLabel, ptv3, yDir, xDir, [0, -1], model.axisTitlePixelOffset, results);
-        scale(xDir, xDir, -1);
+        vec3.scale(xDir, xDir, -1);
       }
 
       dir = [-1, 0];
     } else {
       tmpv3[0] = model.barPosition[0] + 0.5 * model.barSize[0];
       tmpv3[1] = model.barPosition[1] + model.barSize[1];
-      transformMat4(ptv3, tmpv3, invmat);
+      vec3.transformMat4(ptv3, tmpv3, invmat);
       publicAPI.createPolyDataForOneLabel(model.axisLabel, ptv3, xDir, yDir, dir, model.axisTitlePixelOffset, results);
     }
 
@@ -522,7 +521,7 @@ function vtkScalarBarActor(publicAPI, model) {
         tickSeg = seg;
       } else {
         tmp2v3[spacedAxis] = model.barPosition[spacedAxis] + 0.5 * model.barSize[spacedAxis] * (seg.corners[2][spacedAxis] + seg.corners[0][spacedAxis]);
-        transformMat4(ptv3, tmp2v3, invmat);
+        vec3.transformMat4(ptv3, tmp2v3, invmat);
         publicAPI.createPolyDataForOneLabel(seg.title, ptv3, xDir, yDir, dir, model.tickLabelPixelOffset, results);
       }
     } // write the tick labels
@@ -534,7 +533,7 @@ function vtkScalarBarActor(publicAPI, model) {
     for (var t = 0; t < model.ticks.length; t++) {
       var tickPos = (model.ticks[t] - model.lastTickBounds[0]) / (model.lastTickBounds[1] - model.lastTickBounds[0]);
       tmp2v3[spacedAxis] = tickSegmentStart + tickSegmentSize * tickPos;
-      transformMat4(ptv3, tmp2v3, invmat);
+      vec3.transformMat4(ptv3, tmp2v3, invmat);
       publicAPI.createPolyDataForOneLabel(model.tickStrings[t], ptv3, xDir, yDir, dir, model.tickLabelPixelOffset, results);
     }
 
@@ -553,8 +552,8 @@ function vtkScalarBarActor(publicAPI, model) {
 
   publicAPI.updatePolyDataForBarSegments = function () {
     var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    transpose(cmat, cmat);
-    invert(invmat, cmat);
+    mat4.transpose(cmat, cmat);
+    mat4.invert(invmat, cmat);
     var haveExtraColors = typeof model.scalarsToColors.getNanColor === 'function' && typeof model.scalarsToColors.getAboveRangeColor === 'function' && typeof model.scalarsToColors.getBelowRangeColor === 'function';
     var numPts = 4 + (haveExtraColors ? 12 : 0);
     var numQuads = numPts; // handle vector component mode
@@ -580,7 +579,7 @@ function vtkScalarBarActor(publicAPI, model) {
       for (var e = 0; e < 4; e++) {
         tmp2v3[0] = model.barPosition[0] + seg.corners[e][0] * model.barSize[0];
         tmp2v3[1] = model.barPosition[1] + seg.corners[e][1] * model.barSize[1];
-        transformMat4(ptv3, tmp2v3, invmat);
+        vec3.transformMat4(ptv3, tmp2v3, invmat);
         points[ptIdx * 3] = ptv3[0];
         points[ptIdx * 3 + 1] = ptv3[1];
         points[ptIdx * 3 + 2] = ptv3[2];

package/Rendering/Core/Volume.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 vtkVolumeProperty from './VolumeProperty.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; // ----------------------------------------------------------------------------
 // vtkVolume methods
@@ -72,9 +71,9 @@ function vtkVolume(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 */