@kitware/vtk.js 33.0.0-beta.2 → 33.0.0-beta.3

package/IO/XML/XMLPolyDataWriter.js

@@ -36,6 +36,7 @@ function vtkXMLPolyDataWriter(publicAPI, model) {
     });
     publicAPI.processDataSetAttributes(piece, 'PointData', dataObject.getPointData());
     publicAPI.processDataSetAttributes(piece, 'CellData', dataObject.getCellData());
+    publicAPI.processDataSetAttributes(piece, 'FieldData', dataObject.getFieldData());
     publicAPI.processDataArray(piece.ele('Points'), dataObject.getPoints());
     POLYDATA_FIELDS.forEach(cellType => {
       const cellTypeName = camelize(cellType);

package/Interaction/Manipulators/MouseCameraTrackballRollManipulator.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkCompositeCameraManipulator from './CompositeCameraManipulator.js';
 import vtkCompositeMouseManipulator from './CompositeMouseManipulator.js';
-import { r as radiansFromDegrees, C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { r as radiansFromDegrees, A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 
 // ----------------------------------------------------------------------------
 // vtkMouseCameraTrackballRollManipulator methods

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkInteractorStyle from '../../Rendering/Core/InteractorStyle.js';
 import vtkInteractorStyleConstants from '../../Rendering/Core/InteractorStyle/Constants.js';
-import { C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import { Device, Input } from '../../Rendering/Core/RenderWindowInteractor/Constants.js';
 
 const {

package/Rendering/Core/Glyph3DMapper.d.ts

@@ -12,11 +12,11 @@ interface IPrimitiveCount {
 export interface IGlyph3DMapperInitialValues extends IMapperInitialValues {
   orient?: boolean;
   orientationMode?: OrientationModes;
-  orientationArray?: number[];
+  orientationArray?: string;
   scaling?: boolean;
   scaleFactor?: number;
   scaleMode?: ScaleModes;
-  scaleArray?: number[];
+  scaleArray?: string;
   matrixArray?: number[];
   normalArray?: number[];
   colorArray?: number[];
@@ -24,29 +24,26 @@ export interface IGlyph3DMapperInitialValues extends IMapperInitialValues {
 
 export interface vtkGlyph3DMapper extends vtkMapper {
   /**
-   * An orientation array is a vtkDataArray with 3 components. The first
-   * component is the angle of rotation along the X axis. The second component
-   * is the angle of rotation along the Y axis. The third component is the
-   * angle of rotation along the Z axis. Orientation is specified in X,Y,Z
-   * order but the rotations are performed in Z,X an Y.
-   *
-   * This definition is compliant with SetOrientation method on vtkProp3D.
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBounds(): Bounds;
+
+  /**
    *
-   * By using vector or normal there is a degree of freedom or rotation left
-   * (underconstrained). With the orientation array, there is no degree of
-   * freedom left.
    */
-  getOrientationMode(): OrientationModes;
+  buildArrays(): void;
 
   /**
-   * Get orientation as string
+   *
    */
-  getOrientationModeAsString(): string;
+  getPrimitiveCount(): IPrimitiveCount;
 
   /**
-   * Get orientation as array
+   * Get scale mode
+   * @default `SCALE_BY_MAGNITUDE`
    */
-  getOrientationArrayData(): number[];
+  getScaleMode(): ScaleModes;
 
   /**
    * Get scale factor to scale object by.
@@ -54,15 +51,20 @@ export interface vtkGlyph3DMapper extends vtkMapper {
   getScaleFactor(): number;
 
   /**
-   * Get scale mode
-   * @default `SCALE_BY_MAGNITUDE`
+   * Get scale mode as string
    */
-  getScaleMode(): ScaleModes;
+  getScaleModeAsString(): string;
 
   /**
-   * Get scale mode as string
+   * Sets the name of the array to use as scale values.
+   * @param {String} arrayName Name of the array
    */
-  getScaleModeAsString(): string;
+  setScaleArray(arrayName: Nullable<string>): boolean;
+
+  /**
+   * Gets the name of the array used as scale values.
+   */
+  getScaleArray(): string;
 
   /**
    * Get scale mode as array
@@ -70,20 +72,29 @@ export interface vtkGlyph3DMapper extends vtkMapper {
   getScaleArrayData(): number[];
 
   /**
-   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-   * @return {Bounds} The bounds for the mapper.
+   * An orientation array is a vtkDataArray with 3 components. The first
+   * component is the angle of rotation along the X axis. The second component
+   * is the angle of rotation along the Y axis. The third component is the
+   * angle of rotation along the Z axis. Orientation is specified in X,Y,Z
+   * order but the rotations are performed in Z,X an Y.
+   *
+   * This definition is compliant with SetOrientation method on vtkProp3D.
+   *
+   * By using vector or normal there is a degree of freedom or rotation left
+   * (underconstrained). With the orientation array, there is no degree of
+   * freedom left.
    */
-  getBounds(): Bounds;
+  getOrientationMode(): OrientationModes;
 
   /**
-   *
+   * Get orientation as string
    */
-  buildArrays(): void;
+  getOrientationModeAsString(): string;
 
   /**
-   *
+   * Get orientation as array
    */
-  getPrimitiveCount(): IPrimitiveCount;
+  getOrientationArrayData(): number[];
 
   /**
    * Sets the name of the array to use as orientation.
@@ -91,6 +102,11 @@ export interface vtkGlyph3DMapper extends vtkMapper {
    */
   setOrientationArray(arrayName: Nullable<string>): boolean;
 
+  /**
+   * Gets the name of the array used as orientation values.
+   */
+  getOrientationArray(): string;
+
   /**
    * Orientation mode indicates if the OrientationArray provides the direction
    * vector for the orientation or the rotations around each axes.

package/Rendering/Core/ImageCPRMapper.js

@@ -1,4 +1,4 @@
-import { vec3, mat4, quat } from 'gl-matrix';
+import { quat, vec3, mat4 } from 'gl-matrix';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { m as macro } from '../../macros2.js';

package/Rendering/Core/ImageProperty.d.ts

@@ -94,6 +94,28 @@ export interface vtkImageProperty extends vtkObject {
    */
   getScalarOpacity(idx?: number): vtkPiecewiseFunction;
 
+  /**
+   * Enable label outline rendering.
+   * @param {Boolean} useLabelOutline
+   */
+  setUseLabelOutline(useLabelOutline: boolean): boolean;
+
+  /**
+   * Check if label outline rendering.
+   */
+  getUseLabelOutline(): boolean;
+
+  /**
+   * Set the 0 to 1 opacity of the label outline.
+   * @param {Number} opacity
+   */
+  setLabelOutlineOpacity(opacity: number): boolean;
+
+  /**
+   * Get the 0 to 1 opacity of the label outline.
+   */
+  getLabelOutlineOpacity(): number;
+
   /**
    * gets the label outline thickness
    */

package/Rendering/Core/PointPicker.js

@@ -80,6 +80,9 @@ function vtkPointPicker(publicAPI, model) {
             if (maxDist <= tolerance && maxDist < minPtDist) {
               // within tolerance
               minPtId = ptId;
+              x[0];
+              x[1];
+              x[2];
               minPtDist = maxDist;
               tMin = t;
             }
@@ -108,13 +111,19 @@ function vtkPointPicker(publicAPI, model) {
           if (maxDist <= tolerance && maxDist < minPtDist) {
             // within tolerance
             minPtId = ptId;
+            x[0];
+            x[1];
+            x[2];
             minPtDist = maxDist;
             tMin = t;
           }
         }
       }
     }
-    model.pointId = minPtId;
+    if (minPtId > -1 && tMin < model.globalTMin) {
+      model.globalTMin = tMin;
+      model.pointId = minPtId;
+    }
     return tMin;
   };
 }

package/Rendering/Core/Prop3D.js

@@ -1,7 +1,7 @@
 import { mat4, quat } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
-import { C as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians, r as radiansFromDegrees, a as areMatricesEqual } from '../../Common/Core/Math/index.js';
 import vtkProp from './Prop.js';
 
 const VTK_EPSILON = 1e-6;

package/Rendering/Core/RenderWindowInteractor.d.ts

@@ -63,7 +63,7 @@ export interface IRenderWindowInteractorInitialValues {
   mouseScrollDebounceByPass?: boolean;
 }
 
-interface IPosition {
+export interface IPosition {
   type: string;
 }
 

package/Rendering/Core/RenderWindowInteractor.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { C as degreesFromRadians } from '../../Common/Core/Math/index.js';
+import { A as degreesFromRadians } from '../../Common/Core/Math/index.js';
 import Constants from './RenderWindowInteractor/Constants.js';
 
 const {

package/Rendering/Misc/CanvasView.js

@@ -134,8 +134,10 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues);
 
   // Create internal instances
-  model.canvas = document.createElement('canvas');
-  model.canvas.style.width = '100%';
+  if (!model.canvas) {
+    model.canvas = document.createElement('canvas');
+    model.canvas.style.width = '100%';
+  }
 
   // Create internal bgImage
   model.bgImage = new Image();

package/Rendering/Misc/RemoteView.d.ts

@@ -13,21 +13,27 @@ interface IRemoteViewInitialValues {
   rpcGestureEvent?: any;
   rpcWheelEvent?: any;
   viewStream?: vtkViewStream;
+  canvasElement?: HTMLCanvasElement;
 }
 
 export interface vtkRemoteView extends vtkObject {
   /**
-   * Get container element
+   * Get container HTML element
    */
   getContainer(): HTMLElement;
 
   /**
-   *
+   * Get vtkViewStream object
    */
   getViewStream(): vtkViewStream;
 
   /**
-   *
+   * Get the canvas HTML element
+   */
+  getCanvasElement(): HTMLCanvasElement;
+
+  /**
+   * Get the vtkCanvasView object
    */
   getCanvasView(): vtkCanvasView;
 

package/Rendering/Misc/RemoteView.js

@@ -17,7 +17,9 @@ function vtkRemoteView(publicAPI, model) {
   model.classHierarchy.push('vtkRemoteView');
 
   // Constructor
-  model.canvasView = vtkCanvasView.newInstance();
+  model.canvasView = vtkCanvasView.newInstance({
+    canvas: model.canvasElement
+  });
   model.interactorStyle = vtkInteractorStyleRemoteMouse.newInstance();
   model.interactor = vtkRenderWindowInteractor.newInstance();
   model.interactor.setView(model.canvasView);
@@ -60,6 +62,7 @@ function vtkRemoteView(publicAPI, model) {
       model.viewStream.delete();
     }
   }, publicAPI.delete);
+  publicAPI.getCanvasElement = () => model.canvasView.getCanvas();
 
   // --------------------------------------------------------------------------
   // remote handing
@@ -194,7 +197,8 @@ const DEFAULT_VALUES = {
   stillRatio: 1,
   rpcMouseEvent: 'viewport.mouse.interaction',
   rpcGestureEvent: null,
-  rpcWheelEvent: null
+  rpcWheelEvent: null,
+  canvasElement: null
 };
 
 // ----------------------------------------------------------------------------
@@ -203,7 +207,7 @@ function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['container', 'viewStream', 'canvasView', 'interactor', 'interactorStyle', 'interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio']);
+  macro.get(publicAPI, model, ['container', 'viewStream', 'canvasView', 'interactor', 'interactorStyle', 'interactiveQuality', 'interactiveRatio', 'stillQuality', 'stillRatio', 'canvasElement']);
   macro.setGet(publicAPI, model, ['session', 'rpcMouseEvent', 'rpcGestureEvent', 'rpcWheelEvent']);
 
   // Object methods

package/Rendering/Misc/SynchronizableRenderWindow/ObjectManager.d.ts

@@ -1,6 +1,6 @@
 import { vtkObject } from './../../../interfaces';
 import { Nullable } from './../../../types';
-import { ISynchronizerContext, IViewState } from '..';
+import { ISynchronizerContext, IViewState } from '../SynchronizableRenderWindow';
 
 export type BuilderFunction = <T extends vtkObject>(
   type: string,

package/Rendering/OpenGL/ImageMapper.js

@@ -167,9 +167,9 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // check for the outline thickness and opacity
     const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
     if (vtkImageLabelOutline === true) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;', 'uniform int sliceAxis;']).result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ImageLabelOutlineOn', '#define vtkImageLabelOutlineOn').result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', '#endif']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', 'vec2 getSliceCoords(vec3 coord, int axis) {', '  if (axis == 0) return coord.yz;', '  if (axis == 1) return coord.xz;', '  if (axis == 2) return coord.xy;', '}', '#endif']).result;
     }
     if (iComps) {
       const rgba = ['r', 'g', 'b', 'a'];
@@ -201,7 +201,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', [...splitStringOnEnter(`
                 #ifdef vtkImageLabelOutlineOn
                   vec3 centerPosIS = fragCoordToIndexSpace(gl_FragCoord);
-                  float centerValue = texture2D(texture1, centerPosIS.xy).r;
+                  float centerValue = texture2D(texture1, getSliceCoords(centerPosIS, sliceAxis)).r;
                   bool pixelOnBorder = false;
                   vec3 tColor = texture2D(colorTexture1, vec2(centerValue * cscale0 + cshift0, 0.5)).rgb;
                   float scalarOpacity = texture2D(pwfTexture1, vec2(centerValue * pwfscale0 + pwfshift0, 0.5)).r;
@@ -212,7 +212,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                   int actualThickness = int(textureValue * 255.0);
 
                   if (segmentIndex == 0){
-                    gl_FragData[0] = vec4(0.0, 1.0, 1.0, 0.0);
+                    gl_FragData[0] = vec4(0.0, 0.0, 0.0, 0.0);
                     return;
                   }
 
@@ -225,7 +225,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                         gl_FragCoord.y + float(j),
                         gl_FragCoord.z, gl_FragCoord.w);
                       vec3 neighborPosIS = fragCoordToIndexSpace(neighborPixelCoord);
-                      float value = texture2D(texture1, neighborPosIS.xy).r;
+                      float value = texture2D(texture1, getSliceCoords(neighborPosIS, sliceAxis)).r;
                       if (value != centerValue) {
                         pixelOnBorder = true;
                         break;
@@ -474,7 +474,14 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (vtkImageLabelOutline === true) {
       const worldToIndex = image.getWorldToIndex();
       const imageDimensions = image.getDimensions();
-      program.setUniform3i('imageDimensions', imageDimensions[0], imageDimensions[1], 1);
+      let sliceAxis = model.renderable.getClosestIJKAxis().ijkMode;
+
+      // SlicingMode.NONE equates to SlicingMode.K
+      if (sliceAxis === SlicingMode.NONE) {
+        sliceAxis = SlicingMode.K;
+      }
+      program.setUniform3i('imageDimensions', imageDimensions[0], imageDimensions[1], imageDimensions[2]);
+      program.setUniformi('sliceAxis', sliceAxis);
       program.setUniformMatrix('vWCtoIDX', worldToIndex);
       const labelOutlineKeyMats = model.openGLCamera.getKeyMatrices(ren);
 
@@ -896,7 +903,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
   };
   publicAPI.updatelabelOutlineThicknessTexture = image => {
-    const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThickness();
+    const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThicknessByReference();
     const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineThicknessArray);
 
     // compute the join of the labelOutlineThicknessArray so that

package/Rendering/OpenGL/Texture/supportsNorm16Linear.js

@@ -0,0 +1,97 @@
+/**
+ * Even when the EXT_texture_norm16 extension is present, linear filtering
+ * might not be supported for normalized fixed point textures.
+ *
+ * This is a driver bug. See https://github.com/KhronosGroup/WebGL/issues/3706
+ * @return {boolean}
+ */
+function supportsNorm16Linear() {
+  try {
+    const canvasSize = 4;
+    const texWidth = 2;
+    const texHeight = 1;
+    const texData = new Int16Array([0, 2 ** 15 - 1]);
+    const pixelToCheck = [1, 1];
+    const canvas = document.createElement('canvas');
+    canvas.width = canvasSize;
+    canvas.height = canvasSize;
+    const gl = canvas.getContext('webgl2');
+    if (!gl) {
+      return false;
+    }
+    const ext = gl.getExtension('EXT_texture_norm16');
+    if (!ext) {
+      return false;
+    }
+    const vs = `#version 300 es
+    void main() {
+      gl_PointSize = ${canvasSize.toFixed(1)};
+      gl_Position = vec4(0, 0, 0, 1);
+    }
+  `;
+    const fs = `#version 300 es
+    precision highp float;
+    precision highp int;
+    precision highp sampler2D;
+
+    uniform sampler2D u_image;
+
+    out vec4 color;
+
+    void main() {
+        vec4 intColor = texture(u_image, gl_PointCoord.xy);
+        color = vec4(vec3(intColor.rrr), 1);
+    }
+    `;
+    const vertexShader = gl.createShader(gl.VERTEX_SHADER);
+    gl.shaderSource(vertexShader, vs);
+    gl.compileShader(vertexShader);
+    if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
+      return false;
+    }
+    const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
+    gl.shaderSource(fragmentShader, fs);
+    gl.compileShader(fragmentShader);
+    if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
+      return false;
+    }
+    const program = gl.createProgram();
+    gl.attachShader(program, vertexShader);
+    gl.attachShader(program, fragmentShader);
+    gl.linkProgram(program);
+    if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+      return false;
+    }
+    const tex = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texImage2D(gl.TEXTURE_2D, 0, ext.R16_SNORM_EXT, texWidth, texHeight, 0, gl.RED, gl.SHORT, texData);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.useProgram(program);
+    gl.drawArrays(gl.POINTS, 0, 1);
+    const pixel = new Uint8Array(4);
+    gl.readPixels(pixelToCheck[0], pixelToCheck[1], 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, pixel);
+    const [r, g, b] = pixel;
+    const webglLoseContext = gl.getExtension('WEBGL_lose_context');
+    if (webglLoseContext) {
+      webglLoseContext.loseContext();
+    }
+    return r === g && g === b && r !== 0;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * @type {boolean | undefined}
+ */
+let supportsNorm16LinearCache;
+function supportsNorm16LinearCached() {
+  // Only create a canvas+texture+shaders the first time
+  if (supportsNorm16LinearCache === undefined) {
+    supportsNorm16LinearCache = supportsNorm16Linear();
+  }
+  return supportsNorm16LinearCache;
+}
+
+export { supportsNorm16LinearCached as default };

package/Rendering/OpenGL/Texture.js

@@ -5,6 +5,7 @@ import vtkDataArray from '../../Common/Core/DataArray.js';
 import { V as isPowerOfTwo, R as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import supportsNorm16LinearCached from './Texture/supportsNorm16Linear.js';
 
 const {
   Wrap,
@@ -133,6 +134,12 @@ function vtkOpenGLTexture(publicAPI, model) {
       publicAPI.activate();
     }
   };
+  const getNorm16Ext = () => {
+    if ((model.minificationFilter === Filter.LINEAR || model.magnificationFilter === Filter.LINEAR) && !supportsNorm16LinearCached()) {
+      return undefined;
+    }
+    return model.oglNorm16Ext;
+  };
 
   //----------------------------------------------------------------------------
   publicAPI.destroyTexture = () => {
@@ -285,7 +292,7 @@ function vtkOpenGLTexture(publicAPI, model) {
   publicAPI.getDefaultInternalFormat = (vtktype, numComps) => {
     let result = 0;
     // try default next
-    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    result = model._openGLRenderWindow.getDefaultTextureInternalFormat(vtktype, numComps, getNorm16Ext(), publicAPI.useHalfFloat());
     if (result) {
       return result;
     }
@@ -364,9 +371,9 @@ function vtkOpenGLTexture(publicAPI, model) {
           return model.context.UNSIGNED_BYTE;
         // prefer norm16 since that is accurate compared to
         // half float which is not
-        case model.oglNorm16Ext && !useHalfFloat && VtkDataTypes.SHORT:
+        case getNorm16Ext() && !useHalfFloat && VtkDataTypes.SHORT:
           return model.context.SHORT;
-        case model.oglNorm16Ext && !useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
+        case getNorm16Ext() && !useHalfFloat && VtkDataTypes.UNSIGNED_SHORT:
           return model.context.UNSIGNED_SHORT;
         // use half float type
         case useHalfFloat && VtkDataTypes.SHORT:
@@ -659,7 +666,7 @@ function vtkOpenGLTexture(publicAPI, model) {
       }
       if (model._openGLRenderWindow.getWebgl2()) {
         const webGLInfo = model._openGLRenderWindow.getGLInformations();
-        if (webGLInfo.RENDERER.value.match(/WebKit/gi) && navigator.platform.match(/Mac/gi) && model.oglNorm16Ext && (dataType === VtkDataTypes.UNSIGNED_SHORT || dataType === VtkDataTypes.SHORT)) {
+        if (webGLInfo.RENDERER.value.match(/WebKit/gi) && navigator.platform.match(/Mac/gi) && getNorm16Ext() && (dataType === VtkDataTypes.UNSIGNED_SHORT || dataType === VtkDataTypes.SHORT)) {
           // Cannot use texStorage with EXT_texture_norm16 textures on Mac M1 GPU.
           // No errors reported but the texture is unusable.
           return false;
@@ -717,7 +724,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (flip) {
       model.context.pixelStorei(model.context.UNPACK_FLIP_Y_WEBGL, false);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -795,7 +802,7 @@ function vtkOpenGLTexture(publicAPI, model) {
         h /= 2;
       }
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * numComps * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, getNorm16Ext(), publicAPI.useHalfFloat());
     // generateMipmap must not be called here because we manually upload all levels
     // if it is called, all levels will be overwritten
 
@@ -845,7 +852,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataType, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -895,7 +902,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(VtkDataTypes.UNSIGNED_CHAR, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(VtkDataTypes.UNSIGNED_CHAR, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };
@@ -1013,7 +1020,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
 
     // Handle SHORT data type with EXT_texture_norm16 extension
-    if (model.oglNorm16Ext && !useHalfFloat && dataType === VtkDataTypes.SHORT) {
+    if (getNorm16Ext() && !useHalfFloat && dataType === VtkDataTypes.SHORT) {
       for (let c = 0; c < numComps; ++c) {
         model.volumeInfo.scale[c] = 32767.0; // Scale to [-1, 1] range
       }
@@ -1022,7 +1029,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     }
 
     // Handle UNSIGNED_SHORT data type with EXT_texture_norm16 extension
-    if (model.oglNorm16Ext && !useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
+    if (getNorm16Ext() && !useHalfFloat && dataType === VtkDataTypes.UNSIGNED_SHORT) {
       for (let c = 0; c < numComps; ++c) {
         model.volumeInfo.scale[c] = 65535.0; // Scale to [0, 1] range
       }
@@ -1112,7 +1119,7 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (model.generateMipmap) {
       model.context.generateMipmap(model.target);
     }
-    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataTypeToUse, model.oglNorm16Ext, publicAPI.useHalfFloat());
+    model.allocatedGPUMemoryInBytes = model.width * model.height * model.depth * model.components * model._openGLRenderWindow.getDefaultTextureByteSize(dataTypeToUse, getNorm16Ext(), publicAPI.useHalfFloat());
     publicAPI.deactivate();
     return true;
   };

package/Widgets/Widgets3D/AngleWidget/behavior.js

@@ -1,5 +1,6 @@
 import { m as macro } from '../../../macros2.js';
 import { k as add } from '../../../Common/Core/Math/index.js';
+import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkPointPicker from '../../../Rendering/Core/PointPicker.js';
 
 const MAX_POINTS = 3;
@@ -8,6 +9,7 @@ function widgetBehavior(publicAPI, model) {
   model._isDragging = false;
   const picker = vtkPointPicker.newInstance();
   picker.setPickFromList(1);
+  publicAPI.getBounds = () => model.widgetState.getHandleList().reduce((bounds, handle) => vtkBoundingBox.inflate(vtkBoundingBox.addPoint(bounds, ...handle.getOrigin()), publicAPI.getScaleInPixels() ? 0 : handle.getScale1() / 2), [...vtkBoundingBox.INIT_BOUNDS]);
 
   // --------------------------------------------------------------------------
   // Display 2D

package/Widgets/Widgets3D/InteractiveOrientationWidget.js

@@ -2,7 +2,7 @@ import { m as macro } from '../../macros2.js';
 import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkConvexFaceContextRepresentation from '../Representations/ConvexFaceContextRepresentation.js';
 import widgetBehavior from './InteractiveOrientationWidget/behavior.js';
-import { generateState, INITIAL_POINTS } from './InteractiveOrientationWidget/state.js';
+import { INITIAL_POINTS, generateState } from './InteractiveOrientationWidget/state.js';
 import { Behavior } from '../Representations/WidgetRepresentation/Constants.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';