@kitware/vtk.js 26.3.2 → 26.4.1

package/Rendering/Core/InteractorStyle.d.ts

@@ -0,0 +1,229 @@
+import { EventHandler, vtkSubscription } from './../../interfaces';
+import vtkInteractorObserver from './InteractorObserver';
+
+export interface vtkInteractorStyle extends vtkInteractorObserver {
+  /**
+   * Start a Rotate event.
+   */
+  startRotate(): void;
+
+  /**
+   * Invoke a StartRotate event.
+   */
+  invokeStartRotateEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartRotate event.
+   */
+  onStartRotateEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Rotate event.
+   */
+  endRotate(): void;
+
+  /**
+   * Invoke an EndRotate event.
+   */
+  invokeEndRotateEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndRotate event.
+   */
+  onEndRotateEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Pan event.
+   */
+  startPan(): void;
+
+  /**
+   * Invoke a StartPan event.
+   */
+  invokeStartPanEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartPan event.
+   */
+  onStartPanEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Pan event.
+   */
+  endPan(): void;
+
+  /**
+   * Invoke an EndPan event.
+   */
+  invokeEndPanEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndPan event.
+   */
+  onEndPanEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Spin event.
+   */
+  startSpin(): void;
+
+  /**
+   * Invoke a StartSpin event.
+   */
+  invokeStartSpinEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartSpin event.
+   */
+  onStartSpinEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Spin event.
+   */
+  endSpin(): void;
+
+  /**
+   * Invoke an EndSpin event.
+   */
+  invokeEndSpinEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndSpin event.
+   */
+  onEndSpinEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Dolly event.
+   */
+  startDolly(): void;
+
+  /**
+   * Invoke a StartDolly event.
+   */
+  invokeStartDollyEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartDolly event.
+   */
+  onStartDollyEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Dolly event.
+   */
+  endDolly(): void;
+
+  /**
+   * Invoke an EndDolly event.
+   */
+  invokeEndDollyEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndDolly event.
+   */
+  onEndDollyEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a CameraPose event.
+   */
+  startCameraPose(): void;
+
+  /**
+   * Invoke a StartCameraPose event.
+   */
+  invokeStartCameraPoseEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartCameraPose event.
+   */
+  onStartCameraPoseEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a CameraPose event.
+   */
+  endCameraPose(): void;
+
+  /**
+   * Invoke an EndCameraPose event.
+   */
+  invokeEndCameraPoseEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndCameraPose event.
+   */
+  onEndCameraPoseEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a WindowLevel event.
+   */
+  startWindowLevel(): void;
+
+  /**
+   * Invoke a StartWindowLevel event.
+   */
+  invokeStartWindowLevelEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartWindowLevel event.
+   */
+  onStartWindowLevelEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a WindowLevel event.
+   */
+  endWindowLevel(): void;
+
+  /**
+   * Invoke an EndWindowLevel event.
+   */
+  invokeEndWindowLevelEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndWindowLevel event.
+   */
+  onEndWindowLevelEvent(cb: EventHandler, priority?: number): vtkSubscription;
+  /**
+   * Start a Slice event.
+   */
+  startSlice(): void;
+
+  /**
+   * Invoke a StartSlice event.
+   */
+  invokeStartSliceEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on a StartSlice event.
+   */
+  onStartSliceEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Ends a Slice event.
+   */
+  endSlice(): void;
+
+  /**
+   * Invoke an EndSlice event.
+   */
+  invokeEndSliceEvent(...args: unknown[]): void;
+
+  /**
+   * Registers a callback on an EndSlice event.
+   */
+  onEndSliceEvent(cb: EventHandler, priority?: number): vtkSubscription;
+
+  /**
+   * Handles a keypress.
+   */
+  handleKeyPress(callData: unknown): void;
+}
+
+export interface IInteractorStyleInitialValues {
+  autoAdjustCameraClippingRange?: boolean;
+}
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IInteractorStyleInitialValues
+): void;
+
+export const vtkInteractorStyle: {
+  extend: typeof extend;
+};
+
+export default vtkInteractorStyle;

package/Rendering/Core/PointPicker.js

@@ -13,7 +13,7 @@ function vtkPointPicker(publicAPI, model) {
   publicAPI.intersectWithLine = function (p1, p2, tol, mapper) {
     var tMin = Number.MAX_VALUE;
 
-    if (mapper.isA('vtkImageMapper')) {
+    if (mapper.isA('vtkImageMapper') || mapper.isA('vtkImageArrayMapper')) {
       var pickData = mapper.intersectWithLineForPointPicking(p1, p2);
 
       if (pickData) {

package/Rendering/Core/ScalarBarActor.js

@@ -341,7 +341,7 @@ function vtkScalarBarActorHelper(publicAPI, model) {
 
     return segSize;
   }; // based on all the settins compute a barSegments array
-  // containing the segments opf the scalar bar
+  // containing the segments of the scalar bar
   // each segment contains
   //   corners[4][2]
   //   title - e.g. NaN, Above, ticks
@@ -694,7 +694,9 @@ var newScalarBarActorHelper = macro.newInstance(function (publicAPI, model) {
   model.tmPolyData = vtkPolyData.newInstance();
   model.tmMapper = vtkMapper.newInstance();
   model.tmMapper.setInputData(model.tmPolyData);
-  model.tmTexture = vtkTexture.newInstance();
+  model.tmTexture = vtkTexture.newInstance({
+    resizable: true
+  });
   model.tmTexture.setInterpolate(false);
   model.tmActor = vtkActor.newInstance({
     parentProp: publicAPI

package/Rendering/Core/Texture.d.ts

@@ -1,11 +1,16 @@
 import { vtkAlgorithm } from './../../interfaces';
 
+/**
+ * 
+ * @param {boolean} [resizable] Must be set to true if texture can be resized at run time (default: false)
+ */
 export interface ITextureInitialValues {
 	repeat?: boolean;
 	interpolate?: boolean;
 	edgeClamp?: boolean;
 	imageLoaded?: boolean;
 	mipLevel?: number;
+	resizable?: boolean;
 }
 
 export interface vtkTexture extends vtkAlgorithm {

package/Rendering/Core/Texture.js

@@ -261,7 +261,9 @@ var DEFAULT_VALUES = {
   repeat: false,
   interpolate: false,
   edgeClamp: false,
-  mipLevel: 0
+  mipLevel: 0,
+  resizable: false // must be set at construction time if the texture can be resizable
+
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {

package/Rendering/OpenGL/ImageMapper.js

@@ -55,7 +55,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
 
       model.openGLCamera = model._openGLRenderer.getViewNodeFor(ren.getActiveCamera()); // is slice set by the camera
 
-      if (model.renderable.getSliceAtFocalPoint()) {
+      if (model.renderable.isA('vtkImageMapper') && model.renderable.getSliceAtFocalPoint()) {
         model.renderable.setSliceFromCamera(ren.getActiveCamera());
       }
     }
@@ -495,7 +495,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       type: 'StartEvent'
     });
     model.renderable.update();
-    model.currentInput = model.renderable.getInputData();
+    model.currentInput = model.renderable.getCurrentImage();
     publicAPI.invokeEvent({
       type: 'EndEvent'
     });
@@ -548,6 +548,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       return;
     }
 
+    var dataType = imgScalars.getDataType();
+    var numComp = imgScalars.getNumberOfComponents(); // Re-allocate the texture because vtkOpenGLTexture uses texStorage2D
+    // which makes the texture immutable.
+
+    model.openGLTexture.releaseGraphicsResources(model._openGLRenderWindow);
     var actorProperty = actor.getProperty(); // set interpolation on the texture based on property setting
 
     var iType = actorProperty.getInterpolationType();
@@ -564,8 +569,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.pwfTexture.setMagnificationFilter(Filter.LINEAR);
     }
 
-    var dataType = imgScalars.getDataType();
-    var numComp = imgScalars.getNumberOfComponents();
     var iComps = actorProperty.getIndependentComponents();
     var numIComps = iComps ? numComp : 1;
     var textureHeight = iComps ? 2 * numIComps : 1;
@@ -672,9 +675,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (ijkMode !== model.renderable.getSlicingMode()) {
       // If not IJK slicing, get the IJK slice from the XYZ position/slice
       slice = model.renderable.getSliceAtPosition(slice);
-    }
+    } // Use sub-Slice number/offset if mapper being used is vtkImageArrayMapper,
+    // since this mapper uses a collection of vtkImageData (and not just a single vtkImageData).
+
 
-    var nSlice = Math.round(slice); // Find sliceOffset
+    var nSlice = model.renderable.isA('vtkImageArrayMapper') ? model.renderable.getSubSlice() // get subSlice of the current (possibly multi-frame) image
+    : Math.round(slice); // Find sliceOffset
 
     var ext = image.getExtent();
     var sliceOffset;
@@ -889,6 +895,6 @@ var vtkImageMapper = {
   extend: extend
 }; // Register ourself to OpenGL backend if imported
 
-registerOverride('vtkImageMapper', newInstance);
+registerOverride('vtkAbstractImageMapper', newInstance);
 
 export { vtkImageMapper as default, extend, newInstance };

package/Rendering/OpenGL/PolyDataMapper.js

@@ -1209,7 +1209,9 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       tcoords = model.renderable.getColorCoordinates();
 
       if (!model.internalColorTexture) {
-        model.internalColorTexture = vtkOpenGLTexture.newInstance();
+        model.internalColorTexture = vtkOpenGLTexture.newInstance({
+          resizable: true
+        });
       }
 
       var tex = model.internalColorTexture; // the following 4 lines allow for NPOT textures

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -96,6 +96,11 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 */
 	getFramebufferSize(): Vector2;
 
+	/**
+	 * Get the webgl canvas.
+	 */
+	getCanvas(): Nullable<HTMLCanvasElement>;
+
 	/**
 	 * Check if a point is in the viewport.
 	 * @param {Number} x The x coordinate.
@@ -269,8 +274,10 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * @param {VtkDataTypes} vtktype 
 	 * @param {Number} numComps 
 	 * @param {Boolean} useFloat 
+	 * @param {unknown} oglNorm16Ext The WebGL EXT_texture_norm16 extension context
+	 * @param {Boolean} useHalfFloat
 	 */
-	getDefaultTextureInternalFormat(vtktype: VtkDataTypes, numComps: number, oglNorm16Ext?: unknown): void;
+	getDefaultTextureInternalFormat(vtktype: VtkDataTypes, numComps: number, oglNorm16Ext?: unknown, useHalfFloat?: boolean): void;
 
 	/**
 	 * 

package/Rendering/OpenGL/RenderWindow.js

@@ -541,6 +541,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
   publicAPI.getDefaultTextureInternalFormat = function (vtktype, numComps) {
     var oglNorm16Ext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+    var useHalfFloat = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
 
     if (model.webgl2) {
       switch (vtktype) {
@@ -560,7 +561,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
               return model.context.RGBA8;
           }
 
-        case oglNorm16Ext && VtkDataTypes.UNSIGNED_SHORT:
+        case oglNorm16Ext && !useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           switch (numComps) {
             case 1:
               return oglNorm16Ext.R16_EXT;
@@ -578,7 +579,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
         // prioritize norm16 over float
 
-        case oglNorm16Ext && VtkDataTypes.SHORT:
+        case oglNorm16Ext && !useHalfFloat && VtkDataTypes.SHORT:
           switch (numComps) {
             case 1:
               return oglNorm16Ext.R16_SNORM_EXT;

package/Rendering/OpenGL/Texture.js

@@ -311,7 +311,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.getDefaultInternalFormat = function (vtktype, numComps) {
     var result = 0; // try default next
 
-    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext);
+    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext, model.useHalfFloat);
 
     if (result) {
       return result;
@@ -401,10 +401,10 @@ function vtkOpenGLTexture(publicAPI, model) {
         // prefer norm16 since that is accurate compared to
         // half float which is not
 
-        case model.oglNorm16Ext && VtkDataTypes.SHORT:
+        case model.oglNorm16Ext && !model.useHalfFloat && VtkDataTypes.SHORT:
           return model.context.SHORT;
 
-        case model.oglNorm16Ext && VtkDataTypes.UNSIGNED_SHORT:
+        case model.oglNorm16Ext && !model.useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           return model.context.UNSIGNED_SHORT;
         // use half float type
 
@@ -728,7 +728,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.create2DFromRaw = function (width, height, numComps, dataType, data) {
     var flip = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;
     // Now determine the texture parameters using the arguments.
-    publicAPI.getOpenGLDataType(dataType);
+    publicAPI.getOpenGLDataType(dataType, true);
     publicAPI.getInternalFormat(dataType, numComps);
     publicAPI.getFormat(dataType, numComps);
 
@@ -756,7 +756,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     model.context.pixelStorei(model.context.UNPACK_FLIP_Y_WEBGL, flip);
     model.context.pixelStorei(model.context.UNPACK_ALIGNMENT, 1);
 
-    if (model._openGLRenderWindow.getWebgl2()) {
+    if (model._openGLRenderWindow.getWebgl2() && !model.resizable) {
       model.context.texStorage2D(model.target, 1, model.internalFormat, model.width, model.height);
 
       if (scaledData[0] != null) {
@@ -830,7 +830,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     model.context.pixelStorei(model.context.UNPACK_ALIGNMENT, 1);
 
-    if (model._openGLRenderWindow.getWebgl2()) {
+    if (model._openGLRenderWindow.getWebgl2() && !model.resizable) {
       model.context.texStorage2D(model.target, 6, model.internalFormat, model.width, model.height);
     } // We get the 6 images
 
@@ -851,7 +851,7 @@ function vtkOpenGLTexture(publicAPI, model) {
           tempData = invertedData[6 * j + _i3];
         }
 
-        if (model._openGLRenderWindow.getWebgl2()) {
+        if (model._openGLRenderWindow.getWebgl2() && !model.resizable) {
           if (tempData != null) {
             model.context.texSubImage2D(model.context.TEXTURE_CUBE_MAP_POSITIVE_X + _i3, j, 0, 0, w, h, model.format, model.openGLDataType, tempData);
           }
@@ -907,7 +907,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     model.context.pixelStorei(model.context.UNPACK_ALIGNMENT, 1);
 
-    if (model._openGLRenderWindow.getWebgl2()) {
+    if (model._openGLRenderWindow.getWebgl2() && !model.resizable) {
       model.context.texStorage2D(model.target, 1, model.internalFormat, model.width, model.height);
 
       if (data != null) {
@@ -962,7 +962,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height);
     var safeImage = canvas;
 
-    if (model._openGLRenderWindow.getWebgl2()) {
+    if (model._openGLRenderWindow.getWebgl2() && !model.resizable) {
       model.context.texStorage2D(model.target, 1, model.internalFormat, model.width, model.height);
 
       if (safeImage != null) {
@@ -1148,9 +1148,10 @@ function vtkOpenGLTexture(publicAPI, model) {
         computedScale = _computeScaleOffsets.scale;
 
     model.volumeInfo.dataComputedScale = computedScale;
-    model.volumeInfo.dataComputedOffset = computedOffset; // if we can use norm16, there is no need to use halfFloat then
+    model.volumeInfo.dataComputedOffset = computedOffset; // preferSizeOverAccuracy will override norm16 due to bug with norm16 implementation
+    // https://bugs.chromium.org/p/chromium/issues/detail?id=1408247
 
-    model.useHalfFloat = model.oglNorm16Ext ? false : checkUseHalfFloat(dataType, computedOffset, computedScale, preferSizeOverAccuracy); // since our default is to use half float, in case that we can't use it
+    model.useHalfFloat = checkUseHalfFloat(dataType, computedOffset, computedScale, preferSizeOverAccuracy); // since our default is to use half float, in case that we can't use it
     // we need to use another type
 
     if (!model.useHalfFloat) {
@@ -1159,11 +1160,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
 
     if (model._openGLRenderWindow.getWebgl2()) {
-      if (dataType === VtkDataTypes.FLOAT || model.useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
-        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
-      }
-
-      if (model.oglNorm16Ext && dataType === VtkDataTypes.SHORT) {
+      if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.SHORT) {
         for (var _c3 = 0; _c3 < numComps; ++_c3) {
           model.volumeInfo.scale[_c3] = 32767.0;
         }
@@ -1171,7 +1168,7 @@ function vtkOpenGLTexture(publicAPI, model) {
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
       }
 
-      if (model.oglNorm16Ext && dataType === VtkDataTypes.UNSIGNED_SHORT) {
+      if (model.oglNorm16Ext && !model.useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
         for (var _c4 = 0; _c4 < numComps; ++_c4) {
           model.volumeInfo.scale[_c4] = 65535.0;
         }
@@ -1179,6 +1176,10 @@ function vtkOpenGLTexture(publicAPI, model) {
         return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
       }
 
+      if (dataType === VtkDataTypes.FLOAT || model.useHalfFloat && (dataType === VtkDataTypes.SHORT || dataType === VtkDataTypes.UNSIGNED_SHORT)) {
+        return publicAPI.create3DFromRaw(width, height, depth, numComps, dataType, data);
+      }
+
       if (dataType === VtkDataTypes.UNSIGNED_CHAR) {
         for (var _c5 = 0; _c5 < numComps; ++_c5) {
           model.volumeInfo.scale[_c5] = 255.0;
@@ -1341,7 +1342,7 @@ function vtkOpenGLTexture(publicAPI, model) {
 
     model.context.pixelStorei(model.context.UNPACK_ALIGNMENT, 1);
 
-    if (model._openGLRenderWindow.getWebgl2()) {
+    if (model._openGLRenderWindow.getWebgl2() && !model.resizable) {
       model.context.texStorage2D(model.target, 1, model.internalFormat, model.width, model.height);
 
       if (newArray != null) {