@kitware/vtk.js 25.1.0 → 25.1.3

package/Rendering/Core/VolumeProperty.d.ts

@@ -255,7 +255,7 @@ export interface vtkVolumeProperty extends vtkObject {
 	 * @param {Boolean} index 
 	 * @param {Number} value
 	 */
-	setUseGradientOpacity(index: boolean, value: number): boolean;
+	setUseGradientOpacity(index: number, value: boolean): boolean;
 
 	/**
 	 *

package/Rendering/WebGPU/Actor2D.js

@@ -98,6 +98,8 @@ function vtkWebGPUActor2D(publicAPI, model) {
 
       if (model.renderable.getCoordinateSystem() === CoordinateSystem.WORLD) {
         mat4.translate(model.keyMatrices.bcsc, model.keyMatrices.bcwc, [-center[0], -center[1], -center[2]]);
+      } else {
+        mat4.copy(model.keyMatrices.bcsc, model.keyMatrices.bcwc);
       }
 
       model.keyMatricesTime.modified();

package/Rendering/WebGPU/BufferManager.js

@@ -65,7 +65,7 @@ function _getFormatForDataArray(dataArray) {
 
     case 3:
       // only 32bit types support x3
-      if (!format.contains('32')) {
+      if (!format.includes('32')) {
         vtkErrorMacro("unsupported x3 type for ".concat(format));
       }
 

package/Rendering/WebGPU/CellArrayMapper.js

@@ -9,6 +9,7 @@ import vtkWebGPUBufferManager from './BufferManager.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUUniformBuffer from './UniformBuffer.js';
 import vtkWebGPUSimpleMapper from './SimpleMapper.js';
+import vtkWebGPUTypes from './Types.js';
 
 var BufferUsage = vtkWebGPUBufferManager.BufferUsage,
     PrimitiveTypes = vtkWebGPUBufferManager.PrimitiveTypes;
@@ -223,15 +224,23 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
   publicAPI.replaceShaderTCoord = function (hash, pipeline, vertexInput) {
     if (!vertexInput.hasAttribute('tcoord')) return;
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addOutput('vec2<f32>', 'tcoordVS');
+    var tcoords = vertexInput.getBuffer('tcoord');
+    var numComp = vtkWebGPUTypes.getNumberOfComponentsFromBufferFormat(tcoords.getArrayInformation()[0].format);
     var code = vDesc.getCode();
+    vDesc.addOutput("vec".concat(numComp, "<f32>"), 'tcoordVS');
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', ['  output.tcoordVS = tcoord;']).result;
     vDesc.setCode(code);
     var fDesc = pipeline.getShaderDescription('fragment');
     code = fDesc.getCode(); // todo handle multiple textures? Blend multiply ?
 
     if (model.textures.length) {
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', ['var tcolor: vec4<f32> = textureSample(Texture0, Texture0Sampler, input.tcoordVS);', 'computedColor = computedColor*tcolor;']).result;
+      var tdims = model.textures[0].getDimensions();
+
+      if (tdims === numComp) {
+        code = vtkWebGPUShaderCache.substitute(code, '//VTK::TCoord::Impl', ['var tcolor: vec4<f32> = textureSample(Texture0, Texture0Sampler, input.tcoordVS);', 'computedColor = computedColor*tcolor;']).result;
+      } else {
+        console.log("mismatched texture coord dimension ".concat(numComp, " with texture map dimension ").concat(tdims));
+      }
     }
 
     fDesc.setCode(code);
@@ -366,6 +375,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
 
     var usage = publicAPI.getUsage(representation, primType);
+    model._usesCellNormals = false;
 
     if (!model.is2D && ( // no lighting on Property2D
     usage === BufferUsage.Triangles || usage === BufferUsage.Strips)) {
@@ -387,6 +397,7 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
 
         vertexInput.addBuffer(_buff, ['normalMC']);
       } else if (primType === PrimitiveTypes.Triangles) {
+        model._usesCellNormals = true;
         _buffRequest2.hash = "PFN".concat(points.getMTime(), "I").concat(indexBuffer.getMTime(), "snorm8x4");
         _buffRequest2.dataArray = points;
         _buffRequest2.cells = cells;
@@ -548,7 +559,9 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       }
 
       if (model.vertexInput.hasAttribute("tcoord")) {
-        pipelineHash += "t";
+        var tcoords = model.vertexInput.getBuffer('tcoord');
+        var numComp = vtkWebGPUTypes.getNumberOfComponentsFromBufferFormat(tcoords.getArrayInformation()[0].format);
+        pipelineHash += "t".concat(numComp);
       }
 
       if (model.textures.length) {
@@ -556,6 +569,10 @@ function vtkWebGPUCellArrayMapper(publicAPI, model) {
       }
     }
 
+    if (model._usesCellNormals) {
+      pipelineHash += "cn";
+    }
+
     if (model.SSBO) {
       pipelineHash += "ssbo";
     }

package/Rendering/WebGPU/Texture.js

@@ -184,6 +184,10 @@ function vtkWebGPUTexture(publicAPI, model) {
     return tDetails.numComponents;
   };
 
+  publicAPI.getDimensions = function () {
+    return model.depth > 1 ? 3 : 2;
+  };
+
   publicAPI.resizeToMatch = function (tex) {
     if (tex.getWidth() !== model.width || tex.getHeight() !== model.height || tex.getDepth() !== model.depth) {
       model.width = tex.getWidth();

package/Rendering/WebGPU/Types.js

@@ -325,7 +325,7 @@ function getByteStrideFromBufferFormat(format) {
   var numComp = 1;
 
   if (format[format.length - 2] === 'x') {
-    numComp = format[format.length - 1];
+    numComp = Number(format[format.length - 1]);
   }
 
   var sizeStart = numComp === 1 ? format.length - 1 : format.length - 3; // options are 8, 16, 32 resulting in 8, 6, 2 as the last char
@@ -350,7 +350,7 @@ function getNumberOfComponentsFromBufferFormat(format) {
   var numComp = 1;
 
   if (format[format.length - 2] === 'x') {
-    numComp = format[format.length - 1];
+    numComp = Number(format[format.length - 1]);
   }
 
   return numComp;
@@ -421,7 +421,7 @@ function getByteStrideFromShaderFormat(format) {
   var numComp = 1;
 
   if (format.substring(0, 3) === 'vec') {
-    numComp = format[3];
+    numComp = Number(format[3]);
   } else if (format.substring(0, 3) === 'mat') {
     numComp = format[3] * format[5];
   }

package/Widgets/Core/AbstractWidgetFactory.js

@@ -187,19 +187,19 @@ function vtkAbstractWidgetFactory(publicAPI, model) {
   var unsubscribe = NoOp;
   publicAPI.delete = macro.chain(publicAPI.delete, function () {
     return unsubscribe();
-  }); // Defer after object instantiation so model.widgetState actually exist
+  });
 
-  setTimeout(function () {
-    if (model.widgetState) {
-      unsubscribe = model.widgetState.onModified(function () {
-        return publicAPI.invokeWidgetChange(model.widgetState);
-      }).unsubscribe;
-    }
-  }, 0);
+  if (model.widgetState) {
+    unsubscribe = model.widgetState.onModified(function () {
+      return publicAPI.invokeWidgetChange(model.widgetState);
+    }).unsubscribe;
+  }
 } // ----------------------------------------------------------------------------
 
 
 function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, initialValues);
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['widgetState']);
   macro.event(publicAPI, model, 'WidgetChange');

package/Widgets/Widgets3D/AngleWidget.js

@@ -22,8 +22,6 @@ function vtkAngleWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -87,12 +85,18 @@ function vtkAngleWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// manipulator: null,
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // manipulator: null,
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator']);
   vtkAngleWidget(publicAPI, model);

package/Widgets/Widgets3D/DistanceWidget.js

@@ -22,8 +22,6 @@ function vtkDistanceWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -82,12 +80,18 @@ function vtkDistanceWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// manipulator: null,
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // manipulator: null,
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator']);
   vtkDistanceWidget(publicAPI, model);

package/Widgets/Widgets3D/EllipseWidget.js

@@ -21,7 +21,6 @@ function vtkEllipseWidget(publicAPI, model) {
   model.classHierarchy.push('vtkEllipseWidget'); // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = [].concat(_toConsumableArray(model.methodsToLink), ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'drawBorder', 'drawFace', 'opacity']);
-  model.behavior = widgetBehavior;
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -49,7 +48,6 @@ function vtkEllipseWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
 
-  model.widgetState = generateState();
   publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   }));
@@ -60,6 +58,8 @@ function defaultValues(initialValues) {
   var _None;
 
   return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: generateState(),
     modifierBehavior: {
       None: (_None = {}, _defineProperty(_None, BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG), _defineProperty(_None, BehaviorCategory.POINTS, ShapeBehavior[BehaviorCategory.POINTS].CENTER_TO_CORNER), _defineProperty(_None, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FREE), _None),
       Shift: _defineProperty({}, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FIXED),

package/Widgets/Widgets3D/ImageCroppingWidget.js

@@ -100,8 +100,6 @@ function vtkImageCroppingWidget(publicAPI, model) {
     }
   }); // --- Widget Requirement ---------------------------------------------------
 
-  model.behavior = widgetBehavior;
-  model.widgetState = build();
   model.methodsToLink = ['scaleInPixels']; // Given a view type (geometry, slice, volume), return a description
   // of what representations to create and what widget state to pass
   // to the respective representations.
@@ -162,14 +160,20 @@ function vtkImageCroppingWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// cornerManipulator: null,
-  // edgeManipulator: null,
-  // faceManipulator: null
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // cornerManipulator: null,
+    // edgeManipulator: null,
+    // faceManipulator: null,
+    behavior: widgetBehavior,
+    widgetState: build()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['cornerManipulator', 'edgeManipulator', 'faceManipulator']);
   vtkImageCroppingWidget(publicAPI, model);

package/Widgets/Widgets3D/ImplicitPlaneWidget.js

@@ -1,3 +1,4 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
@@ -7,6 +8,9 @@ import vtkTrackballManipulator from '../Manipulators/TrackballManipulator.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import { ViewTypes } from '../Core/WidgetManager/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; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 // Widget linked to a view
 // ----------------------------------------------------------------------------
 
@@ -143,8 +147,6 @@ function widgetBehavior(publicAPI, model) {
 function vtkImplicitPlaneWidget(publicAPI, model) {
   model.classHierarchy.push('vtkPlaneWidget'); // --- Widget Requirement ---------------------------------------------------
 
-  model.widgetState = vtkImplicitPlaneRepresentation.generateState();
-  model.behavior = widgetBehavior;
   model.methodsToLink = ['representationStyle', 'sphereResolution', 'handleSizeRatio', 'axisScale', 'normalVisible', 'originVisible', 'planeVisible', 'outlineVisible'];
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
@@ -162,11 +164,17 @@ function vtkImplicitPlaneWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: vtkImplicitPlaneRepresentation.generateState()
+  }, initialValues);
+}; // ----------------------------------------------------------------------------
+
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   vtkImplicitPlaneWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/InteractiveOrientationWidget.js

@@ -1,3 +1,4 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkConvexFaceContextRepresentation from '../Representations/ConvexFaceContextRepresentation.js';
@@ -6,6 +7,9 @@ import { generateState, INITIAL_POINTS } from './InteractiveOrientationWidget/st
 import { Behavior } from '../Representations/WidgetRepresentation/Constants.js';
 import { ViewTypes } from '../Core/WidgetManager/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; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 // Factory
 // ----------------------------------------------------------------------------
 
@@ -13,8 +17,6 @@ function vtkInteractiveOrientationWidget(publicAPI, model) {
   model.classHierarchy.push('vtkInteractiveOrientationWidget'); // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = ['closePolyLine', 'activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.setBounds = function (bounds) {
     var handles = model.widgetState.getStatesWithLabel('handles');
@@ -107,11 +109,17 @@ function vtkInteractiveOrientationWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
+}; // ----------------------------------------------------------------------------
+
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   vtkInteractiveOrientationWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/LabelWidget.js

@@ -22,8 +22,6 @@ function vtkLabelWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['textProps', 'fontProperties', 'strokeFontProperties', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -72,7 +70,10 @@ function vtkLabelWidget(publicAPI, model) {
 
 
 function defaultValues(initialValues) {
-  return _objectSpread({}, initialValues);
+  return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 } // ----------------------------------------------------------------------------
 
 

package/Widgets/Widgets3D/LineWidget.js

@@ -21,10 +21,8 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 function vtkLineWidget(publicAPI, model) {
   model.classHierarchy.push('vtkLineWidget');
 
-  var superClass = _objectSpread({}, publicAPI);
+  var superClass = _objectSpread({}, publicAPI); // --- Widget Requirement ---------------------------------------------------
 
-  model.widgetState = generateState();
-  model.behavior = widgetBehavior; // --- Widget Requirement ---------------------------------------------------
 
   model.methodsToLink = ['activeScaleFactor', 'activeColor', 'useActiveColor', 'glyphResolution', 'defaultScale', 'scaleInPixels'];
 
@@ -165,12 +163,18 @@ function vtkLineWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// manipulator: null,
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // manipulator: null,
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator']);
   vtkLineWidget(publicAPI, model);

package/Widgets/Widgets3D/PaintWidget.js

@@ -20,9 +20,6 @@ function vtkPaintWidget(publicAPI, model) {
   var superClass = _objectSpread({}, publicAPI); // --- Widget Requirement ---------------------------------------------------
 
 
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState(model.radius);
-
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
       case ViewTypes.DEFAULT:
@@ -67,16 +64,23 @@ function vtkPaintWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  // manipulator: null,
-  radius: 1,
-  painting: false,
-  color: [1]
+var defaultValues = function defaultValues(initialValues) {
+  var _initialValues$radius;
+
+  return _objectSpread({
+    // manipulator: null,
+    radius: 1,
+    painting: false,
+    color: [1],
+    behavior: widgetBehavior,
+    widgetState: generateState((_initialValues$radius = initialValues === null || initialValues === void 0 ? void 0 : initialValues.radius) !== null && _initialValues$radius !== void 0 ? _initialValues$radius : 1)
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['painting']);
   macro.setGet(publicAPI, model, ['manipulator', 'radius', 'color']);

package/Widgets/Widgets3D/PolyLineWidget.js

@@ -22,8 +22,6 @@ function vtkPolyLineWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['activeColor', 'activeScaleFactor', 'closePolyLine', 'defaultScale', 'glyphResolution', 'lineThickness', 'useActiveColor', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -78,12 +76,18 @@ function vtkPolyLineWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {// manipulator: null,
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    manipulator: null,
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator']);
   vtkPolyLineWidget(publicAPI, model);

package/Widgets/Widgets3D/RectangleWidget.js

@@ -21,8 +21,6 @@ function vtkRectangleWidget(publicAPI, model) {
   model.classHierarchy.push('vtkRectangleWidget');
   model.methodsToLink = [].concat(_toConsumableArray(model.methodsToLink), ['activeScaleFactor', 'activeColor', 'useActiveColor', 'drawBorder', 'drawFace', 'opacity']); // --- Widget Requirement ---------------------------------------------------
 
-  model.behavior = widgetBehavior;
-
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
       case ViewTypes.DEFAULT:
@@ -49,7 +47,6 @@ function vtkRectangleWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
 
-  model.widgetState = generateState();
   model.manipulator = vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   });
@@ -60,6 +57,8 @@ function defaultValues(initialValues) {
   var _None;
 
   return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: generateState(),
     modifierBehavior: {
       None: (_None = {}, _defineProperty(_None, BehaviorCategory.PLACEMENT, ShapeBehavior[BehaviorCategory.PLACEMENT].CLICK_AND_DRAG), _defineProperty(_None, BehaviorCategory.POINTS, ShapeBehavior[BehaviorCategory.POINTS].CORNER_TO_CORNER), _defineProperty(_None, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FREE), _None),
       Shift: _defineProperty({}, BehaviorCategory.RATIO, ShapeBehavior[BehaviorCategory.RATIO].FIXED),

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -1,3 +1,4 @@
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import macro from '../../macros.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
@@ -12,6 +13,9 @@ import { ViewTypes } from '../Core/WidgetManager/Constants.js';
 import { mat4, vec4 } from 'gl-matrix';
 import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.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; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 var VTK_INT_MAX = 2147483647;
 var vtkErrorMacro = macro.vtkErrorMacro; // ----------------------------------------------------------------------------
 // Factory
@@ -136,9 +140,6 @@ function vtkResliceCursorWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
 
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
-
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
       case ViewTypes.XY_PLANE:
@@ -400,11 +401,17 @@ function vtkResliceCursorWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
+}; // ----------------------------------------------------------------------------
+
 
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   vtkResliceCursorWidget(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Widgets/Widgets3D/ShapeWidget/behavior.js

@@ -271,7 +271,7 @@ function widgetBehavior(publicAPI, model) {
 
       var displayPlaneNormalPoint = (_model$_apiSpecificRe4 = model._apiSpecificRenderWindow).worldToDisplay.apply(_model$_apiSpecificRe4, _toConsumableArray(planeNormalPoint).concat([model._renderer]));
 
-      var displayPlaneNormal = vtkMath.subtract(displayPlaneNormalPoint, displayPlaneOrigin); // Project view plane into bounding box
+      var displayPlaneNormal = vtkMath.subtract(displayPlaneNormalPoint, displayPlaneOrigin, []); // Project view plane into bounding box
 
       var largeDistance = 10 * vtkBoundingBox.getDiagonalLength(displayBounds);
       vtkPlane.projectPoint(vtkBoundingBox.getCenter(displayBounds), displayPlaneOrigin, displayPlaneNormal, planeOrigin);

package/Widgets/Widgets3D/SphereWidget.js

@@ -17,7 +17,6 @@ function vtkSphereWidget(publicAPI, model) {
 
   var superClass = _objectSpread({}, publicAPI);
 
-  model.behavior = widgetBehavior;
   model.methodsToLink = ['scaleInPixels'];
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
@@ -53,15 +52,21 @@ function vtkSphereWidget(publicAPI, model) {
   // --------------------------------------------------------------------------
 
 
-  model.widgetState = stateGenerator();
   publicAPI.setManipulator(model.manipulator || vtkPlanePointManipulator.newInstance({
     useCameraNormal: true
   }));
 }
 
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    behavior: widgetBehavior,
+    widgetState: stateGenerator()
+  }, initialValues);
+};
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, {}, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator', 'widgetState']);
   vtkSphereWidget(publicAPI, model);

package/Widgets/Widgets3D/SplineWidget.js

@@ -21,8 +21,6 @@ function vtkSplineWidget(publicAPI, model) {
 
 
   model.methodsToLink = ['boundaryCondition', 'close', 'outputBorder', 'fill', 'borderColor', 'errorBorderColor', 'scaleInPixels'];
-  model.behavior = widgetBehavior;
-  model.widgetState = generateState();
 
   publicAPI.getRepresentationsForViewType = function (viewType) {
     switch (viewType) {
@@ -60,21 +58,26 @@ function vtkSplineWidget(publicAPI, model) {
 } // ----------------------------------------------------------------------------
 
 
-var DEFAULT_VALUES = {
-  // manipulator: null,
-  freehandMinDistance: 0.1,
-  allowFreehand: true,
-  resolution: 32,
-  // propagates to SplineContextRepresentation
-  defaultCursor: 'pointer',
-  handleSizeInPixels: 10,
-  // propagates to SplineContextRepresentation
-  resetAfterPointPlacement: false
+var defaultValues = function defaultValues(initialValues) {
+  return _objectSpread({
+    // manipulator: null,
+    freehandMinDistance: 0.1,
+    allowFreehand: true,
+    resolution: 32,
+    // propagates to SplineContextRepresentation
+    defaultCursor: 'pointer',
+    handleSizeInPixels: 10,
+    // propagates to SplineContextRepresentation
+    resetAfterPointPlacement: false,
+    behavior: widgetBehavior,
+    widgetState: generateState()
+  }, initialValues);
 }; // ----------------------------------------------------------------------------
 
+
 function extend(publicAPI, model) {
   var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
   vtkAbstractWidgetFactory.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['manipulator', 'freehandMinDistance', 'allowFreehand', 'resolution', 'defaultCursor', 'handleSizeInPixels', 'resetAfterPointPlacement']);
   vtkSplineWidget(publicAPI, model);

package/package.json

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