@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/ImageMarchingSquares.js

@@ -1,11 +1,14 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkEdgeLocator from '../../Common/DataModel/EdgeLocator.js';
 import vtkCaseTable from './ImageMarchingSquares/caseTable.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro,
-    vtkDebugMacro = macro.vtkDebugMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro,
+  vtkDebugMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkImageMarchingSquares methods
 // ----------------------------------------------------------------------------
 
@@ -15,10 +18,8 @@ function vtkImageMarchingSquares(publicAPI, model) {
    * @returns {[number, number]}
    */
   function getKernels() {
-    var kernelX = 0; // default K slicing mode
-
-    var kernelY = 1;
-
+    let kernelX = 0; // default K slicing mode
+    let kernelY = 1;
     if (model.slicingMode === 1) {
       kernelX = 0;
       kernelY = 2;
@@ -26,35 +27,31 @@ function vtkImageMarchingSquares(publicAPI, model) {
       kernelX = 1;
       kernelY = 2;
     }
-
     return [kernelX, kernelY];
-  } // Set our className
-
+  }
 
+  // Set our className
   model.classHierarchy.push('vtkImageMarchingSquares');
+
   /**
    * Get the list of contour values.
    * @returns {number[]}
    */
+  publicAPI.getContourValues = () => model.contourValues;
 
-  publicAPI.getContourValues = function () {
-    return model.contourValues;
-  };
   /**
    * Set the list contour values.
    * @param {number[]} cValues
    */
-
-
-  publicAPI.setContourValues = function (cValues) {
+  publicAPI.setContourValues = cValues => {
     model.contourValues = cValues;
     publicAPI.modified();
   };
+  const ids = [];
+  const pixelScalars = [];
+  const pixelPts = [];
+  const edgeLocator = vtkEdgeLocator.newInstance();
 
-  var ids = [];
-  var pixelScalars = [];
-  var pixelPts = [];
-  var edgeLocator = vtkEdgeLocator.newInstance();
   /**
    * Retrieve scalars and pixel coordinates.
    * @param {Vector3} ijk origin of the pixel
@@ -64,27 +61,21 @@ function vtkImageMarchingSquares(publicAPI, model) {
    * @param {number} kernelX index of the X element
    * @param {number} kernelY index of the Y element
    */
+  publicAPI.getPixelScalars = (ijk, dims, scalars, increments, kernelX, kernelY) => {
+    const [i, j, k] = ijk;
 
-  publicAPI.getPixelScalars = function (ijk, dims, scalars, increments, kernelX, kernelY) {
-    var _ijk = _slicedToArray(ijk, 3),
-        i = _ijk[0],
-        j = _ijk[1],
-        k = _ijk[2]; // First get the indices for the pixel
-
-
+    // First get the indices for the pixel
     ids[0] = k * dims[1] * dims[0] + j * dims[0] + i; // i, j, k
-
     ids[1] = ids[0] + increments[kernelX]; // i+1, j, k
-
     ids[2] = ids[0] + increments[kernelY]; // i, j+1, k
-
     ids[3] = ids[2] + increments[kernelX]; // i+1, j+1, k
-    // Now retrieve the scalars
 
-    for (var ii = 0; ii < 4; ++ii) {
+    // Now retrieve the scalars
+    for (let ii = 0; ii < 4; ++ii) {
       pixelScalars[ii] = scalars[ids[ii]];
     }
   };
+
   /**
    * Retrieve pixel coordinates.
    * @param {Vector3} ijk origin of the pixel
@@ -93,25 +84,21 @@ function vtkImageMarchingSquares(publicAPI, model) {
    * @param {number} kernelX index of the X element
    * @param {number} kernelY index of the Y element
    */
+  publicAPI.getPixelPoints = (ijk, origin, spacing, kernelX, kernelY) => {
+    const i = ijk[kernelX];
+    const j = ijk[kernelY];
 
-
-  publicAPI.getPixelPoints = function (ijk, origin, spacing, kernelX, kernelY) {
-    var i = ijk[kernelX];
-    var j = ijk[kernelY]; // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
-
+    // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
     pixelPts[0] = origin[kernelX] + i * spacing[kernelX]; // 0
-
     pixelPts[1] = origin[kernelY] + j * spacing[kernelY];
     pixelPts[2] = pixelPts[0] + spacing[kernelX]; // 1
-
     pixelPts[3] = pixelPts[1];
     pixelPts[4] = pixelPts[0]; // 2
-
     pixelPts[5] = pixelPts[1] + spacing[kernelY];
     pixelPts[6] = pixelPts[2]; // 3
-
     pixelPts[7] = pixelPts[5];
   };
+
   /**
    * Produce points and lines for the polydata.
    * @param {number[]} cVal list of contour values
@@ -126,159 +113,147 @@ function vtkImageMarchingSquares(publicAPI, model) {
    * @param {number} kernelX index of the X element
    * @param {number} kernelY index of the Y element
    */
-
-
-  publicAPI.produceLines = function (cVal, ijk, dims, origin, spacing, scalars, points, lines, increments, kernelX, kernelY) {
-    var k = ijk[model.slicingMode];
-    var CASE_MASK = [1, 2, 8, 4]; // case table is actually for quad
-
-    var xyz = [];
-    var pId;
+  publicAPI.produceLines = (cVal, ijk, dims, origin, spacing, scalars, points, lines, increments, kernelX, kernelY) => {
+    const k = ijk[model.slicingMode];
+    const CASE_MASK = [1, 2, 8, 4]; // case table is actually for quad
+    const xyz = [];
+    let pId;
     publicAPI.getPixelScalars(ijk, dims, scalars, increments, kernelX, kernelY);
-    var index = 0;
-
-    for (var idx = 0; idx < 4; idx++) {
+    let index = 0;
+    for (let idx = 0; idx < 4; idx++) {
       if (pixelScalars[idx] >= cVal) {
         index |= CASE_MASK[idx]; // eslint-disable-line no-bitwise
       }
     }
 
-    var pixelLines = vtkCaseTable.getCase(index);
-
+    const pixelLines = vtkCaseTable.getCase(index);
     if (pixelLines[0] < 0) {
       return; // don't get the pixel coordinates, nothing to do
     }
 
     publicAPI.getPixelPoints(ijk, origin, spacing, kernelX, kernelY);
-    var z = origin[model.slicingMode] + k * spacing[model.slicingMode];
-
-    for (var _idx = 0; pixelLines[_idx] >= 0; _idx += 2) {
+    const z = origin[model.slicingMode] + k * spacing[model.slicingMode];
+    for (let idx = 0; pixelLines[idx] >= 0; idx += 2) {
       lines.push(2);
-
-      for (var eid = 0; eid < 2; eid++) {
-        var edgeVerts = vtkCaseTable.getEdge(pixelLines[_idx + eid]);
+      for (let eid = 0; eid < 2; eid++) {
+        const edgeVerts = vtkCaseTable.getEdge(pixelLines[idx + eid]);
         pId = undefined;
-
         if (model.mergePoints) {
-          var _edgeLocator$isInsert;
-
-          pId = (_edgeLocator$isInsert = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])) === null || _edgeLocator$isInsert === void 0 ? void 0 : _edgeLocator$isInsert.value;
+          pId = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])?.value;
         }
-
         if (pId === undefined) {
-          var t = (cVal - pixelScalars[edgeVerts[0]]) / (pixelScalars[edgeVerts[1]] - pixelScalars[edgeVerts[0]]);
-          var x0 = pixelPts.slice(edgeVerts[0] * 2, (edgeVerts[0] + 1) * 2);
-          var x1 = pixelPts.slice(edgeVerts[1] * 2, (edgeVerts[1] + 1) * 2);
+          const t = (cVal - pixelScalars[edgeVerts[0]]) / (pixelScalars[edgeVerts[1]] - pixelScalars[edgeVerts[0]]);
+          const x0 = pixelPts.slice(edgeVerts[0] * 2, (edgeVerts[0] + 1) * 2);
+          const x1 = pixelPts.slice(edgeVerts[1] * 2, (edgeVerts[1] + 1) * 2);
           xyz[kernelX] = x0[0] + t * (x1[0] - x0[0]);
           xyz[kernelY] = x0[1] + t * (x1[1] - x0[1]);
           xyz[model.slicingMode] = z;
           pId = points.length / 3;
           points.push(xyz[0], xyz[1], xyz[2]);
-
           if (model.mergePoints) {
             edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
           }
         }
-
         lines.push(pId);
       }
     }
   };
-
-  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;
     }
-
     if (model.slicingMode == null || model.slicingMode < 0 || model.slicingMode > 2) {
       vtkErrorMacro('Invalid or missing slicing mode');
       return;
     }
+    console.time('msquares');
 
-    console.time('msquares'); // Retrieve output and volume data
-
-    var origin = input.getOrigin();
-    var spacing = input.getSpacing();
-    var dims = input.getDimensions();
-    var extent = input.getExtent();
-    var increments = input.computeIncrements(extent);
-    var scalars = input.getPointData().getScalars().getData();
-
-    var _getKernels = getKernels(),
-        _getKernels2 = _slicedToArray(_getKernels, 2),
-        kernelX = _getKernels2[0],
-        kernelY = _getKernels2[1]; // Points - dynamic array
-
+    // Retrieve output and volume data
+    const origin = input.getOrigin();
+    const spacing = input.getSpacing();
+    const dims = input.getDimensions();
+    const extent = input.getExtent();
+    const increments = input.computeIncrements(extent);
+    const scalars = input.getPointData().getScalars().getData();
+    const [kernelX, kernelY] = getKernels();
 
-    var points = []; // Cells - dynamic array
+    // Points - dynamic array
+    const points = [];
 
-    var lines = []; // Ensure slice is valid
-
-    var k = Math.round(model.slice);
+    // Cells - dynamic array
+    const lines = [];
 
+    // Ensure slice is valid
+    let k = Math.round(model.slice);
     if (k >= dims[model.slicingMode]) {
       k = 0;
-    } // Loop over all contour values, and then pixels, determine case and process
-
+    }
 
-    var ijk = [0, 0, 0];
+    // Loop over all contour values, and then pixels, determine case and process
+    const ijk = [0, 0, 0];
     ijk[model.slicingMode] = k;
-
-    for (var cv = 0; cv < model.contourValues.length; ++cv) {
-      for (var j = 0; j < dims[kernelY] - 1; ++j) {
+    for (let cv = 0; cv < model.contourValues.length; ++cv) {
+      for (let j = 0; j < dims[kernelY] - 1; ++j) {
         ijk[kernelY] = j;
-
-        for (var i = 0; i < dims[kernelX] - 1; ++i) {
+        for (let i = 0; i < dims[kernelX] - 1; ++i) {
           ijk[kernelX] = i;
           publicAPI.produceLines(model.contourValues[cv], ijk, dims, origin, spacing, scalars, points, lines, increments, kernelX, kernelY);
         }
       }
-
       edgeLocator.initialize();
-    } // Update output
-
+    }
 
-    var polydata = vtkPolyData.newInstance();
+    // Update output
+    const polydata = vtkPolyData.newInstance();
     polydata.getPoints().setData(new Float32Array(points), 3);
     polydata.getLines().setData(new Uint32Array(lines));
     outData[0] = polydata;
     vtkDebugMacro('Produced output');
     console.timeEnd('msquares');
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   contourValues: [],
   slicingMode: 2,
   slice: 0,
   mergePoints: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['slicingMode', 'slice', 'mergePoints']); // Object specific methods
+  macro.setGet(publicAPI, model, ['slicingMode', 'slice', 'mergePoints']);
 
+  // Object specific methods
   macro.algo(publicAPI, model, 1, 1);
   vtkImageMarchingSquares(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageMarchingSquares'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageMarchingSquares');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageMarchingSquares$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageMarchingSquares$1 as default, extend, newInstance };

package/Filters/General/ImageOutlineFilter.js

@@ -1,46 +1,40 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkImageData from '../../Common/DataModel/ImageData.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkImageOutlineFilter methods
 // ----------------------------------------------------------------------------
 
 function vtkImageOutlineFilter(publicAPI, model) {
   model.classHierarchy.push('vtkImageOutlineFilter');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-
+    const input = inData[0];
     if (!input || input.getClassName() !== 'vtkImageData') {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-
-    var output = vtkImageData.newInstance(input.get('spacing', 'origin', 'direction'));
-
-    var getIndex = function getIndex(point, dims) {
-      return point[0] + point[1] * dims[0] + point[2] * dims[0] * dims[1];
-    };
-
-    var getIJK = function getIJK(index, dims) {
-      var ijk = [0, 0, 0];
+    const output = vtkImageData.newInstance(input.get('spacing', 'origin', 'direction'));
+    const getIndex = (point, dims) => point[0] + point[1] * dims[0] + point[2] * dims[0] * dims[1];
+    const getIJK = (index, dims) => {
+      const ijk = [0, 0, 0];
       ijk[0] = index % dims[0];
       ijk[1] = Math.floor(index / dims[0]) % dims[1];
       ijk[2] = Math.floor(index / (dims[0] * dims[1]));
       return ijk;
     };
-
-    var dims = input.getDimensions();
+    const dims = input.getDimensions();
     output.setDimensions(dims);
     output.computeTransforms();
-    var values = new Uint8Array(input.getNumberOfPoints());
-    var inputDataArray = input.getPointData().getScalars().getData();
-    var kernelX = 0; // default K slicing mode
-
-    var kernelY = 1;
-
+    const values = new Uint8Array(input.getNumberOfPoints());
+    const inputDataArray = input.getPointData().getScalars().getData();
+    let kernelX = 0; // default K slicing mode
+    let kernelY = 1;
     if (model.slicingMode === 1) {
       kernelX = 0;
       kernelY = 2;
@@ -48,18 +42,15 @@ function vtkImageOutlineFilter(publicAPI, model) {
       kernelX = 1;
       kernelY = 2;
     }
-
-    inputDataArray.forEach(function (el, index) {
+    inputDataArray.forEach((el, index) => {
       if (el !== model.background) {
-        var ijk = getIJK(index, dims);
-        var isBorder = false;
-
-        for (var x = -1; x <= 1 && !isBorder; x++) {
-          for (var y = -1; y <= 1 && !isBorder; y++) {
-            var dx = x;
-            var dy = y;
-            var dz = 0;
-
+        const ijk = getIJK(index, dims);
+        let isBorder = false;
+        for (let x = -1; x <= 1 && !isBorder; x++) {
+          for (let y = -1; y <= 1 && !isBorder; y++) {
+            let dx = x;
+            let dy = y;
+            let dz = 0;
             if (model.slicingMode === 1) {
               dx = x;
               dy = 0;
@@ -69,56 +60,64 @@ function vtkImageOutlineFilter(publicAPI, model) {
               dy = y;
               dz = x;
             }
-
-            var evalX = ijk[kernelX] + dx;
-            var evalY = ijk[kernelY] + dy; // check boundaries
-
+            const evalX = ijk[kernelX] + dx;
+            const evalY = ijk[kernelY] + dy;
+            // check boundaries
             if (evalX >= 0 && evalX < dims[kernelX] && evalY >= 0 && evalY < dims[kernelY]) {
-              var hoodValue = inputDataArray[getIndex([ijk[0] + dx, ijk[1] + dy, ijk[2] + dz], dims)];
+              const hoodValue = inputDataArray[getIndex([ijk[0] + dx, ijk[1] + dy, ijk[2] + dz], dims)];
               if (hoodValue !== el) isBorder = true;
             }
           }
         }
-
         if (isBorder) values[index] = el;else values[index] = model.background;
       } else {
         values[index] = model.background;
       }
     });
-    var dataArray = vtkDataArray.newInstance({
+    const dataArray = vtkDataArray.newInstance({
       numberOfComponents: 1,
-      values: values
+      values
     });
     output.getPointData().setScalars(dataArray);
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   slicingMode: 2,
   background: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['slicingMode', 'background']); // Object specific methods
+  macro.setGet(publicAPI, model, ['slicingMode', 'background']);
 
+  // Object specific methods
   vtkImageOutlineFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageOutlineFilter');
 
-var newInstance = macro.newInstance(extend, 'vtkImageOutlineFilter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkImageOutlineFilter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageOutlineFilter$1 as default, extend, newInstance };

package/Filters/General/ImageSliceFilter.js

@@ -1,73 +1,82 @@
-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;
+
+// ----------------------------------------------------------------------------
 // vtkImageSliceFilter methods
 // ----------------------------------------------------------------------------
 
 function vtkImageSliceFilter(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageSliceFilter');
-
-  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 datasetDefinition = input.get('extent', 'spacing', 'origin');
+    const datasetDefinition = input.get('extent', 'spacing', 'origin');
     datasetDefinition.extent[4] = model.sliceIndex;
     datasetDefinition.extent[5] = datasetDefinition.extent[4];
-    var numberOfComponents = scalars.getNumberOfComponents();
-    var sliceSize = (datasetDefinition.extent[1] - datasetDefinition.extent[0] + 1) * (datasetDefinition.extent[3] - datasetDefinition.extent[2] + 1) * numberOfComponents;
-    var offset = sliceSize * model.sliceIndex;
-    var sliceRawArray = scalars.getData().slice(offset, offset + sliceSize);
-    var sliceArray = vtkDataArray.newInstance({
+    const numberOfComponents = scalars.getNumberOfComponents();
+    const sliceSize = (datasetDefinition.extent[1] - datasetDefinition.extent[0] + 1) * (datasetDefinition.extent[3] - datasetDefinition.extent[2] + 1) * numberOfComponents;
+    const offset = sliceSize * model.sliceIndex;
+    const sliceRawArray = scalars.getData().slice(offset, offset + sliceSize);
+    const sliceArray = vtkDataArray.newInstance({
       name: scalars.getName(),
-      numberOfComponents: numberOfComponents,
+      numberOfComponents,
       values: sliceRawArray
     });
-    var output = vtkImageData.newInstance(datasetDefinition);
+    const output = vtkImageData.newInstance(datasetDefinition);
     output.getPointData().setScalars(sliceArray);
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   sliceIndex: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['sliceIndex', 'orientation']); // Object specific methods
+  macro.setGet(publicAPI, model, ['sliceIndex', 'orientation']);
 
+  // Object specific methods
   vtkImageSliceFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageSliceFilter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageSliceFilter');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageSliceFilter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageSliceFilter$1 as default, extend, newInstance };