@kitware/vtk.js 28.10.2 → 28.11.1

package/Common/DataModel/ITKHelper.js

@@ -1,11 +1,14 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkImageData from './ImageData.js';
 import vtkPolyData from './PolyData.js';
 import vtkDataArray from '../Core/DataArray.js';
 
-var vtkErrorMacro = macro.vtkErrorMacro; // see itk.js PixelTypes.js
+const {
+  vtkErrorMacro
+} = macro;
 
-var ITKJSPixelTypes = {
+// see itk.js PixelTypes.js
+const ITKJSPixelTypes = {
   Unknown: 0,
   Scalar: 1,
   RGB: 2,
@@ -22,9 +25,10 @@ var ITKJSPixelTypes = {
   Matrix: 13,
   VariableLengthVector: 14,
   VariableSizeMatrix: 15
-}; // itk-wasm pixel types from https://github.com/InsightSoftwareConsortium/itk-wasm/blob/master/src/core/PixelTypes.ts
+};
 
-var ITKWASMPixelTypes = {
+// itk-wasm pixel types from https://github.com/InsightSoftwareConsortium/itk-wasm/blob/master/src/core/PixelTypes.ts
+const ITKWASMPixelTypes = {
   Unknown: 'Unknown',
   Scalar: 'Scalar',
   RGB: 'RGB',
@@ -42,32 +46,31 @@ var ITKWASMPixelTypes = {
   VariableLengthVector: 'VariableLengthVector',
   VariableSizeMatrix: 'VariableSizeMatrix'
 };
-var vtkArrayTypeToItkComponentType = new Map([['Uint8Array', 'uint8'], ['Int8Array', 'int8'], ['Uint16Array', 'uint16'], ['Int16Array', 'int16'], ['Uint32Array', 'uint32'], ['Int32Array', 'int32'], ['Float32Array', 'float32'], ['Float64Array', 'float64']]);
-var itkComponentTypeToVtkArrayType = new Map([['uint8', 'Uint8Array'], ['int8', 'Int8Array'], ['uint16', 'Uint16Array'], ['int16', 'Int16Array'], ['uint32', 'Uint32Array'], ['int32', 'Int32Array'], ['float32', 'Float32Array'], ['float64', 'Float64Array']]);
+const vtkArrayTypeToItkComponentType = new Map([['Uint8Array', 'uint8'], ['Int8Array', 'int8'], ['Uint16Array', 'uint16'], ['Int16Array', 'int16'], ['Uint32Array', 'uint32'], ['Int32Array', 'int32'], ['Float32Array', 'float32'], ['Float64Array', 'float64']]);
+const itkComponentTypeToVtkArrayType = new Map([['uint8', 'Uint8Array'], ['int8', 'Int8Array'], ['uint16', 'Uint16Array'], ['int16', 'Int16Array'], ['uint32', 'Uint32Array'], ['int32', 'Int32Array'], ['float32', 'Float32Array'], ['float64', 'Float64Array']]);
+
 /**
  * Converts an itk-wasm Image to a vtk.js vtkImageData.
  *
  * Requires an itk-wasm Image as input.
  */
-
 function convertItkToVtkImage(itkImage) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var vtkImage = {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const vtkImage = {
     origin: [0, 0, 0],
     spacing: [1, 1, 1]
   };
-  var dimensions = [1, 1, 1];
-  var direction = [1, 0, 0, 0, 1, 0, 0, 0, 1]; // Check whether itkImage is an itk.js Image or an itk-wasm Image?
+  const dimensions = [1, 1, 1];
+  const direction = [1, 0, 0, 0, 1, 0, 0, 0, 1];
 
-  var isITKWasm = itkImage.direction.data === undefined;
-  var ITKPixelTypes = isITKWasm ? ITKWASMPixelTypes : ITKJSPixelTypes;
-
-  for (var idx = 0; idx < itkImage.imageType.dimension; ++idx) {
+  // Check whether itkImage is an itk.js Image or an itk-wasm Image?
+  const isITKWasm = itkImage.direction.data === undefined;
+  const ITKPixelTypes = isITKWasm ? ITKWASMPixelTypes : ITKJSPixelTypes;
+  for (let idx = 0; idx < itkImage.imageType.dimension; ++idx) {
     vtkImage.origin[idx] = itkImage.origin[idx];
     vtkImage.spacing[idx] = itkImage.spacing[idx];
     dimensions[idx] = itkImage.size[idx];
-
-    for (var col = 0; col < itkImage.imageType.dimension; ++col) {
+    for (let col = 0; col < itkImage.imageType.dimension; ++col) {
       // ITK (and VTKMath) use a row-major index axis, but the direction
       // matrix on the vtkImageData is a webGL matrix, which uses a
       // column-major data layout. Transpose the direction matrix from
@@ -78,105 +81,87 @@ function convertItkToVtkImage(itkImage) {
         direction[col + idx * 3] = itkImage.direction.data[idx + col * itkImage.imageType.dimension];
       }
     }
-  } // Create VTK Image Data
-
+  }
 
-  var imageData = vtkImageData.newInstance(vtkImage); // Create VTK point data -- the data associated with the pixels / voxels
+  // Create VTK Image Data
+  const imageData = vtkImageData.newInstance(vtkImage);
 
-  var pointData = vtkDataArray.newInstance({
+  // Create VTK point data -- the data associated with the pixels / voxels
+  const pointData = vtkDataArray.newInstance({
     name: options.scalarArrayName || 'Scalars',
     values: itkImage.data,
     numberOfComponents: itkImage.imageType.components
   });
   imageData.setDirection(direction);
-  imageData.setDimensions.apply(imageData, dimensions); // Always associate multi-component pixel types with vtk.js point data
+  imageData.setDimensions(...dimensions);
+  // Always associate multi-component pixel types with vtk.js point data
   // scalars to facilitate multi-component volume rendering
+  imageData.getPointData().setScalars(pointData);
 
-  imageData.getPointData().setScalars(pointData); // Associate the point data that are 3D vectors / tensors
+  // Associate the point data that are 3D vectors / tensors
   // Refer to itk-js/src/PixelTypes.js for numerical values
-
   switch (isITKWasm ? ITKPixelTypes[itkImage.imageType.pixelType] : itkImage.imageType.pixelType) {
     case ITKPixelTypes.Scalar:
       break;
-
     case ITKPixelTypes.RGB:
       break;
-
     case ITKPixelTypes.RGBA:
       break;
-
     case ITKPixelTypes.Offset:
       break;
-
     case ITKPixelTypes.Vector:
       if (itkImage.imageType.dimension === 3 && itkImage.imageType.components === 3) {
         imageData.getPointData().setVectors(pointData);
       }
-
       break;
-
     case ITKPixelTypes.Point:
       break;
-
     case ITKPixelTypes.CovariantVector:
       if (itkImage.imageType.dimension === 3 && itkImage.imageType.components === 3) {
         imageData.getPointData().setVectors(pointData);
       }
-
       break;
-
     case ITKPixelTypes.SymmetricSecondRankTensor:
       if (itkImage.imageType.dimension === 3 && itkImage.imageType.components === 6) {
         imageData.getPointData().setTensors(pointData);
       }
-
       break;
-
     case ITKPixelTypes.DiffusionTensor3D:
       if (itkImage.imageType.dimension === 3 && itkImage.imageType.components === 6) {
         imageData.getPointData().setTensors(pointData);
       }
-
       break;
-
     case ITKPixelTypes.Complex:
       break;
-
     case ITKPixelTypes.FixedArray:
       break;
-
     case ITKPixelTypes.Array:
       break;
-
     case ITKPixelTypes.Matrix:
       break;
-
     case ITKPixelTypes.VariableLengthVector:
       break;
-
     case ITKPixelTypes.VariableSizeMatrix:
       break;
-
     default:
-      vtkErrorMacro("Cannot handle unexpected itk-wasm pixel type ".concat(itkImage.imageType.pixelType));
+      vtkErrorMacro(`Cannot handle unexpected itk-wasm pixel type ${itkImage.imageType.pixelType}`);
       return null;
   }
-
   return imageData;
 }
+
 /**
  * Converts a vtk.js vtkImageData to an itk-wasm Image.
  *
  * Requires a vtk.js vtkImageData as input.
  *
  */
-
 function convertVtkToItkImage(vtkImage) {
-  var copyData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  var dimension = 3;
-  var itkImage = {
+  let copyData = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  const dimension = 3;
+  const itkImage = {
     imageType: {
-      dimension: dimension,
+      dimension,
       pixelType: ITKWASMPixelTypes.Scalar,
       componentType: '',
       components: 1
@@ -187,17 +172,16 @@ function convertVtkToItkImage(vtkImage) {
     direction: new Float64Array(9),
     size: vtkImage.getDimensions()
   };
-  var direction = vtkImage.getDirection(); // Transpose the direction matrix from column-major to row-major
+  const direction = vtkImage.getDirection();
 
-  for (var idx = 0; idx < dimension; ++idx) {
-    for (var idy = 0; idy < dimension; ++idy) {
+  // Transpose the direction matrix from column-major to row-major
+  for (let idx = 0; idx < dimension; ++idx) {
+    for (let idy = 0; idy < dimension; ++idy) {
       itkImage.direction[idx + idy * dimension] = direction[idy + idx * dimension];
     }
   }
-
-  var pointData = vtkImage.getPointData();
-  var vtkArray;
-
+  const pointData = vtkImage.getPointData();
+  let vtkArray;
   if (pointData.getTensors() !== null) {
     itkImage.imageType.pixelType = ITKWASMPixelTypes.DiffusionTensor3D;
     vtkArray = pointData.getTensors();
@@ -207,28 +191,24 @@ function convertVtkToItkImage(vtkImage) {
   } else {
     vtkArray = pointData.getScalars();
   }
-
   itkImage.imageType.componentType = vtkArrayTypeToItkComponentType.get(vtkArray.getDataType());
-
   if (copyData) {
     // Copy the data array
     itkImage.data = vtkArray.getData().slice(0);
   } else {
     itkImage.data = vtkArray.getData();
   }
-
   return itkImage;
 }
+
 /**
  * Converts an itk-wasm PolyData to a vtk.js vtkPolyData.
  *
  * Requires an itk-wasm PolyData as input.
  */
-
 function convertItkToVtkPolyData(itkPolyData) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var pointDataArrays = [];
-
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const pointDataArrays = [];
   if (itkPolyData.pointData.length) {
     pointDataArrays.push({
       data: {
@@ -242,9 +222,7 @@ function convertItkToVtkPolyData(itkPolyData) {
       }
     });
   }
-
-  var cellDataArrays = [];
-
+  const cellDataArrays = [];
   if (itkPolyData.cellData.length) {
     cellDataArrays.push({
       data: {
@@ -258,8 +236,7 @@ function convertItkToVtkPolyData(itkPolyData) {
       }
     });
   }
-
-  var vtkPolyDataModel = {
+  const vtkPolyDataModel = {
     points: {
       vtkClass: 'vtkPoints',
       name: '_points',
@@ -333,166 +310,126 @@ function convertItkToVtkPolyData(itkPolyData) {
       doCopyAllOn: true,
       arrays: cellDataArrays
     }
-  }; // Create VTK PolyData
-
-  var polyData = vtkPolyData.newInstance(vtkPolyDataModel);
-  var pd = polyData.getPointData();
-  var cd = polyData.getCellData();
+  };
 
+  // Create VTK PolyData
+  const polyData = vtkPolyData.newInstance(vtkPolyDataModel);
+  const pd = polyData.getPointData();
+  const cd = polyData.getCellData();
   if (itkPolyData.pointData.length) {
     // Associate the point data that are 3D vectors / tensors
     switch (ITKWASMPixelTypes[itkPolyData.polyDataType.pointPixelType]) {
       case ITKWASMPixelTypes.Scalar:
         pd.setScalars(pd.getArrayByIndex(0));
         break;
-
       case ITKWASMPixelTypes.RGB:
         break;
-
       case ITKWASMPixelTypes.RGBA:
         break;
-
       case ITKWASMPixelTypes.Offset:
         break;
-
       case ITKWASMPixelTypes.Vector:
         if (itkPolyData.polyDataType.pointPixelComponents === 3) {
           pd.setVectors(pd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.Point:
         break;
-
       case ITKWASMPixelTypes.CovariantVector:
         if (itkPolyData.polyDataType.pointPixelComponents === 3) {
           pd.setVectors(pd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.SymmetricSecondRankTensor:
         if (itkPolyData.polyDataType.pointPixelComponents === 6) {
           pd.setTensors(pd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.DiffusionTensor3D:
         if (itkPolyData.polyDataType.pointPixelComponents === 6) {
           pd.setTensors(pd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.Complex:
         break;
-
       case ITKWASMPixelTypes.FixedArray:
         break;
-
       case ITKWASMPixelTypes.Array:
         break;
-
       case ITKWASMPixelTypes.Matrix:
         break;
-
       case ITKWASMPixelTypes.VariableLengthVector:
         break;
-
       case ITKWASMPixelTypes.VariableSizeMatrix:
         break;
-
       default:
-        vtkErrorMacro("Cannot handle unexpected itk-wasm pixel type ".concat(itkPolyData.polyDataType.pointPixelType));
+        vtkErrorMacro(`Cannot handle unexpected itk-wasm pixel type ${itkPolyData.polyDataType.pointPixelType}`);
         return null;
     }
   }
-
   if (itkPolyData.cellData.length) {
     // Associate the cell data that are 3D vectors / tensors
     switch (ITKWASMPixelTypes[itkPolyData.polyDataType.cellPixelType]) {
       case ITKWASMPixelTypes.Scalar:
         cd.setScalars(cd.getArrayByIndex(0));
         break;
-
       case ITKWASMPixelTypes.RGB:
         break;
-
       case ITKWASMPixelTypes.RGBA:
         break;
-
       case ITKWASMPixelTypes.Offset:
         break;
-
       case ITKWASMPixelTypes.Vector:
         if (itkPolyData.polyDataType.pointPixelComponents === 3) {
           cd.setVectors(cd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.Point:
         break;
-
       case ITKWASMPixelTypes.CovariantVector:
         if (itkPolyData.polyDataType.pointPixelComponents === 3) {
           cd.setVectors(cd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.SymmetricSecondRankTensor:
         if (itkPolyData.polyDataType.pointPixelComponents === 6) {
           cd.setTensors(cd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.DiffusionTensor3D:
         if (itkPolyData.polyDataType.pointPixelComponents === 6) {
           cd.setTensors(cd.getArrayByIndex(0));
         }
-
         break;
-
       case ITKWASMPixelTypes.Complex:
         break;
-
       case ITKWASMPixelTypes.FixedArray:
         break;
-
       case ITKWASMPixelTypes.Array:
         break;
-
       case ITKWASMPixelTypes.Matrix:
         break;
-
       case ITKWASMPixelTypes.VariableLengthVector:
         break;
-
       case ITKWASMPixelTypes.VariableSizeMatrix:
         break;
-
       default:
-        vtkErrorMacro("Cannot handle unexpected itk-wasm pixel type ".concat(itkPolyData.polyDataType.pointPixelType));
+        vtkErrorMacro(`Cannot handle unexpected itk-wasm pixel type ${itkPolyData.polyDataType.pointPixelType}`);
         return null;
     }
   }
-
   return polyData;
 }
+
 /**
  * Converts a vtk.js vtkPolyData to an itk-wasm PolyData.
  *
  * Requires a vtk.js vtkPolyData as input.
  *
  */
-
 function convertVtkToItkPolyData(polyData) {
-  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var itkPolyData = {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const itkPolyData = {
     polyDataType: {
       pointPixelComponentType: 'float32',
       pointPixelComponents: 1,
@@ -516,36 +453,30 @@ function convertVtkToItkPolyData(polyData) {
     numberOfCellPixels: 0,
     cellData: new Float32Array()
   };
-  var pd = polyData.getPointData();
-
+  const pd = polyData.getPointData();
   if (pd.getNumberOfArrays()) {
-    var pdArray = options.pointDataName ? pd.getArrayByName(options.pointDataName) : pd.getArrayByIndex(0);
+    const pdArray = options.pointDataName ? pd.getArrayByName(options.pointDataName) : pd.getArrayByIndex(0);
     itkPolyData.numberOfPointPixels = pdArray.getNumberOfTuples();
     itkPolyData.pointData = pdArray.getData();
-    itkPolyData.polyDataType.pointPixelComponentType = vtkArrayTypeToItkComponentType.get(pdArray.getDataType()); // default to the same type
-
+    itkPolyData.polyDataType.pointPixelComponentType = vtkArrayTypeToItkComponentType.get(pdArray.getDataType());
+    // default to the same type
     itkPolyData.polyDataType.cellPixelComponentType = itkPolyData.polyDataType.pointPixelComponentType;
     itkPolyData.polyDataType.pointPixelComponents = pdArray.getNumberOfComponents();
     itkPolyData.polyDataType.cellPixelComponents = itkPolyData.polyDataType.pointPixelComponents;
-
     if (pd.getTensors() === pdArray) {
       itkPolyData.polyDataType.pointPixelType = ITKWASMPixelTypes.SymmetricSecondRankTensor;
     } else if (pd.getVectors() === pdArray) {
       itkPolyData.polyDataType.pointPixelType = ITKWASMPixelTypes.Vector;
     }
-
     itkPolyData.polyDataType.cellPixelType = itkPolyData.polyDataType.pointPixelType;
   }
-
-  var cd = polyData.getCellData();
-
+  const cd = polyData.getCellData();
   if (cd.getNumberOfArrays()) {
-    var cdArray = options.cellDataName ? pd.getArrayByName(options.cellDataName) : pd.getArrayByIndex(0);
+    const cdArray = options.cellDataName ? pd.getArrayByName(options.cellDataName) : pd.getArrayByIndex(0);
     itkPolyData.numberOfCellPixels = cdArray.getNumberOfTuples();
     itkPolyData.cellData = cdArray.getData();
     itkPolyData.polyDataType.cellPixelComponentType = vtkArrayTypeToItkComponentType.get(cdArray.getDataType());
     itkPolyData.polyDataType.cellPixelComponents = cdArray.getNumberOfComponents();
-
     if (cd.getTensors() === cdArray) {
       itkPolyData.polyDataType.cellPixelType = ITKWASMPixelTypes.SymmetricSecondRankTensor;
     } else if (cd.getVectors() === cdArray) {
@@ -554,14 +485,13 @@ function convertVtkToItkPolyData(polyData) {
       itkPolyData.polyDataType.cellPixelType = ITKWASMPixelTypes.Scalar;
     }
   }
-
   return itkPolyData;
 }
 var ITKHelper = {
-  convertItkToVtkImage: convertItkToVtkImage,
-  convertVtkToItkImage: convertVtkToItkImage,
-  convertItkToVtkPolyData: convertItkToVtkPolyData,
-  convertVtkToItkPolyData: convertVtkToItkPolyData
+  convertItkToVtkImage,
+  convertVtkToItkImage,
+  convertItkToVtkPolyData,
+  convertVtkToItkPolyData
 };
 
 export { convertItkToVtkImage, convertItkToVtkPolyData, convertVtkToItkImage, convertVtkToItkPolyData, ITKHelper as default };