@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/ClosedPolyLineToSurfaceFilter.js

@@ -1,218 +1,203 @@
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkCellArray from '../../Common/Core/CellArray.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro;
-
-var SegmentAgregator = /*#__PURE__*/function () {
-  function SegmentAgregator() {
-    _classCallCheck(this, SegmentAgregator);
-
+const {
+  vtkErrorMacro
+} = macro;
+class SegmentAgregator {
+  constructor() {
     this.segmentMapping = {};
     this.segments = [null]; // to force first id to be 1
-
     this.faces = [];
   }
-
-  _createClass(SegmentAgregator, [{
-    key: "addSegment",
-    value: function addSegment(segment) {
-      var first = segment[0];
-      var last = segment[segment.length - 1];
-
-      if (first === last || segment.length < 2) {
-        return;
-      }
-
-      var mappingFirst = this.segmentMapping[first];
-      var mappingLast = this.segmentMapping[last];
-
-      if (mappingFirst !== undefined && mappingLast !== undefined) {
-        if (Math.abs(mappingFirst) === Math.abs(mappingLast)) {
-          // This make a closing loop
-          var idx = mappingFirst < mappingLast ? mappingLast : mappingFirst;
-          var seg = this.segments[idx];
-
-          if (mappingFirst > 0) {
-            for (var i = 1; i < segment.length - 1; i++) {
-              seg.push(segment[i]);
-            }
-          } else {
-            for (var _i = 1; _i < segment.length - 1; _i++) {
-              seg.unshift(segment[segment.length - 1 - _i]);
-            }
-          }
-
-          this.faces.push(seg);
-          this.segments[idx] = null;
-          this.segmentMapping[first] = undefined;
-          this.segmentMapping[last] = undefined;
-        } else {
-          // we need to merge segments
-          // strategie:
-          // => remove and add them again in special order to induce merge
-          var idxHead = Math.abs(mappingFirst);
-          var idxTail = Math.abs(mappingLast);
-          var segHead = this.segments[idxHead];
-          var segTail = this.segments[idxTail];
-          this.segments[idxHead] = null;
-          this.segments[idxTail] = null;
-          this.segmentMapping[segHead[0]] = undefined;
-          this.segmentMapping[segTail[0]] = undefined;
-          this.segmentMapping[segHead[segHead.length - 1]] = undefined;
-          this.segmentMapping[segTail[segTail.length - 1]] = undefined; // This will lead to a single segment
-
-          this.addSegment(segment);
-          this.addSegment(segHead);
-          this.addSegment(segTail);
-        }
-      } else if (mappingFirst !== undefined) {
+  addSegment(segment) {
+    const first = segment[0];
+    const last = segment[segment.length - 1];
+    if (first === last || segment.length < 2) {
+      return;
+    }
+    const mappingFirst = this.segmentMapping[first];
+    const mappingLast = this.segmentMapping[last];
+    if (mappingFirst !== undefined && mappingLast !== undefined) {
+      if (Math.abs(mappingFirst) === Math.abs(mappingLast)) {
+        // This make a closing loop
+        const idx = mappingFirst < mappingLast ? mappingLast : mappingFirst;
+        const seg = this.segments[idx];
         if (mappingFirst > 0) {
-          // The head of our segment match the tail of the existing one
-          var _seg = this.segments[mappingFirst];
-
-          for (var _i2 = 1; _i2 < segment.length; _i2++) {
-            _seg.push(segment[_i2]);
-          } // record new tail
-
-
-          this.segmentMapping[last] = mappingFirst;
-        } else {
-          // our segment should be reverted and put on the front of the existing one
-          var _seg2 = this.segments[-mappingFirst]; // record new head
-
-          this.segmentMapping[last] = mappingFirst;
-
-          for (var _i3 = 1; _i3 < segment.length; _i3++) {
-            _seg2.unshift(segment[_i3]);
+          for (let i = 1; i < segment.length - 1; i++) {
+            seg.push(segment[i]);
           }
-        } // Erase used connection
-
-
-        this.segmentMapping[first] = undefined;
-      } else if (mappingLast !== undefined) {
-        if (mappingLast > 0) {
-          // The tail of our segment match the tail of the existing one
-          var _seg3 = this.segments[mappingLast];
-
-          for (var _i4 = 1; _i4 < segment.length; _i4++) {
-            _seg3.push(segment[segment.length - 1 - _i4]);
-          } // record new tail
-
-
-          this.segmentMapping[first] = mappingLast;
         } else {
-          // our segment should be reverted and put on the front of the existing one
-          var _seg4 = this.segments[-mappingLast]; // record new head
-
-          this.segmentMapping[first] = mappingLast;
-
-          for (var _i5 = 1; _i5 < segment.length; _i5++) {
-            _seg4.unshift(segment[segment.length - _i5 - 1]);
+          for (let i = 1; i < segment.length - 1; i++) {
+            seg.unshift(segment[segment.length - 1 - i]);
           }
-        } // Erase used connection
-
-
+        }
+        this.faces.push(seg);
+        this.segments[idx] = null;
+        this.segmentMapping[first] = undefined;
         this.segmentMapping[last] = undefined;
       } else {
-        // store segment for now
-        var id = this.segments.length;
-        this.segments.push(segment);
-        this.segmentMapping[first] = -id;
-        this.segmentMapping[last] = id;
+        // we need to merge segments
+        // strategie:
+        // => remove and add them again in special order to induce merge
+        const idxHead = Math.abs(mappingFirst);
+        const idxTail = Math.abs(mappingLast);
+        const segHead = this.segments[idxHead];
+        const segTail = this.segments[idxTail];
+        this.segments[idxHead] = null;
+        this.segments[idxTail] = null;
+        this.segmentMapping[segHead[0]] = undefined;
+        this.segmentMapping[segTail[0]] = undefined;
+        this.segmentMapping[segHead[segHead.length - 1]] = undefined;
+        this.segmentMapping[segTail[segTail.length - 1]] = undefined;
+
+        // This will lead to a single segment
+        this.addSegment(segment);
+        this.addSegment(segHead);
+        this.addSegment(segTail);
       }
+    } else if (mappingFirst !== undefined) {
+      if (mappingFirst > 0) {
+        // The head of our segment match the tail of the existing one
+        const seg = this.segments[mappingFirst];
+        for (let i = 1; i < segment.length; i++) {
+          seg.push(segment[i]);
+        }
+        // record new tail
+        this.segmentMapping[last] = mappingFirst;
+      } else {
+        // our segment should be reverted and put on the front of the existing one
+        const seg = this.segments[-mappingFirst];
+        // record new head
+        this.segmentMapping[last] = mappingFirst;
+        for (let i = 1; i < segment.length; i++) {
+          seg.unshift(segment[i]);
+        }
+      }
+      // Erase used connection
+      this.segmentMapping[first] = undefined;
+    } else if (mappingLast !== undefined) {
+      if (mappingLast > 0) {
+        // The tail of our segment match the tail of the existing one
+        const seg = this.segments[mappingLast];
+        for (let i = 1; i < segment.length; i++) {
+          seg.push(segment[segment.length - 1 - i]);
+        }
+        // record new tail
+        this.segmentMapping[first] = mappingLast;
+      } else {
+        // our segment should be reverted and put on the front of the existing one
+        const seg = this.segments[-mappingLast];
+
+        // record new head
+        this.segmentMapping[first] = mappingLast;
+        for (let i = 1; i < segment.length; i++) {
+          seg.unshift(segment[segment.length - i - 1]);
+        }
+      }
+      // Erase used connection
+      this.segmentMapping[last] = undefined;
+    } else {
+      // store segment for now
+      const id = this.segments.length;
+      this.segments.push(segment);
+      this.segmentMapping[first] = -id;
+      this.segmentMapping[last] = id;
     }
-  }]);
+  }
+}
 
-  return SegmentAgregator;
-}(); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkClosedPolyLineToSurfaceFilter methods
 // ----------------------------------------------------------------------------
 
-
 function vtkClosedPolyLineToSurfaceFilter(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkClosedPolyLineToSurfaceFilter'); // --------------------------------------------------------------------------
+  model.classHierarchy.push('vtkClosedPolyLineToSurfaceFilter');
 
-  publicAPI.requestData = function (inData, outData) {
-    // implement requestData
-    var input = inData[0];
+  // --------------------------------------------------------------------------
 
+  publicAPI.requestData = (inData, outData) => {
+    // implement requestData
+    const input = inData[0];
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
+    const output = vtkPolyData.newInstance();
+    output.shallowCopy(input);
 
-    var output = vtkPolyData.newInstance();
-    output.shallowCopy(input); // Extract faces
-
-    var agregator = new SegmentAgregator();
-    var lines = input.getLines().getData();
-    var offset = 0;
-
+    // Extract faces
+    const agregator = new SegmentAgregator();
+    const lines = input.getLines().getData();
+    let offset = 0;
     while (offset < lines.length) {
-      var lineSize = lines[offset++];
-      var lineSegment = [];
-
-      for (var i = 0; i < lineSize; i++) {
+      const lineSize = lines[offset++];
+      const lineSegment = [];
+      for (let i = 0; i < lineSize; i++) {
         lineSegment.push(lines[offset + i]);
       }
-
       agregator.addSegment(lineSegment);
       offset += lineSize;
-    } // Create CellArray for polys
-
-
-    var faces = agregator.faces;
-    var cellArraySize = faces.length;
-
-    for (var _i6 = 0; _i6 < faces.length; _i6++) {
-      cellArraySize += faces[_i6].length;
     }
 
-    var cellArray = new Uint16Array(cellArraySize);
+    // Create CellArray for polys
+    const {
+      faces
+    } = agregator;
+    let cellArraySize = faces.length;
+    for (let i = 0; i < faces.length; i++) {
+      cellArraySize += faces[i].length;
+    }
+    const cellArray = new Uint16Array(cellArraySize);
     offset = 0;
-
-    for (var _i7 = 0; _i7 < faces.length; _i7++) {
-      var face = faces[_i7];
+    for (let i = 0; i < faces.length; i++) {
+      const face = faces[i];
       cellArray[offset++] = face.length;
-
-      for (var j = 0; j < face.length; j++) {
+      for (let j = 0; j < face.length; j++) {
         cellArray[offset++] = face[j];
       }
     }
-
     output.setPolys(vtkCellArray.newInstance({
       values: cellArray,
       name: 'faces'
     }));
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
+const DEFAULT_VALUES = {};
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 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, 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
   vtkClosedPolyLineToSurfaceFilter(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkClosedPolyLineToSurfaceFilter'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkClosedPolyLineToSurfaceFilter');
+
+// ----------------------------------------------------------------------------
 
 var vtkClosedPolyLineToSurfaceFilter$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkClosedPolyLineToSurfaceFilter$1 as default, extend, newInstance };

package/Filters/General/ContourTriangulator/Constants.js

@@ -1,6 +1,6 @@
-var CCS_POLYGON_TOLERANCE = 1e-5;
+const CCS_POLYGON_TOLERANCE = 1e-5;
 var Constants = {
-  CCS_POLYGON_TOLERANCE: CCS_POLYGON_TOLERANCE
+  CCS_POLYGON_TOLERANCE
 };
 
 export { CCS_POLYGON_TOLERANCE, Constants as default };