@kitware/vtk.js 20.1.4 → 20.2.3

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 */
 

package/Rendering/Core/AnnotatedCubeActor.d.ts

@@ -38,31 +38,31 @@ export interface vtkAnnotatedCubeActor extends vtkActor {
 
 	/**
 	 * The -X face property.
-	 * @param {IFaceProperty} prop -X  face property
+	 * @param {IFaceProperty} prop The -X face property.
 	 */
 	setXMinusFaceProperty(prop: IFaceProperty): boolean;
 
 	/**
 	 * The +Y face property.
-	 * @param {IFaceProperty} prop +Y face property
+	 * @param {IFaceProperty} prop The +Y face property.
 	 */
 	setYPlusFaceProperty(prop: IFaceProperty): boolean;
 
 	/**
 	 * The -Y face property.
-	 * @param {IFaceProperty} prop -Y ace property
+	 * @param {IFaceProperty} prop The -Y ace property.
 	 */
 	setYMinusFaceProperty(prop: IFaceProperty): boolean;
 
 	/**
 	 * The +Z face property.
-	 * @param {IFaceProperty} prop +Z face property
+	 * @param {IFaceProperty} prop The +Z face property.
 	 */
 	setZPlusFaceProperty(prop: IFaceProperty): boolean;
 
 	/**
 	 * The -Z face property.
-	 * @param {IFaceProperty} prop -Z face property
+	 * @param {IFaceProperty} prop The -Z face property.
 	 */
 	setZMinusFaceProperty(prop: IFaceProperty): boolean;
 }
@@ -103,4 +103,3 @@ export declare const vtkAnnotatedCubeActor: {
 	extend: typeof extend,
 };
 export default vtkAnnotatedCubeActor;
-

package/Rendering/Core/Camera.js

@@ -1,10 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import { mat4, vec4, vec3, quat } from 'gl-matrix';
 import macro from '../../macros.js';
 import { r as radiansFromDegrees, k as add, j as cross } from '../../Common/Core/Math/index.js';
-import { i as identity, r as rotate, t as translate, g as invert, j as transpose, s as scale, m as multiply$1, d as copy, l as lookAt, o as ortho, k as fromQuat } from '../../vendor/gl-matrix/esm/mat4.js';
-import { t as transformMat4 } from '../../vendor/gl-matrix/esm/vec4.js';
-import { t as transformMat4$1, s as set, a as subtract, n as normalize } from '../../vendor/gl-matrix/esm/vec3.js';
-import { f as fromValues, c as create, a as conjugate, m as multiply, s as setAxisAngle } from '../../vendor/gl-matrix/esm/quat.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro;
 /* eslint-disable new-cap */
@@ -29,12 +26,12 @@ function vtkCamera(publicAPI, model) {
   var origin = new Float64Array(3);
   var dopbasis = new Float64Array([0.0, 0.0, -1.0]);
   var upbasis = new Float64Array([0.0, 1.0, 0.0]);
-  var tmpMatrix = identity(new Float64Array(16));
+  var tmpMatrix = mat4.identity(new Float64Array(16));
   var tmpvec1 = new Float64Array(3);
   var tmpvec2 = new Float64Array(3);
   var tmpvec3 = new Float64Array(3);
-  var rotateMatrix = identity(new Float64Array(16));
-  var trans = identity(new Float64Array(16));
+  var rotateMatrix = mat4.identity(new Float64Array(16));
+  var trans = mat4.identity(new Float64Array(16));
   var newPosition = new Float64Array(3);
   var newFocalPoint = new Float64Array(3); // Internal Functions that don't need to be public
 
@@ -143,10 +140,10 @@ function vtkCamera(publicAPI, model) {
     var at = model.focalPoint;
     var up = model.viewUp;
     var viewUpVec4 = new Float64Array([up[0], up[1], up[2], 0.0]);
-    identity(rotateMatrix);
+    mat4.identity(rotateMatrix);
     var viewDir = new Float64Array([at[0] - eye[0], at[1] - eye[1], at[2] - eye[2]]);
-    rotate(rotateMatrix, rotateMatrix, radiansFromDegrees(angle), viewDir);
-    transformMat4(viewUpVec4, viewUpVec4, rotateMatrix);
+    mat4.rotate(rotateMatrix, rotateMatrix, radiansFromDegrees(angle), viewDir);
+    vec4.transformMat4(viewUpVec4, viewUpVec4, rotateMatrix);
     model.viewUp[0] = viewUpVec4[0];
     model.viewUp[1] = viewUpVec4[1];
     model.viewUp[2] = viewUpVec4[2];
@@ -155,29 +152,29 @@ function vtkCamera(publicAPI, model) {
 
   publicAPI.azimuth = function (angle) {
     var fp = model.focalPoint;
-    identity(trans); // translate the focal point to the origin,
+    mat4.identity(trans); // translate the focal point to the origin,
     // rotate about view up,
     // translate back again
 
-    translate(trans, trans, fp);
-    rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
-    translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
+    mat4.translate(trans, trans, fp);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
+    mat4.translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
 
-    transformMat4$1(newPosition, model.position, trans);
+    vec3.transformMat4(newPosition, model.position, trans);
     publicAPI.setPosition(newPosition[0], newPosition[1], newPosition[2]);
   };
 
   publicAPI.yaw = function (angle) {
     var position = model.position;
-    identity(trans); // translate the camera to the origin,
+    mat4.identity(trans); // translate the camera to the origin,
     // rotate about axis,
     // translate back again
 
-    translate(trans, trans, position);
-    rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
-    translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the position
+    mat4.translate(trans, trans, position);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), model.viewUp);
+    mat4.translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the position
 
-    transformMat4$1(newFocalPoint, model.focalPoint, trans);
+    vec3.transformMat4(newFocalPoint, model.focalPoint, trans);
     publicAPI.setFocalPoint(newFocalPoint[0], newFocalPoint[1], newFocalPoint[2]);
   };
 
@@ -186,15 +183,15 @@ function vtkCamera(publicAPI, model) {
 
     var vt = publicAPI.getViewMatrix();
     var axis = [-vt[0], -vt[1], -vt[2]];
-    identity(trans); // translate the focal point to the origin,
+    mat4.identity(trans); // translate the focal point to the origin,
     // rotate about view up,
     // translate back again
 
-    translate(trans, trans, fp);
-    rotate(trans, trans, radiansFromDegrees(angle), axis);
-    translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
+    mat4.translate(trans, trans, fp);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), axis);
+    mat4.translate(trans, trans, [-fp[0], -fp[1], -fp[2]]); // apply the transform to the position
 
-    transformMat4$1(newPosition, model.position, trans);
+    vec3.transformMat4(newPosition, model.position, trans);
     publicAPI.setPosition(newPosition[0], newPosition[1], newPosition[2]);
   };
 
@@ -202,15 +199,15 @@ function vtkCamera(publicAPI, model) {
     var position = model.position;
     var vt = publicAPI.getViewMatrix();
     var axis = [vt[0], vt[1], vt[2]];
-    identity(trans); // translate the camera to the origin,
+    mat4.identity(trans); // translate the camera to the origin,
     // rotate about axis,
     // translate back again
 
-    translate(trans, trans, position);
-    rotate(trans, trans, radiansFromDegrees(angle), axis);
-    translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the focal point
+    mat4.translate(trans, trans, position);
+    mat4.rotate(trans, trans, radiansFromDegrees(angle), axis);
+    mat4.translate(trans, trans, [-position[0], -position[1], -position[2]]); // apply the transform to the focal point
 
-    transformMat4$1(newFocalPoint, model.focalPoint, trans);
+    vec3.transformMat4(newFocalPoint, model.focalPoint, trans);
     publicAPI.setFocalPoint.apply(publicAPI, _toConsumableArray(newFocalPoint));
   };
 
@@ -236,7 +233,7 @@ function vtkCamera(publicAPI, model) {
     publicAPI.modified();
   };
 
-  publicAPI.applyTransform = function (transformMat4$1) {
+  publicAPI.applyTransform = function (transformMat4) {
     var vuOld = [].concat(_toConsumableArray(model.viewUp), [1.0]);
     var posNew = [];
     var fpNew = [];
@@ -244,9 +241,9 @@ function vtkCamera(publicAPI, model) {
     vuOld[0] += model.position[0];
     vuOld[1] += model.position[1];
     vuOld[2] += model.position[2];
-    transformMat4(posNew, [].concat(_toConsumableArray(model.position), [1.0]), transformMat4$1);
-    transformMat4(fpNew, [].concat(_toConsumableArray(model.focalPoint), [1.0]), transformMat4$1);
-    transformMat4(vuNew, vuOld, transformMat4$1);
+    vec4.transformMat4(posNew, [].concat(_toConsumableArray(model.position), [1.0]), transformMat4);
+    vec4.transformMat4(fpNew, [].concat(_toConsumableArray(model.focalPoint), [1.0]), transformMat4);
+    vec4.transformMat4(vuNew, vuOld, transformMat4);
     vuNew[0] -= posNew[0];
     vuNew[1] -= posNew[1];
     vuNew[2] -= posNew[2];
@@ -302,24 +299,24 @@ function vtkCamera(publicAPI, model) {
 
   publicAPI.physicalOrientationToWorldDirection = function (ori) {
     // push the x axis through the orientation quat
-    var oriq = fromValues(ori[0], ori[1], ori[2], ori[3]);
-    var coriq = create();
-    var qdir = fromValues(0.0, 0.0, 1.0, 0.0);
-    conjugate(coriq, oriq); // rotate the z axis by the quat
+    var oriq = quat.fromValues(ori[0], ori[1], ori[2], ori[3]);
+    var coriq = quat.create();
+    var qdir = quat.fromValues(0.0, 0.0, 1.0, 0.0);
+    quat.conjugate(coriq, oriq); // rotate the z axis by the quat
 
-    multiply(qdir, oriq, qdir);
-    multiply(qdir, qdir, coriq); // return the z axis in world coords
+    quat.multiply(qdir, oriq, qdir);
+    quat.multiply(qdir, qdir, coriq); // return the z axis in world coords
 
     return [qdir[0], qdir[1], qdir[2]];
   };
 
   publicAPI.getPhysicalToWorldMatrix = function (result) {
     publicAPI.getWorldToPhysicalMatrix(result);
-    invert(result, result);
+    mat4.invert(result, result);
   };
 
   publicAPI.getWorldToPhysicalMatrix = function (result) {
-    identity(result); // now the physical to vtk world rotation tform
+    mat4.identity(result); // now the physical to vtk world rotation tform
 
     var physVRight = [3];
     cross(model.physicalViewNorth, model.physicalViewUp, physVRight);
@@ -332,15 +329,15 @@ function vtkCamera(publicAPI, model) {
     result[8] = -model.physicalViewNorth[0];
     result[9] = -model.physicalViewNorth[1];
     result[10] = -model.physicalViewNorth[2];
-    transpose(result, result);
-    set(tmpvec1, 1 / model.physicalScale, 1 / model.physicalScale, 1 / model.physicalScale);
-    scale(result, result, tmpvec1);
-    translate(result, result, model.physicalTranslation);
+    mat4.transpose(result, result);
+    vec3.set(tmpvec1, 1 / model.physicalScale, 1 / model.physicalScale, 1 / model.physicalScale);
+    mat4.scale(result, result, tmpvec1);
+    mat4.translate(result, result, model.physicalTranslation);
   };
 
   publicAPI.computeViewParametersFromViewMatrix = function (vmat) {
     // invert to get view to world
-    invert(tmpMatrix, vmat); // note with glmatrix operations happen in
+    mat4.invert(tmpMatrix, vmat); // note with glmatrix operations happen in
     // the reverse order
     // mat.scale
     // mat.translate
@@ -350,18 +347,18 @@ function vtkCamera(publicAPI, model) {
     // then extract the params position, orientation
     // push 0,0,0 through to get a translation
 
-    transformMat4$1(tmpvec1, origin, tmpMatrix);
+    vec3.transformMat4(tmpvec1, origin, tmpMatrix);
     publicAPI.computeDistance();
     var oldDist = model.distance;
     publicAPI.setPosition(tmpvec1[0], tmpvec1[1], tmpvec1[2]); // push basis vectors to get orientation
 
-    transformMat4$1(tmpvec2, dopbasis, tmpMatrix);
-    subtract(tmpvec2, tmpvec2, tmpvec1);
-    normalize(tmpvec2, tmpvec2);
+    vec3.transformMat4(tmpvec2, dopbasis, tmpMatrix);
+    vec3.subtract(tmpvec2, tmpvec2, tmpvec1);
+    vec3.normalize(tmpvec2, tmpvec2);
     publicAPI.setDirectionOfProjection(tmpvec2[0], tmpvec2[1], tmpvec2[2]);
-    transformMat4$1(tmpvec3, upbasis, tmpMatrix);
-    subtract(tmpvec3, tmpvec3, tmpvec1);
-    normalize(tmpvec3, tmpvec3);
+    vec3.transformMat4(tmpvec3, upbasis, tmpMatrix);
+    vec3.subtract(tmpvec3, tmpvec3, tmpvec1);
+    vec3.normalize(tmpvec3, tmpvec3);
     publicAPI.setViewUp(tmpvec3[0], tmpvec3[1], tmpvec3[2]);
     publicAPI.setDistance(oldDist);
   }; // the provided matrix should include
@@ -374,7 +371,7 @@ function vtkCamera(publicAPI, model) {
     publicAPI.getWorldToPhysicalMatrix(tmpMatrix); // first convert the physical -> view matrix to be
     // world -> view
 
-    multiply$1(tmpMatrix, mat, tmpMatrix);
+    mat4.multiply(tmpMatrix, mat, tmpMatrix);
     publicAPI.computeViewParametersFromViewMatrix(tmpMatrix);
   };
 
@@ -382,9 +379,9 @@ function vtkCamera(publicAPI, model) {
     model.viewMatrix = mat;
 
     if (model.viewMatrix) {
-      copy(tmpMatrix, model.viewMatrix);
+      mat4.copy(tmpMatrix, model.viewMatrix);
       publicAPI.computeViewParametersFromViewMatrix(tmpMatrix);
-      transpose(model.viewMatrix, model.viewMatrix);
+      mat4.transpose(model.viewMatrix, model.viewMatrix);
     }
   };
 
@@ -393,13 +390,13 @@ function vtkCamera(publicAPI, model) {
       return model.viewMatrix;
     }
 
-    lookAt(tmpMatrix, model.position, // eye
+    mat4.lookAt(tmpMatrix, model.position, // eye
     model.focalPoint, // at
     model.viewUp // up
     );
-    transpose(tmpMatrix, tmpMatrix);
+    mat4.transpose(tmpMatrix, tmpMatrix);
     var result = new Float64Array(16);
-    copy(result, tmpMatrix);
+    mat4.copy(result, tmpMatrix);
     return result;
   };
 
@@ -409,18 +406,18 @@ function vtkCamera(publicAPI, model) {
 
   publicAPI.getProjectionMatrix = function (aspect, nearz, farz) {
     var result = new Float64Array(16);
-    identity(result);
+    mat4.identity(result);
 
     if (model.projectionMatrix) {
-      var scale$1 = 1 / model.physicalScale;
-      set(tmpvec1, scale$1, scale$1, scale$1);
-      copy(result, model.projectionMatrix);
-      scale(result, result, tmpvec1);
-      transpose(result, result);
+      var scale = 1 / model.physicalScale;
+      vec3.set(tmpvec1, scale, scale, scale);
+      mat4.copy(result, model.projectionMatrix);
+      mat4.scale(result, result, tmpvec1);
+      mat4.transpose(result, result);
       return result;
     }
 
-    identity(tmpMatrix); // FIXME: Not sure what to do about adjust z buffer here
+    mat4.identity(tmpMatrix); // FIXME: Not sure what to do about adjust z buffer here
     // adjust Z-buffer range
     // this->ProjectionTransform->AdjustZBuffer( -1, +1, nearz, farz );
 
@@ -435,8 +432,8 @@ function vtkCamera(publicAPI, model) {
       var xmax = (model.windowCenter[0] + 1.0) * width;
       var ymin = (model.windowCenter[1] - 1.0) * height;
       var ymax = (model.windowCenter[1] + 1.0) * height;
-      ortho(tmpMatrix, xmin, xmax, ymin, ymax, cRange[0], cRange[1]);
-      transpose(tmpMatrix, tmpMatrix);
+      mat4.ortho(tmpMatrix, xmin, xmax, ymin, ymax, cRange[0], cRange[1]);
+      mat4.transpose(tmpMatrix, tmpMatrix);
     } else if (model.useOffAxisProjection) {
       throw new Error('Off-Axis projection is not supported at this time');
     } else {
@@ -474,7 +471,7 @@ function vtkCamera(publicAPI, model) {
       tmpMatrix[15] = 0.0;
     }
 
-    copy(result, tmpMatrix);
+    mat4.copy(result, tmpMatrix);
     return result;
   };
 
@@ -483,7 +480,7 @@ function vtkCamera(publicAPI, model) {
     var pMat = publicAPI.getProjectionMatrix(aspect, nearz, farz); // mats are transposed so the order is A then B
     // we reuse pMat as it is a copy so we can do what we want with it
 
-    multiply$1(pMat, vMat, pMat);
+    mat4.multiply(pMat, vMat, pMat);
     return pMat;
   };
 
@@ -523,35 +520,35 @@ function vtkCamera(publicAPI, model) {
     var physVRight = [3];
     cross(model.physicalViewNorth, model.physicalViewUp, physVRight); // phone to physical coordinates
 
-    var rotmat = identity(new Float64Array(16));
-    rotate(rotmat, rotmat, radiansFromDegrees(alpha), model.physicalViewUp);
-    rotate(rotmat, rotmat, radiansFromDegrees(beta), physVRight);
-    rotate(rotmat, rotmat, radiansFromDegrees(gamma), model.physicalViewNorth);
-    rotate(rotmat, rotmat, radiansFromDegrees(-screen), model.physicalViewUp);
+    var rotmat = mat4.identity(new Float64Array(16));
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(alpha), model.physicalViewUp);
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(beta), physVRight);
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(gamma), model.physicalViewNorth);
+    mat4.rotate(rotmat, rotmat, radiansFromDegrees(-screen), model.physicalViewUp);
     var dop = new Float64Array([-model.physicalViewUp[0], -model.physicalViewUp[1], -model.physicalViewUp[2]]);
     var vup = new Float64Array(model.physicalViewNorth);
-    transformMat4$1(dop, dop, rotmat);
-    transformMat4$1(vup, vup, rotmat);
+    vec3.transformMat4(dop, dop, rotmat);
+    vec3.transformMat4(vup, vup, rotmat);
     publicAPI.setDirectionOfProjection(dop[0], dop[1], dop[2]);
     publicAPI.setViewUp(vup[0], vup[1], vup[2]);
     publicAPI.modified();
   };
 
   publicAPI.setOrientationWXYZ = function (degrees, x, y, z) {
-    var quatMat = identity(new Float64Array(16));
+    var quatMat = mat4.identity(new Float64Array(16));
 
     if (degrees !== 0.0 && (x !== 0.0 || y !== 0.0 || z !== 0.0)) {
       // convert to radians
       var angle = radiansFromDegrees(degrees);
-      var q = create();
-      setAxisAngle(q, [x, y, z], angle);
-      fromQuat(quatMat, q);
+      var q = quat.create();
+      quat.setAxisAngle(q, [x, y, z], angle);
+      mat4.fromQuat(quatMat, q);
     }
 
     var newdop = new Float64Array(3);
-    transformMat4$1(newdop, [0.0, 0.0, -1.0], quatMat);
+    vec3.transformMat4(newdop, [0.0, 0.0, -1.0], quatMat);
     var newvup = new Float64Array(3);
-    transformMat4$1(newvup, [0.0, 1.0, 0.0], quatMat);
+    vec3.transformMat4(newvup, [0.0, 1.0, 0.0], quatMat);
     publicAPI.setDirectionOfProjection.apply(publicAPI, _toConsumableArray(newdop));
     publicAPI.setViewUp.apply(publicAPI, _toConsumableArray(newvup));
     publicAPI.modified();

package/Rendering/Core/CellPicker.js

@@ -4,7 +4,7 @@ import { l as normalize } from '../../Common/Core/Math/index.js';
 import vtkPicker from './Picker.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
-import { t as transformMat4 } 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; }
 
@@ -198,7 +198,7 @@ function vtkCellPicker(publicAPI, model) {
         model.mapperNormal[2] = -plane[2];
       }
 
-      transformMat4(model.pickPosition, model.mapperPosition, model.transformMatrix); // Transform vector
+      vec3.transformMat4(model.pickPosition, model.mapperPosition, model.transformMatrix); // Transform vector
 
       var mat = model.transformMatrix;
       model.mapperNormal[0] = mat[0] * model.pickNormal[0] + mat[4] * model.pickNormal[1] + mat[8] * model.pickNormal[2];