@kitware/vtk.js 34.16.3 → 34.16.7

package/Common/Core/VariantArray.js

@@ -11,10 +11,7 @@ function vtkVariantArray(publicAPI, model) {
   // Description:
   // Return the data component at the location specified by tupleIdx and
   // compIdx.
-  publicAPI.getComponent = function (tupleIdx) {
-    let compIdx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    return model.values[tupleIdx * model.numberOfComponents + compIdx];
-  };
+  publicAPI.getComponent = (tupleIdx, compIdx = 0) => model.values[tupleIdx * model.numberOfComponents + compIdx];
 
   // Description:
   // Set the data component at the location specified by tupleIdx and compIdx
@@ -29,8 +26,7 @@ function vtkVariantArray(publicAPI, model) {
     }
   };
   publicAPI.getData = () => model.values;
-  publicAPI.getTuple = function (idx) {
-    let tupleToFill = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  publicAPI.getTuple = (idx, tupleToFill = []) => {
     const numberOfComponents = model.numberOfComponents || 1;
     if (tupleToFill.length) {
       tupleToFill.length = numberOfComponents;
@@ -41,10 +37,7 @@ function vtkVariantArray(publicAPI, model) {
     }
     return tupleToFill;
   };
-  publicAPI.getTupleLocation = function () {
-    let idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
-    return idx * model.numberOfComponents;
-  };
+  publicAPI.getTupleLocation = (idx = 1) => idx * model.numberOfComponents;
   publicAPI.getNumberOfComponents = () => model.numberOfComponents;
   publicAPI.getNumberOfValues = () => model.values.length;
   publicAPI.getNumberOfTuples = () => model.values.length / model.numberOfComponents;
@@ -90,8 +83,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   if (!model.empty && !model.values && !model.size) {
     throw new TypeError('Cannot create vtkVariantArray object without: size > 0, values');

package/Common/DataModel/AbstractPointLocator.js

@@ -20,8 +20,7 @@ function defaultValues(initialValues) {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   vtkLocator.extend(publicAPI, model, defaultValues(initialValues));
 
   // Make this a VTK object

package/Common/DataModel/BoundingBox.js

@@ -255,8 +255,7 @@ function computeCornerPoints(bounds, point1, point2) {
   point2[2] = bounds[5];
   return point1;
 }
-function transformBounds(bounds, transform) {
-  let out = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+function transformBounds(bounds, transform, out = []) {
   const corners = getCorners(bounds, []);
   for (let i = 0; i < corners.length; ++i) {
     vec3.transformMat4(corners[i], corners[i], transform);
@@ -264,8 +263,7 @@ function transformBounds(bounds, transform) {
   reset(out);
   return addPoints(out, corners);
 }
-function computeScale3(bounds) {
-  let scale3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+function computeScale3(bounds, scale3 = []) {
   scale3[0] = 0.5 * (bounds[1] - bounds[0]);
   scale3[1] = 0.5 * (bounds[3] - bounds[2]);
   scale3[2] = 0.5 * (bounds[5] - bounds[4]);
@@ -403,7 +401,6 @@ function intersectPlane(bounds, origin, normal) {
   }
   return 0; // no intersection
 }
-
 function intersect(bounds, bBounds) {
   if (!(isValid(bounds) && isValid(bBounds))) {
     return false;
@@ -529,7 +526,6 @@ function cutWithPlane(bounds, origin, normal) {
     if (size === 0) {
       continue; // shouldn't happen
     }
-
     const ti = Math.abs(d[index[dir][i]]) / size;
     if (sign > 0 && ti < t) {
       t = ti;
@@ -575,8 +571,7 @@ function clampDivisions(targetBins, divs) {
  * @param {Array} [adjustedBounds] - Output array to store adjusted bounds if needed
  * @returns {Number} The actual total number of bins
  */
-function computeDivisions(bounds, totalBins, divs) {
-  let adjustedBounds = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
+function computeDivisions(bounds, totalBins, divs, adjustedBounds = []) {
   // This will always produce at least one bin
   // eslint-disable-next-line no-param-reassign
   totalBins = totalBins <= 0 ? 1 : totalBins;
@@ -713,10 +708,7 @@ class BoundingBox {
   reset() {
     return reset(this.bounds);
   }
-  addPoint() {
-    for (var _len = arguments.length, xyz = new Array(_len), _key = 0; _key < _len; _key++) {
-      xyz[_key] = arguments[_key];
-    }
+  addPoint(...xyz) {
     return addPoint(this.bounds, ...xyz);
   }
   addPoints(points) {
@@ -779,8 +771,7 @@ class BoundingBox {
   computeLocalBounds(u, v, w) {
     return computeLocalBounds(this.bounds, u, v, w);
   }
-  transformBounds(transform) {
-    let out = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  transformBounds(transform, out = []) {
     return transformBounds(this.bounds, transform, out);
   }
   computeScale3(scale3) {
@@ -807,8 +798,7 @@ class BoundingBox {
   contains(otherBounds) {
     return intersects(this.bounds, otherBounds);
   }
-  computeDivisions(totalBins, divs) {
-    let adjustedBounds = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  computeDivisions(totalBins, divs, adjustedBounds = []) {
     return computeDivisions(this.bounds, totalBins, divs, adjustedBounds);
   }
   distance2ToBounds(x) {

package/Common/DataModel/Box.js

@@ -102,11 +102,8 @@ function vtkBox(publicAPI, model) {
   model.classHierarchy.push('vtkBox');
 
   // TODO: replace with macro.setArray ?
-  publicAPI.setBounds = function () {
+  publicAPI.setBounds = (...bounds) => {
     let boundsArray = [];
-    for (var _len = arguments.length, bounds = new Array(_len), _key = 0; _key < _len; _key++) {
-      bounds[_key] = arguments[_key];
-    }
     if (Array.isArray(bounds[0])) {
       boundsArray = bounds[0];
     } else {
@@ -169,13 +166,13 @@ function vtkBox(publicAPI, model) {
     }
     return distance;
   };
-  publicAPI.addBounds = function () {
+  publicAPI.addBounds = (...bounds) => {
     let boundsArray = [];
-    if (Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
-      boundsArray = arguments.length <= 0 ? undefined : arguments[0];
+    if (Array.isArray(bounds[0])) {
+      boundsArray = bounds[0];
     } else {
-      for (let i = 0; i < arguments.length; i++) {
-        boundsArray.push(i < 0 || arguments.length <= i ? undefined : arguments[i]);
+      for (let i = 0; i < bounds.length; i++) {
+        boundsArray.push(bounds[i]);
       }
     }
     if (boundsArray.length !== 6) {
@@ -198,8 +195,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/CardinalSpline1D.js

@@ -82,8 +82,7 @@ function vtkCardinalSpline1D(publicAPI, model) {
 
   // --------------------------------------------------------------------------
 
-  publicAPI.computeOpenCoefficients = function (size, work, x, y) {
-    let options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  publicAPI.computeOpenCoefficients = (size, work, x, y, options = {}) => {
     if (!model.coefficients || model.coefficients.length !== 4 * size) {
       model.coefficients = new Float32Array(4 * size);
     }
@@ -216,8 +215,7 @@ const DEFAULT_VALUES = {};
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   vtkSpline1D.extend(publicAPI, model, initialValues);
 

package/Common/DataModel/Cell.js

@@ -9,8 +9,7 @@ import vtkPoints from '../Core/Points.js';
 function vtkCell(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCell');
-  publicAPI.initialize = function (points) {
-    let pointIdsList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  publicAPI.initialize = (points, pointIdsList = null) => {
     if (!pointIdsList) {
       model.points = points;
       model.pointsIds = new Array(points.getNumberOfPoints());
@@ -81,8 +80,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   if (!model.points) {

package/Common/DataModel/CellLinks.js

@@ -95,8 +95,7 @@ function vtkCellLinks(publicAPI, model) {
    * Allocate the specified number of links (i.e., number of points) that
    * will be built.
    */
-  publicAPI.allocate = function (numLinks) {
-    let ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  publicAPI.allocate = (numLinks, ext = 1000) => {
     model.array = Array(numLinks).fill().map(() => ({
       ncells: 0,
       cells: null
@@ -237,8 +236,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   vtkCellLinks(publicAPI, model);

package/Common/DataModel/CellTypes.js

@@ -56,9 +56,7 @@ function vtkCellTypes(publicAPI, model) {
   /**
    * Allocate memory for this array. Delete old storage only if necessary.
    */
-  publicAPI.allocate = function () {
-    let sz = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 512;
-    let ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  publicAPI.allocate = (sz = 512, ext = 1000) => {
     model.size = sz > 0 ? sz : 1;
     model.extend = ext > 0 ? ext : 1;
     model.maxId = -1;
@@ -176,8 +174,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['size', 'maxId', 'extend']);

package/Common/DataModel/Collection.js

@@ -72,8 +72,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/Cone.js

@@ -38,8 +38,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/Cylinder.js

@@ -56,8 +56,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/DataSet/Constants.js

@@ -34,7 +34,6 @@ const FieldDataTypes = {
   // data specifying a table row
   ROW_DATA: 6 // to match VTK
 };
-
 const FieldAssociations = {
   FIELD_ASSOCIATION_POINTS: 0,
   FIELD_ASSOCIATION_CELLS: 1,

package/Common/DataModel/DataSet.js

@@ -82,8 +82,7 @@ function vtkDataSet(publicAPI, model) {
   publicAPI.getBounds = macro.chain(() => publicAPI.computeBounds, publicAPI.getBounds);
   publicAPI.getBoundsByReference = macro.chain(() => publicAPI.computeBounds, publicAPI.getBoundsByReference);
   const superShallowCopy = publicAPI.shallowCopy;
-  publicAPI.shallowCopy = function (other) {
-    let debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  publicAPI.shallowCopy = (other, debug = false) => {
     superShallowCopy(other, debug);
     DATASET_FIELDS.forEach(fieldName => {
       model[fieldName] = vtkDataSetAttributes.newInstance();
@@ -110,8 +109,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/DataSetAttributes/Constants.js

@@ -27,20 +27,17 @@ const CellGhostTypes = {
   // the cell is on the exterior of the data set
   HIDDENCELL: 32 // the cell is needed to maintain connectivity, but the data values should be ignored.
 };
-
 const PointGhostTypes = {
   DUPLICATEPOINT: 1,
   // the cell is present on multiple processors
   HIDDENPOINT: 2 // the point is needed to maintain connectivity, but the data values should be ignored.
 };
-
 const AttributeCopyOperations = {
   COPYTUPLE: 0,
   INTERPOLATE: 1,
   PASSDATA: 2,
   ALLCOPY: 3 // all of the above
 };
-
 const ghostArrayName = 'vtkGhostType';
 const DesiredOutputPrecision = {
   DEFAULT: 0,
@@ -49,7 +46,6 @@ const DesiredOutputPrecision = {
   // use Float32Array
   DOUBLE: 2 // use Float64Array
 };
-
 var Constants = {
   AttributeCopyOperations,
   AttributeLimitTypes,

package/Common/DataModel/DataSetAttributes/FieldData.js

@@ -39,7 +39,6 @@ function vtkFieldData(publicAPI, model) {
     })); // Deep-copy
     // TODO: Copy array information objects (once we support information objects)
   };
-
   publicAPI.getNumberOfArrays = () => model.arrays.length;
   publicAPI.getNumberOfActiveArrays = () => model.arrays.length;
   publicAPI.addArray = arr => {
@@ -92,9 +91,7 @@ function vtkFieldData(publicAPI, model) {
   };
   publicAPI.getCopyFieldFlags = () => model.copyFieldFlags;
   publicAPI.getFlag = arrayName => model.copyFieldFlags[arrayName];
-  publicAPI.passData = function (other) {
-    let fromId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
-    let toId = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+  publicAPI.passData = (other, fromId = -1, toId = -1) => {
     other.getArrays().forEach(arr => {
       const copyFlag = publicAPI.getFlag(arr.getName());
       if (copyFlag !== false && !(model.doCopyAllOff && copyFlag !== true) && arr) {
@@ -141,11 +138,7 @@ function vtkFieldData(publicAPI, model) {
       }
     });
   };
-  publicAPI.interpolateData = function (other) {
-    let fromId1 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
-    let fromId2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
-    let toId = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
-    let t = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0.5;
+  publicAPI.interpolateData = (other, fromId1 = -1, fromId2 = -1, toId = -1, t = 0.5) => {
     other.getArrays().forEach(arr => {
       const copyFlag = publicAPI.getFlag(arr.getName());
       if (copyFlag !== false && !(model.doCopyAllOff && copyFlag !== true) && arr) {
@@ -252,8 +245,7 @@ const DEFAULT_VALUES = {
   doCopyAllOn: true,
   doCopyAllOff: false
 };
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   vtkFieldData(publicAPI, model);

package/Common/DataModel/DataSetAttributes.js

@@ -176,8 +176,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/EdgeLocator.js

@@ -1,6 +1,5 @@
 class EdgeLocator {
-  constructor() {
-    let oriented = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  constructor(oriented = false) {
     this.oriented = oriented;
     this.edgeMap = new Map();
   }
@@ -49,8 +48,7 @@ class EdgeLocator {
     return [pointId0, pointId1];
   }
 }
-function newInstance() {
-  let initialValues = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+function newInstance(initialValues = {}) {
   return new EdgeLocator(initialValues.oriented);
 }
 var vtkEdgeLocator = {

package/Common/DataModel/ITKHelper.js

@@ -54,8 +54,7 @@ const itkComponentTypeToVtkArrayType = new Map([['uint8', 'Uint8Array'], ['int8'
  *
  * Requires an itk-wasm Image as input.
  */
-function convertItkToVtkImage(itkImage) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function convertItkToVtkImage(itkImage, options = {}) {
   const vtkImage = {
     origin: [0, 0, 0],
     spacing: [1, 1, 1]
@@ -156,8 +155,7 @@ function convertItkToVtkImage(itkImage) {
  * Requires a vtk.js vtkImageData as input.
  *
  */
-function convertVtkToItkImage(vtkImage) {
-  let copyData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+function convertVtkToItkImage(vtkImage, copyData = false) {
   const dimension = 3;
   const itkImage = {
     imageType: {
@@ -206,8 +204,7 @@ function convertVtkToItkImage(vtkImage) {
  *
  * Requires an itk-wasm PolyData as input.
  */
-function convertItkToVtkPolyData(itkPolyData) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function convertItkToVtkPolyData(itkPolyData, options = {}) {
   const pointDataArrays = [];
   if (itkPolyData.pointData.length) {
     pointDataArrays.push({
@@ -427,8 +424,7 @@ function convertItkToVtkPolyData(itkPolyData) {
  * Requires a vtk.js vtkPolyData as input.
  *
  */
-function convertVtkToItkPolyData(polyData) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+function convertVtkToItkPolyData(polyData, options = {}) {
   const itkPolyData = {
     polyDataType: {
       pointPixelComponentType: 'float32',

package/Common/DataModel/ImageData.js

@@ -17,14 +17,11 @@ const {
 function vtkImageData(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageData');
-  publicAPI.setExtent = function () {
+  publicAPI.setExtent = (...inExtent) => {
     if (model.deleted) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return false;
     }
-    for (var _len = arguments.length, inExtent = new Array(_len), _key = 0; _key < _len; _key++) {
-      inExtent[_key] = arguments[_key];
-    }
     const extentArray = inExtent.length === 1 ? inExtent[0] : inExtent;
     if (extentArray.length !== 6) {
       return false;
@@ -37,7 +34,7 @@ function vtkImageData(publicAPI, model) {
     }
     return changeDetected;
   };
-  publicAPI.setDimensions = function () {
+  publicAPI.setDimensions = (...dims) => {
     let i;
     let j;
     let k;
@@ -45,15 +42,15 @@ function vtkImageData(publicAPI, model) {
       vtkErrorMacro('instance deleted - cannot call any method');
       return;
     }
-    if (arguments.length === 1) {
-      const array = arguments.length <= 0 ? undefined : arguments[0];
+    if (dims.length === 1) {
+      const array = dims[0];
       i = array[0];
       j = array[1];
       k = array[2];
-    } else if (arguments.length === 3) {
-      i = arguments.length <= 0 ? undefined : arguments[0];
-      j = arguments.length <= 1 ? undefined : arguments[1];
-      k = arguments.length <= 2 ? undefined : arguments[2];
+    } else if (dims.length === 3) {
+      i = dims[0];
+      j = dims[1];
+      k = dims[2];
     } else {
       vtkErrorMacro('Bad dimension specification');
       return;
@@ -171,26 +168,18 @@ function vtkImageData(publicAPI, model) {
     mat4.scale(model.indexToWorld, model.indexToWorld, model.spacing);
     mat4.invert(model.worldToIndex, model.indexToWorld);
   };
-  publicAPI.indexToWorld = function (ain) {
-    let aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  publicAPI.indexToWorld = (ain, aout = []) => {
     vec3.transformMat4(aout, ain, model.indexToWorld);
     return aout;
   };
   publicAPI.indexToWorldVec3 = publicAPI.indexToWorld;
-  publicAPI.worldToIndex = function (ain) {
-    let aout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  publicAPI.worldToIndex = (ain, aout = []) => {
     vec3.transformMat4(aout, ain, model.worldToIndex);
     return aout;
   };
   publicAPI.worldToIndexVec3 = publicAPI.worldToIndex;
-  publicAPI.indexToWorldBounds = function (bin) {
-    let bout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    return vtkBoundingBox.transformBounds(bin, model.indexToWorld, bout);
-  };
-  publicAPI.worldToIndexBounds = function (bin) {
-    let bout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-    return vtkBoundingBox.transformBounds(bin, model.worldToIndex, bout);
-  };
+  publicAPI.indexToWorldBounds = (bin, bout = []) => vtkBoundingBox.transformBounds(bin, model.indexToWorld, bout);
+  publicAPI.worldToIndexBounds = (bin, bout = []) => vtkBoundingBox.transformBounds(bin, model.worldToIndex, bout);
 
   // Make sure the transform is correct
   model._onOriginChanged = publicAPI.computeTransforms;
@@ -198,8 +187,7 @@ function vtkImageData(publicAPI, model) {
   model._onSpacingChanged = publicAPI.computeTransforms;
   publicAPI.computeTransforms();
   publicAPI.getCenter = () => vtkBoundingBox.getCenter(publicAPI.getBounds());
-  publicAPI.computeHistogram = function (worldBounds) {
-    let voxelFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  publicAPI.computeHistogram = (worldBounds, voxelFunction = null) => {
     const bounds = [0, 0, 0, 0, 0, 0];
     publicAPI.worldToIndexBounds(worldBounds, bounds);
     const point1 = [0, 0, 0];
@@ -249,8 +237,7 @@ function vtkImageData(publicAPI, model) {
 
   // TODO: use the unimplemented `vtkDataSetAttributes` for scalar length, that is currently also a TODO (GetNumberOfComponents).
   // Scalar data could be tuples for color information?
-  publicAPI.computeIncrements = function (extent) {
-    let numberOfComponents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  publicAPI.computeIncrements = (extent, numberOfComponents = 1) => {
     const increments = [];
     let incr = numberOfComponents;
 
@@ -267,8 +254,7 @@ function vtkImageData(publicAPI, model) {
    * @param {Number[]} index the localized `[i,j,k]` pixel array position. Float values will be rounded.
    * @return {Number} the corresponding flattened index in the scalar array
    */
-  publicAPI.computeOffsetIndex = _ref => {
-    let [i, j, k] = _ref;
+  publicAPI.computeOffsetIndex = ([i, j, k]) => {
     const extent = publicAPI.getExtent();
     const numberOfComponents = publicAPI.getPointData().getScalars().getNumberOfComponents();
     const increments = publicAPI.computeIncrements(extent, numberOfComponents);
@@ -302,8 +288,7 @@ function vtkImageData(publicAPI, model) {
    * @param {Number?} comp the scalar component index for multi-component scalars
    * @return {Number|NaN} the corresponding pixel's scalar value
    */
-  publicAPI.getScalarValueFromWorld = function (xyz) {
-    let comp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  publicAPI.getScalarValueFromWorld = (xyz, comp = 0) => {
     const numberOfComponents = publicAPI.getPointData().getScalars().getNumberOfComponents();
     if (comp < 0 || comp >= numberOfComponents) {
       vtkErrorMacro(`GetScalarPointer: Scalar Component ${comp} is not within bounds. Current Scalar numberOfComponents: ${numberOfComponents}`);
@@ -348,8 +333,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Inheritance

package/Common/DataModel/ImplicitBoolean.js

@@ -113,8 +113,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/ImplicitFunction.js

@@ -36,8 +36,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Object methods

package/Common/DataModel/IncrementalOctreeNode.js

@@ -580,8 +580,7 @@ const DEFAULT_VALUES = {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Make this a VTK object

package/Common/DataModel/IncrementalOctreePointLocator.js

@@ -99,7 +99,7 @@ function vtkIncrementalOctreePointLocator(publicAPI, model) {
   };
 
   //------------------------------------------------------------------------------
-  publicAPI.initPointInsertion = function (points, bounds) {
+  publicAPI.initPointInsertion = (points, bounds, estNumPts = 0) => {
     let i = 0;
     let bbIndex = 0;
     if (points == null) {
@@ -334,8 +334,7 @@ function defaultValues(initialValues) {
 
 // ----------------------------------------------------------------------------
 
-function extend(publicAPI, model) {
-  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function extend(publicAPI, model, initialValues = {}) {
   vtkAbstractPointLocator.extend(publicAPI, model, defaultValues(initialValues));
 
   // Make this a VTK object