@kitware/vtk.js 28.10.1 → 28.11.0

package/Filters/Sources/ConeSource.js

@@ -1,80 +1,82 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
+// ----------------------------------------------------------------------------
 // vtkConeSource methods
 // ----------------------------------------------------------------------------
 
 function vtkConeSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkConeSource');
-
   function requestData(inData, outData) {
-    var _vtkMatrixBuilder$bui;
-
     if (model.deleted) {
       return;
     }
+    let dataset = outData[0];
+    const angle = 2 * Math.PI / model.resolution;
+    const xbot = -model.height / 2.0;
+    const numberOfPoints = model.resolution + 1;
+    const cellArraySize = 4 * model.resolution + 1 + model.resolution;
 
-    var dataset = outData[0];
-    var angle = 2 * Math.PI / model.resolution;
-    var xbot = -model.height / 2.0;
-    var numberOfPoints = model.resolution + 1;
-    var cellArraySize = 4 * model.resolution + 1 + model.resolution; // Points
+    // Points
+    let pointIdx = 0;
+    const points = macro.newTypedArray(model.pointType, numberOfPoints * 3);
 
-    var pointIdx = 0;
-    var points = macro.newTypedArray(model.pointType, numberOfPoints * 3); // Cells
-
-    var cellLocation = 0;
-    var polys = new Uint32Array(cellArraySize); // Add summit point
+    // Cells
+    let cellLocation = 0;
+    const polys = new Uint32Array(cellArraySize);
 
+    // Add summit point
     points[0] = model.height / 2.0;
     points[1] = 0.0;
-    points[2] = 0.0; // Create bottom cell
+    points[2] = 0.0;
 
+    // Create bottom cell
     if (model.capping) {
       polys[cellLocation++] = model.resolution;
-    } // Add all points
-
+    }
 
-    for (var i = 0; i < model.resolution; i++) {
+    // Add all points
+    for (let i = 0; i < model.resolution; i++) {
       pointIdx++;
       points[pointIdx * 3 + 0] = xbot;
       points[pointIdx * 3 + 1] = model.radius * Math.cos(i * angle);
-      points[pointIdx * 3 + 2] = model.radius * Math.sin(i * angle); // Add points to bottom cell in reverse order
+      points[pointIdx * 3 + 2] = model.radius * Math.sin(i * angle);
 
+      // Add points to bottom cell in reverse order
       if (model.capping) {
         polys[model.resolution - cellLocation++ + 1] = pointIdx;
       }
-    } // Add all triangle cells
-
+    }
 
-    for (var _i = 0; _i < model.resolution; _i++) {
+    // Add all triangle cells
+    for (let i = 0; i < model.resolution; i++) {
       polys[cellLocation++] = 3;
       polys[cellLocation++] = 0;
-      polys[cellLocation++] = _i + 1;
-      polys[cellLocation++] = _i + 2 > model.resolution ? 1 : _i + 2;
-    } // Apply transformation to the points coordinates
-
-
-    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).rotateFromDirections([1, 0, 0], model.direction).apply(points);
+      polys[cellLocation++] = i + 1;
+      polys[cellLocation++] = i + 2 > model.resolution ? 1 : i + 2;
+    }
 
+    // Apply transformation to the points coordinates
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([1, 0, 0], model.direction).apply(points);
     dataset = vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
-    dataset.getPolys().setData(polys, 1); // Update output
+    dataset.getPolys().setData(polys, 1);
 
+    // Update output
     outData[0] = dataset;
-  } // Expose methods
-
+  }
 
+  // Expose methods
   publicAPI.requestData = requestData;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   height: 1.0,
   radius: 0.5,
   resolution: 6,
@@ -82,24 +84,31 @@ var DEFAULT_VALUES = {
   direction: [1.0, 0.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', 'radius', 'resolution', 'capping']);
   macro.setGetArray(publicAPI, model, ['center', 'direction'], 3);
   macro.algo(publicAPI, model, 0, 1);
   vtkConeSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkConeSource'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkConeSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkConeSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkConeSource$1 as default, extend, newInstance };

package/Filters/Sources/CubeSource.js

@@ -1,68 +1,65 @@
-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 vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
 
-var LINE_ARRAY = [2, 0, 1, 2, 2, 3, 2, 4, 5, 2, 6, 7, 2, 0, 2, 2, 1, 3, 2, 4, 6, 2, 5, 7, 2, 0, 4, 2, 1, 5, 2, 2, 6, 2, 3, 7]; // prettier-ignore
+// prettier-ignore
+const LINE_ARRAY = [2, 0, 1, 2, 2, 3, 2, 4, 5, 2, 6, 7, 2, 0, 2, 2, 1, 3, 2, 4, 6, 2, 5, 7, 2, 0, 4, 2, 1, 5, 2, 2, 6, 2, 3, 7];
 
-var POLY_ARRAY = [4, 0, 1, 3, 2, 4, 4, 6, 7, 5, 4, 8, 10, 11, 9, 4, 12, 13, 15, 14, 4, 16, 18, 19, 17, 4, 20, 21, 23, 22]; // ----------------------------------------------------------------------------
+// prettier-ignore
+const POLY_ARRAY = [4, 0, 1, 3, 2, 4, 4, 6, 7, 5, 4, 8, 10, 11, 9, 4, 12, 13, 15, 14, 4, 16, 18, 19, 17, 4, 20, 21, 23, 22];
+
+// ----------------------------------------------------------------------------
 // vtkCubeSource methods
 // ----------------------------------------------------------------------------
 
 function vtkCubeSource(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCubeSource');
-
   function requestData(inData, outData) {
     if (model.deleted) {
       return;
     }
-
-    var polyData = vtkPolyData.newInstance();
+    const polyData = vtkPolyData.newInstance();
     outData[0] = polyData;
-    var numberOfPoints = 24; // Define points
+    const numberOfPoints = 24;
 
-    var points = macro.newTypedArray(model.pointType, numberOfPoints * 3);
+    // Define points
+    const points = macro.newTypedArray(model.pointType, numberOfPoints * 3);
     polyData.getPoints().setData(points, 3);
-    var normals = macro.newTypedArray(model.pointType, numberOfPoints * 3);
-    var normalArray = vtkDataArray.newInstance({
+    const normals = macro.newTypedArray(model.pointType, numberOfPoints * 3);
+    const normalArray = vtkDataArray.newInstance({
       name: 'Normals',
       values: normals,
       numberOfComponents: 3
     });
     polyData.getPointData().setNormals(normalArray);
-    var tcdim = 2;
-
+    let tcdim = 2;
     if (model.generate3DTextureCoordinates === true) {
       tcdim = 3;
     }
-
-    var textureCoords = macro.newTypedArray(model.pointType, numberOfPoints * tcdim);
-    var tcoords = vtkDataArray.newInstance({
+    const textureCoords = macro.newTypedArray(model.pointType, numberOfPoints * tcdim);
+    const tcoords = vtkDataArray.newInstance({
       name: 'TextureCoordinates',
       values: textureCoords,
       numberOfComponents: tcdim
     });
     polyData.getPointData().setTCoords(tcoords);
-    var x = [0.0, 0.0, 0.0];
-    var n = [0.0, 0.0, 0.0];
-    var tc = [0.0, 0.0];
-    var pointIndex = 0;
+    const x = [0.0, 0.0, 0.0];
+    const n = [0.0, 0.0, 0.0];
+    const tc = [0.0, 0.0];
+    let pointIndex = 0;
     x[0] = -model.xLength / 2.0;
     n[0] = -1.0;
     n[1] = 0.0;
     n[2] = 0.0;
-
-    for (var i = 0; i < 2; i++) {
+    for (let i = 0; i < 2; i++) {
       x[1] = -model.yLength / 2.0;
-
-      for (var j = 0; j < 2; j++) {
+      for (let j = 0; j < 2; j++) {
         tc[1] = x[1] + 0.5;
         x[2] = -model.zLength / 2.0;
-
-        for (var k = 0; k < 2; k++) {
+        for (let k = 0; k < 2; k++) {
           tc[0] = (x[2] + 0.5) * (1 - 2 * i);
           points[pointIndex * 3] = x[0];
           points[pointIndex * 3 + 1] = x[1];
@@ -70,7 +67,6 @@ function vtkCubeSource(publicAPI, model) {
           normals[pointIndex * 3] = n[0];
           normals[pointIndex * 3 + 1] = n[1];
           normals[pointIndex * 3 + 2] = n[2];
-
           if (tcdim === 2) {
             textureCoords[pointIndex * tcdim] = tc[0];
             textureCoords[pointIndex * tcdim + 1] = tc[1];
@@ -79,31 +75,24 @@ function vtkCubeSource(publicAPI, model) {
             textureCoords[pointIndex * tcdim + 1] = 2 * j - 1;
             textureCoords[pointIndex * tcdim + 2] = 2 * k - 1;
           }
-
           pointIndex++;
           x[2] += model.zLength;
         }
-
         x[1] += model.yLength;
       }
-
       x[0] += model.xLength;
       n[0] += 2.0;
     }
-
     x[1] = -model.yLength / 2.0;
     n[1] = -1.0;
     n[0] = 0.0;
     n[2] = 0.0;
-
-    for (var _i = 0; _i < 2; _i++) {
+    for (let i = 0; i < 2; i++) {
       x[0] = -model.xLength / 2.0;
-
-      for (var _j = 0; _j < 2; _j++) {
-        tc[0] = (x[0] + 0.5) * (2 * _i - 1);
+      for (let j = 0; j < 2; j++) {
+        tc[0] = (x[0] + 0.5) * (2 * i - 1);
         x[2] = -model.zLength / 2.0;
-
-        for (var _k = 0; _k < 2; _k++) {
+        for (let k = 0; k < 2; k++) {
           tc[1] = (x[2] + 0.5) * -1;
           points[pointIndex * 3] = x[0];
           points[pointIndex * 3 + 1] = x[1];
@@ -111,135 +100,117 @@ function vtkCubeSource(publicAPI, model) {
           normals[pointIndex * 3] = n[0];
           normals[pointIndex * 3 + 1] = n[1];
           normals[pointIndex * 3 + 2] = n[2];
-
           if (tcdim === 2) {
             textureCoords[pointIndex * tcdim] = tc[0];
             textureCoords[pointIndex * tcdim + 1] = tc[1];
           } else {
-            textureCoords[pointIndex * tcdim] = 2 * _j - 1;
-            textureCoords[pointIndex * tcdim + 1] = 2 * _i - 1;
-            textureCoords[pointIndex * tcdim + 2] = 2 * _k - 1;
+            textureCoords[pointIndex * tcdim] = 2 * j - 1;
+            textureCoords[pointIndex * tcdim + 1] = 2 * i - 1;
+            textureCoords[pointIndex * tcdim + 2] = 2 * k - 1;
           }
-
           pointIndex++;
           x[2] += model.zLength;
         }
-
         x[0] += model.xLength;
       }
-
       x[1] += model.yLength;
       n[1] += 2.0;
     }
-
     x[2] = -model.zLength / 2.0;
     n[2] = -1.0;
     n[0] = 0.0;
     n[1] = 0.0;
-
-    for (var _i2 = 0; _i2 < 2; _i2++) {
+    for (let i = 0; i < 2; i++) {
       x[1] = -model.yLength / 2.0;
-
-      for (var _j2 = 0; _j2 < 2; _j2++) {
+      for (let j = 0; j < 2; j++) {
         tc[1] = x[1] + 0.5;
         x[0] = -model.xLength / 2.0;
-
-        for (var _k2 = 0; _k2 < 2; _k2++) {
-          tc[0] = (x[0] + 0.5) * (2 * _i2 - 1);
+        for (let k = 0; k < 2; k++) {
+          tc[0] = (x[0] + 0.5) * (2 * i - 1);
           points[pointIndex * 3] = x[0];
           points[pointIndex * 3 + 1] = x[1];
           points[pointIndex * 3 + 2] = x[2];
           normals[pointIndex * 3] = n[0];
           normals[pointIndex * 3 + 1] = n[1];
           normals[pointIndex * 3 + 2] = n[2];
-
           if (tcdim === 2) {
             textureCoords[pointIndex * tcdim] = tc[0];
             textureCoords[pointIndex * tcdim + 1] = tc[1];
           } else {
-            textureCoords[pointIndex * tcdim] = 2 * _k2 - 1;
-            textureCoords[pointIndex * tcdim + 1] = 2 * _j2 - 1;
-            textureCoords[pointIndex * tcdim + 2] = 2 * _i2 - 1;
+            textureCoords[pointIndex * tcdim] = 2 * k - 1;
+            textureCoords[pointIndex * tcdim + 1] = 2 * j - 1;
+            textureCoords[pointIndex * tcdim + 2] = 2 * i - 1;
           }
-
           pointIndex++;
           x[0] += model.xLength;
         }
-
         x[1] += model.yLength;
       }
-
       x[2] += model.zLength;
       n[2] += 2.0;
-    } // Apply rotation to the points coordinates and normals
-
+    }
 
+    // Apply rotation to the points coordinates and normals
     if (model.rotations) {
       vtkMatrixBuilder.buildFromDegree().rotateX(model.rotations[0]).rotateY(model.rotations[1]).rotateZ(model.rotations[2]).apply(points).apply(normals);
-    } // Apply transformation to the points coordinates
-
+    }
 
+    // Apply transformation to the points coordinates
     if (model.center) {
-      var _vtkMatrixBuilder$bui;
-
-      (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).apply(points);
-    } // Apply optional additionally specified matrix transformation
-
+      vtkMatrixBuilder.buildFromRadian().translate(...model.center).apply(points);
+    }
 
+    // Apply optional additionally specified matrix transformation
     if (model.matrix) {
-      vtkMatrixBuilder.buildFromRadian().setMatrix(model.matrix).apply(points); // prettier-ignore
+      vtkMatrixBuilder.buildFromRadian().setMatrix(model.matrix).apply(points);
 
-      var rotMatrix = [model.matrix[0], model.matrix[1], model.matrix[2], 0, model.matrix[4], model.matrix[5], model.matrix[6], 0, model.matrix[8], model.matrix[9], model.matrix[10], 0, 0, 0, 0, 1];
+      // prettier-ignore
+      const rotMatrix = [model.matrix[0], model.matrix[1], model.matrix[2], 0, model.matrix[4], model.matrix[5], model.matrix[6], 0, model.matrix[8], model.matrix[9], model.matrix[10], 0, 0, 0, 0, 1];
       vtkMatrixBuilder.buildFromRadian().setMatrix(rotMatrix).apply(normals);
-    } // Lastly, generate the necessary cell arrays.
-
+    }
 
+    // Lastly, generate the necessary cell arrays.
     if (model.generateFaces) {
       polyData.getPolys().deepCopy(model._polys);
     } else {
       polyData.getPolys().initialize();
     }
-
     if (model.generateLines) {
-      polyData.getLines().deepCopy(model._lineCells); // only set normals for faces, not for lines.
-
+      polyData.getLines().deepCopy(model._lineCells);
+      // only set normals for faces, not for lines.
       polyData.getPointData().setNormals(null);
     } else {
       polyData.getLines().initialize();
     }
-
     polyData.modified();
   }
-
   publicAPI.setBounds = function () {
-    var boundsArray = [];
-
+    let boundsArray = [];
     if (Array.isArray(arguments.length <= 0 ? undefined : arguments[0])) {
       boundsArray = arguments.length <= 0 ? undefined : arguments[0];
     } else {
-      for (var i = 0; i < arguments.length; i++) {
+      for (let i = 0; i < arguments.length; i++) {
         boundsArray.push(i < 0 || arguments.length <= i ? undefined : arguments[i]);
       }
     }
-
     if (boundsArray.length !== 6) {
       return;
     }
-
     publicAPI.setXLength(boundsArray[1] - boundsArray[0]);
     publicAPI.setYLength(boundsArray[3] - boundsArray[2]);
     publicAPI.setZLength(boundsArray[5] - boundsArray[4]);
     publicAPI.setCenter([(boundsArray[0] + boundsArray[1]) / 2.0, (boundsArray[2] + boundsArray[3]) / 2.0, (boundsArray[4] + boundsArray[5]) / 2.0]);
-  }; // Expose methods
-
+  };
 
+  // Expose methods
   publicAPI.requestData = requestData;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   xLength: 1.0,
   yLength: 1.0,
   zLength: 1.0,
@@ -247,17 +218,21 @@ var DEFAULT_VALUES = {
   generate3DTextureCoordinates: false,
   generateFaces: true,
   generateLines: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['xLength', 'yLength', 'zLength', 'generate3DTextureCoordinates', 'generateFaces', 'generateLines']);
   macro.setGetArray(publicAPI, model, ['center', 'rotations'], 3);
-  macro.setGetArray(publicAPI, model, ['matrix'], 16); // Internal persistent/static objects
+  macro.setGetArray(publicAPI, model, ['matrix'], 16);
 
+  // Internal persistent/static objects
   model._polys = vtkCellArray.newInstance({
     values: Uint16Array.from(POLY_ARRAY)
   });
@@ -267,13 +242,17 @@ function extend(publicAPI, model) {
   macro.moveToProtected(publicAPI, model, ['polys', 'lineCells']);
   macro.algo(publicAPI, model, 0, 1);
   vtkCubeSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCubeSource'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCubeSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkCubeSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkCubeSource$1 as default, extend, newInstance };