@kitware/vtk.js 23.4.2 → 24.0.0-beta.1

package/BREAKING_CHANGES.md

@@ -1,3 +1,36 @@
+## From 23.x to 24
+
+All old-style widgets except OrientationMarkerWidget and PiecewiseGaussianWidget have been removed.
+
+| **Old-style/deprecated widget**   | **New-style widget**            |
+|-----------------------------------|---------------------------------|
+| `Sources/Interaction/Widgets/...` | `Sources/Widgets/Widgets3D/...` |
+| DistanceWidget			              | DistanceWidget                  |
+| HandleWidget				              | PolyLineWidget                  |
+| ImageCroppingRegionsWidget        | ImageCroppingWidget             |
+| LabelWidget                       | LabelWidget                     |
+| LineWidget                        | LineWidget                      |
+| OrientationMarkerWidget (kept)    | *not implemented*               |
+| PiecewiseGaussianWidget (kept)    | *not implemented*               |
+| ResliceCursor                     | ResliceCursorWidget             |
+
+- In SVGLandmarkRepresentation: `model.showCircle` is replaced by `model.circleProps.visible`
+
+## From 22.x to 23
+
+- **imagemapper**: The original behavior of the image mapper was that if a lookup table is provided,
+it mapped the lookup table's scalar range by default. The new behavior disables using the lookup
+table scalar range by default. Instead, the window/level values are used.
+
+## From 21.x to 22
+
+- `config/rules-linter.js` is now gone.
+- **AbstractMapper**: Changed removeClippingPlane to use instance instead of index.
+
+## From 20.x to 21
+
+SplineWidget's handles now scale up automatically.
+
 ## From 19.x to 20
 
 In ShapeWidget: 

package/Common/Core/DataArray.js

@@ -337,6 +337,10 @@ function vtkDataArray(publicAPI, model) {
 
 
   publicAPI.getState = function () {
+    if (model.deleted) {
+      return null;
+    }
+
     var jsonArchive = _objectSpread(_objectSpread({}, model), {}, {
       vtkClass: publicAPI.getClassName()
     }); // Convert typed array to regular array

package/Common/Core/Math/index.js

@@ -829,7 +829,7 @@ function jacobiN(a, n, w, v) {
 
     for (i = j + 1; i < n; i++) {
       // boundary incorrect, shifted already
-      if (w[i] >= tmp) {
+      if (w[i] >= tmp || Math.abs(w[i] - tmp) < VTK_SMALL_NUMBER) {
         // why exchange if same?
         k = i;
         tmp = w[k];
@@ -2329,4 +2329,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { binomial as $, clampValue as A, projectVector as B, arrayRange as C, getMajorAxisIndex as D, isInf as E, rgb2hsv as F, rgb2lab as G, lab2rgb as H, floor as I, round as J, normalize2D as K, nearestPowerOfTwo as L, createUninitializedBounds as M, multiply3x3_vect3 as N, areBoundsInitialized as O, isPowerOfTwo as P, multiplyAccumulate as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, dot2D as a8, projectVector2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, gaussianAmplitude as aa, gaussianWeight as ab, outer2D as ac, norm2D as ad, LUFactor3x3 as ae, LUSolve3x3 as af, linearSolve3x3 as ag, multiply3x3_mat3 as ah, multiplyMatrix as ai, transpose3x3 as aj, invert3x3 as ak, identity3x3 as al, quaternionToMatrix3x3 as am, roundNumber as an, matrix3x3ToQuaternion as ao, multiplyQuaternion as ap, orthogonalize3x3 as aq, diagonalize3x3 as ar, singularValueDecomposition3x3 as as, luFactorLinearSystem as at, luSolveLinearSystem as au, invertMatrix as av, estimateMatrixCondition as aw, jacobi as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, subtract as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, determinant2x2 as m, norm as n, jacobiN as o, perpendiculars as p, vtkMath as q, radiansFromDegrees as r, solveLinearSystem as s, multiplyScalar as t, uninitializeBounds as u, vtkMath$1 as v, random as w, determinant3x3 as x, degreesFromRadians as y, areEquals as z };
+export { binomial as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, isInf as F, rgb2hsv as G, rgb2lab as H, lab2rgb as I, floor as J, round as K, normalize2D as L, nearestPowerOfTwo as M, createUninitializedBounds as N, multiply3x3_vect3 as O, areBoundsInitialized as P, isPowerOfTwo as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, projectVector as a8, dot2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, projectVector2D as aa, gaussianAmplitude as ab, gaussianWeight as ac, outer2D as ad, norm2D as ae, LUFactor3x3 as af, LUSolve3x3 as ag, linearSolve3x3 as ah, multiply3x3_mat3 as ai, multiplyMatrix as aj, transpose3x3 as ak, invert3x3 as al, identity3x3 as am, quaternionToMatrix3x3 as an, roundNumber as ao, matrix3x3ToQuaternion as ap, multiplyQuaternion as aq, orthogonalize3x3 as ar, diagonalize3x3 as as, singularValueDecomposition3x3 as at, luFactorLinearSystem as au, luSolveLinearSystem as av, invertMatrix as aw, estimateMatrixCondition as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, subtract as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, solveLinearSystem as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, vtkMath as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import '@babel/runtime/helpers/slicedToArray';
 import 'seedrandom';
 import '../../macros.js';
-export { ae as LUFactor3x3, af as LUSolve3x3, T as Pi, k as add, R as angleBetweenVectors, O as areBoundsInitialized, z as areEquals, a as areMatricesEqual, Y as arrayMax, X as arrayMin, C as arrayRange, a0 as beginCombination, $ as binomial, aJ as boundsIsWithinOtherBounds, U as ceil, Z as ceilLog2, aF as clampAndNormalizeValue, A as clampValue, e as clampVector, c as computeBoundsFromPoints, M as createUninitializedBounds, j as cross, q as default, y as degreesFromRadians, m as determinant2x2, x as determinant3x3, ar as diagonalize3x3, f as distance2BetweenPoints, d as dot, a8 as dot2D, aw as estimateMatrixCondition, aI as extentIsWithinOtherExtent, _ as factorial, aS as float2CssRGBA, aR as floatRGB2HexCode, aQ as floatToHex2, I as floor, a4 as gaussian, aa as gaussianAmplitude, ab as gaussianWeight, aH as getAdjustedScalarRange, D as getMajorAxisIndex, aG as getScalarTypeFittingRange, a3 as getSeed, aA as hex2float, h as hsv2rgb, al as identity3x3, aM as inf, ak as invert3x3, av as invertMatrix, aO as isFinite, E as isInf, aP as isNaN, i as isNan, P as isPowerOfTwo, ax as jacobi, o as jacobiN, H as lab2rgb, aB as lab2xyz, ag as linearSolve3x3, at as luFactorLinearSystem, au as luSolveLinearSystem, ao as matrix3x3ToQuaternion, W as max, V as min, ah as multiply3x3_mat3, N as multiply3x3_vect3, Q as multiplyAccumulate, a6 as multiplyAccumulate2D, ai as multiplyMatrix, ap as multiplyQuaternion, t as multiplyScalar, a5 as multiplyScalar2D, L as nearestPowerOfTwo, aN as negInf, a1 as nextCombination, n as norm, ad as norm2D, l as normalize, K as normalize2D, aq as orthogonalize3x3, a7 as outer, ac as outer2D, p as perpendiculars, aK as pointIsWithinBounds, B as projectVector, a9 as projectVector2D, am as quaternionToMatrix3x3, r as radiansFromDegrees, w as random, a2 as randomSeed, F as rgb2hsv, G as rgb2lab, aE as rgb2xyz, J as round, an as roundNumber, b as roundVector, S as signedAngleBetweenVectors, as as singularValueDecomposition3x3, aL as solve3PointCircle, ay as solveHomogeneousLeastSquares, az as solveLeastSquares, s as solveLinearSystem, g as subtract, aj as transpose3x3, u as uninitializeBounds, aC as xyz2lab, aD as xyz2rgb } from './Math/index.js';
+export { af as LUFactor3x3, ag as LUSolve3x3, T as Pi, k as add, R as angleBetweenVectors, P as areBoundsInitialized, B as areEquals, a as areMatricesEqual, Y as arrayMax, X as arrayMin, D as arrayRange, a0 as beginCombination, $ as binomial, aJ as boundsIsWithinOtherBounds, U as ceil, Z as ceilLog2, aF as clampAndNormalizeValue, C as clampValue, e as clampVector, c as computeBoundsFromPoints, N as createUninitializedBounds, j as cross, w as default, A as degreesFromRadians, o as determinant2x2, z as determinant3x3, as as diagonalize3x3, f as distance2BetweenPoints, d as dot, a9 as dot2D, ax as estimateMatrixCondition, aI as extentIsWithinOtherExtent, _ as factorial, aS as float2CssRGBA, aR as floatRGB2HexCode, aQ as floatToHex2, J as floor, a4 as gaussian, ab as gaussianAmplitude, ac as gaussianWeight, aH as getAdjustedScalarRange, E as getMajorAxisIndex, aG as getScalarTypeFittingRange, a3 as getSeed, aA as hex2float, h as hsv2rgb, am as identity3x3, aM as inf, al as invert3x3, aw as invertMatrix, aO as isFinite, F as isInf, aP as isNaN, i as isNan, Q as isPowerOfTwo, t as jacobi, p as jacobiN, I as lab2rgb, aB as lab2xyz, ah as linearSolve3x3, au as luFactorLinearSystem, av as luSolveLinearSystem, ap as matrix3x3ToQuaternion, W as max, V as min, ai as multiply3x3_mat3, O as multiply3x3_vect3, m as multiplyAccumulate, a6 as multiplyAccumulate2D, aj as multiplyMatrix, aq as multiplyQuaternion, x as multiplyScalar, a5 as multiplyScalar2D, M as nearestPowerOfTwo, aN as negInf, a1 as nextCombination, n as norm, ae as norm2D, l as normalize, L as normalize2D, ar as orthogonalize3x3, a7 as outer, ad as outer2D, q as perpendiculars, aK as pointIsWithinBounds, a8 as projectVector, aa as projectVector2D, an as quaternionToMatrix3x3, r as radiansFromDegrees, y as random, a2 as randomSeed, G as rgb2hsv, H as rgb2lab, aE as rgb2xyz, K as round, ao as roundNumber, b as roundVector, S as signedAngleBetweenVectors, at as singularValueDecomposition3x3, aL as solve3PointCircle, ay as solveHomogeneousLeastSquares, az as solveLeastSquares, s as solveLinearSystem, g as subtract, ak as transpose3x3, u as uninitializeBounds, aC as xyz2lab, aD as xyz2rgb } from './Math/index.js';

package/Common/DataModel/BoundingBox.js

@@ -53,7 +53,6 @@ function _addPoint(bounds) {
   bounds[3] = yMax > (arguments.length <= 2 ? undefined : arguments[2]) ? yMax : arguments.length <= 2 ? undefined : arguments[2];
   bounds[4] = zMin < (arguments.length <= 3 ? undefined : arguments[3]) ? zMin : arguments.length <= 3 ? undefined : arguments[3];
   bounds[5] = zMax > (arguments.length <= 3 ? undefined : arguments[3]) ? zMax : arguments.length <= 3 ? undefined : arguments[3];
-  return bounds;
 }
 
 function _addBounds(bounds, xMin, xMax, yMin, yMax, zMin, zMax) {
@@ -80,8 +79,6 @@ function _addBounds(bounds, xMin, xMax, yMin, yMax, zMin, zMax) {
     bounds[4] = Math.min(zMin, _zMin);
     bounds[5] = Math.max(zMax, _zMax);
   }
-
-  return bounds;
 }
 
 function _setMinPoint(bounds, x, y, z) {
@@ -127,7 +124,6 @@ function _inflate(bounds, delta) {
   bounds[3] += delta;
   bounds[4] -= delta;
   bounds[5] += delta;
-  return bounds;
 }
 
 function _scale(bounds, sx, sy, sz) {
@@ -237,8 +233,6 @@ function _getCorners(bounds, corners) {
       }
     }
   }
-
-  return corners;
 } // Computes the two corners with minimal and miximal coordinates
 
 function _computeCornerPoints(bounds, point1, point2) {
@@ -248,7 +242,6 @@ function _computeCornerPoints(bounds, point1, point2) {
   point2[0] = bounds[1];
   point2[1] = bounds[3];
   point2[2] = bounds[5];
-  return point1;
 }
 
 function _computeScale(bounds) {
@@ -564,7 +557,9 @@ var BoundingBox = /*#__PURE__*/function () {
     this.bounds = refBounds;
 
     if (!this.bounds) {
-      this.bounds = new Float64Array(INIT_BOUNDS);
+      this.bounds = new Float64Array(6);
+
+      _setBounds(this.bounds, INIT_BOUNDS);
     }
   }
 

package/Common/DataModel/DataSetAttributes/FieldData.js

@@ -242,11 +242,15 @@ function vtkFieldData(publicAPI, model) {
 
   publicAPI.getState = function () {
     var result = superGetState();
-    result.arrays = model.arrays.map(function (item) {
-      return {
-        data: item.data.getState()
-      };
-    });
+
+    if (result) {
+      result.arrays = model.arrays.map(function (item) {
+        return {
+          data: item.data.getState()
+        };
+      });
+    }
+
     return result;
   };
 }

package/Common/DataModel/ITKHelper.js

@@ -1,6 +1,5 @@
 import macro from '../../macros.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
@@ -43,7 +42,6 @@ var ITKWASMPixelTypes = {
   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']]);
 /**
  * Converts an itk-wasm Image to a vtk.js vtkImageData.
  *
@@ -158,7 +156,7 @@ function convertItkToVtkImage(itkImage) {
       break;
 
     default:
-      vtkErrorMacro("Cannot handle unexpected itk-wasm pixel type ".concat(itkImage.imageType.pixelType));
+      vtkErrorMacro("Cannot handle unexpected ITK.js pixel type ".concat(itkImage.imageType.pixelType));
       return null;
   }
 
@@ -220,352 +218,10 @@ function convertVtkToItkImage(vtkImage) {
 
   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 = [];
-
-  if (itkPolyData.pointData.length) {
-    pointDataArrays.push({
-      data: {
-        vtkClass: 'vtkDataArray',
-        name: options.pointDataName || 'PointData',
-        numberOfComponents: itkPolyData.polyDataType.pointPixelComponents,
-        size: itkPolyData.pointData.length,
-        dataType: itkComponentTypeToVtkArrayType.get(itkPolyData.polyDataType.pointPixelComponentType),
-        buffer: itkPolyData.pointData.buffer,
-        values: itkPolyData.pointData
-      }
-    });
-  }
-
-  var cellDataArrays = [];
-
-  if (itkPolyData.cellData.length) {
-    cellDataArrays.push({
-      data: {
-        vtkClass: 'vtkDataArray',
-        name: options.cellDataName || 'CellData',
-        numberOfComponents: itkPolyData.polyDataType.pointPixelComponents,
-        size: itkPolyData.cellData.length,
-        dataType: itkComponentTypeToVtkArrayType.get(itkPolyData.polyDataType.pointPixelComponentType),
-        buffer: itkPolyData.cellData.buffer,
-        values: itkPolyData.cellData
-      }
-    });
-  }
-
-  var vtkPolyDataModel = {
-    points: {
-      vtkClass: 'vtkPoints',
-      name: '_points',
-      numberOfComponents: 3,
-      size: itkPolyData.numberOfPoints,
-      dataType: 'Float32Array',
-      buffer: itkPolyData.points.buffer,
-      values: itkPolyData.points
-    },
-    verts: {
-      vtkClass: 'vtkCellArray',
-      name: '_verts',
-      numberOfComponents: 1,
-      size: itkPolyData.verticesBufferSize,
-      dataType: 'Uint32Array',
-      buffer: itkPolyData.vertices.buffer,
-      values: itkPolyData.vertices
-    },
-    lines: {
-      vtkClass: 'vtkCellArray',
-      name: '_lines',
-      numberOfComponents: 1,
-      size: itkPolyData.linesBufferSize,
-      dataType: 'Uint32Array',
-      buffer: itkPolyData.lines.buffer,
-      values: itkPolyData.lines
-    },
-    polys: {
-      vtkClass: 'vtkCellArray',
-      name: '_polys',
-      numberOfComponents: 1,
-      size: itkPolyData.polygonsBufferSize,
-      dataType: 'Uint32Array',
-      buffer: itkPolyData.polygons.buffer,
-      values: itkPolyData.polygons
-    },
-    strips: {
-      vtkClass: 'vtkCellArray',
-      name: '_strips',
-      numberOfComponents: 1,
-      size: itkPolyData.triangleStripsBufferSize,
-      dataType: 'Uint32Array',
-      buffer: itkPolyData.triangleStrips.buffer,
-      values: itkPolyData.triangleStrips
-    },
-    pointData: {
-      vtkClass: 'vtkDataSetAttributes',
-      activeGlobalIds: -1,
-      activeNormals: -1,
-      activePedigreeIds: -1,
-      activeScalars: -1,
-      activeTCoords: -1,
-      activeTensors: -1,
-      activeVectors: -1,
-      copyFieldFlags: [],
-      doCopyAllOff: false,
-      doCopyAllOn: true,
-      arrays: pointDataArrays
-    },
-    cellData: {
-      vtkClass: 'vtkDataSetAttributes',
-      activeGlobalIds: -1,
-      activeNormals: -1,
-      activePedigreeIds: -1,
-      activeScalars: -1,
-      activeTCoords: -1,
-      activeTensors: -1,
-      activeVectors: -1,
-      copyFieldFlags: [],
-      doCopyAllOff: false,
-      doCopyAllOn: true,
-      arrays: cellDataArrays
-    }
-  }; // Create VTK PolyData
-
-  var polyData = vtkPolyData.newInstance(vtkPolyDataModel);
-  var pd = polyData.getPointData();
-  var 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));
-        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));
-        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 = {
-    polyDataType: {
-      pointPixelComponentType: 'float32',
-      pointPixelComponents: 1,
-      pointPixelType: 'Scalar',
-      cellPixelComponentType: 'float32',
-      cellPixelComponents: 1,
-      cellPixelType: 'Scalar'
-    },
-    numberOfPoints: polyData.getNumberOfPoints(),
-    points: polyData.getPoints().getData(),
-    verticesBufferSize: polyData.getVerts().getNumberOfValues(),
-    vertices: polyData.getVerts().getData(),
-    linesBufferSize: polyData.getLines().getNumberOfValues(),
-    lines: polyData.getLines().getData(),
-    polygonsBufferSize: polyData.getPolys().getNumberOfValues(),
-    polygons: polyData.getPolys().getData(),
-    triangleStripsBufferSize: polyData.getStrips().getNumberOfValues(),
-    triangleStrips: polyData.getStrips().getData(),
-    numberOfPointPixels: 0,
-    pointData: new Float32Array(),
-    numberOfCellPixels: 0,
-    cellData: new Float32Array()
-  };
-  var pd = polyData.getPointData();
-
-  if (pd.getNumberOfArrays()) {
-    var 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.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();
-
-  if (cd.getNumberOfArrays()) {
-    var 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) {
-      itkPolyData.polyDataType.cellPixelType = ITKWASMPixelTypes.Vector;
-    } else {
-      itkPolyData.polyDataType.cellPixelType = ITKWASMPixelTypes.Scalar;
-    }
-  }
-
-  return itkPolyData;
-}
 
 var ITKHelper = {
   convertItkToVtkImage: convertItkToVtkImage,
-  convertVtkToItkImage: convertVtkToItkImage,
-  convertItkToVtkPolyData: convertItkToVtkPolyData,
-  convertVtkToItkPolyData: convertVtkToItkPolyData
+  convertVtkToItkImage: convertVtkToItkImage
 };
 
 export { ITKHelper as default };

package/Common/DataModel/ImageData.d.ts

@@ -69,18 +69,31 @@ export interface vtkImageData extends vtkDataSet {
 	extentToBounds(ex: Extent): Bounds;
 
 	/**
-	 * The Bounds of a vtkImage are returned as pairs of world coordinates
+	 * Get image extents without translation (i.e. with origin set to [0,0,0]) and under unit spacing
+	 * (i.e. spacing = [1, 1, 1]).
+	 * This includes a padding of 0.5 pixel/voxel in each principal direction.
+	 * The padding is necessary for conventional images (textures, png, bmp)
+	 * as well as medical images and volumes, since each pixel/voxel has a pre-defined width
+	 * (based on specified spacing) including the ones on the boundary of the image.
+	 * @internal
+	 */
+	getSpatialExtent(): Extent;
+
+	/**
+	 * Returns the axis-aligned bounds of vtkImageData in world coordinates.
+	 * The axis-aligned Bounds of a vtkImage are returned as pairs of world coordinates
 	 * ```[x_min, x_max, y_min, y_max, z_min, z_max]``` these are calculated
 	 * from the Extent, Origin, and Spacing, defined
 	 * through
 	 * ```js
-	 * bounds[6] =
 	 * [
-	 *   i_min*Spacing[0] + Origin[0], i_max*Spacing[0] + Origin[0],
-	 *   j_min*Spacing[1] + Origin[1], j_max*Spacing[1] + Origin[1],
-	 *   k_min*Spacing[2] + Origin[2], k_max*Spacing[2] + Origin[2]
+	 *   (i_min - 0.5)*Spacing[0] + Origin[0], (i_max + 0.5)*Spacing[0] + Origin[0],
+	 *   (j_min - 0.5)*Spacing[1] + Origin[1], (j_max + 0.5)*Spacing[1] + Origin[1],
+	 *   (k_min - 0.5)*Spacing[2] + Origin[2], (k_max + 0.5)*Spacing[2] + Origin[2]
 	 * ];
 	 *  ```
+	 * Note that this includes a padding of 0.5 voxel spacing in each principal direction,
+	 * as well as any orientation of the image.
 	 * You can't directly set the bounds. First you need to decide how many
 	 * pixels across your image will be (i.e. what the extent should be), and
 	 * then you must find the origin and spacing that will produce the bounds
@@ -89,6 +102,8 @@ export interface vtkImageData extends vtkDataSet {
 	 * 9]` for a 10x10x10 image. Calling `setDimensions(10,10,10)` does exactly
 	 * the same thing as `setExtent(0,9,0,9,0,9)` but you should always do the
 	 * latter to be explicit about where your extent starts.
+	 * Such an image of dimensions [10, 10, 10], origin [0, 0, 0] and voxel-spacing of 1.0,
+	 * will result in bounds equal to [-0.5, 9.5, -0.5, 9.5, -0.5, 9.5].
 	 * @return {Bounds} The bounds for the mapper.
 	 */
 	getBounds(): Bounds;
@@ -217,7 +232,9 @@ export interface vtkImageData extends vtkDataSet {
 	/**
 	 * Calculate the corresponding world bounds for the given index bounds
 	 * `[i_min, i_max, j_min, j_max, k_min, k_max]`. Modifies `out` in place if
-	 * provided, or returns a new array.
+	 * provided, or returns a new array. Returned bounds are NOT padded based
+	 * on voxel spacing (see getBounds). The output is merely a bounding box
+	 * calculated considering voxels as grid points.
 	 * @param {Bounds} bin 
 	 * @param {Bounds} [bout] 
 	 */

package/Common/DataModel/ImageData.js

@@ -191,7 +191,7 @@ function vtkImageData(publicAPI, model) {
 
 
   publicAPI.getBounds = function () {
-    return publicAPI.extentToBounds(model.extent);
+    return publicAPI.extentToBounds(publicAPI.getSpatialExtent());
   };
 
   publicAPI.extentToBounds = function (ex) {
@@ -232,6 +232,13 @@ function vtkImageData(publicAPI, model) {
     }
 
     return bounds;
+  };
+
+  publicAPI.getSpatialExtent = function () {
+    var boundingBox = vtkBoundingBox.newInstance();
+    boundingBox.setBounds(model.extent);
+    boundingBox.inflate(0.5);
+    return boundingBox.getBounds();
   }; // Internal, shouldn't need to call this manually.
 
 

package/Common/DataModel/PolyData.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from '../../types';
+import { CellType, Vector3 } from '../../types';
 import vtkCellArray from '../Core/CellArray';
 import vtkPointSet, { IPointSetInitialValues } from './PointSet';
 
@@ -45,6 +45,13 @@ export interface vtkPolyData extends vtkPointSet {
 	 */
 	getCellPoints(cellId: number): object;
 
+	/**
+	 * Get the type of the cell
+	 * @param {Number} cellId The Id of the cell.
+	 * @return CellType The type of the cell.
+	 */
+	 getCellType(cellId: number): CellType;
+
 	/**
 	 * Get the cell array defining cells.
 	 */

package/Common/DataModel/PolyData.js

@@ -164,12 +164,14 @@ function vtkPolyData(publicAPI, model) {
     }
 
     model.links.buildLinks(publicAPI);
-  }; // Returns an object made of the cellType and a subarray `cellPointIds` of
-  // the cell points.
+  };
 
+  publicAPI.getCellType = function (cellId) {
+    return model.cells.getCellType(cellId);
+  };
 
   publicAPI.getCellPoints = function (cellId) {
-    var cellType = model.cells.getCellType(cellId);
+    var cellType = publicAPI.getCellType(cellId);
     var cells = null;
 
     switch (cellType) {