@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/Sources/CylinderSource.js

@@ -1,178 +1,171 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
+// ----------------------------------------------------------------------------
 // vtkCylinderSource methods
 // ----------------------------------------------------------------------------
 
 function vtkCylinderSource(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkCylinderSource');
-
   function requestData(inData, outData) {
-    var _vtkMatrixBuilder$bui, _vtkMatrixBuilder$bui2;
-
     if (model.deleted) {
       return;
     }
-
-    var dataset = outData[0];
-    var angle = 2.0 * Math.PI / model.resolution;
-    var numberOfPoints = 2 * model.resolution;
-    var numberOfPolys = 5 * model.resolution;
-
+    let dataset = outData[0];
+    const angle = 2.0 * Math.PI / model.resolution;
+    let numberOfPoints = 2 * model.resolution;
+    let numberOfPolys = 5 * model.resolution;
     if (model.capping) {
       numberOfPoints = 4 * model.resolution;
       numberOfPolys = 7 * model.resolution + 2;
-    } // Points
-
+    }
 
-    var points = macro.newTypedArray(model.pointType, numberOfPoints * 3); // Cells
+    // Points
+    const points = macro.newTypedArray(model.pointType, numberOfPoints * 3);
 
-    var cellLocation = 0;
-    var polys = new Uint32Array(numberOfPolys); // Normals
+    // Cells
+    let cellLocation = 0;
+    const polys = new Uint32Array(numberOfPolys);
 
-    var normalsData = new Float32Array(numberOfPoints * 3);
-    var normals = vtkDataArray.newInstance({
+    // Normals
+    const normalsData = new Float32Array(numberOfPoints * 3);
+    const normals = vtkDataArray.newInstance({
       numberOfComponents: 3,
       values: normalsData,
       name: 'Normals'
-    }); // Texture coords
+    });
 
-    var tcData = new Float32Array(numberOfPoints * 2);
-    var tcoords = vtkDataArray.newInstance({
+    // Texture coords
+    const tcData = new Float32Array(numberOfPoints * 2);
+    const tcoords = vtkDataArray.newInstance({
       numberOfComponents: 2,
       values: tcData,
       name: 'TCoords'
-    }); // Generate points for all sides
-
-    var nbot = [0.0, 0.0, 0.0];
-    var ntop = [0.0, 0.0, 0.0];
-    var xbot = [0.0, 0.0, 0.0];
-    var xtop = [0.0, 0.0, 0.0];
-    var tcbot = [0.0, 0.0];
-    var tctop = [0.0, 0.0];
-    var otherRadius = model.otherRadius == null ? model.radius : model.otherRadius;
-
-    for (var i = 0; i < model.resolution; i++) {
+    });
+
+    // Generate points for all sides
+    const nbot = [0.0, 0.0, 0.0];
+    const ntop = [0.0, 0.0, 0.0];
+    const xbot = [0.0, 0.0, 0.0];
+    const xtop = [0.0, 0.0, 0.0];
+    const tcbot = [0.0, 0.0];
+    const tctop = [0.0, 0.0];
+    const otherRadius = model.otherRadius == null ? model.radius : model.otherRadius;
+    for (let i = 0; i < model.resolution; i++) {
       // x coordinate
       nbot[0] = Math.cos(i * angle + model.initAngle);
       ntop[0] = nbot[0];
       xbot[0] = model.radius * nbot[0] + model.center[0];
       xtop[0] = xbot[0];
       tcbot[0] = Math.abs(2.0 * i / model.resolution - 1.0);
-      tctop[0] = tcbot[0]; // y coordinate
+      tctop[0] = tcbot[0];
 
+      // y coordinate
       xbot[1] = 0.5 * model.height + model.center[1];
       xtop[1] = -0.5 * model.height + model.center[1];
       tcbot[1] = 0.0;
-      tctop[1] = 1.0; // z coordinate
+      tctop[1] = 1.0;
 
+      // z coordinate
       nbot[2] = -Math.sin(i * angle + model.initAngle);
       ntop[2] = nbot[2];
       xbot[2] = otherRadius * nbot[2] + model.center[2];
       xtop[2] = xbot[2];
-      var pointIdx = 2 * i;
-
-      for (var j = 0; j < 3; j++) {
+      const pointIdx = 2 * i;
+      for (let j = 0; j < 3; j++) {
         normalsData[pointIdx * 3 + j] = nbot[j];
         normalsData[(pointIdx + 1) * 3 + j] = ntop[j];
         points[pointIdx * 3 + j] = xbot[j];
         points[(pointIdx + 1) * 3 + j] = xtop[j];
-
         if (j < 2) {
           tcData[pointIdx * 2 + j] = tcbot[j];
           tcData[(pointIdx + 1) * 2 + j] = tctop[j];
         }
       }
-    } // Generate polygons for sides
-
+    }
 
-    for (var _i = 0; _i < model.resolution; _i++) {
+    // Generate polygons for sides
+    for (let i = 0; i < model.resolution; i++) {
       polys[cellLocation++] = 4;
-      polys[cellLocation++] = 2 * _i;
-      polys[cellLocation++] = 2 * _i + 1;
-      var pt = (2 * _i + 3) % (2 * model.resolution);
+      polys[cellLocation++] = 2 * i;
+      polys[cellLocation++] = 2 * i + 1;
+      const pt = (2 * i + 3) % (2 * model.resolution);
       polys[cellLocation++] = pt;
       polys[cellLocation++] = pt - 1;
     }
-
     if (model.capping) {
       // Generate points for top/bottom polygons
-      for (var _i2 = 0; _i2 < model.resolution; _i2++) {
+      for (let i = 0; i < model.resolution; i++) {
         // x coordinate
-        xbot[0] = model.radius * Math.cos(_i2 * angle + model.initAngle);
+        xbot[0] = model.radius * Math.cos(i * angle + model.initAngle);
         xtop[0] = xbot[0];
         tcbot[0] = xbot[0];
         tctop[0] = xbot[0];
         xbot[0] += model.center[0];
-        xtop[0] += model.center[0]; // y coordinate
+        xtop[0] += model.center[0];
 
+        // y coordinate
         nbot[1] = 1.0;
         ntop[1] = -1.0;
         xbot[1] = 0.5 * model.height + model.center[1];
-        xtop[1] = -0.5 * model.height + model.center[1]; // z coordinate
+        xtop[1] = -0.5 * model.height + model.center[1];
 
-        xbot[2] = -otherRadius * Math.sin(_i2 * angle + model.initAngle);
+        // z coordinate
+        xbot[2] = -otherRadius * Math.sin(i * angle + model.initAngle);
         xtop[2] = xbot[2];
         tcbot[1] = xbot[2];
         tctop[1] = xbot[2];
         xbot[2] += model.center[2];
         xtop[2] += model.center[2];
-        var botIdx = 2 * model.resolution + _i2;
-        var topIdx = 3 * model.resolution + model.resolution - _i2 - 1;
-
-        for (var _j = 0; _j < 3; _j++) {
-          normalsData[3 * botIdx + _j] = nbot[_j];
-          normalsData[3 * topIdx + _j] = ntop[_j];
-          points[3 * botIdx + _j] = xbot[_j];
-          points[3 * topIdx + _j] = xtop[_j];
-
-          if (_j < 2) {
-            tcData[2 * botIdx + _j] = tcbot[_j];
-            tcData[2 * topIdx + _j] = tctop[_j];
+        const botIdx = 2 * model.resolution + i;
+        const topIdx = 3 * model.resolution + model.resolution - i - 1;
+        for (let j = 0; j < 3; j++) {
+          normalsData[3 * botIdx + j] = nbot[j];
+          normalsData[3 * topIdx + j] = ntop[j];
+          points[3 * botIdx + j] = xbot[j];
+          points[3 * topIdx + j] = xtop[j];
+          if (j < 2) {
+            tcData[2 * botIdx + j] = tcbot[j];
+            tcData[2 * topIdx + j] = tctop[j];
           }
         }
-      } // Generate polygons for top/bottom
-
+      }
 
+      // Generate polygons for top/bottom
       polys[cellLocation++] = model.resolution;
-
-      for (var _i3 = 0; _i3 < model.resolution; _i3++) {
-        polys[cellLocation++] = 2 * model.resolution + _i3;
+      for (let i = 0; i < model.resolution; i++) {
+        polys[cellLocation++] = 2 * model.resolution + i;
       }
-
       polys[cellLocation++] = model.resolution;
-
-      for (var _i4 = 0; _i4 < model.resolution; _i4++) {
-        polys[cellLocation++] = 3 * model.resolution + _i4;
+      for (let i = 0; i < model.resolution; i++) {
+        polys[cellLocation++] = 3 * model.resolution + i;
       }
-    } // Apply transformation to the points coordinates
-
-
-    (_vtkMatrixBuilder$bui = (_vtkMatrixBuilder$bui2 = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui2, _toConsumableArray(model.center)).rotateFromDirections([0, 1, 0], model.direction)).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center.map(function (c) {
-      return c * -1;
-    }))).apply(points);
+    }
 
+    // Apply transformation to the points coordinates
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([0, 1, 0], model.direction).translate(...model.center.map(c => c * -1)).apply(points);
     dataset = vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
     dataset.getPolys().setData(polys, 1);
     dataset.getPointData().setNormals(normals);
-    dataset.getPointData().setTCoords(tcoords); // Update output
+    dataset.getPointData().setTCoords(tcoords);
 
+    // Update output
     outData[0] = dataset;
-  } // Expose methods
-
+  }
 
+  // Expose methods
   publicAPI.requestData = requestData;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   height: 1.0,
   initAngle: 0,
   radius: 1.0,
@@ -181,24 +174,31 @@ var DEFAULT_VALUES = {
   direction: [0.0, 1.0, 0.0],
   capping: true,
   pointType: 'Float64Array'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['height', 'initAngle', 'otherRadius', 'radius', 'resolution', 'capping']);
   macro.setGetArray(publicAPI, model, ['center', 'direction'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkCylinderSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCylinderSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCylinderSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkCylinderSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCylinderSource$1 as default, extend, newInstance };

package/Filters/Sources/ImageGridSource.js

@@ -1,92 +1,85 @@
-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';
 
+// ----------------------------------------------------------------------------
 // vtkImageGridSource methods
 // ----------------------------------------------------------------------------
 
 function vtkImageGridSource(publicAPI, model) {
-  var _this = this;
-
   // Set our className
   model.classHierarchy.push('vtkImageGridSource');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
-
-    var state = {};
-    var dataset = {
+    const state = {};
+    const dataset = {
       type: 'vtkImageData',
       mtime: model.mtime,
       metadata: {
         source: 'vtkImageGridSource',
-        state: state
+        state
       }
-    }; // Add parameter used to create dataset as metadata.state[*]
+    };
 
-    ['gridSpacing', 'gridOrigin', 'dataSpacing', 'dataOrigin'].forEach(function (field) {
+    // Add parameter used to create dataset as metadata.state[*]
+    ['gridSpacing', 'gridOrigin', 'dataSpacing', 'dataOrigin'].forEach(field => {
       state[field] = [].concat(model[field]);
     });
-    var id = vtkImageData.newInstance(dataset);
+    const id = vtkImageData.newInstance(dataset);
     id.setOrigin(model.dataOrigin[0], model.dataOrigin[1], model.dataOrigin[2]);
     id.setSpacing(model.dataSpacing[0], model.dataSpacing[1], model.dataSpacing[2]);
-    id.setExtent.apply(_this, model.dataExtent);
+    id.setExtent.apply(this, model.dataExtent);
     id.setDirection(model.dataDirection);
-    var dims = [0, 0, 0];
-    dims = dims.map(function (_, i) {
-      return model.dataExtent[i * 2 + 1] - model.dataExtent[i * 2] + 1;
-    });
-    var newArray = new Uint8Array(dims[0] * dims[1] * dims[2]);
-    var xval = 0;
-    var yval = 0;
-    var zval = 0;
-    var i = 0;
-
-    for (var z = model.dataExtent[4]; z <= model.dataExtent[5]; z++) {
+    let dims = [0, 0, 0];
+    dims = dims.map((_, i) => model.dataExtent[i * 2 + 1] - model.dataExtent[i * 2] + 1);
+    const newArray = new Uint8Array(dims[0] * dims[1] * dims[2]);
+    let xval = 0;
+    let yval = 0;
+    let zval = 0;
+    let i = 0;
+    for (let z = model.dataExtent[4]; z <= model.dataExtent[5]; z++) {
       if (model.gridSpacing[2]) {
         zval = z % model.gridSpacing[2] === model.gridOrigin[2];
       } else {
         zval = 0;
       }
-
-      for (var y = model.dataExtent[2]; y <= model.dataExtent[3]; y++) {
+      for (let y = model.dataExtent[2]; y <= model.dataExtent[3]; y++) {
         if (model.gridSpacing[1]) {
           yval = y % model.gridSpacing[1] === model.gridOrigin[1];
         } else {
           yval = 0;
         }
-
-        for (var x = model.dataExtent[0]; x <= model.dataExtent[1]; x++) {
+        for (let x = model.dataExtent[0]; x <= model.dataExtent[1]; x++) {
           if (model.gridSpacing[0]) {
             xval = x % model.gridSpacing[0] === model.gridOrigin[0];
           } else {
             xval = 0;
           }
-
           newArray[i] = zval || yval || xval ? model.lineValue : model.fillValue;
           i++;
         }
       }
     }
-
-    var da = vtkDataArray.newInstance({
+    const da = vtkDataArray.newInstance({
       numberOfComponents: 1,
       values: newArray
     });
     da.setName('scalars');
-    var cpd = id.getPointData();
-    cpd.setScalars(da); // Update output
+    const cpd = id.getPointData();
+    cpd.setScalars(da);
 
+    // Update output
     outData[0] = id;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   lineValue: 0,
   fillValue: 255,
   gridSpacing: [10, 10, 0],
@@ -95,12 +88,15 @@ var DEFAULT_VALUES = {
   dataOrigin: [0.0, 0.0, 0.0],
   dataExtent: [0, 255, 0, 255, 0, 0],
   dataDirection: [1, 0, 0, 0, 1, 0, 0, 0, 1]
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['lineValue', 'fillValue']);
   macro.setGetArray(publicAPI, model, ['gridOrigin', 'gridSpacing', 'dataOrigin', 'dataSpacing'], 3);
@@ -108,13 +104,17 @@ function extend(publicAPI, model) {
   macro.setGetArray(publicAPI, model, ['dataDirection'], 9);
   macro.algo(publicAPI, model, 0, 1);
   vtkImageGridSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkImageGridSource'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkImageGridSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageGridSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageGridSource$1 as default, extend, newInstance };

package/Filters/Sources/LineSource.js

@@ -1,92 +1,102 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { s as subtract, n as norm } from '../../Common/Core/Math/index.js';
 
-var vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------
+const {
+  vtkWarningMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkLineSource methods
 // ----------------------------------------------------------------------------
 
 function vtkLineSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLineSource');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     if (model.deleted) {
       return;
     }
+    const dataset = outData[0];
 
-    var dataset = outData[0]; // Check input
-
-    var pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
-    var pd = vtkPolyData.newInstance();
-    var v21 = [];
+    // Check input
+    const pointDataType = dataset ? dataset.getPoints().getDataType() : model.pointType;
+    const pd = vtkPolyData.newInstance();
+    const v21 = [];
     subtract(model.point2, model.point1, v21);
-
     if (norm(v21) <= 0.0) {
       vtkWarningMacro('Zero-length line definition');
       return;
-    } // hand create a line with special scalars
-
+    }
 
-    var res = model.resolution;
-    var numPts = res + 1; // Points
+    // hand create a line with special scalars
+    const res = model.resolution;
+    const numPts = res + 1;
 
-    var points = macro.newTypedArray(pointDataType, numPts * 3);
-    pd.getPoints().setData(points, 3); // Cells
+    // Points
+    const points = macro.newTypedArray(pointDataType, numPts * 3);
+    pd.getPoints().setData(points, 3);
 
-    var lines = new Uint32Array(numPts + 1);
+    // Cells
+    const lines = new Uint32Array(numPts + 1);
     pd.getLines().setData(lines, 1);
-    var idx = 0;
-    var t = 0.0;
-
-    for (var i = 0; i < res + 1; i++) {
+    let idx = 0;
+    let t = 0.0;
+    for (let i = 0; i < res + 1; i++) {
       t = i / res;
       points[idx * 3] = model.point1[0] + t * v21[0];
       points[idx * 3 + 1] = model.point1[1] + t * v21[1];
       points[idx * 3 + 2] = model.point1[2] + t * v21[2];
       idx++;
-    } // Generate line connectivity
-    //
-
+    }
 
+    // Generate line connectivity
+    //
     idx = 0;
     lines[0] = numPts;
+    for (let i = 0; i < numPts; i++) {
+      lines[i + 1] = i;
+    }
 
-    for (var _i = 0; _i < numPts; _i++) {
-      lines[_i + 1] = _i;
-    } // Update output
-
-
+    // Update output
     outData[0] = pd;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   resolution: 10,
   point1: [-1, 0, 0],
   point2: [1, 0, 0],
   pointType: 'Float64Array'
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
+  // Build VTK API
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['resolution']);
   macro.setGetArray(publicAPI, model, ['point1', 'point2'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkLineSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkLineSource');
 
-var newInstance = macro.newInstance(extend, 'vtkLineSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkLineSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkLineSource$1 as default, extend, newInstance };