@kitware/vtk.js 25.11.1 → 25.13.0

package/Common/DataModel/EdgeLocator.d.ts

@@ -1,3 +1,5 @@
+import { Nullable } from './../../types';
+
 /**
  *
  */
@@ -5,6 +7,12 @@ export interface IEdgeLocatorInitialValues {
 	oriented?: boolean;
 }
 
+export interface IEdge<T = unknown> {
+	key: number;
+	edgeId: number;
+	value?: T;
+}
+
 export interface vtkEdgeLocator {
 	/**
 	 * Remove all the edges previously added.
@@ -15,9 +23,9 @@ export interface vtkEdgeLocator {
 	 * Returns the inserted edge or null if no edge was inserted.
 	 * @param {Number} pointId0 Edge first point id
 	 * @param {Number} pointId1 Edge last point id
-	 * @return {key, edgeId, value} or null
+	 * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
 	 */
-	isInsertedEdge(pointId0: number, pointId1: number): { key: any; edgeId: number; value?: any } | null;
+	isInsertedEdge<T = unknown>(pointId0: number, pointId1: number): Nullable<IEdge<T>>;
 
 	/**
 	 * Insert edge if it does not already exist.
@@ -25,16 +33,12 @@ export interface vtkEdgeLocator {
 	 *
 	 * @param {Number} pointId0 Edge first point id
 	 * @param {Number} pointId1 Edge last point id
-	 * @param {any} value Optional value option
-	 * @return {key, edgeId, value}
+	 * @param {unknown} value Optional value option
+	 * @return {IEdge|null} an edge object ({ key, edgeId, value }) or null
 	 * @see insertEdge()
 	 * @see isInsertedEdge()
 	 */
-	insertUniqueEdge(
-		pointId0: number,
-		pointId1: number,
-		value?: any
-	): { key: any; edgeId: number; value?: any };
+	insertUniqueEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;
 
 	/**
 	 * Insert edge. If the edge already exists, it is overwritten by this
@@ -43,15 +47,12 @@ export interface vtkEdgeLocator {
 	 * Returns the newly inserted edge.
 	 * @param {Number} pointId0 Edge first point id
 	 * @param {Number} pointId1 Edge last point id
-	 * @param {any} value Optional value option
-	 * @return {key, edgeId, value} or null
+	 * @param {unknown} value Optional value option
+	 * @return {Edge|null} an edge object ({ key, edgeId, value }) or null
 	 * @see isInsertedEdge
 	 * @see insertUniqueEdge
 	 */
-	insertEdge(pointId0: number,
-		pointId1: number,
-		value?: any
-	): { key: any; edgeId: number; value?: any };
+	insertEdge<T>(pointId0: number, pointId1: number, value?: T): IEdge<T>;
 }
 
 // ----------------------------------------------------------------------------

package/Common/DataModel/EdgeLocator.js

@@ -45,8 +45,7 @@ var EdgeLocator = /*#__PURE__*/function () {
     key: "insertEdge",
     value: function insertEdge(pointId0, pointId1, newEdgeValue) {
       // Generate a unique key
-      var key = this.computeEdgeKey(pointId0, pointId1); // Didn't find key, so add a new edge entry
-
+      var key = this.computeEdgeKey(pointId0, pointId1);
       var node = {
         key: key,
         edgeId: this.edgeMap.size,

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -327,7 +327,18 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	setViewStream(stream: vtkViewStream): boolean;
 
 	/**
-	 *
+	 * Sets the pixel width and height of the rendered image.  
+	 * 
+	 * WebGL and WebGPU render windows apply these values to 
+	 * the width and height attribute of the canvas element.
+	 * 
+	 * To match the device resolution in browser environments, 
+	 * multiply the container size by `window.devicePixelRatio`
+	 * `apiSpecificRenderWindow.setSize(Math.floor(containerWidth * devicePixelRatio), Math.floor(containerHeight * devicePixelRatio));
+	 * See the VTK.js FullscreenRenderWindow class for an example.
+	 * 
+	 * @see getComputedDevicePixelRatio()
+	 * 
 	 * @param {Vector2} size 
 	 */
 	setSize(size: Vector2): void;
@@ -361,6 +372,19 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 *
 	 */
 	getVrResolution(): Vector2;
+
+	/**
+	 * Scales the size of a browser CSS pixel to a rendered canvas pixel.  
+	 * `const renderedPixelWidth = cssPixelWidth * apiRenderWindow.getComputedDevicePixelRatio()`
+	 * Use to scale rendered objects to a consistent perceived size or DOM pixel position.
+	 * 
+	 * Rather than using window.devicePixelRatio directly, the device pixel ratio is inferred
+	 * from the container CSS pixel size and rendered image pixel size. The user directly sets the rendered pixel size.
+	 * 
+	 * @see setSize()
+	 * @see getContainerSize()
+	 */
+	getComputedDevicePixelRatio(): number;
 }
 
 /**

package/Rendering/SceneGraph/RenderWindowViewNode.js

@@ -119,14 +119,20 @@ function vtkRenderWindowViewNode(publicAPI, model) {
     return publicAPI.displayToNormalizedDisplay(x2, y2, z);
   };
 
+  publicAPI.getComputedDevicePixelRatio = function () {
+    return model.size[0] / publicAPI.getContainerSize()[0];
+  };
+
+  publicAPI.getContainerSize = function () {
+    macro.vtkErrorMacro('not implemented');
+  };
+
   publicAPI.getPixelData = function (x1, y1, x2, y2) {
     macro.vtkErrorMacro('not implemented');
-    return undefined;
   };
 
   publicAPI.createSelector = function () {
     macro.vtkErrorMacro('not implemented');
-    return undefined;
   };
 } // ----------------------------------------------------------------------------
 // Object factory

package/Widgets/Core/AbstractWidget.js

@@ -119,7 +119,7 @@ function extend(publicAPI, model) {
   vtkProp.extend(publicAPI, model, initialValues);
   vtkInteractorObserver.extend(publicAPI, model, initialValues);
   macro.setGet(publicAPI, model, ['contextVisibility', 'handleVisibility', '_widgetManager']);
-  macro.get(publicAPI, model, ['representations', 'widgetState']);
+  macro.get(publicAPI, model, ['representations', 'widgetState', 'activeState']);
   macro.moveToProtected(publicAPI, model, ['widgetManager']);
   macro.event(publicAPI, model, 'ActivateHandle');
   vtkAbstractWidget(publicAPI, model);

package/Widgets/Core/WidgetManager.js

@@ -126,7 +126,8 @@ function vtkWidgetManager(publicAPI, model) {
         cwidth = _model$_apiSpecificRe2[0],
         cheight = _model$_apiSpecificRe2[1];
 
-    var ratio = window.devicePixelRatio || 1;
+    var ratio = model._apiSpecificRenderWindow.getComputedDevicePixelRatio();
+
     var bwidth = String(cwidth / ratio);
     var bheight = String(cheight / ratio);
     var viewBox = "0 0 ".concat(cwidth, " ").concat(cheight);
@@ -243,7 +244,9 @@ function vtkWidgetManager(publicAPI, model) {
           vxmax = _renderer$getViewport2[2],
           vymax = _renderer$getViewport2[3];
 
-      var rendererPixelDims = [rwW * (vxmax - vxmin), rwH * (vymax - vymin)];
+      var pixelRatio = _apiSpecificRenderWindow.getComputedDevicePixelRatio();
+
+      var rendererPixelDims = [rwW * (vxmax - vxmin) / pixelRatio, rwH * (vymax - vymin) / pixelRatio];
 
       var cameraPosition = _camera.getPosition();
 
@@ -277,7 +280,7 @@ function vtkWidgetManager(publicAPI, model) {
 
   function _updateSelection() {
     _updateSelection = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(callData, fromTouchEvent, callID) {
-      var position, _yield$publicAPI$getS, requestCount, selectedState, representation, widget, activateHandle, i, w;
+      var position, _yield$publicAPI$getS, requestCount, selectedState, representation, widget, activateHandle, wantRender, i, w;
 
       return _regeneratorRuntime.wrap(function _callee3$(_context3) {
         while (1) {
@@ -322,12 +325,11 @@ function vtkWidgetManager(publicAPI, model) {
               // Default cursor behavior
               model._apiSpecificRenderWindow.setCursor(widget ? 'pointer' : 'default');
 
-              if (model.widgetInFocus === widget && widget.hasFocus()) {
-                activateHandle(widget); // Ken FIXME
-
-                model._interactor.render();
+              wantRender = false;
 
-                model._interactor.render();
+              if (model.widgetInFocus === widget && widget.hasFocus()) {
+                activateHandle(widget);
+                wantRender = true;
               } else {
                 for (i = 0; i < model.widgets.length; i++) {
                   w = model.widgets[i];
@@ -335,18 +337,19 @@ function vtkWidgetManager(publicAPI, model) {
                   if (w === widget && w.getNestedPickable()) {
                     activateHandle(w);
                     model.activeWidget = w;
+                    wantRender = true;
                   } else {
+                    wantRender || (wantRender = !!w.getActiveState());
                     w.deactivateAllHandles();
                   }
-                } // Ken FIXME
-
-
-                model._interactor.render();
+                }
+              }
 
+              if (wantRender) {
                 model._interactor.render();
               }
 
-            case 13:
+            case 15:
             case "end":
               return _context3.stop();
           }
@@ -600,7 +603,7 @@ function vtkWidgetManager(publicAPI, model) {
               model.selections = null;
 
               if (!model.pickingEnabled) {
-                _context2.next = 24;
+                _context2.next = 26;
                 break;
               }
 
@@ -636,7 +639,7 @@ function vtkWidgetManager(publicAPI, model) {
 
             case 16:
               if (!(!model._capturedBuffers || model.captureOn === CaptureOn.MOUSE_MOVE)) {
-                _context2.next = 19;
+                _context2.next = 21;
                 break;
               }
 
@@ -644,24 +647,28 @@ function vtkWidgetManager(publicAPI, model) {
               return captureBuffers(x, y, x, y);
 
             case 19:
+              _context2.next = 25;
+              break;
+
+            case 21:
               // or do we need a pixel that is outside the last capture?
               capturedRegion = model._capturedBuffers.area;
 
               if (!(x < capturedRegion[0] || x > capturedRegion[2] || y < capturedRegion[1] || y > capturedRegion[3])) {
-                _context2.next = 23;
+                _context2.next = 25;
                 break;
               }
 
-              _context2.next = 23;
+              _context2.next = 25;
               return captureBuffers(x, y, x, y);
 
-            case 23:
+            case 25:
               model.selections = model._capturedBuffers.generateSelection(x, y, x, y);
 
-            case 24:
+            case 26:
               return _context2.abrupt("return", publicAPI.getSelectedData());
 
-            case 25:
+            case 27:
             case "end":
               return _context2.stop();
           }

package/package.json

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