@kitware/vtk.js 26.7.0 → 26.8.1

package/Common/DataModel/SelectionNode/Constants.d.ts

@@ -0,0 +1,27 @@
+export declare enum SelectionContent {
+    GLOBALIDS = 0,
+    PEDIGREEIDS = 1,
+    VALUES = 2,
+    INDICES = 3,
+    FRUSTUM = 4,
+    LOCATIONS = 5,
+    THRESHOLDS = 6,
+    BLOCKS = 7,
+    QUERY = 8,
+}
+
+export declare enum SelectionField {
+    CELL = 0,
+    POINT = 1,
+    FIELD = 2,
+    VERTEX = 3,
+    EDGE = 4,
+    ROW = 5,
+}
+
+declare const _default: {
+    SelectionContent: typeof SelectionContent;
+    SelectionField: typeof SelectionField;
+}
+
+export default _default;

package/Common/DataModel/SelectionNode.d.ts

@@ -1,35 +1,70 @@
 import { vtkObject } from './../../interfaces' ;
 import { Bounds } from './../../types';
+import { SelectionContent, SelectionField } from './SelectionNode/Constants';
+import vtkProp from './../../Rendering/Core/Prop';
 
-export enum SelectionContent {
-	GLOBALIDS,
-	PEDIGREEIDS,
-	VALUES,
-	INDICES,
-	FRUSTUM,
-	LOCATIONS,
-	THRESHOLDS,
-	BLOCKS,
-	QUERY,
+export interface ISelectionNodeInitialValues {
+	contentType?: SelectionContent;
+	fieldType?: SelectionField;
+	properties?: ISelectionNodeProperties;
+	selectionList?: number[];
 }
 
-export enum SelectionField {
-	CELL,
-	POINT,
-	FIELD,
-	VERTEX,
-	EDGE,
-	ROW,
+export interface ISelectionNodeProperties {
+	propID?: number;
+	prop?: vtkProp;
+	compositeID?: number;
+	attributeID?: number;
+	pixelCount?: number;
+	displayPosition?: [number, number, number];
+	worldPosition?: [number, number, number];
 }
 
-export interface ISelectionNodeInitialValues {}
-
 export interface vtkSelectionNode extends vtkObject {
-	
 	/**
-	 * 
+	 * Get the bounds of the selection points.
 	 */
 	getBounds(): Bounds;
+
+	/**
+	 * Returns -1 if not initialized.
+	 */
+	getContentType(): SelectionContent | -1;
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setContentType(contentType: SelectionContent): void;
+
+	/**
+	 * Returns -1 if not initialized.
+	 */
+	getFieldType(): SelectionField | -1;
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setFieldType(fieldType: SelectionField): void;
+
+	/**
+	 * Get the selection properties.
+	 */
+	getProperties(): ISelectionNodeProperties;
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setProperties(properties: ISelectionNodeProperties);
+	
+	/**
+	 * Get the list of the underlying selected attribute IDs.
+	 */
+	getSelectionList(): number[];
+
+	/**
+	 * This functions is called internally by VTK.js and is not intended for public use.
+	 */
+	setSelectionList(selectionAttributeIDs: ISelectionNodeProperties);
 }
 
 /**
@@ -57,5 +92,7 @@ export function newInstance(initialValues?: ISelectionNodeInitialValues): vtkSel
 export declare const vtkSelectionNode: {
 	newInstance: typeof newInstance,
 	extend: typeof extend;
+	SelectionContent: typeof SelectionContent;
+    SelectionField: typeof SelectionField;
 };
 export default vtkSelectionNode;

package/Rendering/Core/ColorTransferFunction.d.ts

@@ -1,10 +1,9 @@
 import vtkDataArray from './../../Common/Core/DataArray';
-import { vtkObject } from './../../interfaces';
+import vtkScalarsToColors from './../../Common/Core/ScalarsToColors'
 import { ColorSpace, Scale } from './ColorTransferFunction/Constants';
 
 
-/* TODO: use VtkScalarsToColors instead of VtkObject */
-export interface vtkColorTransferFunction extends vtkObject {
+export interface vtkColorTransferFunction extends vtkScalarsToColors {
   /**
    * Add a point defined in RGB
    * @param {Number} x The index of the point.
@@ -270,13 +269,6 @@ export interface vtkColorTransferFunction extends vtkObject {
    */
   fillFromDataPointer(nb: number, ptr: any): void;
 
-  /**
-   * Set the range of scalars being mapped.
-   * @param {Number} min
-   * @param {Number} max
-   */
-  setMappingRange(min: number, max: number): void;
-
   /**
    * Remove all points out of the new range, and make sure there is a point at
    * each end of that range.

package/Rendering/Core/Mapper.d.ts

@@ -485,6 +485,10 @@ export interface vtkMapper extends vtkAbstractMapper3D {
 	 *
 	 */
 	setInterpolateScalarsBeforeMapping(interpolateScalarsBeforeMapping: boolean): boolean;
+
+	setResolveCoincidentTopologyToPolygonOffset(): boolean;
+
+	setResolveCoincidentTopologyToOff(): boolean;
 }
 
 /**

package/Rendering/Core/RenderWindowInteractor.js

@@ -47,7 +47,9 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
   var animationRequesters = new Set(); // map from pointerId to { pointerId: number, position: [x, y] }
 
-  var pointerCache = new Map(); // Public API methods
+  var pointerCache = new Map(); // Factor to apply on wheel spin.
+
+  var wheelCoefficient = 1; // Public API methods
   //----------------------------------------------------------------------
 
   publicAPI.start = function () {
@@ -622,7 +624,27 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     var callData = _objectSpread(_objectSpread(_objectSpread({}, normalizeWheel(event)), getModifierKeysFor(event)), {}, {
       position: getScreenEventPositionFor(event),
       deviceType: getDeviceTypeFor(event)
-    });
+    }); // Wheel events are thought to scroll pages (i.e. multiple lines at once).
+    // See normalizeWheel() documentation for more context.
+    // While trackpad wheel events are many small (<1) wheel spins,
+    // mouse wheel events have absolute spin values higher than 1.
+    // Here the first spin value is "recorded", and used to normalize
+    // all the following mouse wheel events.
+
+
+    if (model.wheelTimeoutID === 0) {
+      // 0.4 is roughly half-way between a large trackpad first event and small
+      // mouse wheel first event.
+      if (Math.abs(callData.spinY) > 0.4) {
+        // Event is coming from mouse wheel
+        wheelCoefficient = Math.abs(callData.spinY);
+      } else {
+        // Event is coming from trackpad
+        wheelCoefficient = 1;
+      }
+    }
+
+    callData.spinY /= wheelCoefficient;
 
     if (model.wheelTimeoutID === 0) {
       publicAPI.startMouseWheelEvent(callData);

package/Rendering/Core/Renderer.d.ts

@@ -628,6 +628,32 @@ export interface vtkRenderer extends vtkViewport {
 	 * Not Implemented yet
 	 */
 	visibleVolumeCount(): any;
+
+	/**
+     * Set the viewport background.
+	 *
+     * @param {Number} r Defines the red component (between 0 and 1).
+     * @param {Number} g Defines the green component (between 0 and 1).
+     * @param {Number} b Defines the blue component (between 0 and 1).
+     * @param {Number} b Defines the alpha component (between 0 and 1).
+     */
+	setBackground(r: number, g: number, b: number, a: number): boolean;
+
+	/**
+     * Set the viewport background.
+	 *
+     * @param {Number} r Defines the red component (between 0 and 1).
+     * @param {Number} g Defines the green component (between 0 and 1).
+     * @param {Number} b Defines the blue component (between 0 and 1).
+     */
+    setBackground(r: number, g: number, b: number): boolean;
+
+	/**
+     * Set the viewport background.
+	 *
+     * @param {Number[]} background The RGB color array.
+     */
+    setBackground(background: number[]): boolean;
 }
 
 /**

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -151,7 +151,7 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
     // have the forward pass use a texture backed zbuffer
 
     if (forwardPass.getOpaqueActorCount() > 0) {
-      forwardPass.setCurrentOperation('opaquePass');
+      forwardPass.setCurrentOperation('opaqueZBufferPass');
       renNode.traverse(forwardPass);
     }
 

package/Rendering/OpenGL/RenderWindow/Constants.d.ts

@@ -0,0 +1,10 @@
+export declare enum XrSessionTypes {
+	HmdVR = 0,
+	MobileAR = 1,
+  LookingGlassVR = 2
+}
+
+declare const _default: {
+	XrSessionTypes: typeof XrSessionTypes;
+};
+export default _default;

package/Rendering/OpenGL/RenderWindow/Constants.js

@@ -0,0 +1,13 @@
+var XrSessionTypes = {
+  HmdVR: 0,
+  // Head-mounted display (HMD), two-camera virtual reality session
+  MobileAR: 1,
+  // Mobile device, single-camera augmented reality session
+  LookingGlassVR: 2 // Looking Glass hologram display, N-camera virtual reality session
+
+};
+var Constants = {
+  XrSessionTypes: XrSessionTypes
+};
+
+export { XrSessionTypes, Constants as default };

package/Rendering/OpenGL/RenderWindow.d.ts

@@ -34,9 +34,9 @@ export interface IOpenGLRenderWindowInitialValues {
 }
 
 export interface ICaptureOptions {
-	resetCamera: boolean;
-	size: Size;
-	scale: number
+	resetCamera?: boolean;
+	size?: Size;
+	scale?: number
 }
 
 export interface I3DContextOptions {
@@ -232,19 +232,34 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	get3DContext(options: I3DContextOptions): Nullable<WebGLRenderingContext>;
 
 	/**
-	 *
+	 * Request an XR session on the user device with WebXR,
+   * typically in response to a user request such as a button press.
 	 */
-	startVR(): void;
+	startXR(): void;
+
+  /**
+   * When an XR session is available, set up the XRWebGLLayer
+   * and request the first animation frame for the device
+   */
+   enterXR(): void,
+
+   /**
+    * Adjust world-to-physical parameters for different viewing modalities
+    *
+    * @param {Number} inputRescaleFactor
+    * @param {Number} inputTranslateZ
+    */
+   resetXRScene(inputRescaleFactor: number, inputTranslateZ: number): void,
 
 	/**
-	 *
+	 * Request to stop the current XR session
 	 */
-	stopVR(): void;
+	stopXR(): void;
 
 	/**
 	 *
 	 */
-	vrRender(): void;
+	xrRender(): void;
 
 	/**
 	 *
@@ -305,7 +320,7 @@ export interface vtkOpenGLRenderWindow extends vtkOpenGLRenderWindowBase {
 	 * @param {String} format
 	 * @param {ICaptureOptions} options
 	 */
-	captureNextImage(format: string, options: ICaptureOptions): Nullable<Promise<string>>;
+	captureNextImage(format: string, options?: ICaptureOptions): Nullable<Promise<string>>;
 
 	/**
 	 *

package/Rendering/OpenGL/RenderWindow.js

@@ -12,10 +12,12 @@ import vtkTextureUnitManager from './TextureUnitManager.js';
 import vtkViewNodeFactory from './ViewNodeFactory.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkRenderWindowViewNode from '../SceneGraph/RenderWindowViewNode.js';
+import Constants from './RenderWindow/Constants.js';
 import { createContextProxyHandler, GET_UNDERLYING_CONTEXT } from './RenderWindow/ContextProxy.js';
 
 var vtkDebugMacro = macro.vtkDebugMacro,
     vtkErrorMacro = macro.vtkErrorMacro;
+var XrSessionTypes = Constants.XrSessionTypes;
 var SCREENSHOT_PLACEHOLDER = {
   position: 'absolute',
   top: 0,
@@ -266,12 +268,13 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
   // typically in response to a user request such as a button press
 
 
-  publicAPI.startXR = function (isAR) {
+  publicAPI.startXR = function (xrSessionType) {
     if (navigator.xr === undefined) {
       throw new Error('WebXR is not available');
     }
 
-    model.xrSessionIsAR = isAR;
+    model.xrSessionType = xrSessionType !== undefined ? xrSessionType : XrSessionTypes.HmdVR;
+    var isAR = xrSessionType === XrSessionTypes.MobileAR;
     var sessionType = isAR ? 'immersive-ar' : 'immersive-vr';
 
     if (!navigator.xr.isSessionSupported(sessionType)) {
@@ -348,16 +351,17 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     var inputRescaleFactor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_RESET_FACTORS.vr.rescaleFactor;
     var inputTranslateZ = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_RESET_FACTORS.vr.translateZ;
     // Adjust world-to-physical parameters for different modalities
-    // Default parameter values are for VR (model.xrSessionIsAR == false)
+    // Default parameter values are for HMD VR
     var rescaleFactor = inputRescaleFactor;
     var translateZ = inputTranslateZ;
+    var isXrSessionAR = model.xrSessionType === XrSessionTypes.MobileAR;
 
-    if (model.xrSessionIsAR && rescaleFactor === DEFAULT_RESET_FACTORS.vr.rescaleFactor) {
+    if (isXrSessionAR && rescaleFactor === DEFAULT_RESET_FACTORS.vr.rescaleFactor) {
       // Scale down by default in AR
       rescaleFactor = DEFAULT_RESET_FACTORS.ar.rescaleFactor;
     }
 
-    if (model.xrSessionIsAR && translateZ === DEFAULT_RESET_FACTORS.vr.translateZ) {
+    if (isXrSessionAR && translateZ === DEFAULT_RESET_FACTORS.vr.translateZ) {
       // Default closer to the camera in AR
       translateZ = DEFAULT_RESET_FACTORS.ar.translateZ;
     }
@@ -444,7 +448,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
               if (xrPose) {
                 gl = publicAPI.get3DContext();
 
-                if (model.xrSessionIsAR && model.oldCanvasSize !== undefined) {
+                if (model.xrSessionType === XrSessionTypes.MobileAR && model.oldCanvasSize !== undefined) {
                   gl.canvas.width = model.oldCanvasSize[0];
                   gl.canvas.height = model.oldCanvasSize[1];
                 }
@@ -452,16 +456,16 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
                 glLayer = xrSession.renderState.baseLayer;
                 gl.bindFramebuffer(gl.FRAMEBUFFER, glLayer.framebuffer);
                 gl.clear(gl.COLOR_BUFFER_BIT);
-                gl.clear(gl.DEPTH_BUFFER_BIT); // get the first renderer
+                gl.clear(gl.DEPTH_BUFFER_BIT);
+                publicAPI.setSize(glLayer.framebufferWidth, glLayer.framebufferHeight); // get the first renderer
 
                 ren = model.renderable.getRenderers()[0]; // Do a render pass for each eye
 
-                xrPose.views.forEach(function (view) {
-                  var viewport = glLayer.getViewport(view);
-                  gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); // TODO: Appropriate handling for AR passthrough on HMDs
+                xrPose.views.forEach(function (view, index) {
+                  var viewport = glLayer.getViewport(view); // TODO: Appropriate handling for AR passthrough on HMDs
                   // with two eyes will require further investigation.
 
-                  if (!model.xrSessionIsAR) {
+                  if (model.xrSessionType === XrSessionTypes.HmdVR) {
                     if (view.eye === 'left') {
                       ren.setViewport(0, 0, 0.5, 1.0);
                     } else if (view.eye === 'right') {
@@ -470,12 +474,24 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
                       // No handling for non-eye viewport
                       return;
                     }
+                  } else if (model.xrSessionType === XrSessionTypes.LookingGlassVR) {
+                    var startX = viewport.x / glLayer.framebufferWidth;
+                    var startY = viewport.y / glLayer.framebufferHeight;
+                    var endX = (viewport.x + viewport.width) / glLayer.framebufferWidth;
+                    var endY = (viewport.y + viewport.height) / glLayer.framebufferHeight;
+                    ren.setViewport(startX, startY, endX, endY);
+                  } else {
+                    ren.setViewport(0, 0, 1, 1);
                   }
 
                   ren.getActiveCamera().computeViewParametersFromPhysicalMatrix(view.transform.inverse.matrix);
                   ren.getActiveCamera().setProjectionMatrix(view.projectionMatrix);
                   publicAPI.traverseAllPasses();
-                });
+                }); // Reset scissorbox before any subsequent rendering to external displays
+                // on frame end, such as rendering to a Looking Glass display.
+
+                gl.scissor(0, 0, glLayer.framebufferWidth, glLayer.framebufferHeight);
+                gl.disable(gl.SCISSOR_TEST);
               }
 
             case 5:
@@ -919,7 +935,6 @@ var DEFAULT_VALUES = {
   // attempt webgl2 on by default
   activeFramebuffer: null,
   xrSession: null,
-  xrSessionIsAR: false,
   xrReferenceSpace: null,
   xrSupported: true,
   imageFormat: 'image/png',

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICInterface.js

@@ -376,16 +376,19 @@ function vtkOpenGLSurfaceLICInterface(publicAPI, model) {
     fb.bind();
     model.geometryImage.activate();
     model.vectorImage.activate();
-    model.maskVectorImage.activate();
+    model.maskVectorImage.activate(); // Don't use location 1 as it can be used by order independant translucent pass
+    // Translucent pass uses location 1 because of this line:
+    // gl_FragData[1].r = weight;
+
     fb.removeColorBuffer(0);
-    fb.removeColorBuffer(1);
     fb.removeColorBuffer(2);
+    fb.removeColorBuffer(3);
     fb.setColorBuffer(model.geometryImage, 0);
-    fb.setColorBuffer(model.vectorImage, 1);
-    fb.setColorBuffer(model.maskVectorImage, 2);
+    fb.setColorBuffer(model.vectorImage, 2);
+    fb.setColorBuffer(model.maskVectorImage, 3);
     fb.setDepthBuffer(model.depthTexture);
     var gl = model.context;
-    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.COLOR_ATTACHMENT1, gl.COLOR_ATTACHMENT2]);
+    gl.drawBuffers([gl.COLOR_ATTACHMENT0, gl.NONE, gl.COLOR_ATTACHMENT2, gl.COLOR_ATTACHMENT3]);
     gl.viewport.apply(gl, [0, 0].concat(_toConsumableArray(model.size)));
     gl.scissor.apply(gl, [0, 0].concat(_toConsumableArray(model.size)));
     gl.disable(gl.BLEND);

package/Rendering/OpenGL/SurfaceLIC/SurfaceLICMapper.js

@@ -30,7 +30,7 @@ function vtkOpenGLSurfaceLICMapper(publicAPI, model) {
     var array = model.renderable.getInputArrayToProcess(0);
 
     if (array && model.canDrawLIC) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Output::Dec', ['//VTK::Output::Dec', 'layout(location = 1) out vec4 vectorTexture;', 'layout(location = 2) out vec4 maskVectorTexture;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Output::Dec', ['//VTK::Output::Dec', 'layout(location = 2) out vec4 vectorTexture;', 'layout(location = 3) out vec4 maskVectorTexture;']).result;
       var arrayName = array.getName();
       var attributeName = "".concat(arrayName, "MC"); // We need normals even with no lighting
 

package/index.d.ts

@@ -43,6 +43,7 @@
 /// <reference path="./Common/DataModel/PolyLine.d.ts" />
 /// <reference path="./Common/DataModel/Polygon.d.ts" />
 /// <reference path="./Common/DataModel/Quad.d.ts" />
+/// <reference path="./Common/DataModel/SelectionNode/Constants.d.ts" />
 /// <reference path="./Common/DataModel/SelectionNode.d.ts" />
 /// <reference path="./Common/DataModel/Sphere.d.ts" />
 /// <reference path="./Common/DataModel/Spline1D.d.ts" />
@@ -191,6 +192,7 @@
 /// <reference path="./Rendering/Misc/SynchronizableRenderWindow/ObjectManager.d.ts" />
 /// <reference path="./Rendering/Misc/SynchronizableRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/TextureLODsDownloader.d.ts" />
+/// <reference path="./Rendering/OpenGL/RenderWindow/Constants.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
 /// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNode.d.ts" />

package/package.json

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