@kitware/vtk.js 28.10.2 → 28.11.1

package/Rendering/Core/CubeAxesActor.js

@@ -1,9 +1,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 { M as normalize2D, N as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
@@ -11,19 +9,18 @@ import vtkMapper from './Mapper.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTexture from './Texture.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+// ----------------------------------------------------------------------------
 // vtkCubeAxesActor
 // ----------------------------------------------------------------------------
 // faces are -x x -y y -z z
 // point 0 is 0,0,0 and then +x fastest changing, +y then +z
+const faceNormals = [[-1, 0, 0], [1, 0, 0], [0, -1, 0], [0, 1, 0], [0, 0, -1], [0, 0, 1]];
+const 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]];
+const 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]];
+const edgeAxes = [0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2];
+const faceAxes = [[1, 2], [1, 2], [0, 2], [0, 2], [0, 1], [0, 1]];
 
-var faceNormals = [[-1, 0, 0], [1, 0, 0], [0, -1, 0], [0, 1, 0], [0, 0, -1], [0, 0, 1]];
-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]]; //
+//
 // 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
@@ -33,85 +30,80 @@ var faceAxes = [[1, 2], [1, 2], [0, 2], [0, 2], [0, 1], [0, 1]]; //
 // 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);
-var tmpv3 = new Float64Array(3);
-var tmp2v3 = new Float64Array(3);
-var xDir = new Float64Array(3);
-var yDir = new Float64Array(3);
-var invmat = new Float64Array(16);
 
+// some shared temp variables to reduce heap allocs
+const ptv3 = new Float64Array(3);
+const pt2v3 = new Float64Array(3);
+const tmpv3 = new Float64Array(3);
+const tmp2v3 = new Float64Array(3);
+const xDir = new Float64Array(3);
+const yDir = new Float64Array(3);
+const invmat = new Float64Array(16);
 function applyTextStyle(ctx, style) {
   ctx.strokeStyle = style.strokeColor;
   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
+  ctx.font = `${style.fontStyle} ${style.fontSize}px ${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) {
+  publicAPI.setRenderable = 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);
+  };
 
+  // called by updateTexturePolyData
+  publicAPI.createPolyDataForOneLabel = (text, pos, cmat, imat, dir, offset, results) => {
+    const value = model.renderable.get_tmAtlas().get(text);
     if (!value) {
       return;
     }
+    const coords = model.renderable.getTextPolyData().getPoints().getData();
 
-    var coords = model.renderable.getTextPolyData().getPoints().getData(); // compute pixel to distance factors
-
-    var size = model.lastSize;
+    // compute pixel to distance factors
+    const 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
-
+    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.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.transformMat4(pt2v3, tmpv3, imat);
+    // results in WC move of
     vec3.subtract(yDir, pt2v3, ptv3);
-
-    for (var i = 0; i < 3; i++) {
+    for (let 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;
+    // have to find the four corners of the texture polygon for this label
+    // convert anchor point to View Coords
+    let ptIdx = results.ptIdx;
+    let 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]
-
+    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) {
@@ -119,7 +111,6 @@ function vtkCubeAxesActorHelper(publicAPI, model) {
     } 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);
@@ -152,8 +143,9 @@ function vtkCubeAxesActorHelper(publicAPI, model) {
     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
+    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;
@@ -165,35 +157,35 @@ function vtkCubeAxesActorHelper(publicAPI, model) {
     results.polys[cellIdx * 4 + 3] = ptIdx - 1;
     results.ptIdx += 4;
     results.cellIdx += 2;
-  }; // update the polydata associated with drawing the text labels
+  };
+
+  // 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 = () => {
+    const cmat = model.camera.getCompositeProjectionMatrix(model.lastAspectRatio, -1, 1);
+    mat4.transpose(cmat, cmat);
 
-
-  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);
+    // update the polydata
+    const numLabels = model.renderable.getTextValues().length;
+    const numPts = numLabels * 4;
+    const numTris = numLabels * 2;
+    const points = new Float64Array(numPts * 3);
+    const polys = new Uint16Array(numTris * 4);
+    const tcoords = new Float32Array(numPts * 2);
     mat4.invert(invmat, cmat);
-    var results = {
+    const results = {
       ptIdx: 0,
       cellIdx: 0,
-      polys: polys,
-      points: points,
-      tcoords: tcoords
+      polys,
+      points,
+      tcoords
     };
-    var ptIdx = 0;
-    var textIdx = 0;
-    var axisIdx = 0;
-    var coords = model.renderable.getTextPolyData().getPoints().getData();
-    var textValues = model.renderable.getTextValues();
-
+    let ptIdx = 0;
+    let textIdx = 0;
+    let axisIdx = 0;
+    const coords = model.renderable.getTextPolyData().getPoints().getData();
+    const textValues = model.renderable.getTextValues();
     while (ptIdx < coords.length / 3) {
       // compute the direction to move out
       ptv3[0] = coords[ptIdx * 3];
@@ -205,23 +197,23 @@ function vtkCubeAxesActorHelper(publicAPI, model) {
       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
+      const 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
+      textIdx++;
 
-      for (var t = 0; t < model.renderable.getTickCounts()[axisIdx]; t++) {
+      // write the tick labels
+      for (let 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({
+    const tcoordDA = vtkDataArray.newInstance({
       numberOfComponents: 2,
       values: tcoords,
       name: 'TextureCoordinates'
@@ -233,8 +225,7 @@ function vtkCubeAxesActorHelper(publicAPI, model) {
     model.tmPolyData.getPolys().modified();
     model.tmPolyData.modified();
   };
-
-  publicAPI.updateAPISpecificData = function (size, camera, renderWindow) {
+  publicAPI.updateAPISpecificData = (size, camera, renderWindow) => {
     // has the size changed?
     if (model.lastSize[0] !== size[0] || model.lastSize[1] !== size[1]) {
       model.lastSize[0] = size[0];
@@ -242,19 +233,19 @@ function vtkCubeAxesActorHelper(publicAPI, model) {
       model.lastAspectRatio = size[0] / size[1];
       model.forceUpdate = true;
     }
+    model.camera = camera;
 
-    model.camera = camera; // compute bounds for label quads whenever the camera changes
-
+    // 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] : {
+const newCubeAxesActorHelper = macro.newInstance(function (publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
     renderable: null
   };
-  Object.assign(model, {}, initialValues); // Inheritance
+  Object.assign(model, {}, initialValues);
 
+  // Inheritance
   macro.obj(publicAPI, model);
   model.tmPolyData = vtkPolyData.newInstance();
   model.tmMapper = vtkMapper.newInstance();
@@ -274,51 +265,45 @@ var newCubeAxesActorHelper = macro.newInstance(function (publicAPI, model) {
   macro.obj(model.lastRebuildTime, {
     mtime: 0
   });
-  model.lastSize = [-1, -1]; // internal variables
+  model.lastSize = [-1, -1];
 
+  // internal variables
   model.lastTickBounds = [];
   vtkCubeAxesActorHelper(publicAPI, model);
 }, 'vtkCubeAxesActorHelper');
-
 function vtkCubeAxesActor(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCubeAxesActor');
-
-  publicAPI.setCamera = function (cam) {
+  publicAPI.setCamera = cam => {
     if (model.camera === cam) {
       return;
     }
-
     if (model.cameraModifiedSub) {
       model.cameraModifiedSub.unsubscribe();
       model.cameraModifiedSub = null;
     }
-
     model.camera = cam;
-
     if (cam) {
       model.cameraModifiedSub = cam.onModified(publicAPI.update);
     }
-
     publicAPI.update();
     publicAPI.modified();
-  }; // estimate from a camera model what faces to draw
-  // return true if the list of faces to draw has changed
-
+  };
 
-  publicAPI.computeFacesToDraw = function () {
-    var cmat = model.camera.getViewMatrix();
+  // estimate from a camera model what faces to draw
+  // return true if the list of faces to draw has changed
+  publicAPI.computeFacesToDraw = () => {
+    const cmat = model.camera.getViewMatrix();
     mat4.transpose(cmat, cmat);
-    var changed = false;
-    var length = vtkBoundingBox.getDiagonalLength(model.dataBounds);
-    var faceDot = Math.sin(model.faceVisibilityAngle * Math.PI / 180.0);
-
-    for (var f = 0; f < 6; f++) {
-      var drawit = false;
-      var faceAxis = Math.floor(f / 2);
-      var otherAxis1 = (faceAxis + 1) % 3;
-      var otherAxis2 = (faceAxis + 2) % 3; // only for non degenerate axes
-
+    let changed = false;
+    const length = vtkBoundingBox.getDiagonalLength(model.dataBounds);
+    const faceDot = Math.sin(model.faceVisibilityAngle * Math.PI / 180.0);
+    for (let f = 0; f < 6; f++) {
+      let drawit = false;
+      const faceAxis = Math.floor(f / 2);
+      const otherAxis1 = (faceAxis + 1) % 3;
+      const otherAxis2 = (faceAxis + 2) % 3;
+      // only for non degenerate axes
       if (model.dataBounds[otherAxis1 * 2] !== model.dataBounds[otherAxis1 * 2 + 1] && model.dataBounds[otherAxis2 * 2] !== model.dataBounds[otherAxis2 * 2 + 1]) {
         // for each face transform the center and off center to get a direction vector
         ptv3[faceAxis] = model.dataBounds[f] - 0.1 * length * faceNormals[f][faceAxis];
@@ -328,115 +313,111 @@ function vtkCubeAxesActor(publicAPI, model) {
         ptv3[faceAxis] = model.dataBounds[f];
         vec3.transformMat4(tmp2v3, ptv3, cmat);
         vec3.subtract(tmpv3, tmp2v3, tmpv3);
-        vec3.normalize(tmpv3, tmpv3); // tmpv3 now holds the face normal vector
-
-        drawit = tmpv3[2] > faceDot; // for perspctive we need the view direction to the plane
-
+        vec3.normalize(tmpv3, tmpv3);
+        // tmpv3 now holds the face normal vector
+        drawit = tmpv3[2] > faceDot;
+        // for perspctive we need the view direction to the plane
         if (!model.camera.getParallelProjection()) {
           vec3.normalize(tmp2v3, tmp2v3);
           drawit = vec3.dot(tmp2v3, tmpv3) > faceDot;
         }
       }
-
       if (drawit !== model.lastFacesToDraw[f]) {
         model.lastFacesToDraw[f] = drawit;
         changed = true;
       }
     }
-
     return changed;
-  }; // update the polydata that represents the boundingd edges and gridlines
-
+  };
 
-  publicAPI.updatePolyData = function (facesToDraw, edgesToDraw, ticks) {
+  // update the polydata that represents the boundingd edges and gridlines
+  publicAPI.updatePolyData = (facesToDraw, edgesToDraw, ticks) => {
     // compute the number of points and lines required
-    var numPts = 0;
-    var numLines = 0;
+    let numPts = 0;
+    let numLines = 0;
     numPts += 8; // always start with the 8 cube points
-    // count edgesToDraw
-
-    var numEdgesToDraw = 0;
 
-    for (var e = 0; e < 12; e++) {
+    // count edgesToDraw
+    let numEdgesToDraw = 0;
+    for (let e = 0; e < 12; e++) {
       if (edgesToDraw[e] > 0) {
         numEdgesToDraw++;
       }
     }
+    numLines += numEdgesToDraw;
 
-    numLines += numEdgesToDraw; // add values for gridlines
-
+    // add values for gridlines
     if (model.gridLines) {
-      for (var f = 0; f < 6; f++) {
+      for (let f = 0; f < 6; f++) {
         if (facesToDraw[f]) {
           numPts += ticks[faceAxes[f][0]].length * 2 + ticks[faceAxes[f][1]].length * 2;
           numLines += ticks[faceAxes[f][0]].length + ticks[faceAxes[f][1]].length;
         }
       }
-    } // now allocate the memory
-
+    }
 
-    var points = new Float64Array(numPts * 3);
-    var lines = new Uint32Array(numLines * 3);
-    var ptIdx = 0;
-    var lineIdx = 0; // add the 8 corner points
+    // now allocate the memory
+    const points = new Float64Array(numPts * 3);
+    const lines = new Uint32Array(numLines * 3);
+    let ptIdx = 0;
+    let lineIdx = 0;
 
-    for (var z = 0; z < 2; z++) {
-      for (var y = 0; y < 2; y++) {
-        for (var x = 0; x < 2; x++) {
+    // add the 8 corner points
+    for (let z = 0; z < 2; z++) {
+      for (let y = 0; y < 2; y++) {
+        for (let x = 0; x < 2; x++) {
           points[ptIdx * 3] = model.dataBounds[x];
           points[ptIdx * 3 + 1] = model.dataBounds[2 + y];
           points[ptIdx * 3 + 2] = model.dataBounds[4 + z];
           ptIdx++;
         }
       }
-    } // draw the edges
-
+    }
 
-    for (var _e = 0; _e < 12; _e++) {
-      if (edgesToDraw[_e] > 0) {
+    // draw the edges
+    for (let e = 0; e < 12; e++) {
+      if (edgesToDraw[e] > 0) {
         lines[lineIdx * 3] = 2;
-        lines[lineIdx * 3 + 1] = edgePoints[_e][0];
-        lines[lineIdx * 3 + 2] = edgePoints[_e][1];
+        lines[lineIdx * 3 + 1] = edgePoints[e][0];
+        lines[lineIdx * 3 + 2] = edgePoints[e][1];
         lineIdx++;
       }
-    } // now handle gridlines
+    }
+
+    // now handle gridlines
     // grid lines are tick[axis1] + ticks[axes2] lines each having two points
     // for simplicity we don;t worry about duplicating points, this is tiny
 
-
     if (model.gridLines) {
       // for each visible face
       // add the points
-      for (var _f = 0; _f < 6; _f++) {
-        if (facesToDraw[_f]) {
-          var faceIdx = Math.floor(_f / 2);
-          var aticks = ticks[faceAxes[_f][0]];
-
-          for (var t = 0; t < aticks.length; t++) {
-            points[ptIdx * 3 + faceIdx] = model.dataBounds[_f];
-            points[ptIdx * 3 + faceAxes[_f][0]] = aticks[t];
-            points[ptIdx * 3 + faceAxes[_f][1]] = model.dataBounds[faceAxes[_f][1] * 2];
+      for (let f = 0; f < 6; f++) {
+        if (facesToDraw[f]) {
+          const faceIdx = Math.floor(f / 2);
+          let aticks = ticks[faceAxes[f][0]];
+          for (let t = 0; t < aticks.length; t++) {
+            points[ptIdx * 3 + faceIdx] = model.dataBounds[f];
+            points[ptIdx * 3 + faceAxes[f][0]] = aticks[t];
+            points[ptIdx * 3 + faceAxes[f][1]] = model.dataBounds[faceAxes[f][1] * 2];
             ptIdx++;
-            points[ptIdx * 3 + faceIdx] = model.dataBounds[_f];
-            points[ptIdx * 3 + faceAxes[_f][0]] = aticks[t];
-            points[ptIdx * 3 + faceAxes[_f][1]] = model.dataBounds[faceAxes[_f][1] * 2 + 1];
+            points[ptIdx * 3 + faceIdx] = model.dataBounds[f];
+            points[ptIdx * 3 + faceAxes[f][0]] = aticks[t];
+            points[ptIdx * 3 + faceAxes[f][1]] = model.dataBounds[faceAxes[f][1] * 2 + 1];
             ptIdx++;
             lines[lineIdx * 3] = 2;
             lines[lineIdx * 3 + 1] = ptIdx - 2;
             lines[lineIdx * 3 + 2] = ptIdx - 1;
             lineIdx++;
           }
-
-          aticks = ticks[faceAxes[_f][1]];
-
-          for (var _t = 0; _t < aticks.length; _t++) {
-            points[ptIdx * 3 + faceIdx] = model.dataBounds[_f];
-            points[ptIdx * 3 + faceAxes[_f][1]] = aticks[_t];
-            points[ptIdx * 3 + faceAxes[_f][0]] = model.dataBounds[faceAxes[_f][0] * 2];
+          aticks = ticks[faceAxes[f][1]];
+          for (let t = 0; t < aticks.length; t++) {
+            points[ptIdx * 3 + faceIdx] = model.dataBounds[f];
+            points[ptIdx * 3 + faceAxes[f][1]] = aticks[t];
+            points[ptIdx * 3 + faceAxes[f][0]] = model.dataBounds[faceAxes[f][0] * 2];
             ptIdx++;
-            points[ptIdx * 3 + faceIdx] = model.dataBounds[_f];
-            points[ptIdx * 3 + faceAxes[_f][1]] = aticks[_t];
-            points[ptIdx * 3 + faceAxes[_f][0]] = model.dataBounds[faceAxes[_f][0] * 2 + 1];
+            points[ptIdx * 3 + faceIdx] = model.dataBounds[f];
+            points[ptIdx * 3 + faceAxes[f][1]] = aticks[t];
+            points[ptIdx * 3 + faceAxes[f][0]] = model.dataBounds[faceAxes[f][0] * 2 + 1];
             ptIdx++;
             lines[lineIdx * 3] = 2;
             lines[lineIdx * 3 + 1] = ptIdx - 2;
@@ -446,276 +427,259 @@ function vtkCubeAxesActor(publicAPI, model) {
         }
       }
     }
-
     model.polyData.getPoints().setData(points, 3);
     model.polyData.getPoints().modified();
     model.polyData.getLines().setData(lines, 1);
     model.polyData.getLines().modified();
     model.polyData.modified();
-  }; // update the data that represents where to put the labels
+  };
+
+  // update the data that represents where to put the labels
   // in world coordinates. This only changes when faces to draw changes
   // of dataBounds changes
-
-
-  publicAPI.updateTextData = function (facesToDraw, edgesToDraw, ticks, tickStrings) {
+  publicAPI.updateTextData = (facesToDraw, edgesToDraw, ticks, tickStrings) => {
     // count outside edgesToDraw
-    var textPointCount = 0;
-
-    for (var e = 0; e < 12; e++) {
+    let textPointCount = 0;
+    for (let e = 0; e < 12; e++) {
       if (edgesToDraw[e] === 1) {
         textPointCount += 2;
         textPointCount += ticks[edgeAxes[e]].length;
       }
     }
-
-    var points = model.polyData.getPoints().getData();
-    var textPoints = new Float64Array(textPointCount * 3);
-    var ptIdx = 0;
-    var textIdx = 0;
-    var axisCount = 0;
-
-    for (var f = 0; f < 6; f++) {
+    const points = model.polyData.getPoints().getData();
+    const textPoints = new Float64Array(textPointCount * 3);
+    let ptIdx = 0;
+    let textIdx = 0;
+    let axisCount = 0;
+    for (let f = 0; f < 6; f++) {
       if (facesToDraw[f]) {
-        for (var _e2 = 0; _e2 < 4; _e2++) {
-          var edgeIdx = faceEdges[f][_e2];
-
+        for (let e = 0; e < 4; e++) {
+          const edgeIdx = faceEdges[f][e];
           if (edgesToDraw[edgeIdx] === 1) {
-            var edgeAxis = edgeAxes[edgeIdx]; // add a middle point on the edge
-
-            var ptIdx1 = edgePoints[edgeIdx][0] * 3;
-            var ptIdx2 = edgePoints[edgeIdx][1] * 3;
+            const edgeAxis = edgeAxes[edgeIdx];
+            // add a middle point on the edge
+            const ptIdx1 = edgePoints[edgeIdx][0] * 3;
+            const ptIdx2 = edgePoints[edgeIdx][1] * 3;
             textPoints[ptIdx * 3] = 0.5 * (points[ptIdx1] + points[ptIdx2]);
             textPoints[ptIdx * 3 + 1] = 0.5 * (points[ptIdx1 + 1] + points[ptIdx2 + 1]);
             textPoints[ptIdx * 3 + 2] = 0.5 * (points[ptIdx1 + 2] + points[ptIdx2 + 2]);
-            ptIdx++; // add a middle face point, we use this to
+            ptIdx++;
+            // add a middle face point, we use this to
             // move the labels away from the edge in the right direction
-
-            var faceIdx = Math.floor(f / 2);
+            const faceIdx = Math.floor(f / 2);
             textPoints[ptIdx * 3 + faceIdx] = model.dataBounds[f];
             textPoints[ptIdx * 3 + faceAxes[f][0]] = 0.5 * (model.dataBounds[faceAxes[f][0] * 2] + model.dataBounds[faceAxes[f][0] * 2 + 1]);
             textPoints[ptIdx * 3 + faceAxes[f][1]] = 0.5 * (model.dataBounds[faceAxes[f][1] * 2] + model.dataBounds[faceAxes[f][1] * 2 + 1]);
-            ptIdx++; // set the text
-
+            ptIdx++;
+            // set the text
             model.textValues[textIdx] = model.axisLabels[edgeAxis];
-            textIdx++; // now add the tick marks along the edgeAxis
+            textIdx++;
 
-            var otherAxis1 = (edgeAxis + 1) % 3;
-            var otherAxis2 = (edgeAxis + 2) % 3;
-            var aticks = ticks[edgeAxis];
-            var atickStrings = tickStrings[edgeAxis];
+            // now add the tick marks along the edgeAxis
+            const otherAxis1 = (edgeAxis + 1) % 3;
+            const otherAxis2 = (edgeAxis + 2) % 3;
+            const aticks = ticks[edgeAxis];
+            const atickStrings = tickStrings[edgeAxis];
             model.tickCounts[axisCount] = aticks.length;
-
-            for (var t = 0; t < aticks.length; t++) {
+            for (let t = 0; t < aticks.length; t++) {
               textPoints[ptIdx * 3 + edgeAxis] = aticks[t];
               textPoints[ptIdx * 3 + otherAxis1] = points[ptIdx1 + otherAxis1];
               textPoints[ptIdx * 3 + otherAxis2] = points[ptIdx1 + otherAxis2];
-              ptIdx++; // set the text
-
+              ptIdx++;
+              // set the text
               model.textValues[textIdx] = atickStrings[t];
               textIdx++;
             }
-
             axisCount++;
           }
         }
       }
     }
-
     model.textPolyData.getPoints().setData(textPoints, 3);
     model.textPolyData.modified();
-  }; // main method to rebuild the cube axes, gets called on camera modify
-  // and changes to key members
-
+  };
 
-  publicAPI.update = function () {
+  // main method to rebuild the cube axes, gets called on camera modify
+  // and changes to key members
+  publicAPI.update = () => {
     // Can't do anything if we don't have a camera...
     if (!model.camera) {
       return;
-    } // compute what faces to draw
-
-
-    var facesChanged = publicAPI.computeFacesToDraw();
-    var facesToDraw = model.lastFacesToDraw; // have the bounds changed?
+    }
 
-    var boundsChanged = false;
+    // compute what faces to draw
+    const facesChanged = publicAPI.computeFacesToDraw();
+    const facesToDraw = model.lastFacesToDraw;
 
-    for (var i = 0; i < 6; i++) {
+    // have the bounds changed?
+    let boundsChanged = false;
+    for (let i = 0; i < 6; i++) {
       if (model.dataBounds[i] !== model.lastTickBounds[i]) {
         boundsChanged = true;
         model.lastTickBounds[i] = model.dataBounds[i];
       }
-    } // did something significant change? If so rebuild a lot of things
-
+    }
 
+    // did something significant change? If so rebuild a lot of things
     if (facesChanged || boundsChanged || model.forceUpdate) {
       // compute the edges to draw
       // for each drawn face, mark edges, all single mark edges we draw
-      var edgesToDraw = new Array(12).fill(0);
-
-      for (var f = 0; f < 6; f++) {
+      const edgesToDraw = new Array(12).fill(0);
+      for (let f = 0; f < 6; f++) {
         if (facesToDraw[f]) {
-          for (var e = 0; e < 4; e++) {
+          for (let e = 0; e < 4; e++) {
             edgesToDraw[faceEdges[f][e]]++;
           }
         }
-      } // compute tick marks for axes
-
-
-      var ticks = [];
-      var tickStrings = [];
+      }
 
-      for (var _i = 0; _i < 3; _i++) {
-        var scale = d3.scaleLinear().domain([model.dataBounds[_i * 2], model.dataBounds[_i * 2 + 1]]);
-        ticks[_i] = scale.ticks(5);
-        var format = scale.tickFormat(5);
-        tickStrings[_i] = ticks[_i].map(format);
-      } // update gridlines / edge lines
+      // compute tick marks for axes
+      const ticks = [];
+      const tickStrings = [];
+      for (let i = 0; i < 3; i++) {
+        const scale = d3.scaleLinear().domain([model.dataBounds[i * 2], model.dataBounds[i * 2 + 1]]);
+        ticks[i] = scale.ticks(5);
+        const format = scale.tickFormat(5);
+        tickStrings[i] = ticks[i].map(format);
+      }
 
+      // update gridlines / edge lines
+      publicAPI.updatePolyData(facesToDraw, edgesToDraw, ticks);
 
-      publicAPI.updatePolyData(facesToDraw, edgesToDraw, ticks); // compute label world coords and text
+      // compute label world coords and text
+      publicAPI.updateTextData(facesToDraw, edgesToDraw, ticks, tickStrings);
 
-      publicAPI.updateTextData(facesToDraw, edgesToDraw, ticks, tickStrings); // rebuild the texture only when force or changed bounds, face
+      // rebuild the texture only when force or changed bounds, face
       // visibility changes do to change the atlas
-
       if (boundsChanged || model.forceUpdate) {
         publicAPI.updateTextureAtlas(tickStrings);
       }
     }
-
     model.forceUpdate = false;
-  }; // create the texture map atlas that contains the rendering of
+  };
+
+  // create the texture map atlas that contains the rendering of
   // all the text strings. Only needs to be called when the text strings
   // have changed (labels and ticks)
-
-
-  publicAPI.updateTextureAtlas = function (tickStrings) {
+  publicAPI.updateTextureAtlas = tickStrings => {
     // compute the width and height we need
+
     // set the text properties
     model.tmContext.textBaseline = 'bottom';
-    model.tmContext.textAlign = 'left'; // first the three labels
+    model.tmContext.textAlign = 'left';
 
+    // first the three labels
     model._tmAtlas.clear();
-
-    var maxWidth = 0;
-    var totalHeight = 1; // start one pixel in so we have a border
-
-    for (var i = 0; i < 3; i++) {
+    let maxWidth = 0;
+    let totalHeight = 1; // start one pixel in so we have a border
+    for (let i = 0; i < 3; i++) {
       if (!model._tmAtlas.has(model.axisLabels[i])) {
         applyTextStyle(model.tmContext, model.axisTextStyle);
-        var metrics = model.tmContext.measureText(model.axisLabels[i]);
-        var entry = {
+        const metrics = model.tmContext.measureText(model.axisLabels[i]);
+        const entry = {
           height: metrics.actualBoundingBoxAscent + 2,
           startingHeight: totalHeight,
           width: metrics.width + 2,
           textStyle: model.axisTextStyle
         };
-
         model._tmAtlas.set(model.axisLabels[i], entry);
-
         totalHeight += entry.height;
-
         if (maxWidth < entry.width) {
           maxWidth = entry.width;
         }
-      } // and the ticks
-
-
+      }
+      // and the ticks
       applyTextStyle(model.tmContext, model.tickTextStyle);
-
-      for (var t = 0; t < tickStrings[i].length; t++) {
+      for (let t = 0; t < tickStrings[i].length; t++) {
         if (!model._tmAtlas.has(tickStrings[i][t])) {
-          var _metrics = model.tmContext.measureText(tickStrings[i][t]);
-
-          var _entry = {
-            height: _metrics.actualBoundingBoxAscent + 2,
+          const metrics = model.tmContext.measureText(tickStrings[i][t]);
+          const entry = {
+            height: metrics.actualBoundingBoxAscent + 2,
             startingHeight: totalHeight,
-            width: _metrics.width + 2,
+            width: metrics.width + 2,
             textStyle: model.tickTextStyle
           };
-
-          model._tmAtlas.set(tickStrings[i][t], _entry);
-
-          totalHeight += _entry.height;
-
-          if (maxWidth < _entry.width) {
-            maxWidth = _entry.width;
+          model._tmAtlas.set(tickStrings[i][t], entry);
+          totalHeight += entry.height;
+          if (maxWidth < entry.width) {
+            maxWidth = entry.width;
           }
         }
       }
-    } // always use power of two to avoid interpolation
-    // in cases where PO2 is required
-
+    }
 
+    // always use power of two to avoid interpolation
+    // in cases where PO2 is required
     maxWidth = nearestPowerOfTwo(maxWidth);
-    totalHeight = nearestPowerOfTwo(totalHeight); // set the tcoord values
+    totalHeight = nearestPowerOfTwo(totalHeight);
 
-    model._tmAtlas.forEach(function (value) {
+    // set the tcoord values
+    model._tmAtlas.forEach(value => {
       value.tcoords = [0.0, (totalHeight - value.startingHeight - value.height) / totalHeight, value.width / maxWidth, (totalHeight - value.startingHeight - value.height) / totalHeight, value.width / maxWidth, (totalHeight - value.startingHeight) / totalHeight, 0.0, (totalHeight - value.startingHeight) / totalHeight];
-    }); // make sure we have power of two dimensions
-
+    });
 
+    // make sure we have power of two dimensions
     model.tmCanvas.width = maxWidth;
     model.tmCanvas.height = totalHeight;
     model.tmContext.textBaseline = 'bottom';
     model.tmContext.textAlign = 'left';
-    model.tmContext.clearRect(0, 0, maxWidth, totalHeight); // draw the text onto the texture
+    model.tmContext.clearRect(0, 0, maxWidth, totalHeight);
 
-    model._tmAtlas.forEach(function (value, key) {
+    // draw the text onto the texture
+    model._tmAtlas.forEach((value, key) => {
       applyTextStyle(model.tmContext, value.textStyle);
       model.tmContext.fillText(key, 1, value.startingHeight + value.height - 1);
     });
-
     model.tmTexture.setCanvas(model.tmCanvas);
     model.tmTexture.modified();
-  }; // Make sure the data is correct
-
+  };
 
-  publicAPI.onModified(function () {
+  // Make sure the data is correct
+  publicAPI.onModified(() => {
     model.forceUpdate = true;
     publicAPI.update();
   });
-
-  publicAPI.setTickTextStyle = function (tickStyle) {
-    model.tickTextStyle = _objectSpread(_objectSpread({}, model.tickTextStyle), tickStyle);
+  publicAPI.setTickTextStyle = tickStyle => {
+    model.tickTextStyle = {
+      ...model.tickTextStyle,
+      ...tickStyle
+    };
     publicAPI.modified();
   };
-
-  publicAPI.setAxisTextStyle = function (axisStyle) {
-    model.axisTextStyle = _objectSpread(_objectSpread({}, model.axisTextStyle), axisStyle);
+  publicAPI.setAxisTextStyle = axisStyle => {
+    model.axisTextStyle = {
+      ...model.axisTextStyle,
+      ...axisStyle
+    };
     publicAPI.modified();
   };
+  publicAPI.get_tmAtlas = () => model._tmAtlas;
 
-  publicAPI.get_tmAtlas = function () {
-    return model._tmAtlas;
-  }; // try to get the bounds for the annotation. This is complicated
+  // try to get the bounds for the annotation. This is complicated
   // as it relies on the pixel size of the window. Every time the camera
   // changes the bounds change. This method simplifies by just expanding
   // the grid bounds by a user specified factor.
-
-
-  publicAPI.getBounds = function () {
+  publicAPI.getBounds = () => {
     publicAPI.update();
     vtkBoundingBox.setBounds(model.bounds, model.gridActor.getBounds());
     vtkBoundingBox.scaleAboutCenter(model.bounds, model.boundsScaleFactor, model.boundsScaleFactor, model.boundsScaleFactor);
     return model.bounds;
-  }; // Make sure the grid share the actor property
-
+  };
 
-  var _setProp = macro.chain(publicAPI.setProperty, model.gridActor.setProperty);
+  // Make sure the grid share the actor property
+  const _setProp = macro.chain(publicAPI.setProperty, model.gridActor.setProperty);
+  publicAPI.setProperty = p => _setProp(p)[0];
+}
 
-  publicAPI.setProperty = function (p) {
-    return _setProp(p)[0];
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     boundsScaleFactor: 1.3,
     camera: null,
-    dataBounds: _toConsumableArray(vtkBoundingBox.INIT_BOUNDS),
+    dataBounds: [...vtkBoundingBox.INIT_BOUNDS],
     faceVisibilityAngle: 8,
     gridLines: true,
     axisLabels: null,
@@ -732,17 +696,21 @@ function defaultValues(initialValues) {
       fontStyle: 'normal',
       fontSize: 14,
       fontFamily: 'serif'
-    }
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    },
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, defaultValues(initialValues)); // Inheritance
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
 
-  vtkActor.extend(publicAPI, model, initialValues); // internal variables
+  // Inheritance
+  vtkActor.extend(publicAPI, model, initialValues);
 
+  // internal variables
   model.lastFacesToDraw = [false, false, false, false, false, false];
   model.axisLabels = ['X-Axis', 'Y-Axis', 'Z-Axis'];
   model.tickCounts = [];
@@ -750,8 +718,9 @@ function extend(publicAPI, model) {
   model.lastTickBounds = [];
   model.tmCanvas = document.createElement('canvas');
   model.tmContext = model.tmCanvas.getContext('2d');
-  model._tmAtlas = new Map(); // for texture atlas
+  model._tmAtlas = new Map();
 
+  // for texture atlas
   model.tmTexture = vtkTexture.newInstance();
   model.tmTexture.setInterpolate(false);
   publicAPI.getProperty().setDiffuse(0.0);
@@ -767,17 +736,22 @@ function extend(publicAPI, model) {
   macro.setGet(publicAPI, model, ['axisTitlePixelOffset', 'boundsScaleFactor', 'faceVisibilityAngle', 'gridLines', 'tickLabelPixelOffset']);
   macro.setGetArray(publicAPI, model, ['dataBounds'], 6);
   macro.setGetArray(publicAPI, model, ['axisLabels'], 3);
-  macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle', 'camera', 'tmTexture', 'textValues', 'textPolyData', 'tickCounts', 'gridActor']); // Object methods
+  macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle', 'camera', 'tmTexture', 'textValues', 'textPolyData', 'tickCounts', 'gridActor']);
 
+  // Object methods
   vtkCubeAxesActor(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCubeAxesActor'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCubeAxesActor');
+
+// ----------------------------------------------------------------------------
 
 var vtkCubeAxesActor$1 = {
-  newInstance: newInstance,
-  extend: extend,
-  newCubeAxesActorHelper: newCubeAxesActorHelper
+  newInstance,
+  extend,
+  newCubeAxesActorHelper
 };
 
 export { vtkCubeAxesActor$1 as default, extend, newInstance };