@kitware/vtk.js 28.9.0 → 28.10.0

package/Filters/General/ImageMarchingSquares.js

@@ -1,3 +1,4 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import macro from '../../macros.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkEdgeLocator from '../../Common/DataModel/EdgeLocator.js';
@@ -9,12 +10,41 @@ var vtkErrorMacro = macro.vtkErrorMacro,
 // ----------------------------------------------------------------------------
 
 function vtkImageMarchingSquares(publicAPI, model) {
-  // Set our className
+  /**
+   * Get the X,Y kernels based on the set slicing mode.
+   * @returns {[number, number]}
+   */
+  function getKernels() {
+    var kernelX = 0; // default K slicing mode
+
+    var kernelY = 1;
+
+    if (model.slicingMode === 1) {
+      kernelX = 0;
+      kernelY = 2;
+    } else if (model.slicingMode === 0) {
+      kernelX = 1;
+      kernelY = 2;
+    }
+
+    return [kernelX, kernelY];
+  } // Set our className
+
+
   model.classHierarchy.push('vtkImageMarchingSquares');
+  /**
+   * Get the list of contour values.
+   * @returns {number[]}
+   */
 
   publicAPI.getContourValues = function () {
     return model.contourValues;
   };
+  /**
+   * Set the list contour values.
+   * @param {number[]} cValues
+   */
+
 
   publicAPI.setContourValues = function (cValues) {
     model.contourValues = cValues;
@@ -24,47 +54,87 @@ function vtkImageMarchingSquares(publicAPI, model) {
   var ids = [];
   var pixelScalars = [];
   var pixelPts = [];
-  var edgeLocator = vtkEdgeLocator.newInstance(); // Retrieve scalars and pixel coordinates. i-j-k is origin of pixel.
+  var edgeLocator = vtkEdgeLocator.newInstance();
+  /**
+   * Retrieve scalars and pixel coordinates.
+   * @param {Vector3} ijk origin of the pixel
+   * @param {Vector3} dims dimensions of the image
+   * @param {TypedArray} scalars list of scalar values
+   * @param {Vector3} increments IJK slice increments
+   * @param {number} kernelX index of the X element
+   * @param {number} kernelY index of the Y element
+   */
 
-  publicAPI.getPixelScalars = function (i, j, k, slice, dims, origin, spacing, s) {
-    // First get the indices for the pixel
-    ids[0] = k * slice + j * dims[0] + i; // i, j, k
+  publicAPI.getPixelScalars = function (ijk, dims, scalars, increments, kernelX, kernelY) {
+    var _ijk = _slicedToArray(ijk, 3),
+        i = _ijk[0],
+        j = _ijk[1],
+        k = _ijk[2]; // First get the indices for the pixel
 
-    ids[1] = ids[0] + 1; // i+1, j, k
 
-    ids[2] = ids[0] + dims[0]; // i, j+1, k
+    ids[0] = k * dims[1] * dims[0] + j * dims[0] + i; // i, j, k
 
-    ids[3] = ids[2] + 1; // i+1, j+1, k
+    ids[1] = ids[0] + increments[kernelX]; // i+1, j, k
+
+    ids[2] = ids[0] + increments[kernelY]; // i, j+1, k
+
+    ids[3] = ids[2] + increments[kernelX]; // i+1, j+1, k
     // Now retrieve the scalars
 
     for (var ii = 0; ii < 4; ++ii) {
-      pixelScalars[ii] = s[ids[ii]];
+      pixelScalars[ii] = scalars[ids[ii]];
     }
-  }; // Retrieve pixel coordinates. i-j-k is origin of pixel.
+  };
+  /**
+   * Retrieve pixel coordinates.
+   * @param {Vector3} ijk origin of the pixel
+   * @param {Vector3} origin origin of the image
+   * @param {Vector3} spacing spacing of the image
+   * @param {number} kernelX index of the X element
+   * @param {number} kernelY index of the Y element
+   */
+
 
+  publicAPI.getPixelPoints = function (ijk, origin, spacing, kernelX, kernelY) {
+    var i = ijk[kernelX];
+    var j = ijk[kernelY]; // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
 
-  publicAPI.getPixelPoints = function (i, j, k, dims, origin, spacing) {
-    // (i,i+1),(j,j+1),(k,k+1) - i varies fastest; then j; then k
-    pixelPts[0] = origin[0] + i * spacing[0]; // 0
+    pixelPts[0] = origin[kernelX] + i * spacing[kernelX]; // 0
 
-    pixelPts[1] = origin[1] + j * spacing[1];
-    pixelPts[2] = pixelPts[0] + spacing[0]; // 1
+    pixelPts[1] = origin[kernelY] + j * spacing[kernelY];
+    pixelPts[2] = pixelPts[0] + spacing[kernelX]; // 1
 
     pixelPts[3] = pixelPts[1];
     pixelPts[4] = pixelPts[0]; // 2
 
-    pixelPts[5] = pixelPts[1] + spacing[1];
+    pixelPts[5] = pixelPts[1] + spacing[kernelY];
     pixelPts[6] = pixelPts[2]; // 3
 
     pixelPts[7] = pixelPts[5];
   };
-
-  publicAPI.produceLines = function (cVal, i, j, k, slice, dims, origin, spacing, scalars, points, lines) {
+  /**
+   * Produce points and lines for the polydata.
+   * @param {number[]} cVal list of contour values
+   * @param {Vector3} ijk origin of the pixel
+   * @param {Vector3} dims dimensions of the image
+   * @param {Vector3} origin origin of the image
+   * @param {Vector3} spacing sapcing of the image
+   * @param {TypedArray} scalars list of scalar values
+   * @param {number[]} points list of points
+   * @param {number[]} lines list of lines
+   * @param {Vector3} increments IJK slice increments
+   * @param {number} kernelX index of the X element
+   * @param {number} kernelY index of the Y element
+   */
+
+
+  publicAPI.produceLines = function (cVal, ijk, dims, origin, spacing, scalars, points, lines, increments, kernelX, kernelY) {
+    var k = ijk[model.slicingMode];
     var CASE_MASK = [1, 2, 8, 4]; // case table is actually for quad
 
     var xyz = [];
     var pId;
-    publicAPI.getPixelScalars(i, j, k, slice, dims, origin, spacing, scalars);
+    publicAPI.getPixelScalars(ijk, dims, scalars, increments, kernelX, kernelY);
     var index = 0;
 
     for (var idx = 0; idx < 4; idx++) {
@@ -79,8 +149,8 @@ function vtkImageMarchingSquares(publicAPI, model) {
       return; // don't get the pixel coordinates, nothing to do
     }
 
-    publicAPI.getPixelPoints(i, j, k, dims, origin, spacing);
-    var z = origin[2] + k * spacing[2];
+    publicAPI.getPixelPoints(ijk, origin, spacing, kernelX, kernelY);
+    var z = origin[model.slicingMode] + k * spacing[model.slicingMode];
 
     for (var _idx = 0; pixelLines[_idx] >= 0; _idx += 2) {
       lines.push(2);
@@ -99,10 +169,11 @@ function vtkImageMarchingSquares(publicAPI, model) {
           var t = (cVal - pixelScalars[edgeVerts[0]]) / (pixelScalars[edgeVerts[1]] - pixelScalars[edgeVerts[0]]);
           var x0 = pixelPts.slice(edgeVerts[0] * 2, (edgeVerts[0] + 1) * 2);
           var x1 = pixelPts.slice(edgeVerts[1] * 2, (edgeVerts[1] + 1) * 2);
-          xyz[0] = x0[0] + t * (x1[0] - x0[0]);
-          xyz[1] = x0[1] + t * (x1[1] - x0[1]);
+          xyz[kernelX] = x0[0] + t * (x1[0] - x0[0]);
+          xyz[kernelY] = x0[1] + t * (x1[1] - x0[1]);
+          xyz[model.slicingMode] = z;
           pId = points.length / 3;
-          points.push(xyz[0], xyz[1], z);
+          points.push(xyz[0], xyz[1], xyz[2]);
 
           if (model.mergePoints) {
             edgeLocator.insertEdge(ids[edgeVerts[0]], ids[edgeVerts[1]], pId);
@@ -123,29 +194,47 @@ function vtkImageMarchingSquares(publicAPI, model) {
       return;
     }
 
+    if (model.slicingMode == null || model.slicingMode < 0 || model.slicingMode > 2) {
+      vtkErrorMacro('Invalid or missing slicing mode');
+      return;
+    }
+
     console.time('msquares'); // Retrieve output and volume data
 
     var origin = input.getOrigin();
     var spacing = input.getSpacing();
     var dims = input.getDimensions();
-    var s = input.getPointData().getScalars().getData(); // Points - dynamic array
+    var extent = input.getExtent();
+    var increments = input.computeIncrements(extent);
+    var scalars = input.getPointData().getScalars().getData();
 
-    var pBuffer = []; // Cells - dynamic array
+    var _getKernels = getKernels(),
+        _getKernels2 = _slicedToArray(_getKernels, 2),
+        kernelX = _getKernels2[0],
+        kernelY = _getKernels2[1]; // Points - dynamic array
 
-    var lBuffer = []; // Ensure slice is valid
 
-    var slice = dims[0] * dims[1];
+    var points = []; // Cells - dynamic array
+
+    var lines = []; // Ensure slice is valid
+
     var k = Math.round(model.slice);
 
-    if (k >= dims[2]) {
+    if (k >= dims[model.slicingMode]) {
       k = 0;
     } // Loop over all contour values, and then pixels, determine case and process
 
 
+    var ijk = [0, 0, 0];
+    ijk[model.slicingMode] = k;
+
     for (var cv = 0; cv < model.contourValues.length; ++cv) {
-      for (var j = 0; j < dims[1] - 1; ++j) {
-        for (var i = 0; i < dims[0] - 1; ++i) {
-          publicAPI.produceLines(model.contourValues[cv], i, j, k, slice, dims, origin, spacing, s, pBuffer, lBuffer);
+      for (var j = 0; j < dims[kernelY] - 1; ++j) {
+        ijk[kernelY] = j;
+
+        for (var i = 0; i < dims[kernelX] - 1; ++i) {
+          ijk[kernelX] = i;
+          publicAPI.produceLines(model.contourValues[cv], ijk, dims, origin, spacing, scalars, points, lines, increments, kernelX, kernelY);
         }
       }
 
@@ -154,8 +243,8 @@ function vtkImageMarchingSquares(publicAPI, model) {
 
 
     var polydata = vtkPolyData.newInstance();
-    polydata.getPoints().setData(new Float32Array(pBuffer), 3);
-    polydata.getLines().setData(new Uint32Array(lBuffer));
+    polydata.getPoints().setData(new Float32Array(points), 3);
+    polydata.getLines().setData(new Uint32Array(lines));
     outData[0] = polydata;
     vtkDebugMacro('Produced output');
     console.timeEnd('msquares');
@@ -167,6 +256,7 @@ function vtkImageMarchingSquares(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   contourValues: [],
+  slicingMode: 2,
   slice: 0,
   mergePoints: false
 }; // ----------------------------------------------------------------------------
@@ -178,7 +268,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, ['slice', 'mergePoints']); // Object specific methods
+  macro.setGet(publicAPI, model, ['slicingMode', 'slice', 'mergePoints']); // Object specific methods
 
   macro.algo(publicAPI, model, 1, 1);
   vtkImageMarchingSquares(publicAPI, model);

package/Interaction/Style/InteractorStyleRemoteMouse.js

@@ -137,12 +137,25 @@ function vtkInteractorStyleRemoteMouse(publicAPI, model) {
 
 
   publicAPI.handleMouseWheel = function (callData) {
-    publicAPI.invokeRemoteWheelEvent(_objectSpread(_objectSpread({
-      type: 'MouseWheel'
-    }, createRemoteEvent(callData)), {}, {
-      spinY: callData.spinY
-    }));
-    publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
+    var needToSend = true;
+
+    if (model.wheelThrottleDelay) {
+      var ts = Date.now();
+      needToSend = model.wheelThrottleDelay < ts - model.wheelLastThrottleTime;
+
+      if (needToSend) {
+        model.wheelLastThrottleTime = ts;
+      }
+    }
+
+    if (needToSend) {
+      publicAPI.invokeRemoteWheelEvent(_objectSpread(_objectSpread({
+        type: 'MouseWheel'
+      }, createRemoteEvent(callData)), {}, {
+        spinY: callData.spinY
+      }));
+      publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
+    }
   }; //-------------------------------------------------------------------------
 
 
@@ -290,7 +303,9 @@ var DEFAULT_VALUES = {
   sendMouseMove: false,
   throttleDelay: 33.3,
   // 33.3 millisecond <=> 30 events/second
-  lastThrottleTime: 0 // remoteEventAddOn: null,
+  lastThrottleTime: 0,
+  wheelThrottleDelay: 0,
+  wheelLastThrottleTime: 0 // remoteEventAddOn: null,
 
 }; // ----------------------------------------------------------------------------
 
@@ -299,7 +314,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
   vtkInteractorStyle.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['sendMouseMove', 'remoteEventAddOn', 'throttleDelay']);
+  macro.setGet(publicAPI, model, ['sendMouseMove', 'remoteEventAddOn', 'throttleDelay', 'wheelThrottleDelay']);
   macro.event(publicAPI, model, 'RemoteMouseEvent');
   macro.event(publicAPI, model, 'RemoteWheelEvent');
   macro.event(publicAPI, model, 'RemoteGestureEvent'); // Object specific methods

package/Proxy/Representations/GeometryRepresentationProxy.d.ts

@@ -0,0 +1,35 @@
+import { RGBColor } from './../../types';
+import vtkAbstractRepresentationProxy from './../Core/AbstractRepresentationProxy';
+
+export interface vtkGeometryRepresentationProxy
+  extends vtkAbstractRepresentationProxy {
+
+  /**
+   * 
+   * @param representation a string that describes what representation to use for the explicit geometry.
+   *                       possible values are 'Surface with edges', 'Surface' (default), 'Wireframe',
+   *                       and 'Points'. 
+   */
+  setRepresentation(representation: string): boolean;
+  getRepresentation(): string;
+
+  // proxy property mappings
+  getColor(): RGBColor;
+  setColor(color: RGBColor): boolean;
+	getInterpolateScalarsBeforeMapping(): boolean;
+	setInterpolateScalarsBeforeMapping(interpolateScalarsBeforeMapping: boolean): boolean;
+  setOpacity(opacity: boolean): boolean;
+  getOpacity(): boolean;
+  setVisibility(visible: boolean): boolean;
+  getVisibility(): boolean;
+	getPointSize(): number;
+	setPointSize(pointSize: number): boolean;
+  getUseShadow(): boolean;
+  setUseShadow(lighting: boolean): boolean;
+  getUseBounds(): boolean;
+  setUseBounds(useBounds: boolean): boolean;
+  getLineWidth(): number;
+  setLineWidth(width: number): boolean;
+}
+
+export default vtkGeometryRepresentationProxy;

package/Proxy/Representations/GeometryRepresentationProxy.js

@@ -96,6 +96,10 @@ function extend(publicAPI, model) {
       modelKey: 'property',
       property: 'lighting'
     },
+    lineWidth: {
+      modelKey: 'property',
+      property: 'lineWidth'
+    },
     useBounds: {
       modelKey: 'actor',
       property: 'useBounds'

package/index.d.ts

@@ -131,6 +131,7 @@
 /// <reference path="./Proxy/Core/SourceProxy.d.ts" />
 /// <reference path="./Proxy/Core/View2DProxy.d.ts" />
 /// <reference path="./Proxy/Core/ViewProxy.d.ts" />
+/// <reference path="./Proxy/Representations/GeometryRepresentationProxy.d.ts" />
 /// <reference path="./Proxy/Representations/ResliceRepresentationProxy.d.ts" />
 /// <reference path="./Proxy/Representations/SliceRepresentationProxy.d.ts" />
 /// <reference path="./Proxy/Representations/VolumeRepresentationProxy.d.ts" />

package/package.json

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