@kitware/vtk.js 28.10.2 → 28.11.0

package/Filters/General/ImageMarchingCubes.js

@@ -1,90 +1,81 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkEdgeLocator from '../../Common/DataModel/EdgeLocator.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { l as normalize } from '../../Common/Core/Math/index.js';
 import vtkCaseTable from './ImageMarchingCubes/caseTable.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro,
-    vtkDebugMacro = macro.vtkDebugMacro; // ----------------------------------------------------------------------------
+const {
+  vtkErrorMacro,
+  vtkDebugMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
 // vtkImageMarchingCubes methods
 // ----------------------------------------------------------------------------
 
 function vtkImageMarchingCubes(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageMarchingCubes');
-  var ids = [];
-  var voxelScalars = [];
-  var voxelGradients = [];
-  var voxelPts = [];
-  var edgeLocator = vtkEdgeLocator.newInstance(); // Retrieve scalars and voxel coordinates. i-j-k is origin of voxel.
-
-  publicAPI.getVoxelScalars = function (i, j, k, slice, dims, origin, spacing, s) {
+  const ids = [];
+  const voxelScalars = [];
+  const voxelGradients = [];
+  const voxelPts = [];
+  const edgeLocator = vtkEdgeLocator.newInstance();
+
+  // Retrieve scalars and voxel coordinates. i-j-k is origin of voxel.
+  publicAPI.getVoxelScalars = (i, j, k, slice, dims, origin, spacing, s) => {
     // First get the indices for the voxel
     ids[0] = k * slice + j * dims[0] + i; // i, j, k
-
     ids[1] = ids[0] + 1; // i+1, j, k
-
     ids[2] = ids[0] + dims[0]; // i, j+1, k
-
     ids[3] = ids[2] + 1; // i+1, j+1, k
-
     ids[4] = ids[0] + slice; // i, j, k+1
-
     ids[5] = ids[4] + 1; // i+1, j, k+1
-
     ids[6] = ids[4] + dims[0]; // i, j+1, k+1
-
     ids[7] = ids[6] + 1; // i+1, j+1, k+1
-    // Now retrieve the scalars
 
-    for (var ii = 0; ii < 8; ++ii) {
+    // Now retrieve the scalars
+    for (let ii = 0; ii < 8; ++ii) {
       voxelScalars[ii] = s[ids[ii]];
     }
-  }; // Retrieve voxel coordinates. i-j-k is origin of voxel.
-
+  };
 
-  publicAPI.getVoxelPoints = function (i, j, k, origin, spacing) {
+  // Retrieve voxel coordinates. i-j-k is origin of voxel.
+  publicAPI.getVoxelPoints = (i, j, k, origin, spacing) => {
     // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
     voxelPts[0] = origin[0] + i * spacing[0]; // 0
-
     voxelPts[1] = origin[1] + j * spacing[1];
     voxelPts[2] = origin[2] + k * spacing[2];
     voxelPts[3] = voxelPts[0] + spacing[0]; // 1
-
     voxelPts[4] = voxelPts[1];
     voxelPts[5] = voxelPts[2];
     voxelPts[6] = voxelPts[0]; // 2
-
     voxelPts[7] = voxelPts[1] + spacing[1];
     voxelPts[8] = voxelPts[2];
     voxelPts[9] = voxelPts[3]; // 3
-
     voxelPts[10] = voxelPts[7];
     voxelPts[11] = voxelPts[2];
     voxelPts[12] = voxelPts[0]; // 4
-
     voxelPts[13] = voxelPts[1];
     voxelPts[14] = voxelPts[2] + spacing[2];
     voxelPts[15] = voxelPts[3]; // 5
-
     voxelPts[16] = voxelPts[1];
     voxelPts[17] = voxelPts[14];
     voxelPts[18] = voxelPts[0]; // 6
-
     voxelPts[19] = voxelPts[7];
     voxelPts[20] = voxelPts[14];
     voxelPts[21] = voxelPts[3]; // 7
-
     voxelPts[22] = voxelPts[7];
     voxelPts[23] = voxelPts[14];
-  }; // Compute point gradient at i-j-k location
-
+  };
 
-  publicAPI.getPointGradient = function (i, j, k, dims, slice, spacing, s, g) {
-    var sp;
-    var sm; // x-direction
+  // Compute point gradient at i-j-k location
+  publicAPI.getPointGradient = (i, j, k, dims, slice, spacing, s, g) => {
+    let sp;
+    let sm;
 
+    // x-direction
     if (i === 0) {
       sp = s[i + 1 + j * dims[0] + k * slice];
       sm = s[i + j * dims[0] + k * slice];
@@ -97,9 +88,9 @@ function vtkImageMarchingCubes(publicAPI, model) {
       sp = s[i + 1 + j * dims[0] + k * slice];
       sm = s[i - 1 + j * dims[0] + k * slice];
       g[0] = 0.5 * (sm - sp) / spacing[0];
-    } // y-direction
-
+    }
 
+    // y-direction
     if (j === 0) {
       sp = s[i + (j + 1) * dims[0] + k * slice];
       sm = s[i + j * dims[0] + k * slice];
@@ -112,9 +103,9 @@ function vtkImageMarchingCubes(publicAPI, model) {
       sp = s[i + (j + 1) * dims[0] + k * slice];
       sm = s[i + (j - 1) * dims[0] + k * slice];
       g[1] = 0.5 * (sm - sp) / spacing[1];
-    } // z-direction
-
+    }
 
+    // z-direction
     if (k === 0) {
       sp = s[i + j * dims[0] + (k + 1) * slice];
       sm = s[i + j * dims[0] + k * slice];
@@ -128,11 +119,11 @@ function vtkImageMarchingCubes(publicAPI, model) {
       sm = s[i + j * dims[0] + (k - 1) * slice];
       g[2] = 0.5 * (sm - sp) / spacing[2];
     }
-  }; // Compute voxel gradient values. I-j-k is origin point of voxel.
-
+  };
 
-  publicAPI.getVoxelGradients = function (i, j, k, dims, slice, spacing, scalars) {
-    var g = [];
+  // Compute voxel gradient values. I-j-k is origin point of voxel.
+  publicAPI.getVoxelGradients = (i, j, k, dims, slice, spacing, scalars) => {
+    const g = [];
     publicAPI.getPointGradient(i, j, k, dims, slice, spacing, scalars, g);
     voxelGradients[0] = g[0];
     voxelGradients[1] = g[1];
@@ -166,159 +157,155 @@ function vtkImageMarchingCubes(publicAPI, model) {
     voxelGradients[22] = g[1];
     voxelGradients[23] = g[2];
   };
-
-  publicAPI.produceTriangles = function (cVal, i, j, k, extent, slice, dims, origin, spacing, scalars, points, tris, normals) {
-    var CASE_MASK = [1, 2, 4, 8, 16, 32, 64, 128];
-    var VERT_MAP = [0, 1, 3, 2, 4, 5, 7, 6];
-    var xyz = [];
-    var n = [];
-    var pId;
+  publicAPI.produceTriangles = (cVal, i, j, k, extent, slice, dims, origin, spacing, scalars, points, tris, normals) => {
+    const CASE_MASK = [1, 2, 4, 8, 16, 32, 64, 128];
+    const VERT_MAP = [0, 1, 3, 2, 4, 5, 7, 6];
+    const xyz = [];
+    const n = [];
+    let pId;
     publicAPI.getVoxelScalars(i, j, k, slice, dims, origin, spacing, scalars);
-    var index = 0;
-
-    for (var idx = 0; idx < 8; idx++) {
+    let index = 0;
+    for (let idx = 0; idx < 8; idx++) {
       if (voxelScalars[VERT_MAP[idx]] >= cVal) {
         index |= CASE_MASK[idx]; // eslint-disable-line no-bitwise
       }
     }
 
-    var voxelTris = vtkCaseTable.getCase(index);
-
+    const voxelTris = vtkCaseTable.getCase(index);
     if (voxelTris[0] < 0) {
       return; // don't get the voxel coordinates, nothing to do
     }
 
     publicAPI.getVoxelPoints(i + extent[0], j + extent[2], k + extent[4], origin, spacing);
-
     if (model.computeNormals) {
       publicAPI.getVoxelGradients(i, j, k, dims, slice, spacing, scalars);
     }
-
-    for (var _idx = 0; voxelTris[_idx] >= 0; _idx += 3) {
+    for (let idx = 0; voxelTris[idx] >= 0; idx += 3) {
       tris.push(3);
-
-      for (var eid = 0; eid < 3; eid++) {
-        var edgeVerts = vtkCaseTable.getEdge(voxelTris[_idx + eid]);
+      for (let eid = 0; eid < 3; eid++) {
+        const edgeVerts = vtkCaseTable.getEdge(voxelTris[idx + eid]);
         pId = undefined;
-
         if (model.mergePoints) {
-          var _edgeLocator$isInsert;
-
-          pId = (_edgeLocator$isInsert = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])) === null || _edgeLocator$isInsert === void 0 ? void 0 : _edgeLocator$isInsert.value;
+          pId = edgeLocator.isInsertedEdge(ids[edgeVerts[0]], ids[edgeVerts[1]])?.value;
         }
-
         if (pId === undefined) {
-          var t = (cVal - voxelScalars[edgeVerts[0]]) / (voxelScalars[edgeVerts[1]] - voxelScalars[edgeVerts[0]]);
-          var x0 = voxelPts.slice(edgeVerts[0] * 3, (edgeVerts[0] + 1) * 3);
-          var x1 = voxelPts.slice(edgeVerts[1] * 3, (edgeVerts[1] + 1) * 3);
+          const t = (cVal - voxelScalars[edgeVerts[0]]) / (voxelScalars[edgeVerts[1]] - voxelScalars[edgeVerts[0]]);
+          const x0 = voxelPts.slice(edgeVerts[0] * 3, (edgeVerts[0] + 1) * 3);
+          const x1 = voxelPts.slice(edgeVerts[1] * 3, (edgeVerts[1] + 1) * 3);
           xyz[0] = x0[0] + t * (x1[0] - x0[0]);
           xyz[1] = x0[1] + t * (x1[1] - x0[1]);
           xyz[2] = x0[2] + t * (x1[2] - x0[2]);
           pId = points.length / 3;
           points.push(xyz[0], xyz[1], xyz[2]);
-
           if (model.computeNormals) {
-            var n0 = voxelGradients.slice(edgeVerts[0] * 3, (edgeVerts[0] + 1) * 3);
-            var n1 = voxelGradients.slice(edgeVerts[1] * 3, (edgeVerts[1] + 1) * 3);
+            const n0 = voxelGradients.slice(edgeVerts[0] * 3, (edgeVerts[0] + 1) * 3);
+            const n1 = voxelGradients.slice(edgeVerts[1] * 3, (edgeVerts[1] + 1) * 3);
             n[0] = n0[0] + t * (n1[0] - n0[0]);
             n[1] = n0[1] + t * (n1[1] - n0[1]);
             n[2] = n0[2] + t * (n1[2] - n0[2]);
             normalize(n);
             normals.push(n[0], n[1], n[2]);
           }
-
           if (model.mergePoints) {
             edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
           }
         }
-
         tris.push(pId);
       }
     }
   };
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var input = inData[0];
-
+    const input = inData[0];
     if (!input) {
       vtkErrorMacro('Invalid or missing input');
       return;
     }
+    console.time('mcubes');
 
-    console.time('mcubes'); // Retrieve output and volume data
-
-    var origin = input.getOrigin();
-    var spacing = input.getSpacing();
-    var dims = input.getDimensions();
-    var s = input.getPointData().getScalars().getData(); // Points - dynamic array
+    // Retrieve output and volume data
+    const origin = input.getOrigin();
+    const spacing = input.getSpacing();
+    const dims = input.getDimensions();
+    const s = input.getPointData().getScalars().getData();
 
-    var pBuffer = []; // Cells - dynamic array
+    // Points - dynamic array
+    const pBuffer = [];
 
-    var tBuffer = []; // Normals
+    // Cells - dynamic array
+    const tBuffer = [];
 
-    var nBuffer = []; // Loop over all voxels, determine case and process
+    // Normals
+    const nBuffer = [];
 
-    var extent = input.getExtent();
-    var slice = dims[0] * dims[1];
-
-    for (var k = 0; k < dims[2] - 1; ++k) {
-      for (var j = 0; j < dims[1] - 1; ++j) {
-        for (var i = 0; i < dims[0] - 1; ++i) {
+    // Loop over all voxels, determine case and process
+    const extent = input.getExtent();
+    const slice = dims[0] * dims[1];
+    for (let k = 0; k < dims[2] - 1; ++k) {
+      for (let j = 0; j < dims[1] - 1; ++j) {
+        for (let i = 0; i < dims[0] - 1; ++i) {
           publicAPI.produceTriangles(model.contourValue, i, j, k, extent, slice, dims, origin, spacing, s, pBuffer, tBuffer, nBuffer);
         }
       }
     }
+    edgeLocator.initialize();
 
-    edgeLocator.initialize(); // Update output
-
-    var polydata = vtkPolyData.newInstance();
+    // Update output
+    const polydata = vtkPolyData.newInstance();
     polydata.getPoints().setData(new Float32Array(pBuffer), 3);
     polydata.getPolys().setData(new Uint32Array(tBuffer));
-
     if (model.computeNormals) {
-      var nData = new Float32Array(nBuffer);
-      var normals = vtkDataArray.newInstance({
+      const nData = new Float32Array(nBuffer);
+      const normals = vtkDataArray.newInstance({
         numberOfComponents: 3,
         values: nData,
         name: 'Normals'
       });
       polydata.getPointData().setNormals(normals);
     }
-
     outData[0] = polydata;
     vtkDebugMacro('Produced output');
     console.timeEnd('mcubes');
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   contourValue: 0,
   computeNormals: false,
   mergePoints: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
+  // Also make it an algorithm with one input and one output
   macro.algo(publicAPI, model, 1, 1);
-  macro.setGet(publicAPI, model, ['contourValue', 'computeNormals', 'mergePoints']); // Object specific methods
+  macro.setGet(publicAPI, model, ['contourValue', 'computeNormals', 'mergePoints']);
 
+  // Object specific methods
   macro.algo(publicAPI, model, 1, 1);
   vtkImageMarchingCubes(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkImageMarchingCubes'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkImageMarchingCubes');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageMarchingCubes$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageMarchingCubes$1 as default, extend, newInstance };

package/Filters/General/ImageMarchingSquares/caseTable.js

@@ -4,56 +4,24 @@
 // end of the list of edges. Edges are taken three at a time to generate
 // triangle points.
 // ----------------------------------------------------------------------------
-var MARCHING_SQUARES_CASES = [[-1, -1, -1, -1, -1]
-/* 0 */
-, [0, 3, -1, -1, -1]
-/* 1 */
-, [1, 0, -1, -1, -1]
-/* 2 */
-, [1, 3, -1, -1, -1]
-/* 3 */
-, [2, 1, -1, -1, -1]
-/* 4 */
-, [0, 3, 2, 1, -1]
-/* 5 */
-, [2, 0, -1, -1, -1]
-/* 6 */
-, [2, 3, -1, -1, -1]
-/* 7 */
-, [3, 2, -1, -1, -1]
-/* 8 */
-, [0, 2, -1, -1, -1]
-/* 9 */
-, [1, 0, 3, 2, -1]
-/* 10 */
-, [1, 2, -1, -1, -1]
-/* 11 */
-, [3, 1, -1, -1, -1]
-/* 12 */
-, [0, 1, -1, -1, -1]
-/* 13 */
-, [3, 0, -1, -1, -1]
-/* 14 */
-, [-1, -1, -1, -1, -1]
-/* 15 */
-];
-var EDGES = [[0, 1], [1, 3], [2, 3], [0, 2]];
+const MARCHING_SQUARES_CASES = [[-1, -1, -1, -1, -1] /* 0 */, [0, 3, -1, -1, -1] /* 1 */, [1, 0, -1, -1, -1] /* 2 */, [1, 3, -1, -1, -1] /* 3 */, [2, 1, -1, -1, -1] /* 4 */, [0, 3, 2, 1, -1] /* 5 */, [2, 0, -1, -1, -1] /* 6 */, [2, 3, -1, -1, -1] /* 7 */, [3, 2, -1, -1, -1] /* 8 */, [0, 2, -1, -1, -1] /* 9 */, [1, 0, 3, 2, -1] /* 10 */, [1, 2, -1, -1, -1] /* 11 */, [3, 1, -1, -1, -1] /* 12 */, [0, 1, -1, -1, -1] /* 13 */, [3, 0, -1, -1, -1] /* 14 */, [-1, -1, -1, -1, -1] /* 15 */];
 
+const EDGES = [[0, 1], [1, 3], [2, 3], [0, 2]];
 function getCase(index) {
   return MARCHING_SQUARES_CASES[index];
-} // Define the four edges of the pixel by the following pairs of vertices
-
+}
 
+// Define the four edges of the pixel by the following pairs of vertices
 function getEdge(eid) {
   return EDGES[eid];
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
-
-
 var vtkCaseTable = {
-  getCase: getCase,
-  getEdge: getEdge
+  getCase,
+  getEdge
 };
 
 export { vtkCaseTable as default };