@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/ContourTriangulator.js

@@ -1,45 +1,43 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkPolygon from '../../Common/DataModel/Polygon.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 import { vtkCCSMakePolysFromLines, vtkCCSJoinLooseEnds, vtkCCSFindTrueEdges, vtkCCSMakeHoleyPolys, vtkCCSCutHoleyPolys, vtkCCSSplitAtPinchPoints, vtkCCSTriangulate } from './ContourTriangulator/helper.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; }
-var vtkErrorMacro = macro.vtkErrorMacro;
-var TRIANGULATION_ERROR_DISPLAY = false;
+const {
+  vtkErrorMacro
+} = macro;
+const TRIANGULATION_ERROR_DISPLAY = false;
 
+//------------------------------------------------------------------------------
 function triangulateContours(polyData, firstLine, numLines, polys, normal) {
-  var triangulatePolys = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
-  var triangulationFailure = false; // If no cut lines were generated, there's nothing to do
+  let triangulatePolys = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
+  let triangulationFailure = false;
 
+  // If no cut lines were generated, there's nothing to do
   if (numLines <= 0) {
     return false;
   }
+  const points = polyData.getPoints();
 
-  var points = polyData.getPoints(); // Join all the new lines into connected groups, i.e. polygons.
+  // Join all the new lines into connected groups, i.e. polygons.
   // If we are lucky these will be simple, convex polygons. But
   // we can't count on that.
 
-  var newPolys = [];
-  var incompletePolys = [];
-  var oriented = (normal === null || normal === void 0 ? void 0 : normal.length) < 3;
-  vtkCCSMakePolysFromLines(polyData, firstLine, firstLine + numLines, oriented, newPolys, incompletePolys); // if no normal specified, then compute one from largest contour
-
-  var computedNormal = normal;
+  const newPolys = [];
+  const incompletePolys = [];
+  const oriented = normal?.length < 3;
+  vtkCCSMakePolysFromLines(polyData, firstLine, firstLine + numLines, oriented, newPolys, incompletePolys);
 
+  // if no normal specified, then compute one from largest contour
+  let computedNormal = normal;
   if (!oriented) {
     computedNormal = [0, 0, 1];
-    var maxnorm = 0;
-    var n = [];
-
-    for (var i = 0; i < newPolys.length; i++) {
-      var norm = vtkPolygon.getNormal(newPolys[i], points, n);
-
+    let maxnorm = 0;
+    const n = [];
+    for (let i = 0; i < newPolys.length; i++) {
+      const norm = vtkPolygon.getNormal(newPolys[i], points, n);
       if (norm > maxnorm) {
         maxnorm = norm;
         computedNormal[0] = n[0];
@@ -47,116 +45,112 @@ function triangulateContours(polyData, firstLine, numLines, polys, normal) {
         computedNormal[2] = n[2];
       }
     }
-  } // Join any loose ends. If the input was a closed surface then there
+  }
+
+  // Join any loose ends. If the input was a closed surface then there
   // will not be any loose ends, so this is provided as a service to users
   // who want to clip a non-closed surface.
+  vtkCCSJoinLooseEnds(newPolys, incompletePolys, points, computedNormal);
 
-
-  vtkCCSJoinLooseEnds(newPolys, incompletePolys, points, computedNormal); // Some points might be in the middle of straight line segments.
+  // Some points might be in the middle of straight line segments.
   // These points can be removed without changing the shape of the
   // polys, and removing them makes triangulation more stable.
   // Unfortunately removing these points also means that the polys
   // will no longer form a watertight cap over the cut.
 
-  var polyEdges = [];
-  var originalEdges = [];
-  vtkCCSFindTrueEdges(newPolys, points, polyEdges, originalEdges); // Next we have to check for polygons with holes, i.e. polygons that
+  const polyEdges = [];
+  const originalEdges = [];
+  vtkCCSFindTrueEdges(newPolys, points, polyEdges, originalEdges);
+
+  // Next we have to check for polygons with holes, i.e. polygons that
   // have other polygons inside. Each polygon is "grouped" with the
   // polygons that make up its holes.
-  // Initialize each group to hold just one polygon.
 
-  var numNewPolys = newPolys.length;
-  var polyGroups = new Array(numNewPolys);
+  // Initialize each group to hold just one polygon.
+  const numNewPolys = newPolys.length;
+  const polyGroups = new Array(numNewPolys);
+  for (let i = 0; i < numNewPolys; i++) {
+    polyGroups[i] = [i];
+  }
 
-  for (var _i = 0; _i < numNewPolys; _i++) {
-    polyGroups[_i] = [_i];
-  } // Find out which polys are holes in larger polys. Create a group
+  // Find out which polys are holes in larger polys. Create a group
   // for each poly where the first member of the group is the larger
   // poly, and all other members are the holes. The number of polyGroups
   // will be the same as the number of polys, and any polys that are
   // holes will have a matching empty group.
 
+  vtkCCSMakeHoleyPolys(newPolys, points, polyGroups, polyEdges, originalEdges, computedNormal, oriented);
 
-  vtkCCSMakeHoleyPolys(newPolys, points, polyGroups, polyEdges, originalEdges, computedNormal, oriented); // Make cuts to create simple polygons out of the holey polys.
+  // Make cuts to create simple polygons out of the holey polys.
   // After this is done, each polyGroup will have exactly 1 polygon,
   // and no polys will be holes. This is currently the most computationally
   // expensive part of the process.
 
   if (!vtkCCSCutHoleyPolys(newPolys, points, polyGroups, polyEdges, computedNormal)) {
     triangulationFailure = true;
-  } // Some polys might be self-intersecting. Split the polys at each intersection point.
+  }
 
+  // Some polys might be self-intersecting. Split the polys at each intersection point.
+  vtkCCSSplitAtPinchPoints(newPolys, points, polyGroups, polyEdges, computedNormal, oriented);
 
-  vtkCCSSplitAtPinchPoints(newPolys, points, polyGroups, polyEdges, computedNormal, oriented); // ------ Triangulation code ------
-  // Go through all polys and triangulate them
+  // ------ Triangulation code ------
 
-  for (var polyId = 0; polyId < polyGroups.length; polyId++) {
+  // Go through all polys and triangulate them
+  for (let polyId = 0; polyId < polyGroups.length; polyId++) {
     // If group is empty, then poly was a hole without a containing poly
     if (polyGroups[polyId].length === 0) {
       // eslint-disable-next-line no-continue
       continue;
     }
-
     if (!triangulatePolys) {
       polys.insertNextCell(originalEdges.slice(1, originalEdges.length));
     } else if (!vtkCCSTriangulate(newPolys[polyId], points, polyEdges[polyId], originalEdges, polys, computedNormal)) {
-      triangulationFailure = false; // Diagnostic code: show the polys as outlines
+      triangulationFailure = false;
     }
   }
-
   return !triangulationFailure;
-} // ---------------------------------------------------
-
+}
 
+// ---------------------------------------------------
 function triangulatePolygon(polygon, points, triangles) {
-  var poly = _toConsumableArray(polygon);
-
-  var polys = [poly];
-  var originalEdges = [];
-  var polyEdges = [];
+  const poly = [...polygon];
+  const polys = [poly];
+  const originalEdges = [];
+  const polyEdges = [];
   vtkCCSFindTrueEdges(polys, points, polyEdges, originalEdges);
-  var edges = polyEdges[0];
-  var success = true;
-  var normal = [];
-  var norm = vtkPolygon.getNormal(poly, points, normal);
-
+  const edges = polyEdges[0];
+  let success = true;
+  const normal = [];
+  const norm = vtkPolygon.getNormal(poly, points, normal);
   if (norm !== 0) {
     success = vtkCCSTriangulate(poly, points, edges, originalEdges, triangles, normal);
   }
-
   return success;
 }
-
-var STATIC = {
-  triangulateContours: triangulateContours,
-  triangulatePolygon: triangulatePolygon
+const STATIC = {
+  triangulateContours,
+  triangulatePolygon
 };
-
 function vtkContourTriangulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkContourTriangulator');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0]; // FIXME: do not instantiate a new polydata each time the filter is executed.
-
-    var output = vtkPolyData.newInstance();
+    const input = inData[0];
+    // FIXME: do not instantiate a new polydata each time the filter is executed.
+    const output = vtkPolyData.newInstance();
     outData[0] = output;
-
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return false;
     }
-
-    var triangulationError = false;
-    var lines = input.getLines();
-
+    let triangulationError = false;
+    const lines = input.getLines();
     if (lines == null || lines.getNumberOfCells() === 0) {
       return true;
     }
-
     input.buildCells();
-    var polysArray = vtkCellArray.newInstance({
+    const polysArray = vtkCellArray.newInstance({
       dataType: VtkDataTypes.DOUBLE,
       empty: true
     });
@@ -164,39 +158,48 @@ function vtkContourTriangulator(publicAPI, model) {
     output.setPoints(input.getPoints());
     output.getPointData().passData(input.getPointData());
     triangulationError = !triangulateContours(input, input.getNumberOfVerts(), lines.getNumberOfCells(), polysArray, null, model.triangulatePolys);
-
     if (triangulationError && TRIANGULATION_ERROR_DISPLAY) {
       vtkErrorMacro('Triangulation failed, output might have holes.');
     }
-
     return true;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   triangulatePolys: true
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
 
+  // Also make it an algorithm with one input and one output
   macro.algo(publicAPI, model, 1, 1);
-  macro.setGet(publicAPI, model, ['triangulatePolys']); // Object specific methods
+  macro.setGet(publicAPI, model, ['triangulatePolys']);
 
+  // Object specific methods
   vtkContourTriangulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkContourTriangulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkContourTriangulator');
 
-var vtkContourTriangulator$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+// ----------------------------------------------------------------------------
+
+var vtkContourTriangulator$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkContourTriangulator$1 as default, extend, newInstance };

package/Filters/General/ImageCropFilter.js

@@ -1,158 +1,157 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkImageCropFilter methods
 // ----------------------------------------------------------------------------
 
 function vtkImageCropFilter(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkImageCropFilter'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkImageCropFilter');
 
-  publicAPI.reset = function () {
-    var data = publicAPI.getInputData();
+  // --------------------------------------------------------------------------
 
+  publicAPI.reset = () => {
+    const data = publicAPI.getInputData();
     if (data) {
-      publicAPI.setCroppingPlanes.apply(publicAPI, _toConsumableArray(data.getExtent()));
+      publicAPI.setCroppingPlanes(...data.getExtent());
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-
+    const input = inData[0];
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-
-    var scalars = input.getPointData().getScalars();
-
+    const scalars = input.getPointData().getScalars();
     if (!scalars) {
       vtkErrorMacro('No scalars from input');
       return;
     }
-
-    var extent = input.getExtent();
-    var cropped = model.croppingPlanes && model.croppingPlanes.length === 6 ? extent.map(function (e, i) {
+    const extent = input.getExtent();
+    const cropped = model.croppingPlanes && model.croppingPlanes.length === 6 ? extent.map((e, i) => {
       if (i % 2 === 0) {
         // min plane
         return Math.max(e, Math.round(model.croppingPlanes[i]));
-      } // max plane
-
-
+      }
+      // max plane
       return Math.min(e, Math.round(model.croppingPlanes[i]));
     }) : extent.slice();
-
     if (cropped[0] === extent[0] && cropped[1] === extent[1] && cropped[2] === extent[2] && cropped[3] === extent[3] && cropped[4] === extent[4] && cropped[5] === extent[5]) {
-      var sameAsInput = vtkImageData.newInstance();
+      const sameAsInput = vtkImageData.newInstance();
       sameAsInput.shallowCopy(input); // Force new mtime
-
       outData[0] = sameAsInput;
       return;
-    } // reorder if needed
-
+    }
 
-    for (var i = 0; i < 3; ++i) {
+    // reorder if needed
+    for (let i = 0; i < 3; ++i) {
       if (cropped[i * 2] > cropped[i * 2 + 1]) {
-        var _ref = [cropped[i * 2 + 1], cropped[i * 2]];
-        cropped[i * 2] = _ref[0];
-        cropped[i * 2 + 1] = _ref[1];
+        [cropped[i * 2], cropped[i * 2 + 1]] = [cropped[i * 2 + 1], cropped[i * 2]];
       }
-    } // restrict crop bounds based on extent bounds
-
+    }
 
-    for (var _i = 0; _i < 6; _i += 2) {
+    // restrict crop bounds based on extent bounds
+    for (let i = 0; i < 6; i += 2) {
       // min case
-      cropped[_i] = Math.max(cropped[_i], extent[_i]); // max case
-
-      cropped[_i + 1] = Math.min(cropped[_i + 1], extent[_i + 1]);
+      cropped[i] = Math.max(cropped[i], extent[i]);
+      // max case
+      cropped[i + 1] = Math.min(cropped[i + 1], extent[i + 1]);
     }
+    const numberOfComponents = scalars.getNumberOfComponents();
+    const componentSize = (cropped[1] - cropped[0] + 1) * (cropped[3] - cropped[2] + 1) * (cropped[5] - cropped[4] + 1) * numberOfComponents;
+    const scalarsData = scalars.getData();
+    const dims = input.getDimensions();
+    const jStride = numberOfComponents * dims[0];
+    const kStride = numberOfComponents * dims[0] * dims[1];
+    const beginOffset = (cropped[0] - extent[0]) * numberOfComponents;
+    const stripSize = (cropped[1] - cropped[0] + 1) * numberOfComponents; // +1 because subarray end is exclusive
 
-    var numberOfComponents = scalars.getNumberOfComponents();
-    var componentSize = (cropped[1] - cropped[0] + 1) * (cropped[3] - cropped[2] + 1) * (cropped[5] - cropped[4] + 1) * numberOfComponents;
-    var scalarsData = scalars.getData();
-    var dims = input.getDimensions();
-    var jStride = numberOfComponents * dims[0];
-    var kStride = numberOfComponents * dims[0] * dims[1];
-    var beginOffset = (cropped[0] - extent[0]) * numberOfComponents;
-    var stripSize = (cropped[1] - cropped[0] + 1) * numberOfComponents; // +1 because subarray end is exclusive
     // crop image
-
-    var croppedArray = new scalarsData.constructor(componentSize);
-    var index = 0;
-
-    for (var k = cropped[4]; k <= cropped[5]; ++k) {
-      for (var j = cropped[2]; j <= cropped[3]; ++j) {
-        var begin = beginOffset + (j - extent[2]) * jStride + (k - extent[4]) * kStride;
-        var end = begin + stripSize;
-        var slice = scalarsData.subarray(begin, end);
+    const croppedArray = new scalarsData.constructor(componentSize);
+    let index = 0;
+    for (let k = cropped[4]; k <= cropped[5]; ++k) {
+      for (let j = cropped[2]; j <= cropped[3]; ++j) {
+        const begin = beginOffset + (j - extent[2]) * jStride + (k - extent[4]) * kStride;
+        const end = begin + stripSize;
+        const slice = scalarsData.subarray(begin, end);
         croppedArray.set(slice, index);
         index += slice.length;
       }
     }
-
-    var outImage = vtkImageData.newInstance({
+    const outImage = vtkImageData.newInstance({
       extent: cropped,
       origin: input.getOrigin(),
       direction: input.getDirection(),
       spacing: input.getSpacing()
     });
-    var croppedScalars = vtkDataArray.newInstance({
+    const croppedScalars = vtkDataArray.newInstance({
       name: scalars.getName(),
-      numberOfComponents: numberOfComponents,
+      numberOfComponents,
       values: croppedArray
     });
     outImage.getPointData().setScalars(croppedScalars);
     outData[0] = outImage;
   };
-
-  publicAPI.isResetAvailable = function () {
+  publicAPI.isResetAvailable = () => {
     if (model.croppingPlanes == null || model.croppingPlanes.length === 0) {
       return false;
     }
-
-    var data = publicAPI.getInputData();
-
+    const data = publicAPI.getInputData();
     if (data) {
-      var originalExtent = data.getExtent();
-      var findDifference = originalExtent.find(function (v, i) {
-        return Math.abs(model.croppingPlanes[i] - v) > Number.EPSILON;
-      });
+      const originalExtent = data.getExtent();
+      const findDifference = originalExtent.find((v, i) => Math.abs(model.croppingPlanes[i] - v) > Number.EPSILON);
       return findDifference !== undefined;
     }
-
     return false;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {
+  // croppingPlanes: null,
+};
 
-var DEFAULT_VALUES = {// croppingPlanes: null,
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
 
-  macro.algo(publicAPI, model, 1, 1); // no orientation support yet
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 1, 1);
 
-  macro.setGetArray(publicAPI, model, ['croppingPlanes'], 6); // Object specific methods
+  // no orientation support yet
+  macro.setGetArray(publicAPI, model, ['croppingPlanes'], 6);
 
+  // Object specific methods
   vtkImageCropFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageCropFilter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageCropFilter');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageCropFilter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageCropFilter$1 as default, extend, newInstance };

package/Filters/General/ImageDataOutlineFilter.js

@@ -1,82 +1,88 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCubeSource from '../Sources/CubeSource.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; }
+const {
+  vtkErrorMacro
+} = macro;
 
-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; }
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkImageDataOutlineFilter methods
 // ----------------------------------------------------------------------------
 
 function vtkImageDataOutlineFilter(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkImageDataOutlineFilter'); // Capture "parentClass" api for internal use
-
-  var superClass = _objectSpread({}, publicAPI);
+  model.classHierarchy.push('vtkImageDataOutlineFilter');
 
-  publicAPI.requestData = function (inData, outData) {
+  // Capture "parentClass" api for internal use
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-
+    const input = inData[0];
     if (!input || !input.isA('vtkImageData')) {
       vtkErrorMacro('Invalid or missing input');
       return;
-    } // First create a cube polydata in the index-space of the image.
+    }
+
+    // First create a cube polydata in the index-space of the image.
     // The benefit of using `getSpatialExtent` call is that it automatically
     // takes care of 0.5 voxel padding as required by an vtkImageData representation.
-
-
-    var spatialExt = input.getSpatialExtent();
-
+    const spatialExt = input.getSpatialExtent();
     if (!spatialExt) {
       vtkErrorMacro('Unable to fetch spatial extents of input image.');
       return;
     }
+    model._cubeSource.setBounds(spatialExt);
 
-    model._cubeSource.setBounds(spatialExt); // Then apply index-to-world transform to the cube to create the outline.
-
-
+    // Then apply index-to-world transform to the cube to create the outline.
     model._cubeSource.setMatrix(input.getIndexToWorld());
-
     outData[0] = model._cubeSource.getOutputData();
   };
+  publicAPI.getMTime = () => Math.max(superClass.getMTime(), model._cubeSource.getMTime());
 
-  publicAPI.getMTime = function () {
-    return Math.max(superClass.getMTime(), model._cubeSource.getMTime());
-  }; // Forward calls for [set/get]Generate[Faces/Lines] functions to cubeSource:
-
-
+  // Forward calls for [set/get]Generate[Faces/Lines] functions to cubeSource:
   publicAPI.setGenerateFaces = model._cubeSource.setGenerateFaces;
   publicAPI.setGenerateLines = model._cubeSource.setGenerateLines;
   publicAPI.getGenerateFaces = model._cubeSource.getGenerateFaces;
   publicAPI.getGenerateLines = model._cubeSource.getGenerateLines;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Make this a VTK object
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.obj(publicAPI, model); // Also make it an algorithm with one input and one output
+  // Make this a VTK object
+  macro.obj(publicAPI, model);
 
-  macro.algo(publicAPI, model, 1, 1); // Internal persistent objects
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 1, 1);
 
+  // Internal persistent objects
   model._cubeSource = vtkCubeSource.newInstance();
-  macro.moveToProtected(publicAPI, model, ['cubeSource', 'tmpOut']); // Object specific methods
+  macro.moveToProtected(publicAPI, model, ['cubeSource', 'tmpOut']);
 
+  // Object specific methods
   vtkImageDataOutlineFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkImageDataOutlineFilter'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkImageDataOutlineFilter');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageDataOutlineFilter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageDataOutlineFilter$1 as default, extend, newInstance };