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

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -1,5 +1,5 @@
 import { mat3, mat4, quat, vec3 } from 'gl-matrix';
-import { Nullable } from './../../types';
+import { Extent, Nullable } from './../../types';
 import { vtkOutputPort } from './../../interfaces';
 import vtkAbstractMapper3D, {
   IAbstractMapper3DInitialValues,
@@ -307,6 +307,25 @@ export interface vtkImageCPRMapper
    * @param imageData
    */
   setImageConnection(imageData: vtkOutputPort): void;
+
+  /**
+   * Tells the mapper to only update the specified extents.
+   *
+   * If there are zero extents, the mapper updates the entire volume texture.
+   * Otherwise, the mapper will only update the texture by the specified extents
+   * during the next render call.
+   *
+   * This array is cleared after a successful render.
+   * @param extents
+   */
+  setUpdatedExtents(extents: Extent[]): boolean;
+
+  /**
+   * Retrieves the updated extents.
+   *
+   * This array is cleared after every successful render.
+   */
+  getUpdatedExtents(): Extent[];
 }
 
 /**

package/Rendering/Core/ImageCPRMapper.js

@@ -270,7 +270,7 @@ function vtkImageCPRMapper(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   width: 10,
   uniformOrientation: [0, 0, 0, 1],
   useUniformOrientation: false,
@@ -282,14 +282,16 @@ const DEFAULT_VALUES = {
   normalDirection: [0, 0, 1],
   projectionSlabThickness: 1,
   projectionSlabNumberOfSamples: 1,
-  projectionMode: ProjectionMode.MAX
-};
+  projectionMode: ProjectionMode.MAX,
+  updatedExtents: [],
+  ...initialValues
+});
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
 
   // Inheritance
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
@@ -302,7 +304,7 @@ function extend(publicAPI, model) {
   });
 
   // Setters and getters
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode', 'updatedExtents']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageResliceMapper.d.ts

@@ -1,10 +1,9 @@
 import vtkAbstractImageMapper, {
   IAbstractImageMapperInitialValues,
 } from './AbstractImageMapper';
-import vtkImageData from './../../Common/DataModel/ImageData';
 import vtkPlane from './../../Common/DataModel/Plane';
 import vtkPolyData from './../../Common/DataModel/PolyData';
-import { Bounds, Nullable, Vector3 } from './../../types';
+import { Bounds, Extent } from './../../types';
 import { SlabTypes } from './ImageResliceMapper/Constants';
 import CoincidentTopologyHelper, {
   StaticCoincidentTopologyMethods,
@@ -116,6 +115,25 @@ export interface vtkImageResliceMapper
    * @param {vtkPolyData} slicePolyData The polydata to slice the volume with. Default: null
    */
   setSlicePolyData(slicePolyData: vtkPolyData): boolean;
+
+  /**
+   * Tells the mapper to only update the specified extents.
+   *
+   * If there are zero extents, the mapper updates the entire volume texture.
+   * Otherwise, the mapper will only update the texture by the specified extents
+   * during the next render call.
+   *
+   * This array is cleared after a successful render.
+   * @param extents
+   */
+  setUpdatedExtents(extents: Extent[]): boolean;
+
+  /**
+   * Retrieves the updated extents.
+   *
+   * This array is cleared after every successful render.
+   */
+  getUpdatedExtents(): Extent[];
 }
 
 /**

package/Rendering/Core/ImageResliceMapper.js

@@ -38,23 +38,25 @@ function vtkImageResliceMapper(publicAPI, model) {
 // Object factory
 // ----------------------------------------------------------------------------
 
-const DEFAULT_VALUES = {
+const defaultValues = initialValues => ({
   slabThickness: 0.0,
   slabTrapezoidIntegration: 0,
   slabType: SlabTypes.MEAN,
   slicePlane: null,
-  slicePolyData: null
-};
+  slicePolyData: null,
+  updatedExtents: [],
+  ...initialValues
+});
 
 // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
   let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  Object.assign(model, DEFAULT_VALUES, initialValues);
+  Object.assign(model, defaultValues(initialValues));
 
   // Build VTK API
   vtkAbstractImageMapper.extend(publicAPI, model, initialValues);
-  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData']);
+  macro.setGet(publicAPI, model, ['slabThickness', 'slabTrapezoidIntegration', 'slabType', 'slicePlane', 'slicePolyData', 'updatedExtents']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageSlice.d.ts

@@ -17,6 +17,18 @@ export interface vtkImageSlice extends vtkProp3D {
    */
   getActors(): any;
 
+  /**
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBounds(): Bounds;
+
+  /**
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBoundsByReference(): Bounds;
+
   /**
    * Get the bounds for a given slice as [xmin, xmax, ymin, ymax,zmin, zmax].
    * @param {Number} slice The slice index. If undefined, the current slice is considered.
@@ -35,6 +47,11 @@ export interface vtkImageSlice extends vtkProp3D {
    */
   getIsOpaque(): boolean;
 
+  /**
+   *
+   */
+  getProperty(): vtkImageProperty;
+
   /**
    *
    */
@@ -113,6 +130,12 @@ export interface vtkImageSlice extends vtkProp3D {
    */
   setMapper(mapper: vtkAbstractImageMapper): boolean;
 
+  /**
+   *
+   * @param {vtkImageProperty} property The vtkImageProperty instance.
+   */
+  setProperty(property: vtkImageProperty): boolean;
+
   /**
    *
    * @param {boolean} forceOpaque If true, render during opaque pass even if opacity value is below 1.0.
@@ -124,13 +147,6 @@ export interface vtkImageSlice extends vtkProp3D {
    * @param {boolean} forceTranslucent If true, render during translucent pass even if opacity value is 1.0.
    */
   setForceTranslucent(forceTranslucent: boolean): boolean;
-
-  // Inherited from vtkProp3D, but takes a vtkImageProperty instead of a generic vtkObject
-  getProperty(mapperInputPort?: number): vtkImageProperty;
-  getProperties(): vtkImageProperty[];
-  setProperty(mapperInputPort: number, property: vtkImageProperty): boolean;
-  setProperty(property: vtkImageProperty): boolean;
-  setProperties(properties: vtkImageProperty[]): boolean;
 }
 
 /**

package/Rendering/Core/ImageSlice.js

@@ -4,6 +4,10 @@ import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkImageProperty from './ImageProperty.js';
 
+const {
+  vtkDebugMacro
+} = macro;
+
 // ----------------------------------------------------------------------------
 // vtkImageSlice methods
 // ----------------------------------------------------------------------------
@@ -21,11 +25,11 @@ function vtkImageSlice(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.properties[0]) {
+    if (!model.property) {
       // force creation of a property
       publicAPI.getProperty();
     }
-    let isOpaque = model.properties[0].getOpacity() >= 1.0;
+    let isOpaque = model.property.getOpacity() >= 1.0;
 
     // are we using an opaque scalar array, if any?
     isOpaque = isOpaque && (!model.mapper || model.mapper.getIsOpaque());
@@ -39,6 +43,48 @@ function vtkImageSlice(publicAPI, model) {
   // and the Renderer will do the images in their own pass.
   publicAPI.hasTranslucentPolygonalGeometry = () => false;
   publicAPI.makeProperty = vtkImageProperty.newInstance;
+  publicAPI.getProperty = () => {
+    if (model.property === null) {
+      model.property = publicAPI.makeProperty();
+    }
+    return model.property;
+  };
+  publicAPI.getBounds = () => {
+    if (model.mapper === null) {
+      return model.bounds;
+    }
+
+    // Check for the special case when the mapper's bounds are unknown
+    const bds = model.mapper.getBounds();
+    if (!bds || bds.length !== 6) {
+      return bds;
+    }
+
+    // Check for the special case when the actor is empty.
+    if (bds[0] > bds[1]) {
+      model.mapperBounds = bds.concat(); // copy the mapper's bounds
+      model.bounds = [1, -1, 1, -1, 1, -1];
+      model.boundsMTime.modified();
+      return bds;
+    }
+
+    // Check if we have cached values for these bounds - we cache the
+    // values returned by model.mapper.getBounds() and we store the time
+    // of caching. If the values returned this time are different, or
+    // the modified time of this class is newer than the cached time,
+    // then we need to rebuild.
+    const zip = rows => rows[0].map((_, c) => rows.map(row => row[c]));
+    if (!model.mapperBounds || !zip([bds, model.mapperBounds]).reduce((a, b) => a && b[0] === b[1], true) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
+      vtkDebugMacro('Recomputing bounds...');
+      model.mapperBounds = bds.map(x => x);
+      publicAPI.computeMatrix();
+      const tmp4 = new Float64Array(16);
+      mat4.transpose(tmp4, model.matrix);
+      vtkBoundingBox.transformBounds(bds, tmp4, model.bounds);
+      model.boundsMTime.modified();
+    }
+    return model.bounds;
+  };
   publicAPI.getBoundsForSlice = (slice, thickness) => {
     // Check for the special case when the mapper's bounds are unknown
     const bds = model.mapper.getBoundsForSlice(slice, thickness);
@@ -71,6 +117,14 @@ function vtkImageSlice(publicAPI, model) {
 
   // Get the maximum Z bound
   publicAPI.getMaxZBound = () => publicAPI.getBounds()[5];
+  publicAPI.getMTime = () => {
+    let mt = model.mtime;
+    if (model.property !== null) {
+      const time = model.property.getMTime();
+      mt = time > mt ? time : mt;
+    }
+    return mt;
+  };
   publicAPI.getRedrawMTime = () => {
     let mt = model.mtime;
     if (model.mapper !== null) {
@@ -83,13 +137,14 @@ function vtkImageSlice(publicAPI, model) {
         mt = time > mt ? time : mt;
       }
     }
-    model.properties.forEach(property => {
-      mt = Math.max(mt, property.getMTime());
-      const rgbFunc = property.getRGBTransferFunction();
-      if (rgbFunc !== null) {
-        mt = Math.max(mt, rgbFunc.getMTime());
+    if (model.property !== null) {
+      let time = model.property.getMTime();
+      mt = time > mt ? time : mt;
+      if (model.property.getRGBTransferFunction() !== null) {
+        time = model.property.getRGBTransferFunction().getMTime();
+        mt = time > mt ? time : mt;
       }
-    });
+    }
     return mt;
   };
   publicAPI.getSupportsSelection = () => model.mapper ? model.mapper.getSupportsSelection() : false;
@@ -101,8 +156,10 @@ function vtkImageSlice(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   mapper: null,
+  property: null,
   forceOpaque: false,
-  forceTranslucent: false
+  forceTranslucent: false,
+  bounds: [...vtkBoundingBox.INIT_BOUNDS]
 };
 
 // ----------------------------------------------------------------------------
@@ -119,7 +176,9 @@ function extend(publicAPI, model) {
   macro.obj(model.boundsMTime);
 
   // Build VTK API
+  macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['mapper', 'forceOpaque', 'forceTranslucent']);
+  macro.getArray(publicAPI, model, ['bounds'], 6);
 
   // Object methods
   vtkImageSlice(publicAPI, model);

package/Rendering/Core/Mapper.js

@@ -137,11 +137,10 @@ const colorTextureCoordinatesCache = new WeakMap();
  * @param {Range} range The range of the scalars
  * @param {Number} numberOfColorsInRange The number of colors that are used in the range
  * @param {vec3} dimensions The dimensions of the texture
- * @param {boolean} useLogScale If log scale should be used to transform input scalars
  * @param {boolean} useZigzagPattern If a zigzag pattern should be used. Otherwise 1 row for colors (including min and max) and 1 row for NaN are used.
  * @returns A vtkDataArray containing the texture coordinates (2D or 3D)
  */
-function getOrCreateColorTextureCoordinates(input, component, range, numberOfColorsInRange, dimensions, useLogScale, useZigzagPattern) {
+function getOrCreateColorTextureCoordinates(input, component, range, numberOfColorsInRange, dimensions, useZigzagPattern) {
   // Caching using the "arguments" special object (because it is a pure function)
   const argStrings = new Array(arguments.length);
   for (let argIndex = 0; argIndex < arguments.length; ++argIndex) {
@@ -202,11 +201,6 @@ function getOrCreateColorTextureCoordinates(input, component, range, numberOfCol
     }
     inputIdx += numComps;
 
-    // Apply log scale if necessary
-    if (useLogScale) {
-      scalarValue = vtkLookupTable.applyLogScale(scalarValue, range, range);
-    }
-
     // Convert to texture coordinates and update output
     if (isNan(scalarValue)) {
       // Last texels are NaN colors (there is at least one NaN color)
@@ -401,10 +395,6 @@ function vtkMapper(publicAPI, model) {
   model.mapScalarsToTexture = (scalars, cellFlag, alpha) => {
     const range = model.lookupTable.getRange();
     const useLogScale = model.lookupTable.usingLogScale();
-    if (useLogScale) {
-      // convert range to log.
-      vtkLookupTable.getLogRange(range, range);
-    }
     const origAlpha = model.lookupTable.getAlpha();
 
     // Get rid of vertex color array.  Only texture or vertex coloring
@@ -448,14 +438,16 @@ function vtkMapper(publicAPI, model) {
       const numberOfNonSpecialColors = model.numberOfColorsInRange;
       const numberOfNonNaNColors = numberOfNonSpecialColors + 2;
       const textureCoordinates = [0, 0, 0];
-      const rangeMin = range[0];
-      const rangeDifference = range[1] - range[0];
+      const scaledRange = useLogScale ? [Math.log10(range[0]), Math.log10(range[1])] : range;
+      const rangeMin = scaledRange[0];
+      const rangeDifference = scaledRange[1] - scaledRange[0];
       for (let i = 0; i < numberOfNonNaNColors; ++i) {
         const scalarsArrayIndex = getIndexFromCoordinates(textureCoordinates, textureDimensions);
 
         // Minus 1 start at min color
-        const scalarValue = rangeMin + rangeDifference * (i - 1) / (numberOfNonSpecialColors - 1);
-        scalarsArray[scalarsArrayIndex] = useLogScale ? 10.0 ** scalarValue : scalarValue;
+        const intermediateValue = rangeMin + rangeDifference * (i - 1) / (numberOfNonSpecialColors - 1);
+        const scalarValue = useLogScale ? 10.0 ** intermediateValue : intermediateValue;
+        scalarsArray[scalarsArrayIndex] = scalarValue;
 
         // Colors are zigzagging to allow interpolation between two neighbor colors when coloring cells
         updateZigzaggingCoordinates(textureCoordinates, textureDimensions);
@@ -480,7 +472,7 @@ function vtkMapper(publicAPI, model) {
     // A zigzag pattern can be used with cell data, as there will be no texture coordinates interpolation
     // The texture generated using a zigzag pattern in one dimension is the same as without zigzag
     // Therefore, the same code can be used for texture generation of point/cell data but not for texture coordinates
-    model.colorCoordinates = getOrCreateColorTextureCoordinates(scalars, scalarComponent, range, model.numberOfColorsInRange, model.colorTextureMap.getDimensions(), useLogScale, cellFlag);
+    model.colorCoordinates = getOrCreateColorTextureCoordinates(scalars, scalarComponent, range, model.numberOfColorsInRange, model.colorTextureMap.getDimensions(), cellFlag);
   };
   publicAPI.getIsOpaque = () => {
     const input = publicAPI.getInputData();

package/Rendering/Core/Prop3D.d.ts

@@ -1,7 +1,6 @@
 import { mat4, quat } from 'gl-matrix';
 import { Bounds, Vector3, Range } from './../../types';
 import vtkProp, { IPropInitialValues } from './Prop';
-import { vtkObject } from './../../interfaces';
 
 export interface IProp3DInitialValues extends IPropInitialValues {
   origin?: number[];
@@ -20,17 +19,11 @@ export interface vtkProp3D extends vtkProp {
   addPosition(deltaXYZ: number[]): void;
 
   /**
-   * Get the bounds of this actor as [xmin, xmax, ymin, ymax, zmin, zmax].
-   * They are the bounds of the underlying mapper, transformed using the actor's matrix.
-   * @return {Bounds} The bounds for the actor.
+   * Get the bounds as [xmin, xmax, ymin, ymax, zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
    */
   getBounds(): Bounds;
 
-  /**
-   * Same as getBounds() but the returned array is not copied, so it should not be written to.
-   */
-  getBoundsByReference(): Bounds;
-
   /**
    * Check if there was a modification or transformation.
    * @default null
@@ -138,21 +131,6 @@ export interface vtkProp3D extends vtkProp {
    */
   getUserMatrix(): mat4;
 
-  /**
-   * Get the actor property for the specified mapper input port, which defaults to 0
-   * It controls this actors rendering properties. If one isn’t specified,
-   * then one will be generated automatically. Multiple actors can share one
-   * property object.
-   * @param {number} mapperInputPort Defaults to 0
-   */
-  getProperty(mapperInputPort?: number): vtkObject;
-
-  /**
-   * Get the actor properties array
-   * Each element of the array corresponds to a mapper input port
-   */
-  getProperties(): vtkObject[];
-
   /**
    * Rotate the Prop3D in degrees about the X axis using the right hand
    * rule. The axis is the Prop3D’s X axis, which can change as other
@@ -278,21 +256,6 @@ export interface vtkProp3D extends vtkProp {
    * Generate the matrix based on internal model.
    */
   computeMatrix(): void;
-
-  /**
-   * Set the actor property for the specified mapper input port, which defaults to 0
-   * @param {vtkObject} property
-   * @param {number} mapperInputPort Is 0 when not given
-   */
-  setProperty(mapperInputPort: number, property: vtkObject): boolean;
-  setProperty(property: vtkObject): boolean;
-
-  /**
-   * Set the actor properties array
-   * Each element of the array corresponds to a mapper input port
-   * @param {vtkObject[]} properties
-   */
-  setProperties(properties: vtkObject[]): boolean;
 }
 
 /**

package/Rendering/Core/Prop3D.js

@@ -121,54 +121,6 @@ function vtkProp3D(publicAPI, model) {
       model.matrixMTime.modified();
     }
   };
-  publicAPI.getBoundsByReference = () => {
-    if (model.mapper === null) {
-      return model.bounds;
-    }
-
-    // Check for the special case when the mapper's bounds are unknown
-    const bds = model.mapper.getBounds();
-    if (!bds || bds.length !== 6) {
-      return bds;
-    }
-
-    // Check for the special case when the actor is empty.
-    if (bds[0] > bds[1]) {
-      // No need to copy bds, a new array is created when calling getBounds()
-      model.mapperBounds = bds;
-      model.bounds = [...vtkBoundingBox.INIT_BOUNDS];
-      model.boundsMTime.modified();
-      return bds;
-    }
-
-    // Check if we have cached values for these bounds - we cache the
-    // values returned by model.mapper.getBounds() and we store the time
-    // of caching. If the values returned this time are different, or
-    // the modified time of this class is newer than the cached time,
-    // then we need to rebuild.
-    if (!model.mapperBounds || !bds.every((_, i) => bds[i] === model.mapperBounds[i]) || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
-      macro.vtkDebugMacro('Recomputing bounds...');
-      // No need to copy bds, a new array is created when calling getBounds()
-      model.mapperBounds = bds;
-
-      // Compute actor bounds from matrix and mapper bounds
-      publicAPI.computeMatrix();
-      const transposedMatrix = new Float64Array(16);
-      mat4.transpose(transposedMatrix, model.matrix);
-      vtkBoundingBox.transformBounds(bds, transposedMatrix, model.bounds);
-      model.boundsMTime.modified();
-    }
-    return model.bounds;
-  };
-  publicAPI.getBounds = () => {
-    const bounds = publicAPI.getBoundsByReference();
-    // Handle case when bounds are not iterable (for example null or undefined)
-    try {
-      return [...bounds];
-    } catch {
-      return bounds;
-    }
-  };
   publicAPI.getCenter = () => vtkBoundingBox.getCenter(model.bounds);
   publicAPI.getLength = () => vtkBoundingBox.getLength(model.bounds);
   publicAPI.getXRange = () => vtkBoundingBox.getXRange(model.bounds);
@@ -179,35 +131,6 @@ function vtkProp3D(publicAPI, model) {
     publicAPI.computeMatrix();
   }
   publicAPI.onModified(updateIdentityFlag);
-  publicAPI.getProperty = function () {
-    let mapperInputPort = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    if (model.properties[mapperInputPort] == null) {
-      model.properties[mapperInputPort] = publicAPI.makeProperty?.();
-    }
-    return model.properties[mapperInputPort];
-  };
-  publicAPI.setProperty = (firstArg, secondArg) => {
-    // Two options for argument layout:
-    // - (mapperInputPort, property)
-    // - (property)
-    const useInputPortArgument = Number.isInteger(firstArg);
-    const [mapperInputPort, property] = useInputPortArgument ? [firstArg, secondArg] : [0, firstArg];
-    if (model.properties[mapperInputPort] === property) {
-      return false;
-    }
-    model.properties[mapperInputPort] = property;
-    return true;
-  };
-  publicAPI.getMTime = () => {
-    let mt = model.mtime;
-    model.properties.forEach(property => {
-      if (property !== null) {
-        const time = property.getMTime();
-        mt = time > mt ? time : mt;
-      }
-    });
-    return mt;
-  };
 }
 
 // ----------------------------------------------------------------------------
@@ -220,8 +143,7 @@ const DEFAULT_VALUES = {
   orientation: [0, 0, 0],
   rotation: null,
   scale: [1, 1, 1],
-  bounds: [...vtkBoundingBox.INIT_BOUNDS],
-  properties: [],
+  bounds: [1, -1, 1, -1, 1, -1],
   userMatrix: null,
   userMatrixMTime: null,
   cachedProp3D: null,
@@ -241,10 +163,9 @@ function extend(publicAPI, model) {
   macro.obj(model.matrixMTime);
 
   // Build VTK API
-  macro.get(publicAPI, model, ['isIdentity']);
+  macro.get(publicAPI, model, ['bounds', 'isIdentity']);
   macro.getArray(publicAPI, model, ['orientation']);
   macro.setGetArray(publicAPI, model, ['origin', 'position', 'scale'], 3);
-  macro.setGet(publicAPI, model, ['properties']);
 
   // Object internal instance
   model.matrix = mat4.identity(new Float64Array(16));

package/Rendering/Core/ScalarBarActor.js

@@ -566,8 +566,10 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     const tickSegmentSize = model.barSize[spacedAxis] * (tickSeg.corners[2][spacedAxis] - tickSeg.corners[0][spacedAxis]);
     const ticks = publicAPI.getTicks();
     const tickStrings = publicAPI.getTickStrings();
+    const tickPositions = publicAPI.getTickPositions();
     for (let t = 0; t < ticks.length; t++) {
-      const tickPos = (ticks[t] - model.lastTickBounds[0]) / (model.lastTickBounds[1] - model.lastTickBounds[0]);
+      // If tickPositions is not set, use a normalized position
+      const tickPos = tickPositions ? tickPositions[t] : (ticks[t] - model.lastTickBounds[0]) / (model.lastTickBounds[1] - model.lastTickBounds[0]);
       tmpv3[spacedAxis] = tickSegmentStart + tickSegmentSize * tickPos;
       publicAPI.createPolyDataForOneLabel(tickStrings[t], tmpv3, alignment, 'horizontal', tickOffsets, results);
     }
@@ -651,7 +653,7 @@ const newScalarBarActorHelper = macro.newInstance(function (publicAPI, model) {
 
   // Inheritance
   macro.obj(publicAPI, model);
-  macro.setGet(publicAPI, model, ['axisTitlePixelOffset', 'tickLabelPixelOffset', 'renderable', 'topTitle', 'ticks', 'tickStrings']);
+  macro.setGet(publicAPI, model, ['axisTitlePixelOffset', 'tickLabelPixelOffset', 'renderable', 'topTitle', 'ticks', 'tickStrings', 'tickPositions']);
   macro.get(publicAPI, model, ['lastSize', 'lastAspectRatio', 'lastTickBounds', 'axisTextStyle', 'tickTextStyle', 'barActor', 'tmActor']);
   macro.getArray(publicAPI, model, ['boxPosition', 'boxSize']);
   macro.setArray(publicAPI, model, ['boxPosition', 'boxSize'], 2);

package/Rendering/Core/Viewport.js

@@ -46,10 +46,20 @@ function vtkViewport(publicAPI, model) {
     return allProps;
   }
   publicAPI.getViewPropsWithNestedProps = () => {
-    const allPropsArray = [];
-    for (let i = 0; i < model.props.length; i++) {
-      gatherProps(model.props[i], allPropsArray);
+    let allPropsArray = [];
+    // Handle actor2D instances separately so that they can be overlayed and layered
+    const actors2D = publicAPI.getActors2D();
+    // Sort the actor2D list using its layer number
+    actors2D.sort((a, b) => a.getLayerNumber() - b.getLayerNumber());
+    // Filter out all the actor2D instances
+    const newPropList = model.props.filter(item => !actors2D.includes(item));
+    for (let i = 0; i < newPropList.length; i++) {
+      gatherProps(newPropList[i], allPropsArray);
     }
+    // Finally, add the actor2D props at the end of the list
+    // This works because, when traversing the render pass in vtkOpenGLRenderer, the children are
+    // traversed in the order that they are added to the list
+    allPropsArray = allPropsArray.concat(actors2D);
     return allPropsArray;
   };
   publicAPI.addActor2D = publicAPI.addViewProp;

package/Rendering/Core/Volume.d.ts

@@ -29,6 +29,22 @@ export interface vtkVolume extends vtkProp3D {
    */
   getVolumes(): vtkVolume[];
 
+  /**
+   * Get the volume property
+   */
+  getProperty(): vtkVolumeProperty;
+
+  /**
+   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
+   * @return {Bounds} The bounds for the mapper.
+   */
+  getBounds(): Bounds;
+
+  /**
+   * Get the bounds as [xmin, xmax, ymin, ymax, zmin, zmax].
+   */
+  getBoundsByReference(): Bounds;
+
   /**
    * Get the `Modified Time` which is a monotonic increasing integer
    * global for all vtkObjects.
@@ -59,12 +75,11 @@ export interface vtkVolume extends vtkProp3D {
    */
   setMapper(mapper: vtkVolumeMapper): boolean;
 
-  // Inherited from vtkProp3D, but takes a vtkVolumeProperty instead of a generic vtkObject
-  getProperty(mapperInputPort?: number): vtkVolumeProperty;
-  getProperties(): vtkVolumeProperty[];
-  setProperty(mapperInputPort: number, property: vtkVolumeProperty): boolean;
+  /**
+   * Set the volume property
+   * @param {vtkVolumeProperty} property
+   */
   setProperty(property: vtkVolumeProperty): boolean;
-  setProperties(properties: vtkVolumeProperty[]): boolean;
 }
 
 /**