@kitware/vtk.js 21.4.1 → 21.6.1

package/CONTRIBUTING.md

@@ -62,7 +62,7 @@ Please follow the coding style:
 If committing changes to `vtk.js@next` or `vtk.js@next-major`, then set your base branch to be `next`
 or `next-major`, respectively. For more info see the section on release channels below.
 
-8. vtk.js uses GitHub for code review and Travis-CI to test proposed patches before they are merged.
+8. vtk.js uses GitHub for code review and Github Actions to validate proposed patches before they are merged.
 
 ## Release Channels
 
@@ -110,7 +110,7 @@ you are satisfied with the staging branch changes, you can then merge into eithe
 
 To create and debug a test:
 - Create a testFuncNameToTest.js in a "test" folder of the class to test.
-- Add the test path into Sources/tests.js and temporarily comment the other tests
+- If you want to run just your test, use `test.only(...)` instead of `test(...)`.
 - Run `npm run test:debug`
 - In the opened window, click the Debug button and place breakpoints in browser debugger.
 

package/Rendering/Core/ColorTransferFunction.d.ts

@@ -1,269 +1,318 @@
 import { vtkObject } from '@kitware/vtk.js/interfaces';
 
 export enum ColorSpace {
-	RGB,
-	HSV,
-	LAB,
-	DIVERGING,
+  RGB,
+  HSV,
+  LAB,
+  DIVERGING,
 }
 
 export enum Scale {
-	LINEAR,
-	LOG10,
+  LINEAR,
+  LOG10,
 }
 
 /* TODO: use VtkScalarsToColors instead of VtkObject */
 export interface vtkColorTransferFunction extends vtkObject {
-
-	/**
-	 * Add a point defined in RGB
-	 * @param {Number} x The index of the point.
-     * @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).
-	 */
-	addRGBPoint(x: number, r: number, g: number, b: number): number;
-
-	/**
-	 * Add a point defined in RGB
-	 * @param {Number} x The index of the point.
-     * @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} [midpoint] 
-	 * @param {Number} [sharpness] 
-	 */
-	addRGBPointLong(x: number, r: number, g: number, b: number, midpoint?: number, sharpness?: number): number;
-
-	/**
-	 * Add a point defined in HSV
-	 * @param {Number} x The index of the point.
-	 * @param {Number} h Defines the hue of the color (between 0 and 1).
-	 * @param {Number} s Defines the saturation of the color (between 0 and 1).
-	 * @param {Number} v Defines the value of the color (between 0 and 1).
-	 */
-	addHSVPoint(x: number, h: number, s: number, v: number): number;
-
-	/**
-	 * Add a line defined in RGB
-	 * @param {Number} x1 The index of the first point.
-	 * @param {Number} r1 Defines the red component of the first point(between 0 and 1).
-	 * @param {Number} g1 Defines the green component of the first point(between 0 and 1).
-	 * @param {Number} b1 Defines the red component of the first point (between 0 and 1).
-	 * @param {Number} x2 The index of the second point.
-	 * @param {Number} r2 Defines the red component of the second point (between 0 and 1).
-	 * @param {Number} g2 Defines the green component of the second point (between 0 and 1).
-	 * @param {Number} b2 Defines the blue component of the second point (between 0 and 1).
-	 */
-	addRGBSegment(x1: number, r1: number, g1: number, b1: number, x2: number, r2: number, g2: number, b2: number): void;
-
-	/**
-	 * Add a line defined in HSV
-	 * @param {Number} x1 The index of the first point.
-	 * @param {Number} h1 Defines the hue of the color of the first point (between 0 and 1).
-	 * @param {Number} s1 Defines the saturation of the color of the first point (between 0 and 1).
-	 * @param {Number} v1 Defines the value of the color of the first point (between 0 and 1).
-	 * @param {Number} x2 The index of the second point.
-	 * @param {Number} h2 Defines the hue of the colorof the second point (between 0 and 1).
-	 * @param {Number} s2 Defines the saturation of the color of the second point (between 0 and 1).
-	 * @param {Number} v2 Defines the value of the color of the second point (between 0 and 1).
-	 */
-	addHSVSegment(x1: number, h1: number, s1: number, v1: number, x2: number, h2: number, s2: number, v2: number): void;
-
-
-	/**
-	 * Add a point defined in HSV
-	 * @param {Number} x The index of the point.
-	 * @param {Number} h Defines the hue of the color (between 0 and 1).
-	 * @param {Number} s Defines the saturation of the color (between 0 and 1).
-	 * @param {Number} v Defines the value of the color (between 0 and 1).
-	 * @param {Number} [midpoint] 
-	 * @param {Number} [sharpness] 
-	 */
-	addHSVPointLong(x: number, h: number, s: number, v: number, midpoint?: number, sharpness?: number): number;
-
-    /**
-	 * Get the number of points which specify this function
-	 */
-	getSize(): number;
-
-	/**
-	 * Set nodes directly
-	 * @param nodes
-	 */
-	setNodes(nodes: any): void;
-
-	/**
-	 * Sort the vector in increasing order, then fill in
-	 * the Range
-	 */
-	sortAndUpdateRange(): void;
-
-	/**
-	 *
-	 */
-	updateRange(): boolean;
-
-	/**
-	 * Remove a point
-	 * @param {Number} x The index of the point.
-	 */
-	removePoint(x: number): number;
-
-	/**
-	 * Moves point from oldX to newX.
-	 * 
-	 * It removed the point from oldX. If any point existed at newX, it will also be removed.
-	 * @param {Number} oldX The old index of the point.
-	 * @param {Number} newX The new index of the point.
-	 */
-	movePoint(oldX: number, newX: number): void;
-
-	/**
-	 * Remove all points
-	 */
-	removeAllPoints(): void;
-
-	/**
-	 * Get the RGBA color evaluated at the specified location
-	 * @param {Number} x The index of the point.
-	 */
-	mapValue(x: number): any;
-
-	/**
-	 * Get the RGB color evaluated at the specified location
-	 * @param {Number} x The index of the point.
-	 * @param {Number[]} rgb The Array of the RGB color to fill.
-	 */
-	getColor(x: number, rgb: number[]): void;
-		
-	/**
-	 * Get the red color evaluated at the specified location
-	 * @param {Number} x The index of the point.
-	 */
-	getRedValue(x: number): number;
-
-	/**
-	 * Get the green color evaluated at the specified location
-	 * @param {Number} x The index of the point.
-	 */
-	getGreenValue(x: number): number;
-
-	/**
-	 * Get the blue color evaluated at the specified location
-	 * @param {Number} x The index of the point.
-	 */
-	getBlueValue(x: number): number;
-
-	/**
-	 * Get a table of RGB colors at regular intervals along the function
-	 * @param {Number} xStart The index of the first point.
-	 * @param {Number} xEnd The index of the second point.
-	 * @param {Number} size 
-	 * @param {Number[]} table 
-	 */
-	getTable(xStart: number, xEnd: number, size: number, table: number[]): void;
-
-	/**
-	 * @param {Number} xStart The index of the first point.
-	 * @param {Number} xEnd The index of the first point.
-	 * @param {Number} size 
-	 * @param {Boolean} withAlpha 
-	 */
-	getUint8Table(xStart: number, xEnd: number, size: number, withAlpha: boolean): Float32Array;
-
-	/**
-	 * Construct a color transfer function from a table.
-	 * @param {Number} xStart The index of the first point.
-	 * @param {Number} xEnd The index of the first point.
-	 * @param {Number} size 
-	 * @param {Number[]} table 
-	 */
-	buildFunctionFromTable(xStart: number, xEnd: number, size: number, table: number[]): void;
-
-	/**
-	 * For the node specified by index, set/get the location (X), R, G, and B
-	 * values, midpoint, and sharpness values at the node.
-	 * @param {Number} index 
-	 * @param {Number[]} val 
-	 */
-	getNodeValue(index: number, val: number[]): number;
-
-	/**
-	 * For a specified index value, set the node parameters
-	 * @param {Number} index 
-	 * @param {Number[]} val 
-	 */
-	setNodeValue(index: number, val: number[]): number;
-
-	/**
-	 * Get the number of available colors for mapping to.
-	 */
-	getNumberOfAvailableColors(): number;
-
-	/**
-	 * Get the color given an integer index.
-	 * @param {Number} idx The index of the point.
-	 * @param {Number[]} rgba An Array of the RGBA color.
-	 */
-	getIndexedColor(idx: number, rgba: number[]): void;
-		
-	/**
-	 * Defines the nodes from an array ptr with the layout [X1, R1, G1, B1, X2,
-	 * R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the number of nodes.
-	 * @param {Number} nb 
-	 * @param ptr
-	 */
-	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.
-	 * @param {Number[]} range 
-	 */
-	adjustRange(range: number[]): number;
-		
-	/**
-	 * Estimates the minimum size of a table such that it would correctly sample this function.
-	 * @param {Number} x1 
-	 * @param {Number} x2 
-	 */
-	estimateMinNumberOfSamples(x1: number, x2: number): number;
-
-	/**
-	 * Traverses the nodes to find the minimum distance.
-	 */
-	findMinimumXDistance(): number;
-
-	/**
-	 *
-	 * @param input
-	 * @param output
-	 * @param outFormat
-	 * @param inputOffset
-	 */
-	mapScalarsThroughTable(input: any, output: any, outFormat: any, inputOffset: any): void;
-
-	/**
-	 * Map a set of scalars through the lookup table.
-	 * @param input
-	 * @param output
-	 * @param outFormat
-	 * @param inputOffset
-	 */
-	mapData(input: any, output: any, outFormat: any, inputOffset: any): void;
-
-	/**
-	 * @param colorMap
-	 */
-	applyColorMap(colorMap: any): void;
+  /**
+   * Add a point defined in RGB
+   * @param {Number} x The index of the point.
+   * @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).
+   */
+  addRGBPoint(x: number, r: number, g: number, b: number): number;
+
+  /**
+   * Add a point defined in RGB
+   * @param {Number} x The index of the point.
+   * @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} [midpoint]
+   * @param {Number} [sharpness]
+   */
+  addRGBPointLong(
+    x: number,
+    r: number,
+    g: number,
+    b: number,
+    midpoint?: number,
+    sharpness?: number
+  ): number;
+
+  /**
+   * Add a point defined in HSV
+   * @param {Number} x The index of the point.
+   * @param {Number} h Defines the hue of the color (between 0 and 1).
+   * @param {Number} s Defines the saturation of the color (between 0 and 1).
+   * @param {Number} v Defines the value of the color (between 0 and 1).
+   */
+  addHSVPoint(x: number, h: number, s: number, v: number): number;
+
+  /**
+   * Add a line defined in RGB
+   * @param {Number} x1 The index of the first point.
+   * @param {Number} r1 Defines the red component of the first point(between 0 and 1).
+   * @param {Number} g1 Defines the green component of the first point(between 0 and 1).
+   * @param {Number} b1 Defines the red component of the first point (between 0 and 1).
+   * @param {Number} x2 The index of the second point.
+   * @param {Number} r2 Defines the red component of the second point (between 0 and 1).
+   * @param {Number} g2 Defines the green component of the second point (between 0 and 1).
+   * @param {Number} b2 Defines the blue component of the second point (between 0 and 1).
+   */
+  addRGBSegment(
+    x1: number,
+    r1: number,
+    g1: number,
+    b1: number,
+    x2: number,
+    r2: number,
+    g2: number,
+    b2: number
+  ): void;
+
+  /**
+   * Add a line defined in HSV
+   * @param {Number} x1 The index of the first point.
+   * @param {Number} h1 Defines the hue of the color of the first point (between 0 and 1).
+   * @param {Number} s1 Defines the saturation of the color of the first point (between 0 and 1).
+   * @param {Number} v1 Defines the value of the color of the first point (between 0 and 1).
+   * @param {Number} x2 The index of the second point.
+   * @param {Number} h2 Defines the hue of the colorof the second point (between 0 and 1).
+   * @param {Number} s2 Defines the saturation of the color of the second point (between 0 and 1).
+   * @param {Number} v2 Defines the value of the color of the second point (between 0 and 1).
+   */
+  addHSVSegment(
+    x1: number,
+    h1: number,
+    s1: number,
+    v1: number,
+    x2: number,
+    h2: number,
+    s2: number,
+    v2: number
+  ): void;
+
+  /**
+   * Add a point defined in HSV
+   * @param {Number} x The index of the point.
+   * @param {Number} h Defines the hue of the color (between 0 and 1).
+   * @param {Number} s Defines the saturation of the color (between 0 and 1).
+   * @param {Number} v Defines the value of the color (between 0 and 1).
+   * @param {Number} [midpoint]
+   * @param {Number} [sharpness]
+   */
+  addHSVPointLong(
+    x: number,
+    h: number,
+    s: number,
+    v: number,
+    midpoint?: number,
+    sharpness?: number
+  ): number;
+
+  /**
+   * Get the number of points which specify this function
+   */
+  getSize(): number;
+
+  /**
+   * Set nodes directly
+   * @param nodes
+   *
+   * @returns true if a change happen
+   */
+  setNodes(nodes: any): boolean;
+
+  /**
+   * Sort the vector in increasing order, then fill in
+   * the Range
+   *
+   * @returns true if a change happen
+   */
+  sortAndUpdateRange(): boolean;
+
+  /**
+   * @returns true if a change happen
+   */
+  updateRange(): boolean;
+
+  /**
+   * Remove a point
+   * @param {Number} x The index of the point.
+   */
+  removePoint(x: number): number;
+
+  /**
+   * Moves point from oldX to newX.
+   *
+   * It removed the point from oldX. If any point existed at newX, it will also be removed.
+   * @param {Number} oldX The old index of the point.
+   * @param {Number} newX The new index of the point.
+   */
+  movePoint(oldX: number, newX: number): void;
+
+  /**
+   * Remove all points
+   */
+  removeAllPoints(): void;
+
+  /**
+   * Get the RGBA color evaluated at the specified location
+   * @param {Number} x The index of the point.
+   */
+  mapValue(x: number): any;
+
+  /**
+   * Get the RGB color evaluated at the specified location
+   * @param {Number} x The index of the point.
+   * @param {Number[]} rgb The Array of the RGB color to fill.
+   */
+  getColor(x: number, rgb: number[]): void;
+
+  /**
+   * Get the red color evaluated at the specified location
+   * @param {Number} x The index of the point.
+   */
+  getRedValue(x: number): number;
+
+  /**
+   * Get the green color evaluated at the specified location
+   * @param {Number} x The index of the point.
+   */
+  getGreenValue(x: number): number;
+
+  /**
+   * Get the blue color evaluated at the specified location
+   * @param {Number} x The index of the point.
+   */
+  getBlueValue(x: number): number;
+
+  /**
+   * Get a table of RGB colors at regular intervals along the function
+   * @param {Number} xStart The index of the first point.
+   * @param {Number} xEnd The index of the second point.
+   * @param {Number} size
+   * @param {Number[]} table
+   */
+  getTable(xStart: number, xEnd: number, size: number, table: number[]): void;
+
+  /**
+   * @param {Number} xStart The index of the first point.
+   * @param {Number} xEnd The index of the first point.
+   * @param {Number} size
+   * @param {Boolean} withAlpha
+   */
+  getUint8Table(
+    xStart: number,
+    xEnd: number,
+    size: number,
+    withAlpha: boolean
+  ): Float32Array;
+
+  /**
+   * Construct a color transfer function from a table.
+   * @param {Number} xStart The index of the first point.
+   * @param {Number} xEnd The index of the first point.
+   * @param {Number} size
+   * @param {Number[]} table
+   */
+  buildFunctionFromTable(
+    xStart: number,
+    xEnd: number,
+    size: number,
+    table: number[]
+  ): void;
+
+  /**
+   * For the node specified by index, set/get the location (X), R, G, and B
+   * values, midpoint, and sharpness values at the node.
+   * @param {Number} index
+   * @param {Number[]} val
+   */
+  getNodeValue(index: number, val: number[]): number;
+
+  /**
+   * For a specified index value, set the node parameters
+   * @param {Number} index
+   * @param {Number[]} val
+   */
+  setNodeValue(index: number, val: number[]): number;
+
+  /**
+   * Get the number of available colors for mapping to.
+   */
+  getNumberOfAvailableColors(): number;
+
+  /**
+   * Get the color given an integer index.
+   * @param {Number} idx The index of the point.
+   * @param {Number[]} rgba An Array of the RGBA color.
+   */
+  getIndexedColor(idx: number, rgba: number[]): void;
+
+  /**
+   * Defines the nodes from an array ptr with the layout [X1, R1, G1, B1, X2,
+   * R2, G2, B2, ..., Xn, Rn, Gn, Bn] where n is the number of nodes.
+   * @param {Number} nb
+   * @param ptr
+   */
+  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.
+   * @param {Number[]} range
+   */
+  adjustRange(range: number[]): number;
+
+  /**
+   * Estimates the minimum size of a table such that it would correctly sample this function.
+   * @param {Number} x1
+   * @param {Number} x2
+   */
+  estimateMinNumberOfSamples(x1: number, x2: number): number;
+
+  /**
+   * Traverses the nodes to find the minimum distance.
+   */
+  findMinimumXDistance(): number;
+
+  /**
+   *
+   * @param input
+   * @param output
+   * @param outFormat
+   * @param inputOffset
+   */
+  mapScalarsThroughTable(
+    input: any,
+    output: any,
+    outFormat: any,
+    inputOffset: any
+  ): void;
+
+  /**
+   * Map a set of scalars through the lookup table.
+   * @param input
+   * @param output
+   * @param outFormat
+   * @param inputOffset
+   */
+  mapData(input: any, output: any, outFormat: any, inputOffset: any): void;
+
+  /**
+   * @param colorMap
+   */
+  applyColorMap(colorMap: any): void;
 }
 
 /**
@@ -273,7 +322,11 @@ export interface vtkColorTransferFunction extends vtkObject {
  * @param model object on which data structure will be bounds (protected)
  * @param {object} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: object): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: object
+): void;
 
 /**
  * Method use to create a new instance of vtkColorTransferFunction
@@ -303,7 +356,7 @@ export function newInstance(initialValues?: object): vtkColorTransferFunction;
  */
 
 export declare const vtkColorTransferFunction: {
-    newInstance: typeof newInstance,
-    extend: typeof extend,
+  newInstance: typeof newInstance;
+  extend: typeof extend;
 };
 export default vtkColorTransferFunction;

package/Rendering/Core/ColorTransferFunction.js

@@ -221,23 +221,32 @@ function vtkColorTransferFunction(publicAPI, model) {
 
   publicAPI.setNodes = function (nodes) {
     if (model.nodes !== nodes) {
+      var before = JSON.stringify(model.nodes);
       model.nodes = nodes;
-      publicAPI.sortAndUpdateRange();
+      var after = JSON.stringify(model.nodes);
+      return publicAPI.sortAndUpdateRange() || before !== after;
     }
+
+    return false;
   }; //----------------------------------------------------------------------------
   // Sort the vector in increasing order, then fill in
   // the Range
 
 
   publicAPI.sortAndUpdateRange = function () {
+    var before = JSON.stringify(model.nodes);
     model.nodes.sort(function (a, b) {
       return a.x - b.x;
     });
+    var after = JSON.stringify(model.nodes);
     var modifiedInvoked = publicAPI.updateRange(); // If range is updated, Modified() has been called, don't call it again.
 
-    if (!modifiedInvoked) {
+    if (!modifiedInvoked && before !== after) {
       publicAPI.modified();
+      return true;
     }
+
+    return modifiedInvoked;
   }; //----------------------------------------------------------------------------
 
 

package/Rendering/Misc/SynchronizableRenderWindow/vtkObjectManager.js

@@ -102,12 +102,29 @@ function bindArrays(arraysToBind) {
 
 function createNewArrayHandler(instance, arrayMetadata, arraysToBind) {
   return function (values) {
+    var regMethod = arrayMetadata.registration ? arrayMetadata.registration : 'addArray';
+    var location = arrayMetadata.location ? instance.getReferenceByName(arrayMetadata.location) : instance; // Try to prevent unncessary modified
+
+    var previousArray = null;
+
+    if (arrayMetadata.location) {
+      previousArray = instance.getReferenceByName(arrayMetadata.location).getArray(arrayMetadata.name);
+    } else {
+      previousArray = instance["get".concat(regMethod.substring(3))]();
+    }
+
+    if (previousArray) {
+      if (previousArray.getData() !== values) {
+        arraysToBind.push([previousArray.setData, [values, arrayMetadata.numberOfComponents]]);
+      }
+
+      return previousArray;
+    }
+
     var vtkClass = arrayMetadata.vtkClass ? arrayMetadata.vtkClass : 'vtkDataArray';
     var array = DATA_ARRAY_MAPPER[vtkClass].newInstance(_objectSpread(_objectSpread({}, arrayMetadata), {}, {
       values: values
     }));
-    var regMethod = arrayMetadata.registration ? arrayMetadata.registration : 'addArray';
-    var location = arrayMetadata.location ? instance.getReferenceByName(arrayMetadata.location) : instance;
     arraysToBind.push([location[regMethod], [array]]);
     return array;
   };
@@ -273,6 +290,11 @@ function genericUpdater(instance, state, context) {
     context.start(); // -> start(arraysToBind)
 
     dependencies.push(Promise.all(promises).then(function () {
+      // Since some arrays are getting updated, we should modify our dataset
+      if (arraysToBind.length) {
+        instance.modified();
+      }
+
       bindArrays(arraysToBind);
       return true;
     }).catch(function (error) {
@@ -429,8 +451,6 @@ function colorTransferFunctionUpdater(instance, state, context) {
   instance.set(_objectSpread(_objectSpread({}, state.properties), {}, {
     nodes: nodes
   }), true);
-  instance.sortAndUpdateRange();
-  instance.modified();
   context.end(); // -> end(colorTransferFunctionUpdater)
 }
 
@@ -454,12 +474,30 @@ function piecewiseFunctionUpdater(instance, state, context) {
   instance.set(_objectSpread(_objectSpread({}, state.properties), {}, {
     nodes: nodes
   }), true);
-  instance.sortAndUpdateRange();
-  instance.modified();
+  instance.sortAndUpdateRange(); // instance.modified();
+
   context.end(); // -> end(piecewiseFunctionUpdater)
 } // ----------------------------------------------------------------------------
 
 
+function removeUnavailableArrays(fields, availableNames) {
+  var namesToDelete = [];
+  var size = fields.getNumberOfArrays();
+
+  for (var i = 0; i < size; i++) {
+    var array = fields.getArray(i);
+    var name = array.getName();
+
+    if (!availableNames.has(name)) {
+      namesToDelete.push(name);
+    }
+  }
+
+  for (var _i = 0; _i < namesToDelete.length; _i++) {
+    fields.removeArray(namesToDelete[_i]);
+  }
+}
+
 function createDataSetUpdate() {
   var piecesToFetch = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
   return function (instance, state, context) {
@@ -489,8 +527,18 @@ function createDataSetUpdate() {
 
     delete state.properties.fields; // Reset any pre-existing fields array
 
-    instance.getPointData().removeAllArrays();
-    instance.getCellData().removeAllArrays(); // Generic handling
+    var arrayToKeep = {
+      pointData: new Set(),
+      cellData: new Set(),
+      fieldData: new Set()
+    };
+    fieldsArrays.forEach(function (_ref5) {
+      var location = _ref5.location,
+          name = _ref5.name;
+      arrayToKeep[location].add(name);
+    });
+    removeUnavailableArrays(instance.getPointData(), arrayToKeep.pointData);
+    removeUnavailableArrays(instance.getCellData(), arrayToKeep.cellData); // Generic handling
 
     var res = genericUpdater(instance, state, context); // Finish what we started
 

package/Rendering/OpenGL/RenderWindow.js

@@ -22,6 +22,19 @@ var SCREENSHOT_PLACEHOLDER = {
   width: '100%',
   height: '100%'
 };
+var DEFAULT_RESET_FACTORS = {
+  vr: {
+    rescaleFactor: 1.0,
+    translateZ: -0.7 // 0.7 m forward from the camera
+
+  },
+  ar: {
+    rescaleFactor: 0.25,
+    // scale down AR for viewing comfort by default
+    translateZ: -0.5 // 0.5 m forward from the camera
+
+  }
+};
 
 function checkRenderTargetSupport(gl, format, type) {
   // create temporary frame buffer and texture
@@ -245,21 +258,28 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
   // typically in response to a user request such as a button press
 
 
-  publicAPI.startXR = function () {
+  publicAPI.startXR = function (isAR) {
     if (navigator.xr === undefined) {
       throw new Error('WebXR is not available');
     }
 
-    if (!navigator.xr.isSessionSupported('immersive-vr')) {
-      throw new Error('VR display is not available');
+    model.xrSessionIsAR = isAR;
+    var sessionType = isAR ? 'immersive-ar' : 'immersive-vr';
+
+    if (!navigator.xr.isSessionSupported(sessionType)) {
+      if (isAR) {
+        throw new Error('Device does not support AR session');
+      } else {
+        throw new Error('VR display is not available');
+      }
     }
 
     if (model.xrSession === null) {
-      navigator.xr.requestSession('immersive-vr').then(publicAPI.enterXR, function () {
-        throw new Error('Failed to create VR session!');
+      navigator.xr.requestSession(sessionType).then(publicAPI.enterXR, function () {
+        throw new Error('Failed to create XR session!');
       });
     } else {
-      throw new Error('VR Session already exists!');
+      throw new Error('XR Session already exists!');
     }
   }; // When an XR session is available, set up the XRWebGLLayer
   // and request the first animation frame for the device
@@ -276,7 +296,7 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
               model.oldCanvasSize = model.size.slice();
 
               if (!(model.xrSession !== null)) {
-                _context.next = 14;
+                _context.next = 15;
                 break;
               }
 
@@ -293,15 +313,16 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
               model.xrSession.requestReferenceSpace('local').then(function (refSpace) {
                 model.xrReferenceSpace = refSpace;
               });
+              publicAPI.resetXRScene();
               model.renderable.getInteractor().switchToXRAnimation();
               model.xrSceneFrame = model.xrSession.requestAnimationFrame(publicAPI.xrRender);
-              _context.next = 15;
+              _context.next = 16;
               break;
 
-            case 14:
+            case 15:
               throw new Error('Failed to enter VR with a null xrSession.');
 
-            case 15:
+            case 16:
             case "end":
               return _context.stop();
           }
@@ -314,6 +335,36 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     };
   }();
 
+  publicAPI.resetXRScene = function () {
+    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)
+    var rescaleFactor = inputRescaleFactor;
+    var translateZ = inputTranslateZ;
+
+    if (model.xrSessionIsAR && 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) {
+      // Default closer to the camera in AR
+      translateZ = DEFAULT_RESET_FACTORS.ar.translateZ;
+    }
+
+    var ren = model.renderable.getRenderers()[0];
+    ren.resetCamera();
+    var camera = ren.getActiveCamera();
+    var physicalScale = camera.getPhysicalScale();
+    var physicalTranslation = camera.getPhysicalTranslation();
+    physicalScale /= rescaleFactor;
+    translateZ *= physicalScale;
+    physicalTranslation[2] += translateZ;
+    camera.setPhysicalScale(physicalScale);
+    camera.setPhysicalTranslation(physicalTranslation);
+  };
+
   publicAPI.stopXR = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
     var gl, ren;
     return _regeneratorRuntime.wrap(function _callee2$(_context2) {
@@ -348,7 +399,10 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
             model.xrSession = null;
 
           case 10:
-            publicAPI.setSize.apply(publicAPI, _toConsumableArray(model.oldCanvasSize)); // Reset to default canvas
+            if (model.oldCanvasSize !== undefined) {
+              publicAPI.setSize.apply(publicAPI, _toConsumableArray(model.oldCanvasSize));
+            } // Reset to default canvas
+
 
             ren = model.renderable.getRenderers()[0];
             ren.getActiveCamera().setProjectionMatrix(null);
@@ -378,6 +432,12 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
               if (xrPose) {
                 gl = publicAPI.get3DContext();
+
+                if (model.xrSessionIsAR && model.oldCanvasSize !== undefined) {
+                  gl.canvas.width = model.oldCanvasSize[0];
+                  gl.canvas.height = model.oldCanvasSize[1];
+                }
+
                 glLayer = xrSession.renderState.baseLayer;
                 gl.bindFramebuffer(gl.FRAMEBUFFER, glLayer.framebuffer);
                 gl.clear(gl.COLOR_BUFFER_BIT);
@@ -387,15 +447,18 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
 
                 xrPose.views.forEach(function (view) {
                   var viewport = glLayer.getViewport(view);
-                  gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
-
-                  if (view.eye === 'left') {
-                    ren.setViewport(0, 0, 0.5, 1.0);
-                  } else if (view.eye === 'right') {
-                    ren.setViewport(0.5, 0, 1.0, 1.0);
-                  } else {
-                    // No handling for non-eye viewport
-                    return;
+                  gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); // TODO: Appropriate handling for AR passthrough on HMDs
+                  // with two eyes will require further investigation.
+
+                  if (!model.xrSessionIsAR) {
+                    if (view.eye === 'left') {
+                      ren.setViewport(0, 0, 0.5, 1.0);
+                    } else if (view.eye === 'right') {
+                      ren.setViewport(0.5, 0, 1.0, 1.0);
+                    } else {
+                      // No handling for non-eye viewport
+                      return;
+                    }
                   }
 
                   ren.getActiveCamera().computeViewParametersFromPhysicalMatrix(view.transform.inverse.matrix);
@@ -777,7 +840,9 @@ var DEFAULT_VALUES = {
   // attempt webgl2 on by default
   activeFramebuffer: null,
   xrSession: null,
+  xrSessionIsAR: false,
   xrReferenceSpace: null,
+  xrSupported: true,
   imageFormat: 'image/png',
   useOffScreen: false,
   useBackgroundImage: false
@@ -820,7 +885,7 @@ function extend(publicAPI, model) {
   macro.event(publicAPI, model, 'imageReady');
   macro.event(publicAPI, model, 'haveVRDisplay'); // Build VTK API
 
-  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage']);
+  macro.get(publicAPI, model, ['shaderCache', 'textureUnitManager', 'webgl2', 'vrDisplay', 'useBackgroundImage', 'xrSupported']);
   macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'renderPasses', 'notifyStartCaptureImage', 'defaultToWebgl2', 'cursor', 'useOffScreen', // might want to make this not call modified as
   // we change the active framebuffer a lot. Or maybe
   // only mark modified if the size or depth

package/Rendering/WebGPU/RenderWindow.js

@@ -616,7 +616,8 @@ var DEFAULT_VALUES = {
   imageFormat: 'image/png',
   useOffScreen: false,
   useBackgroundImage: false,
-  nextPropID: 1
+  nextPropID: 1,
+  xrSupported: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -652,7 +653,7 @@ function extend(publicAPI, model) {
   macro.event(publicAPI, model, 'imageReady');
   macro.event(publicAPI, model, 'initialized'); // Build VTK API
 
-  macro.get(publicAPI, model, ['commandEncoder', 'device', 'useBackgroundImage']);
+  macro.get(publicAPI, model, ['commandEncoder', 'device', 'useBackgroundImage', 'xrSupported']);
   macro.setGet(publicAPI, model, ['initialized', 'context', 'canvas', 'device', 'renderPasses', 'notifyStartCaptureImage', 'cursor', 'useOffScreen']);
   macro.setGetArray(publicAPI, model, ['size'], 2); // Object methods
 

package/Rendering/WebGPU/StorageBuffer.js

@@ -178,7 +178,7 @@ function vtkWebGPUStorageBuffer(publicAPI, model) {
       lines.push("  ".concat(entry.name, ": ").concat(entry.type, ";"));
     }
 
-    lines.push("\n};\n[[block]] struct ".concat(model.name, "Struct\n{\n  values: array<").concat(model.name, "StructEntry>;\n};\n[[binding(").concat(binding, "), group(").concat(group, ")]] var<storage, read> ").concat(model.name, ": ").concat(model.name, "Struct;\n"));
+    lines.push("\n};\nstruct ".concat(model.name, "Struct\n{\n  values: array<").concat(model.name, "StructEntry>;\n};\n[[binding(").concat(binding, "), group(").concat(group, ")]] var<storage, read> ").concat(model.name, ": ").concat(model.name, "Struct;\n"));
     return lines.join('\n');
   };
 

package/Rendering/WebGPU/UniformBuffer.js

@@ -45,18 +45,34 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     }
 
     var currOffset = 0;
-    var newEntries = []; // pack anything whose size is a multiple of 16 bytes first
-    // this includes a couple types that don't require 16 byte alignment
-    // such as mat2x2<f32> but that is OK
+    var newEntries = []; // compute the max alignment, this is required as WebGPU defines a UBO to have
+    // a size that is a multiple of the maxAlignment
+
+    var maxAlignment = 4;
 
     for (var i = 0; i < model.bufferEntries.length; i++) {
       var entry = model.bufferEntries[i];
 
-      if (entry.packed === false && entry.sizeInBytes % 16 === 0) {
-        entry.packed = true;
-        entry.offset = currOffset;
-        newEntries.push(entry);
-        currOffset += entry.sizeInBytes;
+      if (entry.sizeInBytes % 16 === 0) {
+        maxAlignment = Math.max(16, maxAlignment);
+      }
+
+      if (entry.sizeInBytes % 8 === 0) {
+        maxAlignment = Math.max(8, maxAlignment);
+      }
+    } // pack anything whose size is a multiple of 16 bytes first
+    // this includes a couple types that don't require 16 byte alignment
+    // such as mat2x2<f32> but that is OK
+
+
+    for (var _i = 0; _i < model.bufferEntries.length; _i++) {
+      var _entry = model.bufferEntries[_i];
+
+      if (_entry.packed === false && _entry.sizeInBytes % 16 === 0) {
+        _entry.packed = true;
+        _entry.offset = currOffset;
+        newEntries.push(_entry);
+        currOffset += _entry.sizeInBytes;
       }
     } // now it gets tough, we have the following common types (f32, i32, u32)
     // - vec2<f32> 8 byte size, 8 byte alignment
@@ -65,18 +81,18 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     // try adding 12 byte, 4 byte pairs
 
 
-    for (var _i = 0; _i < model.bufferEntries.length; _i++) {
-      var _entry = model.bufferEntries[_i];
+    for (var _i2 = 0; _i2 < model.bufferEntries.length; _i2++) {
+      var _entry2 = model.bufferEntries[_i2];
 
-      if (_entry.packed === false && _entry.sizeInBytes === 12) {
+      if (_entry2.packed === false && _entry2.sizeInBytes === 12) {
         for (var i2 = 0; i2 < model.bufferEntries.length; i2++) {
           var entry2 = model.bufferEntries[i2];
 
           if (entry2.packed === false && entry2.sizeInBytes === 4) {
-            _entry.packed = true;
-            _entry.offset = currOffset;
-            newEntries.push(_entry);
-            currOffset += _entry.sizeInBytes;
+            _entry2.packed = true;
+            _entry2.offset = currOffset;
+            newEntries.push(_entry2);
+            currOffset += _entry2.sizeInBytes;
             entry2.packed = true;
             entry2.offset = currOffset;
             newEntries.push(entry2);
@@ -88,22 +104,22 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     } // try adding 8 byte, 8 byte pairs
 
 
-    for (var _i2 = 0; _i2 < model.bufferEntries.length; _i2++) {
-      var _entry2 = model.bufferEntries[_i2];
+    for (var _i3 = 0; _i3 < model.bufferEntries.length; _i3++) {
+      var _entry3 = model.bufferEntries[_i3];
 
-      if (!_entry2.packed && _entry2.sizeInBytes % 8 === 0) {
-        for (var _i3 = _i2 + 1; _i3 < model.bufferEntries.length; _i3++) {
-          var _entry3 = model.bufferEntries[_i3];
+      if (!_entry3.packed && _entry3.sizeInBytes % 8 === 0) {
+        for (var _i4 = _i3 + 1; _i4 < model.bufferEntries.length; _i4++) {
+          var _entry4 = model.bufferEntries[_i4];
 
-          if (!_entry3.packed && _entry3.sizeInBytes % 8 === 0) {
-            _entry2.packed = true;
-            _entry2.offset = currOffset;
-            newEntries.push(_entry2);
-            currOffset += _entry2.sizeInBytes;
+          if (!_entry4.packed && _entry4.sizeInBytes % 8 === 0) {
             _entry3.packed = true;
             _entry3.offset = currOffset;
             newEntries.push(_entry3);
             currOffset += _entry3.sizeInBytes;
+            _entry4.packed = true;
+            _entry4.offset = currOffset;
+            newEntries.push(_entry4);
+            currOffset += _entry4.sizeInBytes;
             break;
           }
         }
@@ -111,28 +127,28 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     } // try adding 8 byte, 4 byte 4 byte triplets
 
 
-    for (var _i4 = 0; _i4 < model.bufferEntries.length; _i4++) {
-      var _entry4 = model.bufferEntries[_i4];
+    for (var _i5 = 0; _i5 < model.bufferEntries.length; _i5++) {
+      var _entry5 = model.bufferEntries[_i5];
 
-      if (!_entry4.packed && _entry4.sizeInBytes % 8 === 0) {
+      if (!_entry5.packed && _entry5.sizeInBytes % 8 === 0) {
         var found = false;
 
-        for (var _i5 = 0; !found && _i5 < model.bufferEntries.length; _i5++) {
-          var _entry5 = model.bufferEntries[_i5];
+        for (var _i6 = 0; !found && _i6 < model.bufferEntries.length; _i6++) {
+          var _entry6 = model.bufferEntries[_i6];
 
-          if (!_entry5.packed && _entry5.sizeInBytes === 4) {
-            for (var i3 = _i5 + 1; i3 < model.bufferEntries.length; i3++) {
+          if (!_entry6.packed && _entry6.sizeInBytes === 4) {
+            for (var i3 = _i6 + 1; i3 < model.bufferEntries.length; i3++) {
               var entry3 = model.bufferEntries[i3];
 
               if (!entry3.packed && entry3.sizeInBytes === 4) {
-                _entry4.packed = true;
-                _entry4.offset = currOffset;
-                newEntries.push(_entry4);
-                currOffset += _entry4.sizeInBytes;
                 _entry5.packed = true;
                 _entry5.offset = currOffset;
                 newEntries.push(_entry5);
                 currOffset += _entry5.sizeInBytes;
+                _entry6.packed = true;
+                _entry6.offset = currOffset;
+                newEntries.push(_entry6);
+                currOffset += _entry6.sizeInBytes;
                 entry3.packed = true;
                 entry3.offset = currOffset;
                 newEntries.push(entry3);
@@ -149,27 +165,27 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     // in a failed UBO
 
 
-    for (var _i6 = 0; _i6 < model.bufferEntries.length; _i6++) {
-      var _entry6 = model.bufferEntries[_i6];
-
-      if (!_entry6.packed && _entry6.sizeInBytes > 4) {
-        _entry6.packed = true;
-        _entry6.offset = currOffset;
-        newEntries.push(_entry6);
-        currOffset += _entry6.sizeInBytes;
-      }
-    } // finally add remaining 4 byte items
-
-
     for (var _i7 = 0; _i7 < model.bufferEntries.length; _i7++) {
       var _entry7 = model.bufferEntries[_i7];
 
-      if (!_entry7.packed) {
+      if (!_entry7.packed && _entry7.sizeInBytes > 4) {
         _entry7.packed = true;
         _entry7.offset = currOffset;
         newEntries.push(_entry7);
         currOffset += _entry7.sizeInBytes;
       }
+    } // finally add remaining 4 byte items
+
+
+    for (var _i8 = 0; _i8 < model.bufferEntries.length; _i8++) {
+      var _entry8 = model.bufferEntries[_i8];
+
+      if (!_entry8.packed) {
+        _entry8.packed = true;
+        _entry8.offset = currOffset;
+        newEntries.push(_entry8);
+        currOffset += _entry8.sizeInBytes;
+      }
     } // update entries and entryNames
 
 
@@ -177,11 +193,12 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
 
     model._bufferEntryNames.clear();
 
-    for (var _i8 = 0; _i8 < model.bufferEntries.length; _i8++) {
-      model._bufferEntryNames.set(model.bufferEntries[_i8].name, _i8);
+    for (var _i9 = 0; _i9 < model.bufferEntries.length; _i9++) {
+      model._bufferEntryNames.set(model.bufferEntries[_i9].name, _i9);
     }
 
     model.sizeInBytes = currOffset;
+    model.sizeInBytes = maxAlignment * Math.ceil(model.sizeInBytes / maxAlignment);
     model.sortDirty = false;
   };
 
@@ -284,7 +301,7 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
   publicAPI.getShaderCode = function (binding, group) {
     // sort the entries
     publicAPI.sortBufferEntries();
-    var lines = ["[[block]] struct ".concat(model.name, "Struct\n{")];
+    var lines = ["struct ".concat(model.name, "Struct\n{")];
 
     for (var i = 0; i < model.bufferEntries.length; i++) {
       var entry = model.bufferEntries[i];

package/Rendering/WebGPU/VolumePass.js

@@ -218,7 +218,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       fDesc.addOutput('vec4<f32>', 'outColor1');
       fDesc.addOutput('vec4<f32>', 'outColor2');
       var code = fDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor1 = vec4<f32>(stopval, 0.0, 0.0, 0.0);', 'output.outColor2 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor1 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);', 'output.outColor2 = vec4<f32>(stopval, 0.0, 0.0, 0.0);']).result;
       fDesc.setCode(code);
     });
     model.depthRangeEncoder.setDescription({

package/macros.js

@@ -304,8 +304,8 @@ function obj() {
           vtkWarningMacro("Warning: Set value to model directly ".concat(name, ", ").concat(map[name]));
         }
 
+        ret = model[name] !== map[name] || ret;
         model[name] = map[name];
-        ret = true;
       }
     });
     return ret;

package/package.json

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