@kitware/vtk.js 28.10.2 → 28.11.1

package/Filters/Cornerstone/ImageDataToCornerstoneImage.js

@@ -1,11 +1,16 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+const {
+  vtkErrorMacro
+} = macro;
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // TODO:
 // - Support image stack
 // - Support slice orientation (see stack?)
 // - may need some data conversion
 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
 // ----------------------------------------------------------------------------
 // vtkImageDataToCornerstoneImage methods
 // ----------------------------------------------------------------------------
@@ -13,34 +18,31 @@ var vtkErrorMacro = macro.vtkErrorMacro; // ++++++++++++++++++++++++++++++++++++
 function vtkImageDataToCornerstoneImage(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkImageDataToCornerstoneImage');
-
-  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;
-    } // Retrieve output and volume data
-    // const origin = input.getOrigin();
-
-
-    var spacing = input.getSpacing();
-    var dims = input.getDimensions();
-    var scalars = input.getPointData().getScalars();
-    var dataRange = scalars.getRange(0);
-    var rawData = scalars.getData(); // FIXME probably need to expand to RGBA
-
-    var pixelData = null;
+    }
 
+    // Retrieve output and volume data
+    // const origin = input.getOrigin();
+    const spacing = input.getSpacing();
+    const dims = input.getDimensions();
+    const scalars = input.getPointData().getScalars();
+    const dataRange = scalars.getRange(0);
+    const rawData = scalars.getData();
+
+    // FIXME probably need to expand to RGBA
+    let pixelData = null;
     if (dims[2] === 1) {
       pixelData = !scalars.data ? rawData : scalars.data;
     } else {
-      var offset = model.sliceIndex * dims[0] * dims[1] * rawData.BYTES_PER_ELEMENT;
+      const offset = model.sliceIndex * dims[0] * dims[1] * rawData.BYTES_PER_ELEMENT;
       pixelData = macro.newTypedArray(scalars.getDataType(), rawData.buffer, offset, dims[0] * dims[1]);
     }
-
-    var cornerstoneImage = {
+    const cornerstoneImage = {
       imageId: model.imageId,
       color: scalars.getNumberOfComponents() > 1,
       columnPixelSpacing: spacing[0],
@@ -58,40 +60,50 @@ function vtkImageDataToCornerstoneImage(publicAPI, model) {
       windowCenter: Math.round((dataRange[0] + dataRange[1]) / 2),
       windowWidth: dataRange[1] - dataRange[0],
       decodeTimeInMS: 0,
-      getPixelData: function getPixelData() {
+      getPixelData() {
         return pixelData;
       }
     };
     outData[0] = cornerstoneImage;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   imageId: 'default-image-id',
   sliceIndex: 0
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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, ['imageId', 'sliceIndex']); // Object specific methods
+  macro.setGet(publicAPI, model, ['imageId', 'sliceIndex']);
 
+  // Object specific methods
   macro.algo(publicAPI, model, 1, 1);
   vtkImageDataToCornerstoneImage(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
-var newInstance = macro.newInstance(extend, 'vtkImageDataToCornerstoneImage'); // ----------------------------------------------------------------------------
+const newInstance = macro.newInstance(extend, 'vtkImageDataToCornerstoneImage');
+
+// ----------------------------------------------------------------------------
 
 var vtkImageDataToCornerstoneImage$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkImageDataToCornerstoneImage$1 as default, extend, newInstance };

package/Filters/Cornerstone.js

@@ -1,7 +1,7 @@
 import vtkImageDataToCornerstoneImage from './Cornerstone/ImageDataToCornerstoneImage.js';
 
 var Cornerstone = {
-  vtkImageDataToCornerstoneImage: vtkImageDataToCornerstoneImage
+  vtkImageDataToCornerstoneImage
 };
 
 export { Cornerstone as default };

package/Filters/General/AppendPolyData.js

@@ -1,93 +1,83 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import { DesiredOutputPrecision } from '../../Common/DataModel/DataSetAttributes/Constants.js';
 import { VtkDataTypes } from '../../Common/Core/DataArray/Constants.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro;
-
+const {
+  vtkErrorMacro
+} = macro;
 function offsetCellArray(typedArray, offset) {
-  var currentIdx = 0;
-  return typedArray.map(function (value, index) {
+  let currentIdx = 0;
+  return typedArray.map((value, index) => {
     if (index === currentIdx) {
       currentIdx += value + 1;
       return value;
     }
-
     return value + offset;
   });
 }
-
 function appendCellData(dest, src, ptOffset, cellOffset) {
   dest.set(offsetCellArray(src, ptOffset), cellOffset);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkAppendPolyData methods
 // ----------------------------------------------------------------------------
 
-
 function vtkAppendPolyData(publicAPI, model) {
   // Set our classname
   model.classHierarchy.push('vtkAppendPolyData');
-
-  publicAPI.requestData = function (inData, outData) {
+  publicAPI.requestData = (inData, outData) => {
     // implement requestData
-    var numberOfInputs = publicAPI.getNumberOfInputPorts();
-
+    const numberOfInputs = publicAPI.getNumberOfInputPorts();
     if (!numberOfInputs) {
       vtkErrorMacro('No input specified.');
       return;
     }
-
     if (numberOfInputs === 1) {
       // pass through filter
       outData[0] = inData[0];
       return;
-    } // Allocate output
-
-
-    var output = vtkPolyData.newInstance();
-    var numPts = 0;
-    var pointType = 0;
-    var ttype = 1;
-    var firstType = 1;
-    var numVerts = 0;
-    var numLines = 0;
-    var numStrips = 0;
-    var numPolys = 0; // Field data is propagated to output only if present in all inputs
-
-    var hasPtNormals = true; // assume present by default
-
-    var hasPtTCoords = true;
-    var hasPtScalars = true;
-
-    for (var i = 0; i < numberOfInputs; i++) {
-      var ds = inData[i];
+    }
 
+    // Allocate output
+    const output = vtkPolyData.newInstance();
+    let numPts = 0;
+    let pointType = 0;
+    let ttype = 1;
+    let firstType = 1;
+    let numVerts = 0;
+    let numLines = 0;
+    let numStrips = 0;
+    let numPolys = 0;
+
+    // Field data is propagated to output only if present in all inputs
+    let hasPtNormals = true; // assume present by default
+    let hasPtTCoords = true;
+    let hasPtScalars = true;
+    for (let i = 0; i < numberOfInputs; i++) {
+      const ds = inData[i];
       if (!ds) {
         // eslint-disable-next-line
         continue;
       }
-
-      var dsNumPts = ds.getPoints().getNumberOfPoints();
+      const dsNumPts = ds.getPoints().getNumberOfPoints();
       numPts += dsNumPts;
       numVerts += ds.getVerts().getNumberOfValues();
       numLines += ds.getLines().getNumberOfValues();
       numStrips += ds.getStrips().getNumberOfValues();
       numPolys += ds.getPolys().getNumberOfValues();
-
       if (dsNumPts) {
         if (firstType) {
           firstType = 0;
           pointType = ds.getPoints().getDataType();
         }
-
         ttype = ds.getPoints().getDataType();
         pointType = pointType > ttype ? pointType : ttype;
       }
-
-      var ptD = ds.getPointData();
-
+      const ptD = ds.getPointData();
       if (ptD) {
         hasPtNormals = hasPtNormals && ptD.getNormals() !== null;
         hasPtTCoords = hasPtTCoords && ptD.getTCoords() !== null;
@@ -98,29 +88,26 @@ function vtkAppendPolyData(publicAPI, model) {
         hasPtScalars = false;
       }
     }
-
     if (model.outputPointsPrecision === DesiredOutputPrecision.SINGLE) {
       pointType = VtkDataTypes.FLOAT;
     } else if (model.outputPointsPrecision === DesiredOutputPrecision.DOUBLE) {
       pointType = VtkDataTypes.DOUBLE;
     }
-
-    var points = vtkPoints.newInstance({
+    const points = vtkPoints.newInstance({
       dataType: pointType
     });
     points.setNumberOfPoints(numPts);
-    var pointData = points.getData();
-    var vertData = new Uint32Array(numVerts);
-    var lineData = new Uint32Array(numLines);
-    var stripData = new Uint32Array(numStrips);
-    var polyData = new Uint32Array(numPolys);
-    var newPtNormals = null;
-    var newPtTCoords = null;
-    var newPtScalars = null;
-    var lds = inData[numberOfInputs - 1];
-
+    const pointData = points.getData();
+    const vertData = new Uint32Array(numVerts);
+    const lineData = new Uint32Array(numLines);
+    const stripData = new Uint32Array(numStrips);
+    const polyData = new Uint32Array(numPolys);
+    let newPtNormals = null;
+    let newPtTCoords = null;
+    let newPtScalars = null;
+    const lds = inData[numberOfInputs - 1];
     if (hasPtNormals) {
-      var dsNormals = lds.getPointData().getNormals();
+      const dsNormals = lds.getPointData().getNormals();
       newPtNormals = vtkDataArray.newInstance({
         numberOfComponents: 3,
         numberOfTuples: numPts,
@@ -129,9 +116,8 @@ function vtkAppendPolyData(publicAPI, model) {
         name: dsNormals.getName()
       });
     }
-
     if (hasPtTCoords) {
-      var dsTCoords = lds.getPointData().getTCoords();
+      const dsTCoords = lds.getPointData().getTCoords();
       newPtTCoords = vtkDataArray.newInstance({
         numberOfComponents: 2,
         numberOfTuples: numPts,
@@ -140,9 +126,8 @@ function vtkAppendPolyData(publicAPI, model) {
         name: dsTCoords.getName()
       });
     }
-
     if (hasPtScalars) {
-      var dsScalars = lds.getPointData().getScalars();
+      const dsScalars = lds.getPointData().getScalars();
       newPtScalars = vtkDataArray.newInstance({
         numberOfComponents: dsScalars.getNumberOfComponents(),
         numberOfTuples: numPts,
@@ -151,92 +136,91 @@ function vtkAppendPolyData(publicAPI, model) {
         name: dsScalars.getName()
       });
     }
-
     numPts = 0;
     numVerts = 0;
     numLines = 0;
     numStrips = 0;
     numPolys = 0;
-
-    for (var _i = 0; _i < numberOfInputs; _i++) {
-      var _ds = inData[_i];
-      pointData.set(_ds.getPoints().getData(), numPts * 3);
-      appendCellData(vertData, _ds.getVerts().getData(), numPts, numVerts);
-      numVerts += _ds.getVerts().getNumberOfValues();
-      appendCellData(lineData, _ds.getLines().getData(), numPts, numLines);
-      numLines += _ds.getLines().getNumberOfValues();
-      appendCellData(stripData, _ds.getStrips().getData(), numPts, numStrips);
-      numStrips += _ds.getStrips().getNumberOfValues();
-      appendCellData(polyData, _ds.getPolys().getData(), numPts, numPolys);
-      numPolys += _ds.getPolys().getNumberOfValues();
-
-      var dsPD = _ds.getPointData();
-
+    for (let i = 0; i < numberOfInputs; i++) {
+      const ds = inData[i];
+      pointData.set(ds.getPoints().getData(), numPts * 3);
+      appendCellData(vertData, ds.getVerts().getData(), numPts, numVerts);
+      numVerts += ds.getVerts().getNumberOfValues();
+      appendCellData(lineData, ds.getLines().getData(), numPts, numLines);
+      numLines += ds.getLines().getNumberOfValues();
+      appendCellData(stripData, ds.getStrips().getData(), numPts, numStrips);
+      numStrips += ds.getStrips().getNumberOfValues();
+      appendCellData(polyData, ds.getPolys().getData(), numPts, numPolys);
+      numPolys += ds.getPolys().getNumberOfValues();
+      const dsPD = ds.getPointData();
       if (hasPtNormals) {
-        var ptNorms = dsPD.getNormals();
+        const ptNorms = dsPD.getNormals();
         newPtNormals.getData().set(ptNorms.getData(), numPts * 3);
       }
-
       if (hasPtTCoords) {
-        var ptTCoords = dsPD.getTCoords();
+        const ptTCoords = dsPD.getTCoords();
         newPtTCoords.getData().set(ptTCoords.getData(), numPts * 2);
       }
-
       if (hasPtScalars) {
-        var ptScalars = dsPD.getScalars();
+        const ptScalars = dsPD.getScalars();
         newPtScalars.getData().set(ptScalars.getData(), numPts * newPtScalars.getNumberOfComponents());
       }
-
-      numPts += _ds.getPoints().getNumberOfPoints();
+      numPts += ds.getPoints().getNumberOfPoints();
     }
-
     output.setPoints(points);
     output.getVerts().setData(vertData);
     output.getLines().setData(lineData);
     output.getStrips().setData(stripData);
     output.getPolys().setData(polyData);
-
     if (newPtNormals) {
       output.getPointData().setNormals(newPtNormals);
     }
-
     if (newPtTCoords) {
       output.getPointData().setTCoords(newPtTCoords);
     }
-
     if (newPtScalars) {
       output.getPointData().setScalars(newPtScalars);
     }
-
     outData[0] = output;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   outputPointsPrecision: DesiredOutputPrecision.DEFAULT
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 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);
 
-  macro.setGet(publicAPI, model, ['outputPointsPrecision']); // Make this a VTK object
+  // Build VTK API
+  macro.setGet(publicAPI, model, ['outputPointsPrecision']);
 
-  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
   vtkAppendPolyData(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkAppendPolyData');
 
-var newInstance = macro.newInstance(extend, 'vtkAppendPolyData'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkAppendPolyData$1 = {
-  newInstance: newInstance,
-  extend: extend
+  newInstance,
+  extend
 };
 
 export { vtkAppendPolyData$1 as default, extend, newInstance };