@kitware/vtk.js 28.10.2 → 28.11.0

package/Imaging/Core/ImagePointDataIterator.js

@@ -1,7 +1,9 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
+
 // ----------------------------------------------------------------------------
 // vtkImagePointDataIterator methods
 // ----------------------------------------------------------------------------
@@ -9,39 +11,33 @@ import macro from '../../macros.js';
 function vtkImagePointDataIterator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImagePointDataIterator');
-
-  publicAPI.initialize = function (image, inExtent, stencil, algorithm) {
-    var dataExtent = image.getExtent();
-    var extent = inExtent;
-
+  publicAPI.initialize = (image, inExtent, stencil, algorithm) => {
+    const dataExtent = image.getExtent();
+    let extent = inExtent;
     if (extent == null) {
       extent = dataExtent;
     }
-
-    var emptyExtent = false;
-
-    for (var i = 0; i < 6; i += 2) {
+    let emptyExtent = false;
+    for (let i = 0; i < 6; i += 2) {
       model.extent[i] = Math.max(extent[i], dataExtent[i]);
       model.extent[i + 1] = Math.min(extent[i + 1], dataExtent[i + 1]);
-
       if (model.extent[i] > model.extent[i + 1]) {
         emptyExtent = true;
       }
     }
-
     model.rowIncrement = dataExtent[1] - dataExtent[0] + 1;
     model.sliceIncrement = model.rowIncrement * (dataExtent[3] - dataExtent[2] + 1);
-    var rowSpan;
-    var sliceSpan;
-    var volumeSpan;
-
+    let rowSpan;
+    let sliceSpan;
+    let volumeSpan;
     if (!emptyExtent) {
       // Compute the span of the image region to be covered.
       rowSpan = model.extent[1] - model.extent[0] + 1;
       sliceSpan = model.extent[3] - model.extent[2] + 1;
       volumeSpan = model.extent[5] - model.extent[4] + 1;
-      model.id = model.extent[0] - dataExtent[0] + (model.extent[2] - dataExtent[2]) * model.rowIncrement + (model.extent[4] - dataExtent[4]) * model.sliceIncrement; // Compute the end increments (continuous increments).
+      model.id = model.extent[0] - dataExtent[0] + (model.extent[2] - dataExtent[2]) * model.rowIncrement + (model.extent[4] - dataExtent[4]) * model.sliceIncrement;
 
+      // Compute the end increments (continuous increments).
       model.rowEndIncrement = model.rowIncrement - rowSpan;
       model.sliceEndIncrement = model.rowEndIncrement + model.sliceIncrement - model.rowIncrement * sliceSpan;
     } else {
@@ -52,74 +48,69 @@ function vtkImagePointDataIterator(publicAPI, model) {
       model.id = 0;
       model.rowEndIncrement = 0;
       model.sliceEndIncrement = 0;
-
-      for (var _i = 0; _i < 6; _i += 2) {
-        model.extent[_i] = dataExtent[_i];
-        model.extent[_i + 1] = dataExtent[_i] - 1;
+      for (let i = 0; i < 6; i += 2) {
+        model.extent[i] = dataExtent[i];
+        model.extent[i + 1] = dataExtent[i] - 1;
       }
-    } // Get the end pointers for row, slice, and volume.
-
+    }
 
+    // Get the end pointers for row, slice, and volume.
     model.spanEnd = model.id + rowSpan;
     model.rowEnd = model.id + rowSpan;
     model.sliceEnd = model.id + (model.rowIncrement * sliceSpan - model.rowEndIncrement);
-    model.end = model.id + (model.sliceIncrement * volumeSpan - model.sliceEndIncrement); // For keeping track of the current x,y,z index.
+    model.end = model.id + (model.sliceIncrement * volumeSpan - model.sliceEndIncrement);
 
+    // For keeping track of the current x,y,z index.
     model.index[0] = model.extent[0];
     model.index[1] = model.extent[2];
-    model.index[2] = model.extent[4]; // For resetting the Y index after each slice.
+    model.index[2] = model.extent[4];
 
-    model.startY = model.index[1]; // Code for when a stencil is provided.
+    // For resetting the Y index after each slice.
+    model.startY = model.index[1];
 
+    // Code for when a stencil is provided.
     if (stencil) {
       model.hasStencil = true;
       model.inStencil = false;
       model.spanIndex = 0;
-      var stencilExtent = stencil.getExtent(); // The stencil has a YZ array of span lists, we need increments
-      // to get to the next Z position in the YZ array.
+      const stencilExtent = stencil.getExtent();
 
+      // The stencil has a YZ array of span lists, we need increments
+      // to get to the next Z position in the YZ array.
       model.spanSliceIncrement = 0;
       model.spanSliceEndIncrement = 0;
-
       if (stencilExtent[3] >= stencilExtent[2] && stencilExtent[5] >= stencilExtent[4]) {
         model.spanSliceIncrement = stencilExtent[3] - stencilExtent[2] + 1;
-        var botOffset = model.extent[2] - stencilExtent[2];
-
+        const botOffset = model.extent[2] - stencilExtent[2];
         if (botOffset >= 0) {
           model.spanSliceEndIncrement += botOffset;
         }
-
-        var topOffset = stencilExtent[3] - model.extent[3];
-
+        const topOffset = stencilExtent[3] - model.extent[3];
         if (topOffset >= 0) {
           model.spanSliceEndIncrement += topOffset;
         }
-      } // Find the offset to the start position within the YZ array.
-
-
-      var startOffset = 0;
-      var yOffset = model.extent[2] - stencilExtent[2];
+      }
 
+      // Find the offset to the start position within the YZ array.
+      let startOffset = 0;
+      const yOffset = model.extent[2] - stencilExtent[2];
       if (yOffset < 0) {
-        model.extent[2] = stencilExtent[2]; // starting before start of stencil: subtract the increment that
+        model.extent[2] = stencilExtent[2];
+        // starting before start of stencil: subtract the increment that
         // will be added in NextSpan() upon entry into stencil extent
-
         startOffset -= 1;
       } else {
         // starting partway into the stencil, so add an offset
         startOffset += yOffset;
       }
-
       if (stencilExtent[3] <= model.extent[3]) {
         model.extent[3] = stencilExtent[3];
       }
-
-      var zOffset = model.extent[4] - stencilExtent[4];
-
+      const zOffset = model.extent[4] - stencilExtent[4];
       if (zOffset < 0) {
-        model.extent[4] = stencilExtent[4]; // starting before start of stencil: subtract the increment that
+        model.extent[4] = stencilExtent[4];
+        // starting before start of stencil: subtract the increment that
         // will be added in NextSpan() upon entry into stencil extent
-
         if (yOffset >= 0) {
           startOffset -= 1 + model.spanSliceEndIncrement;
         }
@@ -127,15 +118,14 @@ function vtkImagePointDataIterator(publicAPI, model) {
         // starting partway into the stencil, so add an offset
         startOffset += zOffset * model.spanSliceIncrement;
       }
-
       if (stencilExtent[5] <= model.extent[5]) {
         model.extent[5] = stencilExtent[5];
       }
-
       if (model.extent[2] <= model.extent[3] && model.extent[4] <= model.extent[5]) {
         model.spanCountPointer = stencil.extentListLengths.subarray(startOffset);
-        model.spanListPointer = stencil.extentLists.subarray(startOffset); // Get the current position within the span list for the current row
+        model.spanListPointer = stencil.extentLists.subarray(startOffset);
 
+        // Get the current position within the span list for the current row
         if (yOffset >= 0 && zOffset >= 0) {
           // If starting within stencil extent, check stencil immediately
           model.inStencil = true;
@@ -155,10 +145,9 @@ function vtkImagePointDataIterator(publicAPI, model) {
       model.spanCountPointer = null;
       model.spanListPointer = null;
     }
-
     if (algorithm) {
       model.algorithm = algorithm;
-      var maxCount = sliceSpan * volumeSpan;
+      const maxCount = sliceSpan * volumeSpan;
       model.target = maxCount / 50 + 1;
       model.count = model.target * 50 - maxCount / model.target * model.target + 1;
     } else {
@@ -167,42 +156,37 @@ function vtkImagePointDataIterator(publicAPI, model) {
       model.count = 0;
     }
   };
-
-  publicAPI.setSpanState = function (idX) {
+  publicAPI.setSpanState = idX => {
     // Find the span that includes idX
-    var inStencil = false;
-    var spans = model.spanListPointer;
-    var n = model.spanCountPointer[0];
-    var i;
-
+    let inStencil = false;
+    const spans = model.spanListPointer;
+    const n = model.spanCountPointer[0];
+    let i;
     for (i = 0; i < n; ++i) {
       if (spans[i] > idX) {
         break;
       }
-
       inStencil = !inStencil;
-    } // Set the primary span state variables
-
+    }
 
+    // Set the primary span state variables
     model.spanIndex = i;
-    model.inStencil = inStencil; // Clamp the span end to MaxX+1
-
-    var endIdX = model.extent[1] + 1;
+    model.inStencil = inStencil;
 
+    // Clamp the span end to MaxX+1
+    let endIdX = model.extent[1] + 1;
     if (i < n && spans[i] <= model.extent[1]) {
       endIdX = spans[i];
-    } // Compute the pointers for idX and endIdX
-
+    }
 
-    var rowStart = model.rowEnd - (model.rowIncrement - model.rowEndIncrement);
+    // Compute the pointers for idX and endIdX
+    const rowStart = model.rowEnd - (model.rowIncrement - model.rowEndIncrement);
     model.id = rowStart + (idX - model.extent[0]);
     model.spanEnd = rowStart + (endIdX - model.extent[0]);
   };
-
-  publicAPI.nextSpan = function () {
+  publicAPI.nextSpan = () => {
     if (model.spanEnd === model.rowEnd) {
-      var spanIncr = 1;
-
+      let spanIncr = 1;
       if (model.spanEnd !== model.sliceEnd) {
         // Move to the next row
         model.id = model.rowEnd + model.rowEndIncrement;
@@ -222,11 +206,10 @@ function vtkImagePointDataIterator(publicAPI, model) {
         // reached End
         model.id = model.end;
         return;
-      } // Start of next row
-
+      }
 
+      // Start of next row
       model.index[0] = model.extent[0];
-
       if (model.hasStencil) {
         if (model.index[1] >= model.extent[2] && model.index[1] <= model.extent[3] && model.index[2] >= model.extent[4] && model.index[2] <= model.extent[5]) {
           model.spanCountPointer = model.spanCountPointer.subarray(spanIncr);
@@ -236,71 +219,54 @@ function vtkImagePointDataIterator(publicAPI, model) {
           model.inStencil = false;
         }
       }
-
       if (model.algorithm) {
         publicAPI.reportProgress();
       }
     } else {
       // Move to the next span in the current row
       model.id = model.spanEnd;
-      var spanCount = model.spanCountPointer[0];
-      var endIdX = model.extent[1] + 1;
+      const spanCount = model.spanCountPointer[0];
+      let endIdX = model.extent[1] + 1;
       model.index[0] = endIdX;
-
       if (model.spanIndex < spanCount) {
-        var tmpIdX = model.spanListPointer[model.spanIndex];
-
+        const tmpIdX = model.spanListPointer[model.spanIndex];
         if (tmpIdX < endIdX) {
           model.index[0] = tmpIdX;
         }
-      } // Get the index to the start of the span after the next
-
+      }
 
+      // Get the index to the start of the span after the next
       model.spanIndex++;
-
       if (model.spanIndex < spanCount) {
-        var _tmpIdX = model.spanListPointer[model.spanIndex];
-
-        if (_tmpIdX < endIdX) {
-          endIdX = _tmpIdX;
+        const tmpIdX = model.spanListPointer[model.spanIndex];
+        if (tmpIdX < endIdX) {
+          endIdX = tmpIdX;
         }
-      } // Compute the end of the span
-
+      }
 
-      model.spanEnd = model.rowEnd - (model.rowIncrement - model.rowEndIncrement) + (endIdX - model.extent[0]); // Flip the state
+      // Compute the end of the span
+      model.spanEnd = model.rowEnd - (model.rowIncrement - model.rowEndIncrement) + (endIdX - model.extent[0]);
 
+      // Flip the state
       model.inStencil = !model.inStencil;
     }
   };
-
-  publicAPI.isAtEnd = function () {
-    return model.id === model.end;
-  };
-
-  publicAPI.isInStencil = function () {
-    return model.inStencil;
-  };
-
-  publicAPI.spanEndId = function () {
-    return model.spanEnd;
-  };
-
-  publicAPI.reportProgress = function () {};
-
-  publicAPI.getArray = function (array, i) {
-    return array.getData().subarray(i * array.getNumberOfComponents());
-  };
-
+  publicAPI.isAtEnd = () => model.id === model.end;
+  publicAPI.isInStencil = () => model.inStencil;
+  publicAPI.spanEndId = () => model.spanEnd;
+  publicAPI.reportProgress = () => {};
+  publicAPI.getArray = (array, i) => array.getData().subarray(i * array.getNumberOfComponents());
   publicAPI.getScalars = function (image) {
-    var i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let i = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     return publicAPI.getArray(image.getPointData().getScalars(), i);
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   spanState: 0,
   extent: [0, -1, 0, -1, 0, -1],
   end: 0,
@@ -324,23 +290,31 @@ var DEFAULT_VALUES = {
   algorithm: null,
   target: 0,
   count: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues); // Object methods
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
 
+  // Object methods
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['id', 'index']); // Object specific methods
+  macro.get(publicAPI, model, ['id', 'index']);
 
+  // Object specific methods
   vtkImagePointDataIterator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImagePointDataIterator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImagePointDataIterator');
+
+// ----------------------------------------------------------------------------
 
 var vtkImagePointDataIterator$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImagePointDataIterator$1 as default, extend, newInstance };

package/Imaging/Core/ImageReslice/Constants.js

@@ -1,11 +1,11 @@
-var SlabMode = {
+const SlabMode = {
   MIN: 0,
   MAX: 1,
   MEAN: 2,
   SUM: 3
 };
 var Constants = {
-  SlabMode: SlabMode
+  SlabMode
 };
 
 export { SlabMode, Constants as default };