@kitware/vtk.js 22.5.5 → 22.5.8

package/Common/Core/Math/index.js

@@ -2329,4 +2329,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { binomial as $, clampValue as A, projectVector as B, arrayRange as C, getMajorAxisIndex as D, isInf as E, rgb2hsv as F, rgb2lab as G, lab2rgb as H, floor as I, round as J, nearestPowerOfTwo as K, normalize2D as L, createUninitializedBounds as M, multiply3x3_vect3 as N, areBoundsInitialized as O, isPowerOfTwo as P, multiplyAccumulate as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, dot2D as a8, projectVector2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, gaussianAmplitude as aa, gaussianWeight as ab, outer2D as ac, norm2D as ad, LUFactor3x3 as ae, LUSolve3x3 as af, linearSolve3x3 as ag, multiply3x3_mat3 as ah, multiplyMatrix as ai, transpose3x3 as aj, invert3x3 as ak, identity3x3 as al, quaternionToMatrix3x3 as am, roundNumber as an, matrix3x3ToQuaternion as ao, multiplyQuaternion as ap, orthogonalize3x3 as aq, diagonalize3x3 as ar, singularValueDecomposition3x3 as as, luFactorLinearSystem as at, luSolveLinearSystem as au, invertMatrix as av, estimateMatrixCondition as aw, jacobi as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, subtract as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, determinant2x2 as m, norm as n, jacobiN as o, perpendiculars as p, vtkMath as q, radiansFromDegrees as r, solveLinearSystem as s, multiplyScalar as t, uninitializeBounds as u, vtkMath$1 as v, random as w, determinant3x3 as x, degreesFromRadians as y, areEquals as z };
+export { binomial as $, clampValue as A, projectVector as B, arrayRange as C, getMajorAxisIndex as D, isInf as E, rgb2hsv as F, rgb2lab as G, lab2rgb as H, floor as I, round as J, normalize2D as K, nearestPowerOfTwo as L, createUninitializedBounds as M, multiply3x3_vect3 as N, areBoundsInitialized as O, isPowerOfTwo as P, multiplyAccumulate as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, dot2D as a8, projectVector2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, gaussianAmplitude as aa, gaussianWeight as ab, outer2D as ac, norm2D as ad, LUFactor3x3 as ae, LUSolve3x3 as af, linearSolve3x3 as ag, multiply3x3_mat3 as ah, multiplyMatrix as ai, transpose3x3 as aj, invert3x3 as ak, identity3x3 as al, quaternionToMatrix3x3 as am, roundNumber as an, matrix3x3ToQuaternion as ao, multiplyQuaternion as ap, orthogonalize3x3 as aq, diagonalize3x3 as ar, singularValueDecomposition3x3 as as, luFactorLinearSystem as at, luSolveLinearSystem as au, invertMatrix as av, estimateMatrixCondition as aw, jacobi as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, subtract as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, determinant2x2 as m, norm as n, jacobiN as o, perpendiculars as p, vtkMath as q, radiansFromDegrees as r, solveLinearSystem as s, multiplyScalar as t, uninitializeBounds as u, vtkMath$1 as v, random as w, determinant3x3 as x, degreesFromRadians as y, areEquals as z };

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import '@babel/runtime/helpers/slicedToArray';
 import 'seedrandom';
 import '../../macros.js';
-export { ae as LUFactor3x3, af as LUSolve3x3, T as Pi, k as add, R as angleBetweenVectors, O as areBoundsInitialized, z as areEquals, a as areMatricesEqual, Y as arrayMax, X as arrayMin, C as arrayRange, a0 as beginCombination, $ as binomial, aJ as boundsIsWithinOtherBounds, U as ceil, Z as ceilLog2, aF as clampAndNormalizeValue, A as clampValue, e as clampVector, c as computeBoundsFromPoints, M as createUninitializedBounds, j as cross, q as default, y as degreesFromRadians, m as determinant2x2, x as determinant3x3, ar as diagonalize3x3, f as distance2BetweenPoints, d as dot, a8 as dot2D, aw as estimateMatrixCondition, aI as extentIsWithinOtherExtent, _ as factorial, aS as float2CssRGBA, aR as floatRGB2HexCode, aQ as floatToHex2, I as floor, a4 as gaussian, aa as gaussianAmplitude, ab as gaussianWeight, aH as getAdjustedScalarRange, D as getMajorAxisIndex, aG as getScalarTypeFittingRange, a3 as getSeed, aA as hex2float, h as hsv2rgb, al as identity3x3, aM as inf, ak as invert3x3, av as invertMatrix, aO as isFinite, E as isInf, aP as isNaN, i as isNan, P as isPowerOfTwo, ax as jacobi, o as jacobiN, H as lab2rgb, aB as lab2xyz, ag as linearSolve3x3, at as luFactorLinearSystem, au as luSolveLinearSystem, ao as matrix3x3ToQuaternion, W as max, V as min, ah as multiply3x3_mat3, N as multiply3x3_vect3, Q as multiplyAccumulate, a6 as multiplyAccumulate2D, ai as multiplyMatrix, ap as multiplyQuaternion, t as multiplyScalar, a5 as multiplyScalar2D, K as nearestPowerOfTwo, aN as negInf, a1 as nextCombination, n as norm, ad as norm2D, l as normalize, L as normalize2D, aq as orthogonalize3x3, a7 as outer, ac as outer2D, p as perpendiculars, aK as pointIsWithinBounds, B as projectVector, a9 as projectVector2D, am as quaternionToMatrix3x3, r as radiansFromDegrees, w as random, a2 as randomSeed, F as rgb2hsv, G as rgb2lab, aE as rgb2xyz, J as round, an as roundNumber, b as roundVector, S as signedAngleBetweenVectors, as as singularValueDecomposition3x3, aL as solve3PointCircle, ay as solveHomogeneousLeastSquares, az as solveLeastSquares, s as solveLinearSystem, g as subtract, aj as transpose3x3, u as uninitializeBounds, aC as xyz2lab, aD as xyz2rgb } from './Math/index.js';
+export { ae as LUFactor3x3, af as LUSolve3x3, T as Pi, k as add, R as angleBetweenVectors, O as areBoundsInitialized, z as areEquals, a as areMatricesEqual, Y as arrayMax, X as arrayMin, C as arrayRange, a0 as beginCombination, $ as binomial, aJ as boundsIsWithinOtherBounds, U as ceil, Z as ceilLog2, aF as clampAndNormalizeValue, A as clampValue, e as clampVector, c as computeBoundsFromPoints, M as createUninitializedBounds, j as cross, q as default, y as degreesFromRadians, m as determinant2x2, x as determinant3x3, ar as diagonalize3x3, f as distance2BetweenPoints, d as dot, a8 as dot2D, aw as estimateMatrixCondition, aI as extentIsWithinOtherExtent, _ as factorial, aS as float2CssRGBA, aR as floatRGB2HexCode, aQ as floatToHex2, I as floor, a4 as gaussian, aa as gaussianAmplitude, ab as gaussianWeight, aH as getAdjustedScalarRange, D as getMajorAxisIndex, aG as getScalarTypeFittingRange, a3 as getSeed, aA as hex2float, h as hsv2rgb, al as identity3x3, aM as inf, ak as invert3x3, av as invertMatrix, aO as isFinite, E as isInf, aP as isNaN, i as isNan, P as isPowerOfTwo, ax as jacobi, o as jacobiN, H as lab2rgb, aB as lab2xyz, ag as linearSolve3x3, at as luFactorLinearSystem, au as luSolveLinearSystem, ao as matrix3x3ToQuaternion, W as max, V as min, ah as multiply3x3_mat3, N as multiply3x3_vect3, Q as multiplyAccumulate, a6 as multiplyAccumulate2D, ai as multiplyMatrix, ap as multiplyQuaternion, t as multiplyScalar, a5 as multiplyScalar2D, L as nearestPowerOfTwo, aN as negInf, a1 as nextCombination, n as norm, ad as norm2D, l as normalize, K as normalize2D, aq as orthogonalize3x3, a7 as outer, ac as outer2D, p as perpendiculars, aK as pointIsWithinBounds, B as projectVector, a9 as projectVector2D, am as quaternionToMatrix3x3, r as radiansFromDegrees, w as random, a2 as randomSeed, F as rgb2hsv, G as rgb2lab, aE as rgb2xyz, J as round, an as roundNumber, b as roundVector, S as signedAngleBetweenVectors, as as singularValueDecomposition3x3, aL as solve3PointCircle, ay as solveHomogeneousLeastSquares, az as solveLeastSquares, s as solveLinearSystem, g as subtract, aj as transpose3x3, u as uninitializeBounds, aC as xyz2lab, aD as xyz2rgb } from './Math/index.js';

package/Rendering/Core/CubeAxesActor.js

@@ -1,14 +1,13 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { mat4, vec3 } from 'gl-matrix';
+import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { K as nearestPowerOfTwo, L as normalize2D } from '../../Common/Core/Math/index.js';
+import { K as normalize2D, L as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkMapper from './Mapper.js';
-import vtkPixelSpaceCallbackMapper from './PixelSpaceCallbackMapper.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTexture from './Texture.js';
 
@@ -24,7 +23,17 @@ var faceNormals = [[-1, 0, 0], [1, 0, 0], [0, -1, 0], [0, 1, 0], [0, 0, -1], [0,
 var faceEdges = [[8, 7, 11, 3], [9, 1, 10, 5], [4, 9, 0, 8], [2, 11, 6, 10], [0, 3, 2, 1], [4, 5, 6, 7]];
 var edgePoints = [[0, 1], [1, 3], [2, 3], [0, 2], [4, 5], [5, 7], [6, 7], [4, 6], [0, 4], [1, 5], [3, 7], [2, 6]];
 var edgeAxes = [0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2];
-var faceAxes = [[1, 2], [1, 2], [0, 2], [0, 2], [0, 1], [0, 1]]; // some shared temp variables to reduce heap allocs
+var faceAxes = [[1, 2], [1, 2], [0, 2], [0, 2], [0, 1], [0, 1]]; //
+// Developer note: This class is broken into the main class and a helper
+// class. The main class holds view independent properties (those properties
+// that do not change as the view's resolution/aspect ratio change). The
+// helper class is instantiated one per view and holds properties that can
+// depend on view specific values such as resolution. The helper class code
+// could have been left to the View specific implementation (such as
+// vtkWebGPUCubeAxesActor) but is instead placed here to it can be shared by
+// multiple rendering backends.
+//
+// some shared temp variables to reduce heap allocs
 
 var ptv3 = new Float64Array(3);
 var pt2v3 = new Float64Array(3);
@@ -39,8 +48,238 @@ function applyTextStyle(ctx, style) {
   ctx.lineWidth = style.strokeSize;
   ctx.fillStyle = style.fontColor;
   ctx.font = "".concat(style.fontStyle, " ").concat(style.fontSize, "px ").concat(style.fontFamily);
+} // many properties of this actor depend on the API specific view The main
+// dependency being the resolution as that drives what font sizes to use.
+// Bacause of this we need to do some of the calculations in a API specific
+// subclass. But... we don't want a lot of duplicated code between WebGL and
+// WebGPU for example so we have this helper class, that is designed to be
+// fairly API independent so that API specific views can call this to do
+// most of the work.
+
+
+function vtkCubeAxesActorHelper(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkCubeAxesActorHelper');
+
+  publicAPI.setRenderable = function (renderable) {
+    if (model.renderable === renderable) {
+      return;
+    }
+
+    model.renderable = renderable;
+    model.tmActor.addTexture(model.renderable.getTmTexture());
+    model.tmActor.setProperty(renderable.getProperty());
+    model.tmActor.setParentProp(renderable);
+    publicAPI.modified();
+  }; // called by updateTexturePolyData
+
+
+  publicAPI.createPolyDataForOneLabel = function (text, pos, cmat, imat, dir, offset, results) {
+    var value = model.renderable.get_tmAtlas().get(text);
+
+    if (!value) {
+      return;
+    }
+
+    var coords = model.renderable.getTextPolyData().getPoints().getData(); // compute pixel to distance factors
+
+    var size = model.lastSize;
+    ptv3[0] = coords[pos * 3];
+    ptv3[1] = coords[pos * 3 + 1];
+    ptv3[2] = coords[pos * 3 + 2];
+    vec3.transformMat4(tmpv3, ptv3, cmat); // moving 0.1 in NDC
+
+    tmpv3[0] += 0.1;
+    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
+
+    vec3.subtract(xDir, pt2v3, ptv3);
+    tmpv3[0] -= 0.1;
+    tmpv3[1] += 0.1;
+    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
+
+    vec3.subtract(yDir, pt2v3, ptv3);
+
+    for (var i = 0; i < 3; i++) {
+      xDir[i] /= 0.5 * 0.1 * size[0];
+      yDir[i] /= 0.5 * 0.1 * size[1];
+    } // have to find the four corners of the texture polygon for this label
+    // convert anchor point to View Coords
+
+
+    var ptIdx = results.ptIdx;
+    var cellIdx = results.cellIdx;
+    ptv3[0] = coords[pos * 3];
+    ptv3[1] = coords[pos * 3 + 1];
+    ptv3[2] = coords[pos * 3 + 2]; // horizontal left, right, or middle alignment based on dir[0]
+
+    if (dir[0] < -0.5) {
+      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width);
+    } else if (dir[0] > 0.5) {
+      vec3.scale(tmpv3, xDir, dir[0] * offset);
+    } else {
+      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width / 2.0);
+    }
+
+    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++;
+    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++;
+    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++;
+    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];
+    results.tcoords[ptIdx * 2] = value.tcoords[6];
+    results.tcoords[ptIdx * 2 + 1] = value.tcoords[7];
+    ptIdx++; // add the two triangles to represent the quad
+
+    results.polys[cellIdx * 4] = 3;
+    results.polys[cellIdx * 4 + 1] = ptIdx - 4;
+    results.polys[cellIdx * 4 + 2] = ptIdx - 3;
+    results.polys[cellIdx * 4 + 3] = ptIdx - 2;
+    cellIdx++;
+    results.polys[cellIdx * 4] = 3;
+    results.polys[cellIdx * 4 + 1] = ptIdx - 4;
+    results.polys[cellIdx * 4 + 2] = ptIdx - 2;
+    results.polys[cellIdx * 4 + 3] = ptIdx - 1;
+    results.ptIdx += 4;
+    results.cellIdx += 2;
+  }; // update the polydata associated with drawing the text labels
+  // specifically the quads used for each label and their associated tcoords
+  // etc. This changes every time the camera viewpoint changes
+
+
+  publicAPI.updateTexturePolyData = function () {
+    var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
+    mat4.transpose(cmat, cmat); // update the polydata
+
+    var numLabels = model.renderable.getTextValues().length;
+    var numPts = numLabels * 4;
+    var numTris = numLabels * 2;
+    var points = new Float64Array(numPts * 3);
+    var polys = new Uint16Array(numTris * 4);
+    var tcoords = new Float32Array(numPts * 2);
+    mat4.invert(invmat, cmat);
+    var results = {
+      ptIdx: 0,
+      cellIdx: 0,
+      polys: polys,
+      points: points,
+      tcoords: tcoords
+    };
+    var ptIdx = 0;
+    var textIdx = 0;
+    var axisIdx = 0;
+    var coords = model.renderable.getTextPolyData().getPoints().getData();
+    var textValues = model.renderable.getTextValues();
+
+    while (ptIdx < coords.length / 3) {
+      // compute the direction to move out
+      ptv3[0] = coords[ptIdx * 3];
+      ptv3[1] = coords[ptIdx * 3 + 1];
+      ptv3[2] = coords[ptIdx * 3 + 2];
+      vec3.transformMat4(tmpv3, ptv3, cmat);
+      ptv3[0] = coords[ptIdx * 3 + 3];
+      ptv3[1] = coords[ptIdx * 3 + 4];
+      ptv3[2] = coords[ptIdx * 3 + 5];
+      vec3.transformMat4(tmp2v3, ptv3, cmat);
+      vec3.subtract(tmpv3, tmpv3, tmp2v3);
+      var dir = [tmpv3[0], tmpv3[1]];
+      normalize2D(dir); // write the axis label
+
+      publicAPI.createPolyDataForOneLabel(textValues[textIdx], ptIdx, cmat, invmat, dir, model.renderable.getAxisTitlePixelOffset(), results);
+      ptIdx += 2;
+      textIdx++; // write the tick labels
+
+      for (var t = 0; t < model.renderable.getTickCounts()[axisIdx]; t++) {
+        publicAPI.createPolyDataForOneLabel(textValues[textIdx], ptIdx, cmat, invmat, dir, model.renderable.getTickLabelPixelOffset(), results);
+        ptIdx++;
+        textIdx++;
+      }
+
+      axisIdx++;
+    }
+
+    var tcoordDA = vtkDataArray.newInstance({
+      numberOfComponents: 2,
+      values: tcoords,
+      name: 'TextureCoordinates'
+    });
+    model.tmPolyData.getPointData().setTCoords(tcoordDA);
+    model.tmPolyData.getPoints().setData(points, 3);
+    model.tmPolyData.getPoints().modified();
+    model.tmPolyData.getPolys().setData(polys, 1);
+    model.tmPolyData.getPolys().modified();
+    model.tmPolyData.modified();
+  };
+
+  publicAPI.updateAPISpecificData = function (size, camera, renderWindow) {
+    // has the size changed?
+    if (model.lastSize[0] !== size[0] || model.lastSize[1] !== size[1]) {
+      model.lastSize[0] = size[0];
+      model.lastSize[1] = size[1];
+      model.lastAspectRatio = size[0] / size[1];
+      model.forceUpdate = true;
+    }
+
+    model.camera = camera; // compute bounds for label quads whenever the camera changes
+
+    publicAPI.updateTexturePolyData();
+  };
 }
 
+var newCubeAxesActorHelper = macro.newInstance(function (publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    renderable: null
+  };
+  Object.assign(model, {}, initialValues); // Inheritance
+
+  macro.obj(publicAPI, model);
+  model.tmPolyData = vtkPolyData.newInstance();
+  model.tmMapper = vtkMapper.newInstance();
+  model.tmMapper.setInputData(model.tmPolyData);
+  model.tmActor = vtkActor.newInstance({
+    parentProp: publicAPI
+  });
+  model.tmActor.setMapper(model.tmMapper);
+  macro.setGet(publicAPI, model, ['renderable']);
+  macro.get(publicAPI, model, ['lastSize', 'lastAspectRatio', 'axisTextStyle', 'tickTextStyle', 'tmActor', 'ticks']);
+  model.forceUpdate = false;
+  model.lastRedrawTime = {};
+  macro.obj(model.lastRedrawTime, {
+    mtime: 0
+  });
+  model.lastRebuildTime = {};
+  macro.obj(model.lastRebuildTime, {
+    mtime: 0
+  });
+  model.lastSize = [-1, -1]; // internal variables
+
+  model.lastTickBounds = [];
+  vtkCubeAxesActorHelper(publicAPI, model);
+}, 'vtkCubeAxesActorHelper');
+
 function vtkCubeAxesActor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCubeAxesActor');
@@ -341,10 +580,8 @@ function vtkCubeAxesActor(publicAPI, model) {
       if (boundsChanged || model.forceUpdate) {
         publicAPI.updateTextureAtlas(tickStrings);
       }
-    } // compute bounds for label quads whenever the camera changes
-
+    }
 
-    publicAPI.updateTexturePolyData();
     model.forceUpdate = false;
   }; // create the texture map atlas that contains the rendering of
   // all the text strings. Only needs to be called when the text strings
@@ -428,178 +665,8 @@ function vtkCubeAxesActor(publicAPI, model) {
       model.tmContext.fillText(key, 1, value.startingHeight + value.height - 1);
     });
 
-    var image = new Image();
-    image.src = model.tmCanvas.toDataURL('image/png');
-    model.tmTexture.setImage(image);
+    model.tmTexture.setCanvas(model.tmCanvas);
     model.tmTexture.modified();
-  }; // called by updateTexturePolyData
-
-
-  publicAPI.createPolyDataForOneLabel = function (text, pos, cmat, imat, dir, offset, results) {
-    var value = model._tmAtlas.get(text);
-
-    if (!value) {
-      return;
-    }
-
-    var coords = model.textPolyData.getPoints().getData(); // compute pixel to distance factors
-
-    var size = model.lastSize;
-    ptv3[0] = coords[pos * 3];
-    ptv3[1] = coords[pos * 3 + 1];
-    ptv3[2] = coords[pos * 3 + 2];
-    vec3.transformMat4(tmpv3, ptv3, cmat); // moving 0.1 in NDC
-
-    tmpv3[0] += 0.1;
-    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
-
-    vec3.subtract(xDir, pt2v3, ptv3);
-    tmpv3[0] -= 0.1;
-    tmpv3[1] += 0.1;
-    vec3.transformMat4(pt2v3, tmpv3, imat); // results in WC move of
-
-    vec3.subtract(yDir, pt2v3, ptv3);
-
-    for (var i = 0; i < 3; i++) {
-      xDir[i] /= 0.5 * 0.1 * size[0];
-      yDir[i] /= 0.5 * 0.1 * size[1];
-    } // have to find the four corners of the texture polygon for this label
-    // convert anchor point to View Coords
-
-
-    var ptIdx = results.ptIdx;
-    var cellIdx = results.cellIdx;
-    ptv3[0] = coords[pos * 3];
-    ptv3[1] = coords[pos * 3 + 1];
-    ptv3[2] = coords[pos * 3 + 2]; // horizontal left, right, or middle alignment based on dir[0]
-
-    if (dir[0] < -0.5) {
-      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width);
-    } else if (dir[0] > 0.5) {
-      vec3.scale(tmpv3, xDir, dir[0] * offset);
-    } else {
-      vec3.scale(tmpv3, xDir, dir[0] * offset - value.width / 2.0);
-    }
-
-    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++;
-    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++;
-    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++;
-    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];
-    results.tcoords[ptIdx * 2] = value.tcoords[6];
-    results.tcoords[ptIdx * 2 + 1] = value.tcoords[7];
-    ptIdx++; // add the two triangles to represent the quad
-
-    results.polys[cellIdx * 4] = 3;
-    results.polys[cellIdx * 4 + 1] = ptIdx - 4;
-    results.polys[cellIdx * 4 + 2] = ptIdx - 3;
-    results.polys[cellIdx * 4 + 3] = ptIdx - 2;
-    cellIdx++;
-    results.polys[cellIdx * 4] = 3;
-    results.polys[cellIdx * 4 + 1] = ptIdx - 4;
-    results.polys[cellIdx * 4 + 2] = ptIdx - 2;
-    results.polys[cellIdx * 4 + 3] = ptIdx - 1;
-    results.ptIdx += 4;
-    results.cellIdx += 2;
-  }; // update the polydata associated with drawing the text labels
-  // specifically the quads used for each label and their associated tcoords
-  // etc. This changes every time the camera viewpoint changes
-
-
-  publicAPI.updateTexturePolyData = function () {
-    var cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
-    mat4.transpose(cmat, cmat); // update the polydata
-
-    var numLabels = model.textValues.length;
-    var numPts = numLabels * 4;
-    var numTris = numLabels * 2;
-    var points = new Float64Array(numPts * 3);
-    var polys = new Uint16Array(numTris * 4);
-    var tcoords = new Float32Array(numPts * 2);
-    mat4.invert(invmat, cmat);
-    var results = {
-      ptIdx: 0,
-      cellIdx: 0,
-      polys: polys,
-      points: points,
-      tcoords: tcoords
-    };
-    var ptIdx = 0;
-    var textIdx = 0;
-    var axisIdx = 0;
-    var coords = model.textPolyData.getPoints().getData();
-
-    while (ptIdx < coords.length / 3) {
-      // compute the direction to move out
-      ptv3[0] = coords[ptIdx * 3];
-      ptv3[1] = coords[ptIdx * 3 + 1];
-      ptv3[2] = coords[ptIdx * 3 + 2];
-      vec3.transformMat4(tmpv3, ptv3, cmat);
-      ptv3[0] = coords[ptIdx * 3 + 3];
-      ptv3[1] = coords[ptIdx * 3 + 4];
-      ptv3[2] = coords[ptIdx * 3 + 5];
-      vec3.transformMat4(tmp2v3, ptv3, cmat);
-      vec3.subtract(tmpv3, tmpv3, tmp2v3);
-      var dir = [tmpv3[0], tmpv3[1]];
-      normalize2D(dir); // write the axis label
-
-      publicAPI.createPolyDataForOneLabel(model.textValues[textIdx], ptIdx, cmat, invmat, dir, model.axisTitlePixelOffset, results);
-      ptIdx += 2;
-      textIdx++; // write the tick labels
-
-      for (var t = 0; t < model.tickCounts[axisIdx]; t++) {
-        publicAPI.createPolyDataForOneLabel(model.textValues[textIdx], ptIdx, cmat, invmat, dir, model.tickLabelPixelOffset, results);
-        ptIdx++;
-        textIdx++;
-      }
-
-      axisIdx++;
-    }
-
-    var tcoordDA = vtkDataArray.newInstance({
-      numberOfComponents: 2,
-      values: tcoords,
-      name: 'TextureCoordinates'
-    });
-    model.tmPolyData.getPointData().setTCoords(tcoordDA);
-    model.tmPolyData.getPoints().setData(points, 3);
-    model.tmPolyData.getPoints().modified();
-    model.tmPolyData.getPolys().setData(polys, 1);
-    model.tmPolyData.getPolys().modified();
-    model.tmPolyData.modified();
-  };
-
-  publicAPI.getActors = function () {
-    return [model.pixelActor, model.tmActor];
-  };
-
-  publicAPI.getNestedProps = function () {
-    return publicAPI.getActors();
   }; // Make sure the data is correct
 
 
@@ -607,11 +674,6 @@ function vtkCubeAxesActor(publicAPI, model) {
     model.forceUpdate = true;
     publicAPI.update();
   });
-  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);
@@ -658,51 +720,31 @@ function extend(publicAPI, model) {
 
   vtkActor.extend(publicAPI, model, initialValues); // internal variables
 
-  model.lastSize = [800, 800];
-  model.lastAspectRatio = 1.0;
   model.lastFacesToDraw = [false, false, false, false, false, false];
   model.axisLabels = ['X-Axis', 'Y-Axis', 'Z-Axis'];
   model.tickCounts = [];
   model.textValues = [];
   model.lastTickBounds = [];
-  model._tmAtlas = new Map();
-  model.mapper = vtkMapper.newInstance();
-  model.polyData = vtkPolyData.newInstance();
-  model.mapper.setInputData(model.polyData);
-  publicAPI.getProperty().setDiffuse(0.0);
-  publicAPI.getProperty().setAmbient(1.0);
-  model.textPolyData = vtkPolyData.newInstance(); // for texture atlas
+  model.tmCanvas = document.createElement('canvas');
+  model.tmContext = model.tmCanvas.getContext('2d');
+  model._tmAtlas = new Map(); // for texture atlas
 
-  model.tmPolyData = vtkPolyData.newInstance();
-  model.tmMapper = vtkMapper.newInstance();
-  model.tmMapper.setInputData(model.tmPolyData);
   model.tmTexture = vtkTexture.newInstance();
   model.tmTexture.setInterpolate(false);
-  model.tmActor = vtkActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.tmActor.setMapper(model.tmMapper);
-  model.tmActor.addTexture(model.tmTexture);
-  model.tmCanvas = document.createElement('canvas');
-  model.tmContext = model.tmCanvas.getContext('2d'); // PixelSpaceCallbackMapper - we do need an empty polydata
-  // really just used to get the window size which we need to do
-  // proper text positioning and scaling.
-
-  model.pixelMapper = vtkPixelSpaceCallbackMapper.newInstance();
-  model.pixelMapperPolyData = vtkPolyData.newInstance();
-  model.pixelMapper.setInputData(model.pixelMapperPolyData);
-  model.pixelMapper.setCallback(function (coords, camera, aspect, depthValues, size) {
-    model.lastSize = size;
-    model.lastAspectRatio = size[0] / size[1];
-  });
-  model.pixelActor = vtkActor.newInstance({
-    parentProp: publicAPI
-  });
-  model.pixelActor.setMapper(model.pixelMapper);
+  publicAPI.getProperty().setDiffuse(0.0);
+  publicAPI.getProperty().setAmbient(1.0);
+  model.gridMapper = vtkMapper.newInstance();
+  model.polyData = vtkPolyData.newInstance();
+  model.gridMapper.setInputData(model.polyData);
+  model.gridActor = vtkActor.newInstance();
+  model.gridActor.setMapper(model.gridMapper);
+  model.gridActor.setProperty(publicAPI.getProperty());
+  model.gridActor.setParentProp(publicAPI);
+  model.textPolyData = vtkPolyData.newInstance();
   macro.setGet(publicAPI, model, ['axisTitlePixelOffset', 'faceVisibilityAngle', 'gridLines', 'tickLabelPixelOffset']);
   macro.setGetArray(publicAPI, model, ['dataBounds'], 6);
   macro.setGetArray(publicAPI, model, ['axisLabels'], 3);
-  macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle', 'camera']); // Object methods
+  macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle', 'camera', 'tmTexture', 'textValues', 'textPolyData', '_tmAtlas', 'tickCounts', 'gridActor']); // Object methods
 
   vtkCubeAxesActor(publicAPI, model);
 } // ----------------------------------------------------------------------------
@@ -711,7 +753,8 @@ var newInstance = macro.newInstance(extend, 'vtkCubeAxesActor'); // ------------
 
 var vtkCubeAxesActor$1 = {
   newInstance: newInstance,
-  extend: extend
+  extend: extend,
+  newCubeAxesActorHelper: newCubeAxesActorHelper
 };
 
 export { vtkCubeAxesActor$1 as default, extend, newInstance };

package/Rendering/Core/ScalarBarActor.js

@@ -2,7 +2,7 @@ import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { K as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { L as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import macro from '../../macros.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';

package/Rendering/Misc/SynchronizableRenderWindow.d.ts

@@ -1,13 +1,13 @@
 import vtkRenderWindow, { IRenderWindowInitialValues } from '@kitware/vtk.js/Rendering/Core/RenderWindow';
 
 // Keeps state for client / server scene synchronization.
-export interface SynchContext {
+export interface ISynchronizerContext {
     // Set a function that fetches the data array for the given object.
     setFetchArrayFunction(fetcher: (hash: string, dataType: any) => Promise<ArrayBuffer>): void;
     // Invokes the fetcher registered by setFetchArrayFunction.
-    getArray(sha: string, dataType: any, context: SynchContext): Promise<ArrayBuffer>;
+    getArray(sha: string, dataType: any, context: ISynchronizerContext): Promise<ArrayBuffer>;
     emptyCachedArrays(): void;
-    freeOldArrays(threshold: number, context: SynchContext): void;
+    freeOldArrays(threshold: number, context: ISynchronizerContext): void;
 
     // instanceMap
     getInstance(id: any): any;
@@ -25,14 +25,14 @@ export interface SynchContext {
     // TODO: fill progresshandler
 }
 
-export interface IInitialValues extends IRenderWindowInitialValues {
+export interface ISynchronizableRenderWindowInitialValues extends IRenderWindowInitialValues {
   synchronizerContextName?: string; // default: 'default':
-  synchronizerContext?: SynchContext | null;
+  synchronizerContext?: ISynchronizerContext | null;
   synchronizedViewId?: string | null;
 }
 
 // Server-side view state.
-export interface ViewState {
+export interface IViewState {
   id: string;
   // vtk object type.
   type: string;
@@ -42,7 +42,7 @@ export interface ViewState {
   parent?: string | null;
   properties?: {[key: string]: any};
   // Child objects.
-  dependencies?: ViewState[];
+  dependencies?: IViewState[];
   extra?: any;
   // List of [methodName, args] to be invoked on the object.
   calls?: [string, string[]][];
@@ -50,24 +50,116 @@ export interface ViewState {
   [key: string]: any;
 }
 
-export interface vtkSynchronizableRenderWindowInstance extends vtkRenderWindow {
-  getSynchronizerContext(): SynchContext;
+export interface vtkSynchronizableRenderWindow extends vtkRenderWindow {
+
+  /**
+   * 
+   */
+  getSynchronizerContext(): ISynchronizerContext;
 
   // methods added by createSyncFunction
-  synchronize(state: ViewState): Promise<boolean>;
+
+  /**
+   * 
+   * @param {IViewState} state 
+   */
+  synchronize(state: IViewState): Promise<boolean>;
+
+  /**
+   * 
+   * @param {String} viewId 
+   */
   setSynchronizedViewId(viewId: string): void;
+
+  /**
+   * 
+   */
   getSynchronizedViewId(): string;
+
+  /**
+   * 
+   * @param {Number} v 
+   */
   updateGarbageCollectorThreshold(v: number): void;
-  getManagedInstanceIds(): Array<string>;
+
+  /**
+   * 
+   */
+  getManagedInstanceIds(): string[];
+
+  /**
+   * 
+   */
   clearOneTimeUpdaters(): void;
 }
 
-export function newInstance(props: IInitialValues): vtkSynchronizableRenderWindowInstance;
-export function getSynchronizerContext(name?: string): SynchContext;
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkCellArray characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ISynchronizableRenderWindowInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: ISynchronizableRenderWindowInitialValues): void;
+
+/**
+ * Method used to create a new instance of vtkSynchronizableRenderWindow
+ * @param {ISynchronizableRenderWindowInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(initialValues?: ISynchronizableRenderWindowInitialValues): vtkSynchronizableRenderWindow;
 
-export const vtkSynchronizableRenderWindow: {
+/**
+ * 
+ * @param {String} [name] 
+ */
+export function getSynchronizerContext(name?: string): ISynchronizerContext;
+
+/**
+ * 
+ * @param {String} name 
+ * @param {ISynchronizerContext} ctx 
+ */
+export function setSynchronizerContext(name: string, ctx: ISynchronizerContext): ISynchronizerContext;
+
+/**
+ * 
+ * @param {vtkRenderWindow} renderWindow 
+ * @param {String} [name] 
+ */
+export function decorate(renderWindow: vtkRenderWindow, name?: string): object;
+
+/**
+ * 
+ */
+export function createInstanceMap(): object;
+
+/**
+ * 
+ */
+export function createArrayHandler(): object;
+
+/**
+ * 
+ */
+export function createProgressHandler(): object;
+
+/**
+ * 
+ */
+export function createSceneMtimeHandler(): object;
+
+/**
+ * 
+ */
+export declare const vtkSynchronizableRenderWindow: {
   newInstance: typeof newInstance;
   getSynchronizerContext: typeof getSynchronizerContext;
+  setSynchronizerContext: typeof setSynchronizerContext;
+  decorate: typeof decorate,
+  createInstanceMap: typeof createInstanceMap,
+  createArrayHandler: typeof createArrayHandler,
+  createProgressHandler: typeof createProgressHandler,
+  createSceneMtimeHandler: typeof createSceneMtimeHandler,
+  vtkObjectManager: object
 };
-
 export default vtkSynchronizableRenderWindow;

package/Rendering/OpenGL/CubeAxesActor.js

@@ -0,0 +1,61 @@
+import { newInstance as newInstance$1 } from '../../macros.js';
+import vtkCubeAxesActor from '../Core/CubeAxesActor.js';
+import vtkViewNode from '../SceneGraph/ViewNode.js';
+import { registerOverride } from './ViewNodeFactory.js';
+
+// vtkOpenGLCubeAxesActor methods
+// ----------------------------------------------------------------------------
+
+function vtkOpenGLCubeAxesActor(publicAPI, model) {
+  model.classHierarchy.push('vtkOpenGLCubeAxesActor'); // Builds myself.
+
+  publicAPI.buildPass = function (prepass) {
+    if (prepass) {
+      model.openGLRenderer = publicAPI.getFirstAncestorOfType('vtkOpenGLRenderer');
+      model.openGLRenderWindow = model.openGLRenderer.getParent();
+
+      if (!model.CubeAxesActorHelper.getRenderable()) {
+        model.CubeAxesActorHelper.setRenderable(model.renderable);
+      }
+
+      publicAPI.prepareNodes();
+      publicAPI.addMissingNode(model.CubeAxesActorHelper.getTmActor());
+      publicAPI.addMissingNode(model.renderable.getGridActor());
+      publicAPI.removeUnusedNodes();
+    }
+  };
+
+  publicAPI.opaquePass = function (prepass, renderPass) {
+    if (prepass) {
+      var camera = model.openGLRenderer ? model.openGLRenderer.getRenderable().getActiveCamera() : null;
+      var tsize = model.openGLRenderer.getTiledSizeAndOrigin();
+      model.CubeAxesActorHelper.updateAPISpecificData([tsize.usize, tsize.vsize], camera, model.openGLRenderWindow.getRenderable());
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+
+  vtkViewNode.extend(publicAPI, model, initialValues);
+  model.CubeAxesActorHelper = vtkCubeAxesActor.newCubeAxesActorHelper(); // Object methods
+
+  vtkOpenGLCubeAxesActor(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = newInstance$1(extend, 'vtkOpenGLCubeAxesActor'); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+}; // Register ourself to OpenGL backend if imported
+
+registerOverride('vtkCubeAxesActor', newInstance);
+
+export { index as default, extend, newInstance };

package/Rendering/OpenGL/Profiles/All.js

@@ -2,6 +2,7 @@ import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
 import '../Actor2D.js';
+import '../CubeAxesActor.js';
 import '../PolyDataMapper.js';
 import '../PolyDataMapper2D.js';
 import '../ScalarBarActor.js';

package/Rendering/OpenGL/Profiles/Geometry.js

@@ -2,6 +2,7 @@ import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
 import '../Actor2D.js';
+import '../CubeAxesActor.js';
 import '../PolyDataMapper.js';
 import '../PolyDataMapper2D.js';
 import '../ScalarBarActor.js';

package/Rendering/OpenGL/RenderWindow.js

@@ -703,13 +703,17 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
           publicAPI.modified();
 
           if (resetCamera) {
-            // If resetCamera was requested, we first save camera parameters
+            var isUserResetCamera = resetCamera !== true; // If resetCamera was requested, we first save camera parameters
             // from all the renderers, so we can restore them later
+
             model._screenshot.cameras = model.renderable.getRenderers().map(function (renderer) {
               var camera = renderer.getActiveCamera();
               var params = camera.get('focalPoint', 'position', 'parallelScale');
               return {
-                resetCameraFn: renderer.resetCamera,
+                resetCameraArgs: isUserResetCamera ? {
+                  renderer: renderer
+                } : undefined,
+                resetCameraFn: isUserResetCamera ? resetCamera : renderer.resetCamera,
                 restoreParamsFn: camera.set,
                 // "clone" the params so we don't keep refs to properties
                 arg: JSON.parse(JSON.stringify(params))
@@ -719,8 +723,9 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
             // linked cameras among the renderers.
 
             model._screenshot.cameras.forEach(function (_ref6) {
-              var resetCameraFn = _ref6.resetCameraFn;
-              return resetCameraFn();
+              var resetCameraFn = _ref6.resetCameraFn,
+                  resetCameraArgs = _ref6.resetCameraArgs;
+              return resetCameraFn(resetCameraArgs);
             });
           } // Trigger a render at the custom size
 

package/Rendering/OpenGL/ShaderCache.js

@@ -1,4 +1,4 @@
-import md5 from 'blueimp-md5';
+import Md5 from 'spark-md5';
 import macro from '../../macros.js';
 import vtkShaderProgram from './ShaderProgram.js';
 
@@ -88,7 +88,7 @@ function vtkShaderCache(publicAPI, model) {
   publicAPI.getShaderProgram = function (vertexCode, fragmentCode, geometryCode) {
     // compute the MD5 and the check the map
     var hashInput = "".concat(vertexCode).concat(fragmentCode).concat(geometryCode);
-    var result = md5(hashInput); // does it already exist?
+    var result = Md5.hash(hashInput); // does it already exist?
 
     var loc = Object.keys(model.shaderPrograms).indexOf(result);
 

package/Rendering/OpenGL/Texture.js

@@ -3,7 +3,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { newInstance as newInstance$1, obj, set, setGet, get, newTypedArray, vtkDebugMacro as vtkDebugMacro$1, vtkErrorMacro as vtkErrorMacro$1, vtkWarningMacro as vtkWarningMacro$1 } from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { P as isPowerOfTwo, K as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { P as isPowerOfTwo, L as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL.js

@@ -4,6 +4,7 @@ import vtkBufferObject from './OpenGL/BufferObject.js';
 import vtkCamera from './OpenGL/Camera.js';
 import vtkCellArrayBufferObject from './OpenGL/CellArrayBufferObject.js';
 import vtkConvolution2DPass from './OpenGL/Convolution2DPass.js';
+import './OpenGL/CubeAxesActor.js';
 import vtkForwardPass from './OpenGL/ForwardPass.js';
 import vtkOpenGLFramebuffer from './OpenGL/Framebuffer.js';
 import vtkGlyph3DMapper from './OpenGL/Glyph3DMapper.js';

package/Rendering/Profiles/All.js

@@ -2,6 +2,7 @@ import '../OpenGL/Camera.js';
 import '../OpenGL/Renderer.js';
 import '../OpenGL/Actor.js';
 import '../OpenGL/Actor2D.js';
+import '../OpenGL/CubeAxesActor.js';
 import '../OpenGL/PolyDataMapper.js';
 import '../OpenGL/PolyDataMapper2D.js';
 import '../OpenGL/ScalarBarActor.js';
@@ -19,6 +20,7 @@ import '../OpenGL/StickMapper.js';
 import '../WebGPU/Camera.js';
 import '../WebGPU/Renderer.js';
 import '../WebGPU/Actor.js';
+import '../WebGPU/CubeAxesActor.js';
 import '../WebGPU/PolyDataMapper.js';
 import '../WebGPU/ScalarBarActor.js';
 import '../WebGPU/Texture.js';

package/Rendering/Profiles/Geometry.js

@@ -2,6 +2,7 @@ import '../OpenGL/Camera.js';
 import '../OpenGL/Renderer.js';
 import '../OpenGL/Actor.js';
 import '../OpenGL/Actor2D.js';
+import '../OpenGL/CubeAxesActor.js';
 import '../OpenGL/PolyDataMapper.js';
 import '../OpenGL/PolyDataMapper2D.js';
 import '../OpenGL/ScalarBarActor.js';
@@ -11,6 +12,7 @@ import '../OpenGL/PixelSpaceCallbackMapper.js';
 import '../WebGPU/Camera.js';
 import '../WebGPU/Renderer.js';
 import '../WebGPU/Actor.js';
+import '../WebGPU/CubeAxesActor.js';
 import '../WebGPU/PolyDataMapper.js';
 import '../WebGPU/ScalarBarActor.js';
 import '../WebGPU/Texture.js';

package/Rendering/WebGPU/CubeAxesActor.js

@@ -0,0 +1,61 @@
+import { newInstance as newInstance$1 } from '../../macros.js';
+import vtkCubeAxesActor from '../Core/CubeAxesActor.js';
+import vtkViewNode from '../SceneGraph/ViewNode.js';
+import { registerOverride } from './ViewNodeFactory.js';
+
+// vtkWebGPUCubeAxesActor methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUCubeAxesActor(publicAPI, model) {
+  model.classHierarchy.push('vtkWebGPUCubeAxesActor'); // Builds myself.
+
+  publicAPI.buildPass = function (prepass) {
+    if (prepass) {
+      model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
+      model.WebGPURenderWindow = model.WebGPURenderer.getParent();
+
+      if (!model.CubeAxesActorHelper.getRenderable()) {
+        model.CubeAxesActorHelper.setRenderable(model.renderable);
+      }
+
+      publicAPI.prepareNodes();
+      publicAPI.addMissingNode(model.CubeAxesActorHelper.getTmActor());
+      publicAPI.addMissingNode(model.renderable.getGridActor());
+      publicAPI.removeUnusedNodes();
+    }
+  };
+
+  publicAPI.opaquePass = function (prepass, renderPass) {
+    if (prepass) {
+      var camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
+      var tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
+      model.CubeAxesActorHelper.updateAPISpecificData([tsize.usize, tsize.vsize], camera, model.WebGPURenderWindow.getRenderable());
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+
+  vtkViewNode.extend(publicAPI, model, initialValues);
+  model.CubeAxesActorHelper = vtkCubeAxesActor.newCubeAxesActorHelper(); // Object methods
+
+  vtkWebGPUCubeAxesActor(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = newInstance$1(extend, 'vtkWebGPUCubeAxesActor'); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+}; // Register ourself to WebGPU backend if imported
+
+registerOverride('vtkCubeAxesActor', newInstance);
+
+export { index as default, extend, newInstance };

package/Rendering/WebGPU/Profiles/All.js

@@ -1,6 +1,7 @@
 import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
+import '../CubeAxesActor.js';
 import '../PolyDataMapper.js';
 import '../ScalarBarActor.js';
 import '../Texture.js';

package/Rendering/WebGPU/Profiles/Geometry.js

@@ -1,6 +1,7 @@
 import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
+import '../CubeAxesActor.js';
 import '../PolyDataMapper.js';
 import '../ScalarBarActor.js';
 import '../Texture.js';

package/Rendering/WebGPU/RenderWindow.js

@@ -412,13 +412,17 @@ function vtkWebGPURenderWindow(publicAPI, model) {
           publicAPI.modified();
 
           if (resetCamera) {
-            // If resetCamera was requested, we first save camera parameters
+            var isUserResetCamera = resetCamera !== true; // If resetCamera was requested, we first save camera parameters
             // from all the renderers, so we can restore them later
+
             model._screenshot.cameras = model.renderable.getRenderers().map(function (renderer) {
               var camera = renderer.getActiveCamera();
               var params = camera.get('focalPoint', 'position', 'parallelScale');
               return {
-                resetCameraFn: renderer.resetCamera,
+                resetCameraArgs: isUserResetCamera ? {
+                  renderer: renderer
+                } : undefined,
+                resetCameraFn: isUserResetCamera ? resetCamera : renderer.resetCamera,
                 restoreParamsFn: camera.set,
                 // "clone" the params so we don't keep refs to properties
                 arg: JSON.parse(JSON.stringify(params))
@@ -428,8 +432,9 @@ function vtkWebGPURenderWindow(publicAPI, model) {
             // linked cameras among the renderers.
 
             model._screenshot.cameras.forEach(function (_ref4) {
-              var resetCameraFn = _ref4.resetCameraFn;
-              return resetCameraFn();
+              var resetCameraFn = _ref4.resetCameraFn,
+                  resetCameraArgs = _ref4.resetCameraArgs;
+              return resetCameraFn(resetCameraArgs);
             });
           } // Trigger a render at the custom size
 

package/Rendering/WebGPU.js

@@ -1,6 +1,7 @@
 import vtkRenderWindow from './WebGPU/RenderWindow.js';
 import './WebGPU/Actor.js';
 import './WebGPU/Camera.js';
+import './WebGPU/CubeAxesActor.js';
 import './WebGPU/ForwardPass.js';
 import './WebGPU/Glyph3DMapper.js';
 import './WebGPU/HardwareSelector.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "22.5.5",
+  "version": "22.5.8",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",
@@ -31,7 +31,6 @@
   "module": "./index.js",
   "dependencies": {
     "@babel/runtime": "7.16.7",
-    "blueimp-md5": "2.19.0",
     "commander": "8.3.0",
     "d3-scale": "4.0.2",
     "gl-matrix": "3.4.3",
@@ -41,6 +40,7 @@
     "seedrandom": "3.0.5",
     "shader-loader": "1.3.1",
     "shelljs": "0.8.5",
+    "spark-md5": "^3.0.2",
     "stream-browserify": "3.0.0",
     "webworker-promise": "0.4.4",
     "worker-loader": "3.0.8",