@kitware/vtk.js 25.11.0 → 25.12.0

package/Common/Core/ScalarsToColors.d.ts

@@ -105,10 +105,8 @@ export interface vtkScalarsToColors extends vtkObject {
 
 	/**
 	 * 
-	 * @param {Number} min 
-	 * @param {Number} max 
 	 */
-	getRange(min: number, max: number): Range;
+	getRange(): Range;
 
 	/**
 	 * Get which component of a vector to map to colors.

package/Common/Core/ScalarsToColors.js

@@ -501,7 +501,7 @@ function vtkScalarsToColors(publicAPI, model) {
     return publicAPI.setMappingRange(min, max);
   };
 
-  publicAPI.getRange = function (min, max) {
+  publicAPI.getRange = function () {
     return publicAPI.getMappingRange();
   };
 } // ----------------------------------------------------------------------------

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/OpenGL/Texture.js

@@ -298,7 +298,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.getInternalFormat = function (vtktype, numComps) {
-    if (!model.internalFormat) {
+    if (!model._forceInternalFormat) {
       model.internalFormat = publicAPI.getDefaultInternalFormat(vtktype, numComps);
     }
 
@@ -332,6 +332,8 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
   publicAPI.setInternalFormat = function (iFormat) {
+    model._forceInternalFormat = true;
+
     if (iFormat !== model.internalFormat) {
       model.internalFormat = iFormat;
       publicAPI.modified();
@@ -388,6 +390,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.resetFormatAndType = function () {
     model.format = 0;
     model.internalFormat = 0;
+    model._forceInternalFormat = false;
     model.openGLDataType = 0;
   }; //----------------------------------------------------------------------------
 
@@ -1288,6 +1291,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 var DEFAULT_VALUES = {
   _openGLRenderWindow: null,
+  _forceInternalFormat: false,
   context: null,
   handle: 0,
   sendParametersTime: null,

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/Rendering/SceneGraph/ViewNode.js

@@ -181,6 +181,7 @@ function vtkViewNode(publicAPI, model) {
         }
 
         deleted.push(child);
+        child.delete();
       } else {
         child.setVisited(false);
       }
@@ -208,6 +209,16 @@ function vtkViewNode(publicAPI, model) {
 
     return ret;
   };
+
+  var parentDelete = publicAPI.delete;
+
+  publicAPI.delete = function () {
+    for (var i = 0; i < model.children.length; i++) {
+      model.children[i].delete();
+    }
+
+    parentDelete();
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

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();
 

package/package.json

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