@kitware/vtk.js 23.2.0 → 23.4.0

package/Common/DataModel/BoundingBox.js

@@ -53,6 +53,7 @@ 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) {
@@ -79,6 +80,8 @@ 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) {
@@ -124,6 +127,7 @@ function _inflate(bounds, delta) {
   bounds[3] += delta;
   bounds[4] -= delta;
   bounds[5] += delta;
+  return bounds;
 }
 
 function _scale(bounds, sx, sy, sz) {
@@ -233,6 +237,8 @@ function _getCorners(bounds, corners) {
       }
     }
   }
+
+  return corners;
 } // Computes the two corners with minimal and miximal coordinates
 
 function _computeCornerPoints(bounds, point1, point2) {
@@ -242,6 +248,7 @@ function _computeCornerPoints(bounds, point1, point2) {
   point2[0] = bounds[1];
   point2[1] = bounds[3];
   point2[2] = bounds[5];
+  return point1;
 }
 
 function _computeScale(bounds) {
@@ -557,9 +564,7 @@ var BoundingBox = /*#__PURE__*/function () {
     this.bounds = refBounds;
 
     if (!this.bounds) {
-      this.bounds = new Float64Array(6);
-
-      _setBounds(this.bounds, INIT_BOUNDS);
+      this.bounds = new Float64Array(INIT_BOUNDS);
     }
   }
 

package/Common/DataModel/ITKHelper.js

@@ -1,5 +1,6 @@
 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
@@ -42,6 +43,7 @@ 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.
  *
@@ -156,7 +158,7 @@ function convertItkToVtkImage(itkImage) {
       break;
 
     default:
-      vtkErrorMacro("Cannot handle unexpected ITK.js pixel type ".concat(itkImage.imageType.pixelType));
+      vtkErrorMacro("Cannot handle unexpected itk-wasm pixel type ".concat(itkImage.imageType.pixelType));
       return null;
   }
 
@@ -218,10 +220,352 @@ 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
+  convertVtkToItkImage: convertVtkToItkImage,
+  convertItkToVtkPolyData: convertItkToVtkPolyData,
+  convertVtkToItkPolyData: convertVtkToItkPolyData
 };
 
 export { ITKHelper as default };

package/Imaging/Core/ImageInterpolator.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractImageInterpolator from './AbstractImageInterpolator.js';
-import { vtkInterpolationMathRound, vtkInterpolationMathClamp, vtkInterpolationMathMirror, vtkInterpolationMathWrap, vtkInterpolationWeights, vtkInterpolationMathFloor } from './AbstractImageInterpolator/InterpolationInfo.js';
+import { vtkInterpolationMathRound, vtkInterpolationMathClamp, vtkInterpolationMathMirror, vtkInterpolationMathWrap, vtkInterpolationMathFloor, vtkInterpolationWeights } from './AbstractImageInterpolator/InterpolationInfo.js';
 import { InterpolationMode, ImageBorderMode } from './AbstractImageInterpolator/Constants.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
@@ -92,10 +92,80 @@ function vtkImageInterpolator(publicAPI, model) {
     }
   };
 
+  publicAPI.interpolateLinear = function (interpolationInfo, point, value) {
+    var inExt = interpolationInfo.extent;
+    var inInc = interpolationInfo.increments;
+    var numscalars = interpolationInfo.numberOfComponents;
+    var floorX = vtkInterpolationMathFloor(point[0]);
+    var floorY = vtkInterpolationMathFloor(point[1]);
+    var floorZ = vtkInterpolationMathFloor(point[2]);
+    var inIdX0 = floorX.floored;
+    var inIdY0 = floorY.floored;
+    var inIdZ0 = floorZ.floored;
+    var fx = floorX.error;
+    var fy = floorY.error;
+    var fz = floorZ.error;
+    var inIdX1 = inIdX0 + (fx !== 0);
+    var inIdY1 = inIdY0 + (fy !== 0);
+    var inIdZ1 = inIdZ0 + (fz !== 0);
+
+    switch (interpolationInfo.borderMode) {
+      case ImageBorderMode.REPEAT:
+        inIdX0 = vtkInterpolationMathWrap(inIdX0, inExt[0], inExt[1]);
+        inIdY0 = vtkInterpolationMathWrap(inIdY0, inExt[2], inExt[3]);
+        inIdZ0 = vtkInterpolationMathWrap(inIdZ0, inExt[4], inExt[5]);
+        inIdX1 = vtkInterpolationMathWrap(inIdX1, inExt[0], inExt[1]);
+        inIdY1 = vtkInterpolationMathWrap(inIdY1, inExt[2], inExt[3]);
+        inIdZ1 = vtkInterpolationMathWrap(inIdZ1, inExt[4], inExt[5]);
+        break;
+
+      case ImageBorderMode.MIRROR:
+        inIdX0 = vtkInterpolationMathMirror(inIdX0, inExt[0], inExt[1]);
+        inIdY0 = vtkInterpolationMathMirror(inIdY0, inExt[2], inExt[3]);
+        inIdZ0 = vtkInterpolationMathMirror(inIdZ0, inExt[4], inExt[5]);
+        inIdX1 = vtkInterpolationMathMirror(inIdX1, inExt[0], inExt[1]);
+        inIdY1 = vtkInterpolationMathMirror(inIdY1, inExt[2], inExt[3]);
+        inIdZ1 = vtkInterpolationMathMirror(inIdZ1, inExt[4], inExt[5]);
+        break;
+
+      default:
+        inIdX0 = vtkInterpolationMathClamp(inIdX0, inExt[0], inExt[1]);
+        inIdY0 = vtkInterpolationMathClamp(inIdY0, inExt[2], inExt[3]);
+        inIdZ0 = vtkInterpolationMathClamp(inIdZ0, inExt[4], inExt[5]);
+        inIdX1 = vtkInterpolationMathClamp(inIdX1, inExt[0], inExt[1]);
+        inIdY1 = vtkInterpolationMathClamp(inIdY1, inExt[2], inExt[3]);
+        inIdZ1 = vtkInterpolationMathClamp(inIdZ1, inExt[4], inExt[5]);
+        break;
+    }
+
+    var factX0 = inIdX0 * inInc[0];
+    var factX1 = inIdX1 * inInc[0];
+    var factY0 = inIdY0 * inInc[1];
+    var factY1 = inIdY1 * inInc[1];
+    var factZ0 = inIdZ0 * inInc[2];
+    var factZ1 = inIdZ1 * inInc[2];
+    var i00 = factY0 + factZ0;
+    var i01 = factY0 + factZ1;
+    var i10 = factY1 + factZ0;
+    var i11 = factY1 + factZ1;
+    var rx = 1 - fx;
+    var ry = 1 - fy;
+    var rz = 1 - fz;
+    var ryrz = ry * rz;
+    var fyrz = fy * rz;
+    var ryfz = ry * fz;
+    var fyfz = fy * fz;
+    var inPtr = interpolationInfo.pointer;
+
+    for (var i = 0; i < numscalars; ++i) {
+      value[i] = rx * (ryrz * inPtr[factX0 + i00 + i * 4] + ryfz * inPtr[factX0 + i01 + i * 4] + fyrz * inPtr[factX0 + i10 + i * 4] + fyfz * inPtr[factX0 + i11 + i * 4]) + fx * (ryrz * inPtr[factX1 + i00 + i * 4] + ryfz * inPtr[factX1 + i01 + i * 4] + fyrz * inPtr[factX1 + i10 + i * 4] + fyfz * inPtr[factX1 + i11 + i * 4]);
+    }
+  };
+
   publicAPI.interpolatePoint = function (interpolationInfo, point, value) {
     switch (model.interpolationMode) {
       case InterpolationMode.LINEAR:
-        console.log('LINEAR not implemented');
+        publicAPI.interpolateLinear(interpolationInfo, point, value);
         break;
 
       case InterpolationMode.CUBIC:
@@ -123,10 +193,115 @@ function vtkImageInterpolator(publicAPI, model) {
     }
   };
 
+  publicAPI.interpolateRowLinear = function (weights, idX, idY, idZ, outPtr, n) {
+    var stepX = weights.kernelSize[0];
+    var stepY = weights.kernelSize[1];
+    var stepZ = weights.kernelSize[2];
+    var idXtemp = idX * stepX;
+    var idYtemp = idY * stepY;
+    var idZtemp = idZ * stepZ;
+    var fX = weights.weights[0].subarray(idXtemp);
+    var fY = weights.weights[1].subarray(idYtemp);
+    var fZ = weights.weights[2].subarray(idZtemp);
+    var iX = weights.positions[0].subarray(idXtemp);
+    var iY = weights.positions[1].subarray(idYtemp);
+    var iZ = weights.positions[2].subarray(idZtemp);
+    var inPtr = weights.pointer; // get the number of components per pixel
+
+    var numscalars = weights.numberOfComponents; // create a 2x2 bilinear kernel in local variables
+
+    var i00 = iY.subarray(iZ[0]);
+    var i01 = i00;
+    var i10 = i00;
+    var i11 = i00;
+    var ry = 1;
+    var fy = 0;
+    var rz = 1;
+    var fz = 0;
+
+    if (stepY === 2) {
+      i10 = iY[1].subarray(iZ[0]);
+      i11 = i10;
+      ry = fY[0];
+      fy = fY[1];
+    }
+
+    if (stepZ === 2) {
+      i01 = iY[0].subarray(iZ[1]);
+      i11 = i01;
+      rz = fZ[0];
+      fz = fZ[1];
+    }
+
+    if (stepY + stepZ === 4) {
+      i11 = iY[1].subarray(iZ[1]);
+    }
+
+    var ryrz = ry * rz;
+    var ryfz = ry * fz;
+    var fyrz = fy * rz;
+    var fyfz = fy * fz;
+
+    if (stepX === 1) {
+      if (fy === 0 && fz === 0) {
+        // no interpolation needed at all
+        for (var i = n; i > 0; --i) {
+          for (var j = 0; j < numscalars; j++) {
+            outPtr[j + n - i] = inPtr[i00 + iX[n - i] + j];
+          }
+        }
+      } else if (fy === 0) {
+        // only need linear z interpolation
+        for (var _i = n; _i > 0; --_i) {
+          for (var _j = 0; _j < numscalars; _j++) {
+            outPtr[_j + n - _i] = rz * inPtr[iX[n - _i] + i00 + _j * 4] + fz * inPtr[iX[n - _i] + i01 + _j * 4];
+          }
+        }
+      } else {
+        // interpolate in y and z but not in x
+        for (var _i2 = n; _i2 > 0; --_i2) {
+          for (var _j2 = 0; _j2 < numscalars; _j2++) {
+            outPtr[_j2 + n - _i2] = ryrz * inPtr[iX[n - _i2] + i00 + _j2 * 4] + ryfz * inPtr[iX[n - _i2] + i01 + _j2 * 4] + fyrz * inPtr[iX[n - _i2] + i10 + _j2 * 4] + fyfz * inPtr[iX[n - _i2] + i11 + _j2 * 4];
+          }
+        }
+      }
+    } else if (fz === 0) {
+      var x = 0; // bilinear interpolation in x,y
+
+      for (var _i3 = n; _i3 > 0; --_i3) {
+        var rx = fX[0 + 2 * x];
+        var fx = fX[1 + 2 * x];
+        var t0 = iX[0 + 2 * x];
+        var t1 = iX[1 + 2 * x];
+
+        for (var _j3 = 0; _j3 < numscalars; _j3++) {
+          outPtr[_j3 + n - _i3] = rx * (ry * inPtr[t0 + i00 + _j3 * 4] + fy * inPtr[t0 + i10 + _j3 * 4]) + fx * (ry * inPtr[t1 + i00 + _j3 * 4] + fy * inPtr[t1 + i10 + _j3 * 4]);
+        }
+
+        x++;
+      }
+    } else {
+      var _x = 0; // do full trilinear interpolation
+
+      for (var _i4 = n; _i4 > 0; --_i4) {
+        var _rx = fX[0 + 2 * _x];
+        var _fx = fX[1 + 2 * _x];
+        var _t = iX[0 + 2 * _x];
+        var _t2 = iX[1 + 2 * _x];
+
+        for (var _j4 = 0; _j4 < numscalars; _j4++) {
+          outPtr[_j4] = _rx * (ryrz * inPtr[_t + i00 + _j4 * 4] + ryfz * inPtr[_t + i01 + _j4 * 4] + fyrz * inPtr[_t + i10 + _j4 * 4] + fyfz * inPtr[_t + i11 + _j4 * 4]) + _fx * (ryrz * inPtr[_t2 + i00 + _j4 * 4] + ryfz * inPtr[_t2 + i01 + _j4 * 4] + fyrz * inPtr[_t2 + i10 + _j4 * 4] + fyfz * inPtr[_t2 + i11 + _j4 * 4]);
+        }
+
+        _x++;
+      }
+    }
+  };
+
   publicAPI.interpolateRow = function (weights, xIdx, yIdx, zIdx, value, n) {
     switch (model.interpolationMode) {
       case InterpolationMode.LINEAR:
-        console.log('LINEAR not implemented');
+        publicAPI.interpolateRowLinear(weights, xIdx, yIdx, zIdx, value, n);
         break;
 
       case InterpolationMode.CUBIC:
@@ -311,9 +486,9 @@ function vtkImageInterpolator(publicAPI, model) {
 
     if (!validClip) {
       // output extent doesn't itersect input extent
-      for (var _j = 0; _j < 3; _j++) {
-        clipExt[2 * _j] = outExt[2 * _j];
-        clipExt[2 * _j + 1] = outExt[2 * _j] - 1;
+      for (var _j5 = 0; _j5 < 3; _j5++) {
+        clipExt[2 * _j5] = outExt[2 * _j5];
+        clipExt[2 * _j5 + 1] = outExt[2 * _j5] - 1;
       }
     }
   };

package/Imaging/Core/ImageReslice.js

@@ -1000,7 +1000,7 @@ function extend(publicAPI, model) {
   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, ['outputDimensionality', 'outputScalarType', 'scalarShift', 'scalarScale', 'transformInputSampling', 'autoCropOutput', 'wrap', 'mirror', 'border', 'backgroundColor', 'slabMode', 'slabTrapezoidIntegration', 'slabNumberOfSlices', 'slabSliceSpacingFraction']);
+  macro.setGet(publicAPI, model, ['outputDimensionality', 'outputScalarType', 'scalarShift', 'scalarScale', 'transformInputSampling', 'autoCropOutput', 'wrap', 'mirror', 'border', 'backgroundColor', 'interpolationMode', 'slabMode', 'slabTrapezoidIntegration', 'slabNumberOfSlices', 'slabSliceSpacingFraction']);
   macro.setGetArray(publicAPI, model, ['outputOrigin', 'outputSpacing'], 3);
   macro.setGetArray(publicAPI, model, ['outputExtent'], 6);
   setNullArray(publicAPI, model, ['outputOrigin', 'outputSpacing', 'outputExtent']);

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -544,18 +544,18 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     var shiftScaleEnabled = cellBO.getCABO().getCoordShiftAndScaleEnabled();
     var inverseShiftScaleMatrix = shiftScaleEnabled ? cellBO.getCABO().getInverseShiftAndScaleMatrix() : null; // Get the position of the actor
 
-    var size = model.openGLRenderer.getTiledSizeAndOrigin();
+    var view = ren.getRenderWindow().getViews()[0];
+    var size = view.getViewportSize(ren);
     var vport = ren.getViewport();
-    var actorPos = actor.getActualPositionCoordinate().getComputedViewportValue(ren); // Get the window info
-    // const tileViewport = ren.getVTKWindow().getTileViewport();
+    var actorPos = actor.getActualPositionCoordinate().getComputedDoubleViewportValue(ren); // Get the window info
     // Assume tile viewport is 0 1 based on vtkOpenGLRenderer
 
     var tileViewport = [0.0, 0.0, 1.0, 1.0];
-    var visVP = [0, 1, 0, 1];
+    var visVP = [0.0, 0.0, 1.0, 1.0];
     visVP[0] = vport[0] >= tileViewport[0] ? vport[0] : tileViewport[0];
     visVP[1] = vport[1] >= tileViewport[1] ? vport[1] : tileViewport[1];
-    visVP[2] = vport[2] >= tileViewport[2] ? vport[2] : tileViewport[2];
-    visVP[3] = vport[3] >= tileViewport[3] ? vport[3] : tileViewport[3];
+    visVP[2] = vport[2] <= tileViewport[2] ? vport[2] : tileViewport[2];
+    visVP[3] = vport[3] <= tileViewport[3] ? vport[3] : tileViewport[3];
 
     if (visVP[0] >= visVP[2]) {
       return;
@@ -565,16 +565,16 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
       return;
     }
 
-    size.usize = round(size.usize * (visVP[2] - visVP[0]) / (vport[2] - vport[0]));
-    size.vsize = round(size.vsize * (visVP[3] - visVP[1]) / (vport[3] - vport[1]));
+    size[0] = round(size[0] * (visVP[2] - visVP[0]) / (vport[2] - vport[0]));
+    size[1] = round(size[1] * (visVP[3] - visVP[1]) / (vport[3] - vport[1]));
     var winSize = model.openGLRenderer.getParent().getSize();
     var xoff = round(actorPos[0] - (visVP[0] - vport[0]) * winSize[0]);
     var yoff = round(actorPos[1] - (visVP[1] - vport[1]) * winSize[1]); // set ortho projection
 
     var left = -xoff;
-    var right = -xoff + size.usize;
+    var right = -xoff + size[0];
     var bottom = -yoff;
-    var top = -yoff + size.vsize; // it's an error to call glOrtho with
+    var top = -yoff + size[1]; // it's an error to call glOrtho with
     // either left==right or top==bottom
 
     if (left === right) {

package/Widgets/Representations/SphereContextRepresentation.js

@@ -0,0 +1,131 @@
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkSphereSource from '../../Filters/Sources/SphereSource.js';
+import vtkActor from '../../Rendering/Core/Actor.js';
+import vtkGlyph3DMapper from '../../Rendering/Core/Glyph3DMapper.js';
+import { ScalarMode } from '../../Rendering/Core/Mapper/Constants.js';
+import vtkContextRepresentation from './ContextRepresentation.js';
+import vtkWidgetRepresentation from './WidgetRepresentation.js';
+import macro from '../../macros.js';
+
+function vtkSphereContextRepresentation(publicAPI, model) {
+  model.classHierarchy.push('vtkSphereContextRepresentation');
+  model.internalPolyData = vtkPolyData.newInstance({
+    mtime: 0
+  });
+  model.internalArrays = {
+    points: model.internalPolyData.getPoints(),
+    scale: vtkDataArray.newInstance({
+      name: 'scale',
+      numberOfComponents: 3,
+      empty: true
+    }),
+    color: vtkDataArray.newInstance({
+      name: 'color',
+      numberOfComponents: 1,
+      empty: true
+    })
+  };
+  model.internalPolyData.getPointData().addArray(model.internalArrays.scale);
+  model.internalPolyData.getPointData().addArray(model.internalArrays.color);
+  model.pipelines = {
+    circle: {
+      source: publicAPI,
+      glyph: vtkSphereSource.newInstance({
+        phiResolution: model.glyphResolution,
+        thetaResolution: model.glyphResolution
+      }),
+      mapper: vtkGlyph3DMapper.newInstance({
+        scaleArray: 'scale',
+        scaleMode: vtkGlyph3DMapper.ScaleModes.SCALE_BY_MAGNITUDE,
+        colorByArrayName: 'color',
+        scalarMode: ScalarMode.USE_POINT_FIELD_DATA
+      }),
+      actor: vtkActor.newInstance({
+        pickable: false,
+        parentProp: publicAPI
+      })
+    }
+  };
+  model.pipelines.circle.actor.getProperty().setOpacity(0.2);
+  vtkWidgetRepresentation.connectPipeline(model.pipelines.circle);
+  publicAPI.addActor(model.pipelines.circle.actor);
+  publicAPI.setGlyphResolution = macro.chain(publicAPI.setGlyphResolution, function (r) {
+    return model.pipelines.circle.glyph.setResolution(r);
+  });
+
+  publicAPI.setDrawBorder = function (draw) {
+    model.pipelines.circle.glyph.setLines(draw);
+  };
+
+  publicAPI.setDrawFace = function (draw) {
+    model.pipelines.circle.glyph.setFace(draw);
+  };
+
+  publicAPI.setOpacity = function (opacity) {
+    model.pipelines.circle.actor.getProperty().setOpacity(opacity);
+  };
+
+  publicAPI.requestData = function (inData, outData) {
+    var _model$internalArrays = model.internalArrays,
+        points = _model$internalArrays.points,
+        scale = _model$internalArrays.scale,
+        color = _model$internalArrays.color;
+    var list = publicAPI.getRepresentationStates(inData[0]).filter(function (state) {
+      return state.getOrigin && state.getOrigin() && state.isVisible && state.isVisible();
+    });
+    var totalCount = list.length;
+
+    if (color.getNumberOfValues() !== totalCount) {
+      // Need to resize dataset
+      points.setData(new Float32Array(3 * totalCount));
+      scale.setData(new Float32Array(3 * totalCount));
+      color.setData(new Float32Array(totalCount));
+    }
+
+    var typedArray = {
+      points: points.getData(),
+      scale: scale.getData(),
+      color: color.getData()
+    };
+
+    for (var i = 0; i < totalCount; i += 1) {
+      var state = list[i];
+      var isActive = state.getActive();
+      var scaleFactor = isActive ? model.activeScaleFactor : 1;
+      var coord = state.getOrigin();
+      typedArray.points[i * 3 + 0] = coord[0];
+      typedArray.points[i * 3 + 1] = coord[1];
+      typedArray.points[i * 3 + 2] = coord[2];
+      typedArray.scale[i] = scaleFactor * (state.getScale1 ? state.getScale1() : model.defaultScale);
+      typedArray.color[i] = model.useActiveColor && isActive ? model.activeColor : state.getColor();
+    }
+
+    model.internalPolyData.modified();
+    outData[0] = model.internalPolyData;
+  };
+}
+
+var DEFAULT_VALUES = {
+  glyphResolution: 32,
+  defaultScale: 1,
+  drawBorder: false,
+  drawFace: true
+}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+  vtkContextRepresentation.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['glyphResolution', 'defaultScale']);
+  macro.get(publicAPI, model, ['glyph', 'mapper', 'actor']);
+  vtkSphereContextRepresentation(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = macro.newInstance(extend, 'vtkSphereContextRepresentation');
+var vtkSphereContextRepresentation$1 = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { vtkSphereContextRepresentation$1 as default, extend, newInstance };

package/Widgets/Widgets3D/SphereWidget/behavior.js

@@ -0,0 +1,177 @@
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import macro from '../../../macros.js';
+import { vec3 } from 'gl-matrix';
+
+function widgetBehavior(publicAPI, model) {
+  var state = model.widgetState;
+  var moveHandle = state.getMoveHandle();
+  var centerHandle = state.getCenterHandle();
+  var borderHandle = state.getBorderHandle();
+  var shapeHandle = state.getSphereHandle(); // Set while moving the center or border handle.
+
+  model.isDragging = false; // The last world coordinate of the mouse cursor during dragging.
+
+  model.previousPosition = null;
+  centerHandle.setManipulator(model.manipulator);
+  borderHandle.setManipulator(model.manipulator);
+  model.classHierarchy.push('vtkSphereWidgetProp');
+  moveHandle.setVisible(true);
+  centerHandle.setVisible(false);
+  borderHandle.setVisible(false);
+  shapeHandle.setVisible(true);
+
+  function isValidHandle(handle) {
+    return handle === centerHandle || handle === borderHandle || handle === moveHandle;
+  }
+
+  function isPlaced() {
+    return !!centerHandle.getOrigin() && !!borderHandle.getOrigin();
+  } // Update the sphereHandle parameters from {center,border}Handle.
+
+
+  function updateSphere() {
+    var center = centerHandle.getOrigin();
+    if (!center) return;
+    centerHandle.setVisible(true);
+    var border = borderHandle.getOrigin();
+
+    if (border) {
+      borderHandle.setVisible(true);
+    } else {
+      border = moveHandle.getOrigin();
+      if (!border) return;
+    }
+
+    if (isPlaced()) {
+      moveHandle.setVisible(false);
+    }
+
+    var radius = vec3.distance(center, border);
+    shapeHandle.setVisible(true);
+    shapeHandle.setOrigin(center);
+    shapeHandle.setScale1(radius * 2);
+    model.interactor.render();
+  }
+
+  function currentWorldCoords(e) {
+    return model.manipulator.handleEvent(e, model.apiSpecificRenderWindow);
+  } // Update the sphere's center and radius.  Example:
+  // handle.setCenterAndRadius([1,2,3], 10);
+
+
+  publicAPI.setCenterAndRadius = function (newCenter, newRadius) {
+    var oldCenter = centerHandle.getOrigin();
+    var oldBorder = borderHandle.getOrigin();
+    var newBorder = [newCenter[0] + newRadius, newCenter[1], newCenter[2]];
+
+    if (oldBorder) {
+      // Move the boundary handle to reflect the new radius, while preserving
+      // its direction relative to the center.
+      var direction = vec3.sub(vec3.create(), oldBorder, oldCenter);
+      var oldRadius = vec3.length(direction);
+
+      if (oldRadius > 1e-10) {
+        newBorder = vec3.add(vec3.create(), newCenter, vec3.scale(vec3.create(), direction, newRadius / oldRadius));
+      }
+    }
+
+    centerHandle.setOrigin(newCenter);
+    borderHandle.setOrigin(newBorder);
+    updateSphere();
+    model.widgetManager.enablePicking();
+  };
+
+  publicAPI.handleLeftButtonPress = function (e) {
+    if (!isValidHandle(model.activeState)) {
+      model.activeState = null;
+      return macro.VOID;
+    }
+
+    var worldCoords = currentWorldCoords(e);
+
+    if (model.activeState === moveHandle) {
+      // Initial sphere placement.
+      if (!centerHandle.getOrigin()) {
+        centerHandle.setOrigin(worldCoords);
+      } else if (!borderHandle.getOrigin()) {
+        borderHandle.setOrigin(worldCoords);
+      }
+
+      updateSphere();
+    }
+
+    model.isDragging = true;
+    model.apiSpecificRenderWindow.setCursor('grabbing');
+    model.previousPosition = _toConsumableArray(currentWorldCoords(e));
+    publicAPI.invokeStartInteractionEvent();
+    return macro.EVENT_ABORT;
+  };
+
+  publicAPI.handleLeftButtonRelease = function (e) {
+    if (!model.isDragging) {
+      model.activeState = null;
+      return macro.VOID;
+    }
+
+    if (isPlaced()) {
+      model.previousPosition = null;
+      model.widgetManager.enablePicking();
+      model.apiSpecificRenderWindow.setCursor('pointer');
+      model.isDragging = false;
+      model.activeState = null;
+      state.deactivate();
+    }
+
+    publicAPI.invokeEndInteractionEvent();
+    return macro.EVENT_ABORT;
+  };
+
+  publicAPI.handleMouseMove = function (e) {
+    if (!model.isDragging) {
+      model.activeState = null;
+      return macro.VOID;
+    }
+
+    if (!model.activeState) throw Error('no activestate');
+    var worldCoords = currentWorldCoords(e);
+    model.activeState.setOrigin(worldCoords);
+
+    if (model.activeState === centerHandle) {
+      // When the sphere is fully placed, and the user is moving the
+      // center, we move the whole sphere.
+      if (borderHandle.getOrigin()) {
+        if (!model.previousPosition) {
+          // !previousPosition here happens only immediately
+          // after grabFocus, but grabFocus resets
+          // borderHandle.origin.
+          throw Error("no pos ".concat(model.activeState, " ").concat(model.previousPosition));
+        }
+
+        var translation = vec3.sub(vec3.create(), worldCoords, model.previousPosition);
+        borderHandle.setOrigin(vec3.add(vec3.create(), borderHandle.getOrigin(), translation));
+      }
+    }
+
+    model.previousPosition = worldCoords;
+    updateSphere();
+    return macro.VOID;
+  };
+
+  publicAPI.grabFocus = function () {
+    moveHandle.setVisible(true);
+    centerHandle.setVisible(false);
+    borderHandle.setVisible(false);
+    centerHandle.setOrigin(null);
+    borderHandle.setOrigin(null);
+    model.isDragging = true;
+    model.activeState = moveHandle;
+    model.interactor.render();
+  };
+
+  publicAPI.loseFocus = function () {
+    model.isDragging = false;
+    model.activeState = null;
+  };
+}
+
+export { widgetBehavior as default };

package/Widgets/Widgets3D/SphereWidget/state.js

@@ -0,0 +1,45 @@
+import vtkStateBuilder from '../../Core/StateBuilder.js';
+
+// See https://kitware.github.io/vtk-js/docs/concepts_widgets.html.
+
+function stateGenerator() {
+  return vtkStateBuilder.createBuilder() // The handle used only for during initial placement.
+  .addStateFromMixin({
+    labels: ['moveHandle'],
+    mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
+    name: 'moveHandle',
+    initialValues: {
+      scale1: 20,
+      visible: true
+    }
+  }) // The handle for the center of the sphere.
+  .addStateFromMixin({
+    labels: ['centerHandle'],
+    mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
+    name: 'centerHandle',
+    initialValues: {
+      scale1: 20,
+      visible: true
+    }
+  }) // The handle for a border point of the sphere.
+  .addStateFromMixin({
+    labels: ['borderHandle'],
+    mixins: ['origin', 'color', 'scale1', 'visible', 'manipulator'],
+    name: 'borderHandle',
+    initialValues: {
+      scale1: 20,
+      visible: true
+    }
+  }) // For displaying the sphere.
+  .addStateFromMixin({
+    labels: ['sphereHandle'],
+    mixins: ['origin', 'color', 'scale1', 'visible', 'orientation'],
+    name: 'sphereHandle',
+    initialValues: {
+      visible: true,
+      radius: 1
+    }
+  }).build();
+}
+
+export { stateGenerator as default };

package/Widgets/Widgets3D/SphereWidget.d.ts

@@ -0,0 +1,50 @@
+import vtkAbstractWidget from '../Core/AbstractWidget';
+import { Vector3, Bounds } from '../../types';
+
+export interface ISphereWidgetHandleState {
+  getOrigin(): Vector3;
+  setOrigin(arg: Vector3): void;
+  getColor(): string;
+  setColor(arg: string):void;
+  getScale1(): number;
+  setScale1(arg: number): void;
+  getVisible(): boolean;
+  setVisible(arg: boolean):void
+  setShape(arg: string): void;
+  getShape(): string;
+}
+
+// The internal state of the widget.
+export interface vtkSphereWidgetState {
+  // A handle that defines the center of the sphere.
+  getCenterHandle(): ISphereWidgetHandleState;
+  // An arbitrary point at the sphere border. Used only to set the radius.
+  getBorderHandle(): ISphereWidgetHandleState;
+}
+
+// The type of object returned by vtkWidgetManager.addWidget()
+export interface vtkSphereWidgetHandle {
+  // Set the sphere parameters.
+  setCenterAndRadius(center: Vector3, radius: number): void;
+}
+
+export interface vtkSphereWidget {
+  // Abstract widget methods.
+  getWidgetState(): vtkSphereWidgetState;
+  onWidgetChange(fn: () => void): void;
+  placeWidget(bounds: Bounds): void;
+  setPlaceFactor(factor: number): void;
+
+  // Methods specific to vtkSphereWidget.
+  getRadius(): number;
+}
+
+export interface ISphereWidgetInitialValues {}
+
+export function newInstance(props?: ISphereWidgetInitialValues): vtkSphereWidget;
+
+export const vtkSphereWidget: {
+  newInstance: typeof newInstance;
+};
+
+export default vtkSphereWidget;

package/Widgets/Widgets3D/SphereWidget.js

@@ -0,0 +1,62 @@
+import { f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
+import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
+import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
+import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
+import vtkSphereContextRepresentation from '../Representations/SphereContextRepresentation.js';
+import macro from '../../macros.js';
+import widgetBehavior from './SphereWidget/behavior.js';
+import stateGenerator from './SphereWidget/state.js';
+
+function vtkSphereWidget(publicAPI, model) {
+  model.classHierarchy.push('vtkSphereWidget');
+  model.behavior = widgetBehavior;
+
+  publicAPI.getRepresentationsForViewType = function (viewType) {
+    return [{
+      builder: vtkSphereHandleRepresentation,
+      labels: ['moveHandle'],
+      initialValues: {
+        scaleInPixels: true
+      }
+    }, {
+      builder: vtkSphereHandleRepresentation,
+      labels: ['centerHandle'],
+      initialValues: {
+        scaleInPixels: true
+      }
+    }, {
+      builder: vtkSphereHandleRepresentation,
+      labels: ['borderHandle'],
+      initialValues: {
+        scaleInPixels: true
+      }
+    }, {
+      builder: vtkSphereContextRepresentation,
+      labels: ['sphereHandle']
+    }];
+  };
+
+  publicAPI.getRadius = function () {
+    var h1 = model.widgetState.getCenterHandle();
+    var h2 = model.widgetState.getBorderHandle();
+    return Math.sqrt(distance2BetweenPoints(h1.getOrigin(), h2.getOrigin()));
+  };
+
+  model.manipulator = vtkPlanePointManipulator.newInstance();
+  model.widgetState = stateGenerator();
+}
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, {}, initialValues);
+  vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['manipulator', 'widgetState']);
+  vtkSphereWidget(publicAPI, model);
+}
+var newInstance = macro.newInstance(extend, 'vtkSphereWidget');
+var index = {
+  newInstance: newInstance,
+  extend: extend
+};
+
+export { index as default, extend, newInstance };

package/index.d.ts

@@ -90,7 +90,6 @@
 /// <reference path="./IO/XML/XMLPolyDataReader.d.ts" />
 /// <reference path="./IO/XML/XMLReader.d.ts" />
 /// <reference path="./Rendering/Core/AbstractMapper.d.ts" />
-/// <reference path="./Rendering/Core/AbstractMapper3D.d.ts" />
 /// <reference path="./Rendering/Core/AbstractPicker.d.ts" />
 /// <reference path="./Rendering/Core/Actor.d.ts" />
 /// <reference path="./Rendering/Core/Actor2D.d.ts" />
@@ -131,7 +130,6 @@
 /// <reference path="./Rendering/Misc/FullScreenRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/GenericRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/RemoteView.d.ts" />
-/// <reference path="./Rendering/Misc/RenderWindowWithControlBar.d.ts" />
 /// <reference path="./Rendering/Misc/SynchronizableRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/TextureLODsDownloader.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
@@ -143,4 +141,7 @@
 /// <reference path="./Widgets/Manipulators/TrackballManipulator.d.ts" />
 /// <reference path="./Widgets/Representations/ResliceCursorContextRepresentation.d.ts" />
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
+/// <reference path="./Widgets/Widgets3D/SphereWidget.d.ts" />
+/// <reference path="./Rendering/Core/AbstractMapper3D.d.ts" />
+/// <reference path="./Rendering/Misc/RenderWindowWithControlBar.d.ts" />
 /// <reference path="./Common/Core/Math.d.ts" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "23.2.0",
+  "version": "23.4.0",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",