@kitware/vtk.js 23.2.0 → 23.3.0-beta.1

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/package.json

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