@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/Sources/ConcentricCylinderSource.js

@@ -1,110 +1,89 @@
-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';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 
+// ----------------------------------------------------------------------------
 // vtkConcentricCylinderSource methods
 // ----------------------------------------------------------------------------
 
 function vtkConcentricCylinderSource(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkConcentricCylinderSource'); // Internal private function
+  model.classHierarchy.push('vtkConcentricCylinderSource');
 
+  // Internal private function
   function validateCellFields() {
     while (model.cellFields.length < model.radius.length) {
       model.cellFields.push(model.cellFields.length);
     }
   }
-
-  publicAPI.clearRadius = function () {
+  publicAPI.clearRadius = () => {
     model.radius = [];
     model.cellFields = [];
     publicAPI.modified();
   };
-
-  publicAPI.addRadius = function (radius, cellField) {
+  publicAPI.addRadius = (radius, cellField) => {
     model.radius.push(radius);
-
     if (cellField !== undefined) {
       model.cellFields.push(cellField);
     }
-
     validateCellFields();
     publicAPI.modified();
   };
-
-  publicAPI.getNumberOfRadius = function () {
-    return model.radius.length;
-  };
-
+  publicAPI.getNumberOfRadius = () => model.radius.length;
   publicAPI.getRadius = function () {
-    var index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let index = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
     return model.radius[index];
   };
-
-  publicAPI.setRadius = function (index, radius) {
+  publicAPI.setRadius = (index, radius) => {
     model.radius[index] = radius;
     publicAPI.modified();
   };
-
-  publicAPI.setCellField = function (index, field) {
+  publicAPI.setCellField = (index, field) => {
     model.cellFields[index] = field;
     publicAPI.modified();
   };
-
-  publicAPI.removeMask = function () {
+  publicAPI.removeMask = () => {
     model.mask = null;
     publicAPI.modified();
   };
-
-  publicAPI.setMaskLayer = function (index, hidden) {
-    var changeDetected = false;
-
+  publicAPI.setMaskLayer = (index, hidden) => {
+    let changeDetected = false;
     if (!model.mask && hidden) {
       changeDetected = true;
       model.mask = [];
     }
-
     if (model.mask) {
       if (!model.mask[index] !== !hidden) {
         changeDetected = true;
       }
-
       model.mask[index] = hidden;
     }
-
     if (changeDetected) {
       publicAPI.modified();
     }
   };
-
-  publicAPI.getMaskLayer = function (index) {
-    return index === undefined ? model.mask : model.mask[index];
-  };
-
+  publicAPI.getMaskLayer = index => index === undefined ? model.mask : model.mask[index];
   function requestData(inData, outData) {
-    var _vtkMatrixBuilder$bui;
-
     if (model.deleted || !model.radius.length) {
       return;
-    } // Make sure we have consistency
-
+    }
 
+    // Make sure we have consistency
     validateCellFields();
-    var dataset = outData[0];
-    var numLayers = model.radius.length;
-    var zRef = model.height / 2.0; // Compute cell count
-
-    var cellArraySize = 0;
-    var numCells = 0;
-    var startTheta = model.startTheta < model.endTheta ? model.startTheta : model.endTheta;
+    let dataset = outData[0];
+    const numLayers = model.radius.length;
+    const zRef = model.height / 2.0;
+
+    // Compute cell count
+    let cellArraySize = 0;
+    let numCells = 0;
+    let startTheta = model.startTheta < model.endTheta ? model.startTheta : model.endTheta;
     startTheta *= Math.PI / 180.0;
-    var endTheta = model.endTheta > model.startTheta ? model.endTheta : model.startTheta;
+    let endTheta = model.endTheta > model.startTheta ? model.endTheta : model.startTheta;
     endTheta *= Math.PI / 180.0;
-    var thetaResolution = model.resolution;
-    var partialDisk = false;
-
+    let thetaResolution = model.resolution;
+    let partialDisk = false;
     if (endTheta >= startTheta + 2 * Math.PI) {
       // complete, closed cylinder
       endTheta = startTheta + 2 * Math.PI;
@@ -114,10 +93,10 @@ function vtkConcentricCylinderSource(publicAPI, model) {
       ++thetaResolution;
       partialDisk = true;
     }
+    const deltaTheta = (endTheta - startTheta) / model.resolution;
+    const numberOfPoints = thetaResolution * numLayers * 2 + 2;
 
-    var deltaTheta = (endTheta - startTheta) / model.resolution;
-    var numberOfPoints = thetaResolution * numLayers * 2 + 2; // 5 entries per poly, 4 polys (top, bottom, in, out) per resolution
-
+    // 5 entries per poly, 4 polys (top, bottom, in, out) per resolution
     if (!model.skipInnerFaces && !model.mask) {
       // We keep everything
       cellArraySize = 2 * (thetaResolution + 1) + 5 * thetaResolution + (numLayers - 1) * thetaResolution * 20 + (partialDisk ? 10 * numLayers : 0);
@@ -128,10 +107,9 @@ function vtkConcentricCylinderSource(publicAPI, model) {
       if (!model.mask[0]) {
         cellArraySize += 2 * (thetaResolution + 1) + 5 * thetaResolution + (partialDisk ? 10 : 0);
         numCells += 2 + thetaResolution + (partialDisk ? 2 : 0);
-      } // Handle inside cylinders
-
-
-      for (var layer = 1; layer < numLayers; layer++) {
+      }
+      // Handle inside cylinders
+      for (let layer = 1; layer < numLayers; layer++) {
         if (!model.mask[layer]) {
           // Add inside cylinder count
           cellArraySize += thetaResolution * 20 + (partialDisk ? 10 : 0);
@@ -144,48 +122,51 @@ function vtkConcentricCylinderSource(publicAPI, model) {
         // core handling
         cellArraySize += 2 * (thetaResolution + 1) + (partialDisk ? 10 : 0);
         numCells += 2 + (partialDisk ? 2 : 0);
-
         if (model.radius.length === 1 || !model.skipInnerFaces || model.mask && model.mask[1]) {
           // add side faces
           cellArraySize += 5 * thetaResolution;
           numCells += thetaResolution;
         }
-      } // Handle inside cylinders
-
+      }
 
-      for (var _layer = 1; _layer < numLayers; _layer++) {
-        if (!model.skipInnerFaces || !model.mask || !model.mask[_layer]) {
-          var lastLayer = numLayers - 1 === _layer; // Add inside cylinder
+      // Handle inside cylinders
+      for (let layer = 1; layer < numLayers; layer++) {
+        if (!model.skipInnerFaces || !model.mask || !model.mask[layer]) {
+          const lastLayer = numLayers - 1 === layer;
 
+          // Add inside cylinder
           cellArraySize += thetaResolution * 10 + (partialDisk ? 10 : 0);
           numCells += thetaResolution * 2 + (partialDisk ? 2 : 0); // top + bottom + side caps
-          // Do we add innerFaces
 
-          if (!model.skipInnerFaces || model.mask && model.mask[_layer - 1]) {
+          // Do we add innerFaces
+          if (!model.skipInnerFaces || model.mask && model.mask[layer - 1]) {
             cellArraySize += thetaResolution * 5;
             numCells += thetaResolution;
-          } // Do we add outerFaces
-
+          }
 
-          if (lastLayer || !model.skipInnerFaces || model.mask && model.mask[_layer + 1]) {
+          // Do we add outerFaces
+          if (lastLayer || !model.skipInnerFaces || model.mask && model.mask[layer + 1]) {
             cellArraySize += thetaResolution * 5;
             numCells += thetaResolution;
           }
         }
       }
-    } // 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
+    // Cells
+    let cellLocation = 0;
+    const polys = new Uint32Array(cellArraySize);
 
-    var cellLocation = 0;
-    var polys = new Uint32Array(cellArraySize); // CellFields
+    // CellFields
+    let fieldLocation = 0;
+    const field = new Float32Array(numCells);
 
-    var fieldLocation = 0;
-    var field = new Float32Array(numCells); // Create points
+    // Create points
     // First two are centered, top and bottom. Used only if partialDisk is true.
-
     points[pointIdx * 3 + 0] = 0;
     points[pointIdx * 3 + 1] = 0;
     points[pointIdx * 3 + 2] = zRef;
@@ -194,64 +175,60 @@ function vtkConcentricCylinderSource(publicAPI, model) {
     points[pointIdx * 3 + 1] = 0;
     points[pointIdx * 3 + 2] = -zRef;
     pointIdx++;
-
-    for (var _layer2 = 0; _layer2 < numLayers; _layer2++) {
-      var radius = model.radius[_layer2]; // Create top
-
-      for (var i = 0; i < thetaResolution; i++) {
-        var theta = startTheta + i * deltaTheta;
+    for (let layer = 0; layer < numLayers; layer++) {
+      const radius = model.radius[layer];
+      // Create top
+      for (let i = 0; i < thetaResolution; i++) {
+        const theta = startTheta + i * deltaTheta;
         points[pointIdx * 3 + 0] = radius * Math.cos(theta);
         points[pointIdx * 3 + 1] = radius * Math.sin(theta);
         points[pointIdx * 3 + 2] = zRef;
         pointIdx++;
-      } // Create bottom
-
-
-      for (var _i = 0; _i < thetaResolution; _i++) {
-        var _theta = startTheta + _i * deltaTheta;
+      }
 
-        points[pointIdx * 3 + 0] = radius * Math.cos(_theta);
-        points[pointIdx * 3 + 1] = radius * Math.sin(_theta);
+      // Create bottom
+      for (let i = 0; i < thetaResolution; i++) {
+        const theta = startTheta + i * deltaTheta;
+        points[pointIdx * 3 + 0] = radius * Math.cos(theta);
+        points[pointIdx * 3 + 1] = radius * Math.sin(theta);
         points[pointIdx * 3 + 2] = -zRef;
         pointIdx++;
       }
-    } // Create cells for the core
-
+    }
 
-    var currentField = model.cellFields[0]; // Core: filtering
+    // Create cells for the core
+    let currentField = model.cellFields[0];
 
+    // Core: filtering
     if (!model.mask || !model.mask[0]) {
       // Core: Top disk
-      field[fieldLocation++] = currentField; // partial adds the center point and the last point.
-
+      field[fieldLocation++] = currentField;
+      // partial adds the center point and the last point.
       polys[cellLocation++] = thetaResolution + (partialDisk ? 1 : 0);
       if (partialDisk) polys[cellLocation++] = 0;
+      for (let i = 0; i < thetaResolution; i++) {
+        polys[cellLocation++] = i + 2;
+      }
 
-      for (var _i2 = 0; _i2 < thetaResolution; _i2++) {
-        polys[cellLocation++] = _i2 + 2;
-      } // Core: Bottom disk
-
-
+      // Core: Bottom disk
       field[fieldLocation++] = currentField;
       polys[cellLocation++] = thetaResolution + (partialDisk ? 1 : 0);
       if (partialDisk) polys[cellLocation++] = 1;
+      for (let i = 0; i < thetaResolution; i++) {
+        polys[cellLocation++] = 2 * thetaResolution - i - 1 + 2;
+      }
 
-      for (var _i3 = 0; _i3 < thetaResolution; _i3++) {
-        polys[cellLocation++] = 2 * thetaResolution - _i3 - 1 + 2;
-      } // Core: sides
-
-
+      // Core: sides
       if (!model.skipInnerFaces || model.mask && model.mask[1] || numLayers === 1) {
-        for (var _i4 = 0; _i4 < model.resolution; _i4++) {
+        for (let i = 0; i < model.resolution; i++) {
           polys[cellLocation++] = 4;
-          polys[cellLocation++] = (_i4 + 1) % thetaResolution + 2;
-          polys[cellLocation++] = _i4 + 2;
-          polys[cellLocation++] = _i4 + thetaResolution + 2;
-          polys[cellLocation++] = (_i4 + 1) % thetaResolution + thetaResolution + 2;
+          polys[cellLocation++] = (i + 1) % thetaResolution + 2;
+          polys[cellLocation++] = i + 2;
+          polys[cellLocation++] = i + thetaResolution + 2;
+          polys[cellLocation++] = (i + 1) % thetaResolution + thetaResolution + 2;
           field[fieldLocation++] = currentField;
         }
       }
-
       if (partialDisk) {
         polys[cellLocation++] = 4;
         polys[cellLocation++] = 2;
@@ -266,115 +243,108 @@ function vtkConcentricCylinderSource(publicAPI, model) {
         polys[cellLocation++] = 1;
         field[fieldLocation++] = currentField;
       }
-    } // Create cells for the layers
-
+    }
 
-    for (var _layer3 = 1; _layer3 < numLayers; _layer3++) {
+    // Create cells for the layers
+    for (let layer = 1; layer < numLayers; layer++) {
       // Skip layer if masked
-      if (model.mask && model.mask[_layer3]) {
+      if (model.mask && model.mask[layer]) {
         /* eslint-disable no-continue */
         continue;
         /* eslint-enable no-continue */
-      } // two for center points, then skip previous layer's points
-
-
-      var offset = thetaResolution * 2 * (_layer3 - 1) + 2;
-      var a = offset + 2 * thetaResolution; // next layer offset
-
-      var _lastLayer = numLayers - 1 === _layer3;
+      }
 
-      currentField = model.cellFields[_layer3]; // Create top
+      // two for center points, then skip previous layer's points
+      const offset = thetaResolution * 2 * (layer - 1) + 2;
+      const a = offset + 2 * thetaResolution; // next layer offset
+      const lastLayer = numLayers - 1 === layer;
+      currentField = model.cellFields[layer];
 
-      for (var _i5 = 0; _i5 < model.resolution; _i5++) {
+      // Create top
+      for (let i = 0; i < model.resolution; i++) {
         polys[cellLocation++] = 4;
-        polys[cellLocation++] = _i5 + offset;
-        polys[cellLocation++] = (_i5 + 1) % thetaResolution + offset;
-        polys[cellLocation++] = (_i5 + 1) % thetaResolution + a;
-        polys[cellLocation++] = _i5 + a;
+        polys[cellLocation++] = i + offset;
+        polys[cellLocation++] = (i + 1) % thetaResolution + offset;
+        polys[cellLocation++] = (i + 1) % thetaResolution + a;
+        polys[cellLocation++] = i + a;
         field[fieldLocation++] = currentField;
-      } // Create bottom
-
+      }
 
-      for (var _i6 = 0; _i6 < model.resolution; _i6++) {
+      // Create bottom
+      for (let i = 0; i < model.resolution; i++) {
         polys[cellLocation++] = 4;
-        polys[cellLocation++] = (_i6 + 1) % thetaResolution + offset + thetaResolution;
-        polys[cellLocation++] = _i6 + offset + thetaResolution;
-        polys[cellLocation++] = _i6 + a + thetaResolution;
-        polys[cellLocation++] = (_i6 + 1) % thetaResolution + a + thetaResolution;
+        polys[cellLocation++] = (i + 1) % thetaResolution + offset + thetaResolution;
+        polys[cellLocation++] = i + offset + thetaResolution;
+        polys[cellLocation++] = i + a + thetaResolution;
+        polys[cellLocation++] = (i + 1) % thetaResolution + a + thetaResolution;
         field[fieldLocation++] = currentField;
-      } // Create inner
-
+      }
 
-      if (!model.skipInnerFaces || model.mask && model.mask[_layer3 - 1]) {
-        for (var _i7 = 0; _i7 < model.resolution; _i7++) {
+      // Create inner
+      if (!model.skipInnerFaces || model.mask && model.mask[layer - 1]) {
+        for (let i = 0; i < model.resolution; i++) {
           polys[cellLocation++] = 4;
-          polys[cellLocation++] = _i7 + offset;
-          polys[cellLocation++] = (_i7 + 1) % thetaResolution + offset;
-          polys[cellLocation++] = (_i7 + 1) % thetaResolution + thetaResolution + offset;
-          polys[cellLocation++] = _i7 + thetaResolution + offset;
+          polys[cellLocation++] = i + offset;
+          polys[cellLocation++] = (i + 1) % thetaResolution + offset;
+          polys[cellLocation++] = (i + 1) % thetaResolution + thetaResolution + offset;
+          polys[cellLocation++] = i + thetaResolution + offset;
           field[fieldLocation++] = currentField;
         }
-      } // Create outer
-
+      }
 
-      if (!model.skipInnerFaces || _lastLayer || model.mask && (model.mask[_layer3 + 1] || _lastLayer)) {
-        for (var _i8 = 0; _i8 < model.resolution; _i8++) {
+      // Create outer
+      if (!model.skipInnerFaces || lastLayer || model.mask && (model.mask[layer + 1] || lastLayer)) {
+        for (let i = 0; i < model.resolution; i++) {
           polys[cellLocation++] = 4;
-          polys[cellLocation++] = (_i8 + 1) % thetaResolution + a;
-          polys[cellLocation++] = _i8 + a;
-          polys[cellLocation++] = _i8 + thetaResolution + a;
-          polys[cellLocation++] = (_i8 + 1) % thetaResolution + thetaResolution + a;
+          polys[cellLocation++] = (i + 1) % thetaResolution + a;
+          polys[cellLocation++] = i + a;
+          polys[cellLocation++] = i + thetaResolution + a;
+          polys[cellLocation++] = (i + 1) % thetaResolution + thetaResolution + a;
           field[fieldLocation++] = currentField;
         }
-      } // create caps
-
-
+      }
+      // create caps
       if (partialDisk) {
         polys[cellLocation++] = 4;
         polys[cellLocation++] = a; // from first outer
-
         polys[cellLocation++] = offset; // first inner
-
         polys[cellLocation++] = thetaResolution + offset; // first inner
-
         polys[cellLocation++] = thetaResolution + a; // first outer
 
         field[fieldLocation++] = currentField;
         polys[cellLocation++] = 4;
         polys[cellLocation++] = model.resolution + a; // last outer
-
         polys[cellLocation++] = model.resolution + offset; // last inner
-
         polys[cellLocation++] = model.resolution + thetaResolution + offset; // last inner
-
         polys[cellLocation++] = model.resolution + thetaResolution + a; // last outer
 
         field[fieldLocation++] = currentField;
       }
-    } // Apply transformation to the point coordinates
-
-
-    (_vtkMatrixBuilder$bui = vtkMatrixBuilder.buildFromRadian()).translate.apply(_vtkMatrixBuilder$bui, _toConsumableArray(model.center)).rotateFromDirections([0, 0, 1], model.direction).apply(points);
+    }
 
+    // Apply transformation to the point coordinates
+    vtkMatrixBuilder.buildFromRadian().translate(...model.center).rotateFromDirections([0, 0, 1], model.direction).apply(points);
     dataset = vtkPolyData.newInstance();
     dataset.getPoints().setData(points, 3);
     dataset.getPolys().setData(polys, 1);
     dataset.getCellData().setScalars(vtkDataArray.newInstance({
       name: 'layer',
       values: field
-    })); // Update output
+    }));
 
+    // 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],
   cellFields: [1],
@@ -387,25 +357,32 @@ var DEFAULT_VALUES = {
   mask: null,
   // If present, array to know if a layer should be skipped(=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', 'resolution', 'startTheta', 'endTheta', 'skipInnerFaces']);
   macro.setGetArray(publicAPI, model, ['center', 'direction'], 3);
   macro.getArray(publicAPI, model, ['cellFields']);
   macro.algo(publicAPI, model, 0, 1);
   vtkConcentricCylinderSource(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkConcentricCylinderSource'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkConcentricCylinderSource');
+
+// ----------------------------------------------------------------------------
 
 var vtkConcentricCylinderSource$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkConcentricCylinderSource$1 as default, extend, newInstance };