@kitware/vtk.js 28.10.1 → 28.11.0

package/Filters/General/ImageStreamline.js

@@ -1,28 +1,31 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkImageStreamline methods
 // ----------------------------------------------------------------------------
 
 function vtkImageStreamline(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageStreamline');
-  var indices = new Int32Array(3);
-  var paramCoords = new Float32Array(3);
-  var weights = new Float32Array(8);
-  var voxelIndices = new Uint32Array(8);
-  var dimensions = new Uint32Array(3);
-  var velAt = new Float32Array(3);
-  var xtmp = new Float32Array(3);
-
-  publicAPI.interpolationFunctions = function (pcoords, sf) {
-    var r = pcoords[0];
-    var s = pcoords[1];
-    var t = pcoords[2];
-    var rm = 1.0 - r;
-    var sm = 1.0 - s;
-    var tm = 1.0 - t;
+  const indices = new Int32Array(3);
+  const paramCoords = new Float32Array(3);
+  const weights = new Float32Array(8);
+  const voxelIndices = new Uint32Array(8);
+  const dimensions = new Uint32Array(3);
+  const velAt = new Float32Array(3);
+  const xtmp = new Float32Array(3);
+  publicAPI.interpolationFunctions = (pcoords, sf) => {
+    const r = pcoords[0];
+    const s = pcoords[1];
+    const t = pcoords[2];
+    const rm = 1.0 - r;
+    const sm = 1.0 - s;
+    const tm = 1.0 - t;
     sf[0] = rm * sm * tm;
     sf[1] = r * sm * tm;
     sf[2] = rm * s * tm;
@@ -32,28 +35,26 @@ function vtkImageStreamline(publicAPI, model) {
     sf[6] = rm * s * t;
     sf[7] = r * s * t;
   };
-
-  publicAPI.computeStructuredCoordinates = function (x, ijk, pcoords, extent, spacing, origin, bounds) {
+  publicAPI.computeStructuredCoordinates = (x, ijk, pcoords, extent, spacing, origin, bounds) => {
     // tolerance is needed for 2D data (this is squared tolerance)
-    var tol2 = 1e-12; //
+    const tol2 = 1e-12;
+    //
     //  Compute the ijk location
     //
-
-    var isInBounds = true;
-
-    for (var i = 0; i < 3; i++) {
-      var d = x[i] - origin[i];
-      var doubleLoc = d / spacing[i]; // Floor for negative indexes.
-
+    let isInBounds = true;
+    for (let i = 0; i < 3; i++) {
+      const d = x[i] - origin[i];
+      const doubleLoc = d / spacing[i];
+      // Floor for negative indexes.
       ijk[i] = Math.floor(doubleLoc);
       pcoords[i] = doubleLoc - ijk[i];
-      var tmpInBounds = false;
-      var minExt = extent[i * 2];
-      var maxExt = extent[i * 2 + 1]; // check if data is one pixel thick
+      let tmpInBounds = false;
+      const minExt = extent[i * 2];
+      const maxExt = extent[i * 2 + 1];
 
+      // check if data is one pixel thick
       if (minExt === maxExt) {
-        var dist = x[i] - bounds[2 * i];
-
+        const dist = x[i] - bounds[2 * i];
         if (dist * dist <= spacing[i] * spacing[i] * tol2) {
           pcoords[i] = 0.0;
           ijk[i] = minExt;
@@ -74,39 +75,30 @@ function vtkImageStreamline(publicAPI, model) {
         }
       } else {
         tmpInBounds = true;
-      } // clear isInBounds if out of bounds for this dimension
-
+      }
 
+      // clear isInBounds if out of bounds for this dimension
       isInBounds = isInBounds && tmpInBounds;
     }
-
     return isInBounds;
   };
-
-  publicAPI.getVoxelIndices = function (ijk, dims, ids) {
+  publicAPI.getVoxelIndices = (ijk, dims, ids) => {
     ids[0] = ijk[2] * dims[0] * dims[1] + ijk[1] * dims[0] + ijk[0];
     ids[1] = ids[0] + 1; // i+1, j, k
-
     ids[2] = ids[0] + dims[0]; // i, j+1, k
-
     ids[3] = ids[2] + 1; // i+1, j+1, k
-
     ids[4] = ids[0] + dims[0] * dims[1]; // i, j, k+1
-
     ids[5] = ids[4] + 1; // i+1, j, k+1
-
     ids[6] = ids[4] + dims[0]; // i, j+1, k+1
-
     ids[7] = ids[6] + 1; // i+1, j+1, k+1
   };
 
-  publicAPI.vectorAt = function (xyz, velArray, image, velAtArg) {
+  publicAPI.vectorAt = (xyz, velArray, image, velAtArg) => {
     if (!publicAPI.computeStructuredCoordinates(xyz, indices, paramCoords, image.getExtent(), image.getSpacing(), image.getOrigin(), image.getBounds())) {
       return false;
     }
-
     publicAPI.interpolationFunctions(paramCoords, weights);
-    var extent = image.getExtent();
+    const extent = image.getExtent();
     dimensions[0] = extent[1] - extent[0] + 1;
     dimensions[1] = extent[3] - extent[2] + 1;
     dimensions[2] = extent[5] - extent[4] + 1;
@@ -114,163 +106,154 @@ function vtkImageStreamline(publicAPI, model) {
     velAtArg[0] = 0.0;
     velAtArg[1] = 0.0;
     velAtArg[2] = 0.0;
-    var vel = new Array(3);
-
-    for (var i = 0; i < 8; i++) {
+    const vel = new Array(3);
+    for (let i = 0; i < 8; i++) {
       velArray.getTuple(voxelIndices[i], vel);
-
-      for (var j = 0; j < 3; j++) {
+      for (let j = 0; j < 3; j++) {
         velAtArg[j] += weights[i] * vel[j];
       }
     }
-
     return true;
   };
-
-  publicAPI.computeNextStep = function (velArray, image, delT, xyz) {
+  publicAPI.computeNextStep = (velArray, image, delT, xyz) => {
     // This does Runge-Kutta 2
+
     // Start with evaluating velocity @ initial point
     if (!publicAPI.vectorAt(xyz, velArray, image, velAt)) {
       return false;
-    } // Now find the mid point
-
-
-    for (var i = 0; i < 3; i++) {
+    }
+    // Now find the mid point
+    for (let i = 0; i < 3; i++) {
       xtmp[i] = xyz[i] + delT / 2.0 * velAt[i];
-    } // Use the velocity @ that point to project
-
-
+    }
+    // Use the velocity @ that point to project
     if (!publicAPI.vectorAt(xtmp, velArray, image, velAt)) {
       return false;
     }
-
-    for (var _i = 0; _i < 3; _i++) {
-      xyz[_i] += delT * velAt[_i];
+    for (let i = 0; i < 3; i++) {
+      xyz[i] += delT * velAt[i];
     }
-
     if (!publicAPI.vectorAt(xyz, velArray, image, velAt)) {
       return false;
     }
-
     return true;
   };
-
-  publicAPI.streamIntegrate = function (velArray, image, seed, offset) {
-    var retVal = [];
-    var maxSteps = model.maximumNumberOfSteps;
-    var delT = model.integrationStep;
-    var xyz = new Float32Array(3);
+  publicAPI.streamIntegrate = (velArray, image, seed, offset) => {
+    const retVal = [];
+    const maxSteps = model.maximumNumberOfSteps;
+    const delT = model.integrationStep;
+    const xyz = new Float32Array(3);
     xyz[0] = seed[0];
     xyz[1] = seed[1];
     xyz[2] = seed[2];
-    var pointsBuffer = [];
-    var step = 0;
-
+    const pointsBuffer = [];
+    let step = 0;
     for (step = 0; step < maxSteps; step++) {
       if (!publicAPI.computeNextStep(velArray, image, delT, xyz)) {
         break;
       }
-
-      for (var i = 0; i < 3; i++) {
+      for (let i = 0; i < 3; i++) {
         pointsBuffer[3 * step + i] = xyz[i];
       }
     }
-
-    var pd = vtkPolyData.newInstance();
-    var points = new Float32Array(pointsBuffer);
+    const pd = vtkPolyData.newInstance();
+    const points = new Float32Array(pointsBuffer);
     retVal[0] = points;
     pd.getPoints().setData(points, 3);
-    var npts = points.length / 3;
-    var line = new Uint32Array(npts + 1);
+    const npts = points.length / 3;
+    const line = new Uint32Array(npts + 1);
     line[0] = npts;
-
-    for (var _i2 = 0; _i2 < npts; _i2++) {
-      line[_i2 + 1] = _i2 + offset;
+    for (let i = 0; i < npts; i++) {
+      line[i + 1] = i + offset;
     }
-
     retVal[1] = line;
     pd.getLines().setData(line);
     return retVal;
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-    var seeds = inData[1];
-
+    const input = inData[0];
+    const seeds = inData[1];
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
-
     if (!seeds) {
       vtkErrorMacro('Invalid or missing seeds');
       return;
     }
-
-    var seedPts = seeds.getPoints();
-    var nSeeds = seedPts.getNumberOfPoints();
-    var offset = 0;
-    var datas = [];
-    var vectors = input.getPointData().getVectors();
-    var point = [];
-
-    for (var i = 0; i < nSeeds; i++) {
+    const seedPts = seeds.getPoints();
+    const nSeeds = seedPts.getNumberOfPoints();
+    let offset = 0;
+    const datas = [];
+    const vectors = input.getPointData().getVectors();
+    const point = [];
+    for (let i = 0; i < nSeeds; i++) {
       seedPts.getTuple(i, point);
-      var retVal = publicAPI.streamIntegrate(vectors, input, point, offset);
+      const retVal = publicAPI.streamIntegrate(vectors, input, point, offset);
       offset += retVal[0].length / 3;
       datas.push(retVal);
     }
-
-    var cellArrayLength = 0;
-    var pointArrayLength = 0;
-    datas.forEach(function (data) {
+    let cellArrayLength = 0;
+    let pointArrayLength = 0;
+    datas.forEach(data => {
       cellArrayLength += data[1].length;
       pointArrayLength += data[0].length;
     });
     offset = 0;
-    var offset2 = 0;
-    var cellArray = new Uint32Array(cellArrayLength);
-    var pointArray = new Float32Array(pointArrayLength);
-    datas.forEach(function (data) {
+    let offset2 = 0;
+    const cellArray = new Uint32Array(cellArrayLength);
+    const pointArray = new Float32Array(pointArrayLength);
+    datas.forEach(data => {
       cellArray.set(data[1], offset);
       offset += data[1].length;
       pointArray.set(data[0], offset2);
       offset2 += data[0].length;
     });
-    var output = vtkPolyData.newInstance();
+    const output = vtkPolyData.newInstance();
     output.getPoints().setData(pointArray, 3);
     output.getLines().setData(cellArray);
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   integrationStep: 1,
   maximumNumberOfSteps: 1000
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, 2, 1); // Generate macros for properties
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 2, 1);
 
-  macro.setGet(publicAPI, model, ['integrationStep', 'maximumNumberOfSteps']); // Object specific methods
+  // Generate macros for properties
+  macro.setGet(publicAPI, model, ['integrationStep', 'maximumNumberOfSteps']);
 
+  // Object specific methods
   vtkImageStreamline(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageStreamline'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageStreamline');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageStreamline$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageStreamline$1 as default, extend, newInstance };

package/Filters/General/LineFilter.js

@@ -1,42 +1,53 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
+// ----------------------------------------------------------------------------
 // vtkLineFilter methods
 // ----------------------------------------------------------------------------
 
 function vtkLineFilter(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkLineFilter');
-
-  publicAPI.requestData = function (inData, outData) {
-    var dataset = vtkPolyData.newInstance();
+  publicAPI.requestData = (inData, outData) => {
+    const dataset = vtkPolyData.newInstance();
     dataset.getPoints().setData(inData[0].getPoints().getData());
     dataset.getLines().setData(inData[0].getLines().getData());
     outData[0] = dataset;
   };
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+const DEFAULT_VALUES = {};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
-  macro.setGet(publicAPI, model, []); // Make this a VTK object
+  // Build VTK API
+  macro.setGet(publicAPI, model, []);
 
-  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); // Object specific methods
+  // Also make it an algorithm with one input and one output
+  macro.algo(publicAPI, model, 1, 1);
 
+  // Object specific methods
   vtkLineFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkLineFilter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkLineFilter');
+
+// ----------------------------------------------------------------------------
 
 var vtkLineFilter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkLineFilter$1 as default, extend, newInstance };