@kitware/vtk.js 33.3.2 → 34.0.0-beta.2

package/BREAKING_CHANGES.md

@@ -1,3 +1,13 @@
+## From 33.x to 34
+
+- **vtkMapper**: many properties have moved to `vtkVolumeProperty`. The full list of changed methods is: `getAnisotropy`, `getComputeNormalFromOpacity`, `getFilterMode`, `getFilterModeAsString`, `getGlobalIlluminationReach`, `getIpScalarRange`, `getIpScalarRangeByReference`, `getLAOKernelRadius`, `getLAOKernelSize`, `getLocalAmbientOcclusion`, `getPreferSizeOverAccuracy`, `getVolumetricScatteringBlending`, `setAnisotropy`, `setAverageIPScalarRange`, `setComputeNormalFromOpacity`, `setFilterMode`, `setFilterModeToNormalized`, `setFilterModeToOff`, `setFilterModeToRaw`, `setGlobalIlluminationReach`, `setIpScalarRange`, `setIpScalarRangeFrom`, `setLAOKernelRadius`, `setLAOKernelSize`, `setLocalAmbientOcclusion`, `setPreferSizeOverAccuracy`, `setVolumetricScatteringBlending`.
+- **vtkRenderWindowInteractor**: KeyPress, KeyDown and KeyUp events are now observed on the container and no longer on the document. "tabIndex=0" is now automatically added on RWI containers to give focus on your render windows and catch key events. Check the KeyPressEvents example for usage.
+- **vtkOpenGLTexture**: The public `create2D*` and `create3D*` methods used to have positional parameters. These methods now use named parameters via passing in an object record.
+
+## From 32.x to 33
+
+- **vtkColorTransferFunction**, **vtkMapper**: Previous log scaling was disabled but functionality is now quite different from what it maybe was before it was disabled. ColorTransfer function now maps the model.nodes in logarithmic scales so there's an even spacing between powers of ten.
+
 ## From 31.x to 32
 
 - **vtkMapper**: remove `mapScalarsToTexture` from the public API. The function becomes protected and its API changes. This shouldn't cause any issue in most cases.

package/IO/Geometry/GLTFImporter/Decoder.js

@@ -1,79 +1,65 @@
 import BinaryHelper from '../../Core/BinaryHelper.js';
-import { BINARY_HEADER_LENGTH, BINARY_HEADER_MAGIC, BINARY_CHUNK_TYPES, BINARY_CHUNK_HEADER_INTS, BINARY_HEADER_INTS } from './Constants.js';
+import { BINARY_HEADER_MAGIC, BINARY_CHUNK_TYPES, BINARY_CHUNK_HEADER_INTS, BINARY_HEADER_LENGTH, BINARY_HEADER_INTS } from './Constants.js';
 
 function getChunkInfo(headerStart, data) {
-  // Cache array view
   const header = new Uint32Array(data, headerStart, BINARY_CHUNK_HEADER_INTS);
   const chunkStart = headerStart + BINARY_CHUNK_HEADER_INTS * 4;
+  const chunkLength = header[0];
+  const chunkType = header[1];
   return {
     start: chunkStart,
-    length: header[0],
-    type: header[1]
+    length: chunkLength,
+    type: chunkType
   };
 }
 function getAllChunkInfos(data) {
-  // Pre-calculate array size
-  const maxChunks = Math.floor((data.byteLength - BINARY_HEADER_LENGTH) / 8);
-  const infos = new Array(maxChunks);
+  const infos = [];
   let chunkStart = BINARY_HEADER_INTS * 4;
-  let chunkCount = 0;
   while (chunkStart < data.byteLength) {
     const chunkInfo = getChunkInfo(chunkStart, data);
-    infos[chunkCount++] = chunkInfo;
+    infos.push(chunkInfo);
     chunkStart += chunkInfo.length + BINARY_CHUNK_HEADER_INTS * 4;
   }
-
-  // Trim array to actual size
-  return infos.slice(0, chunkCount);
+  return infos;
 }
 function getJsonFromChunk(chunkInfo, data) {
+  const chunkLength = chunkInfo.length;
   const jsonStart = (BINARY_HEADER_INTS + BINARY_CHUNK_HEADER_INTS) * 4;
-  const jsonView = new Uint8Array(data, jsonStart, chunkInfo.length);
-  const decoder = new TextDecoder('utf-8');
-  const jsonString = decoder.decode(jsonView);
-  return JSON.parse(jsonString);
+  const jsonSlice = new Uint8Array(data, jsonStart, chunkLength);
+  const stringBuffer = BinaryHelper.arrayBufferToString(jsonSlice);
+  return JSON.parse(stringBuffer);
 }
 function getBufferFromChunk(chunkInfo, data) {
   return data.slice(chunkInfo.start, chunkInfo.start + chunkInfo.length);
 }
 function parseGLB(data) {
-  if (data.byteLength < BINARY_HEADER_LENGTH) {
-    throw new Error('Invalid GLB: File too small');
-  }
-
-  // Cache DataView
+  let json;
+  const buffers = [];
   const headerView = new DataView(data, 0, BINARY_HEADER_LENGTH);
-  const magic = new Uint8Array(data, 0, 4);
   const header = {
-    magic: BinaryHelper.arrayBufferToString(magic),
+    magic: BinaryHelper.arrayBufferToString(new Uint8Array(data, 0, 4)),
     version: headerView.getUint32(4, true),
     length: headerView.getUint32(8, true)
   };
   if (header.magic !== BINARY_HEADER_MAGIC) {
     throw new Error('Unsupported glTF-Binary header.');
-  }
-  if (header.version < 2.0) {
+  } else if (header.version < 2.0) {
     throw new Error('Unsupported legacy binary file detected.');
   }
-  if (header.length > data.byteLength) {
-    throw new Error('Invalid GLB: Declared length exceeds file size');
-  }
   const chunkInfos = getAllChunkInfos(data);
-  let json = null;
-  const buffers = [];
-
-  // Process chunks sequentially
-  for (let i = 0; i < chunkInfos.length; i++) {
-    const chunkInfo = chunkInfos[i];
+  chunkInfos.forEach(chunkInfo => {
     if (chunkInfo.type === BINARY_CHUNK_TYPES.JSON && !json) {
       json = getJsonFromChunk(chunkInfo, data);
     } else if (chunkInfo.type === BINARY_CHUNK_TYPES.BIN) {
       buffers.push(getBufferFromChunk(chunkInfo, data));
     }
-  }
+  });
   if (!json) {
     throw new Error('glTF-Binary: JSON content not found.');
   }
+  if (!buffers) {
+    throw new Error('glTF-Binary: Binary chunk not found.');
+  }
   return {
     json,
     buffers

package/IO/Geometry/GLTFImporter/ORMTexture.worker.js

@@ -0,0 +1,42 @@
+import registerWebworker from 'webworker-promise/lib/register';
+
+/**
+ *
+ * @param {ArrayBuffer} imageBuffer
+ * @param {string} mimeType
+ * @param {string} channel
+ * @returns {Promise<ImageData>}
+ */
+registerWebworker(async _ref => {
+  let {
+    imageBuffer,
+    mimeType,
+    channel
+  } = _ref;
+  const channelsMap = {
+    r: 0,
+    g: 1,
+    b: 2
+  };
+  const blob = new Blob([imageBuffer], {
+    type: mimeType
+  });
+  const img = await createImageBitmap(blob);
+  const canvas = new OffscreenCanvas(img.width, img.height);
+  const ctx = canvas.getContext('2d');
+  ctx.drawImage(img, 0, 0, img.width, img.height);
+  const bitmap = ctx.getImageData(0, 0, img.width, img.height);
+  if (channel) {
+    const idx = channelsMap[channel];
+    for (let i = 0; i < bitmap.data.length; i += 4) {
+      const channelValue = bitmap.data[i + idx];
+      bitmap.data[i] = channelValue; // red channel
+      bitmap.data[i + 1] = channelValue; // green channel
+      bitmap.data[i + 2] = channelValue; // blue channel
+    }
+  }
+
+  return {
+    bitmap
+  };
+});

package/IO/Geometry/GLTFImporter/Parser.js

@@ -210,24 +210,15 @@ class GLTFParser {
     if (accessor.bufferView) {
       const buffer = accessor.bufferView.buffer;
       const {
-        ArrayType
+        ArrayType,
+        byteLength
       } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
-      const baseByteOffset = (accessor.bufferView.byteOffset || 0) + buffer.byteOffset;
-      const byteOffset = baseByteOffset + (accessor.byteOffset || 0);
-      let arrayBufferView;
+      const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
+      let slicedBufffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
       if (accessor.bufferView.byteStride) {
-        // Only extract if stride is not equal to element size
-        if (accessor.bufferView.byteStride === accessor.bytesPerElement) {
-          arrayBufferView = new ArrayType(buffer.arrayBuffer, byteOffset, accessor.count * accessor.components);
-        } else {
-          // Interleaved buffer, extract only needed bytes
-          const interleavedBuffer = this.getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
-          arrayBufferView = new ArrayType(interleavedBuffer);
-        }
-      } else {
-        arrayBufferView = new ArrayType(buffer.arrayBuffer, byteOffset, accessor.count * accessor.components);
+        slicedBufffer = this.getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
       }
-      accessor.value = arrayBufferView;
+      accessor.value = new ArrayType(slicedBufffer);
     }
     return accessor;
   }

package/IO/Geometry/GLTFImporter/Reader.js

@@ -149,7 +149,6 @@ async function createPolyDataFromGLTFMesh(primitive) {
       polyData.setStrips(cells);
       break;
     default:
-      cells.delete();
       vtkWarningMacro('Invalid primitive draw mode. Ignoring connectivity.');
   }
   return polyData;
@@ -199,7 +198,15 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
       const sampler = tex.sampler;
       const image = await loadImage(tex.source);
       const diffuseTex = createVTKTextureFromGLTFTexture(image, sampler);
-      property.setDiffuseTexture(diffuseTex);
+
+      // FIXME: Workaround for textures not showing up in WebGL
+      const viewAPI = model.renderer.getRenderWindow();
+      const isWebGL = viewAPI.getViews()[0].isA('vtkOpenGLRenderWindow');
+      if (isWebGL) {
+        actor.addTexture(diffuseTex);
+      } else {
+        property.setDiffuseTexture(diffuseTex);
+      }
     }
 
     // Handle metallic-roughness texture (metallicRoughnessTexture)
@@ -217,7 +224,7 @@ async function createPropertyFromGLTFMaterial(model, material, actor) {
       material.occlusionTexture.extensions;
       const tex = material.occlusionTexture.texture;
       const sampler = tex.sampler;
-      const aoImage = await loadImage(tex.source);
+      const aoImage = await loadImage(tex.source, 'r');
       const aoTex = createVTKTextureFromGLTFTexture(aoImage, sampler);
       property.setAmbientOcclusionTexture(aoTex);
     }
@@ -292,8 +299,6 @@ function handlePrimitiveExtensions(nodeId, extensions, model) {
       case 'KHR_materials_variants':
         model.variantMappings.set(nodeId, extension.mappings);
         break;
-      case 'KHR_draco_mesh_compression':
-        break;
       default:
         vtkWarningMacro(`Unhandled extension: ${extensionName}`);
     }
@@ -309,7 +314,6 @@ async function createActorFromGTLFNode(worldMatrix) {
   const actor = vtkActor.newInstance();
   const mapper = vtkMapper.newInstance();
   mapper.setColorModeToDirectScalars();
-  mapper.setInterpolateScalarsBeforeMapping(true);
   actor.setMapper(mapper);
   actor.setUserMatrix(worldMatrix);
   const polydata = vtkPolyData.newInstance();
@@ -326,7 +330,6 @@ async function createActorFromGTLFPrimitive(model, primitive, worldMatrix) {
   const actor = vtkActor.newInstance();
   const mapper = vtkMapper.newInstance();
   mapper.setColorModeToDirectScalars();
-  mapper.setInterpolateScalarsBeforeMapping(true);
   actor.setMapper(mapper);
   actor.setUserMatrix(worldMatrix);
   const polydata = await createPolyDataFromGLTFMesh(primitive);

package/IO/Geometry/GLTFImporter/Utils.js

@@ -1,5 +1,7 @@
+import WebworkerPromise from 'webworker-promise';
 import { m as macro } from '../../../macros2.js';
 import vtkTexture from '../../../Rendering/Core/Texture.js';
+import { W as WorkerFactory } from '../../../_virtual/rollup-plugin-worker-loader__module_Sources/IO/Geometry/GLTFImporter/ORMTexture.worker.js';
 import { ARRAY_TYPES, COMPONENTS, BYTES, GL_SAMPLER } from './Constants.js';
 
 const {
@@ -81,18 +83,33 @@ function resolveUrl(url, originalPath) {
 /**
  * Loads image from buffer or URI
  * @param {*} image
+ * @param {*} channel
  * @returns
  */
-async function loadImage(image) {
+async function loadImage(image, channel) {
+  let forceReLoad = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  // Initialize cache if it doesn't exist
+  if (!image.cache) {
+    image.cache = {};
+  }
+
+  // Return cached result for the channel if available and not forced to reload
+  if (!forceReLoad && image.cache[channel]) {
+    return image.cache[channel];
+  }
+  const worker = new WebworkerPromise(new WorkerFactory());
   if (image.bufferView) {
-    const blob = new Blob([image.bufferView.data], {
-      type: image.mimeType
-    });
-    const bitmap = await createImageBitmap(blob, {
-      colorSpaceConversion: 'none',
-      imageOrientation: 'flipY'
+    return worker.postMessage({
+      imageBuffer: image.bufferView.data,
+      mimeType: image.mimeType,
+      channel
+    }).then(result => {
+      // Cache the bitmap based on the channel
+      image.cache[channel] = result.bitmap;
+      return result.bitmap;
+    }).finally(() => {
+      worker.terminate();
     });
-    return bitmap;
   }
   if (image.uri) {
     vtkWarningMacro('Falling back to image uri', image.uri);
@@ -100,6 +117,7 @@ async function loadImage(image) {
       const img = new Image();
       img.crossOrigin = 'Anonymous';
       img.onload = () => {
+        image.cache[channel] = img; // Cache the loaded image based on the channel
         resolve(img);
       };
       img.onerror = reject;
@@ -140,7 +158,7 @@ function createVTKTextureFromGLTFTexture(image, sampler, extensions) {
       texture.setEdgeClamp(true);
     }
   }
-  texture.setImageBitmap(image);
+  texture.setJsImageData(image);
   return texture;
 }
 

package/Interaction/Manipulators/KeyboardCameraManipulator.d.ts

@@ -0,0 +1,113 @@
+import { Vector3 } from './../../types';
+import { vtkObject } from './../../interfaces';
+import vtkCompositeKeyboardManipulator from './CompositeKeyboardManipulator';
+import vtkRenderWindowInteractor from './../../Rendering/Core/RenderWindowInteractor';
+import vtkCamera from './../../Rendering/Core/Camera';
+import vtkRenderer from './../../Rendering/Core/Renderer';
+
+export interface vtkKeyboardCameraManipulator
+  extends vtkObject,
+    vtkCompositeKeyboardManipulator {
+  /**
+   * Returns whether a movement is ongoing.
+   */
+  inMotion(): boolean;
+
+  /**
+   * Reset the movement speed to be proportional to the longest length of the renderer's bounds.
+   */
+  resetMovementSpeed(): void;
+
+  /**
+   * Initialize a movement of the current camera.
+   */
+  startMovement(): void;
+
+  /**
+   * Cancel any ongoing camera movement.
+   */
+  endMovement(): void;
+
+  /**
+   * Update active camera direction, depending on currently pressed keys.
+   */
+  calculateCurrentDirection(): void;
+
+  /**
+   * Returns the direction vector of the given camera for the given key.
+   * @param key the movedkey
+   * @param camera the camera
+   */
+  getDirectionFromKey(key: KeyboardEvent['key'], camera: vtkCamera): Vector3;
+
+  /**
+   * Moves the given camera, in the given direction, at the given speed.
+   * @param camera the moved camera
+   * @param direction the direction of the movemnt
+   * @param speed the speed
+   */
+  moveCamera(camera: vtkCamera, direction: Vector3, speed: number): void;
+
+  /**
+   * Handles a keypress event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyPress(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keydown event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyDown(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+
+  /**
+   * Handles a keyup event.
+   * @param interactor the interactor
+   * @param renderer the renderer
+   * @param key the key
+   */
+  onKeyUp(
+    interactor: vtkRenderWindowInteractor,
+    renderer: vtkRenderer,
+    key: KeyboardEvent['key']
+  ): void;
+}
+
+export interface IKeyboardCameraManipulatorInitialValues {
+  movementSpeed?: number;
+  moveForwardKeys?: KeyboardEvent['key'][];
+  moveLeftKeys?: KeyboardEvent['key'][];
+  moveBackwardKeys?: KeyboardEvent['key'][];
+  moveRightKeys?: KeyboardEvent['key'][];
+  moveUpKeys?: KeyboardEvent['key'][];
+  moveDownKeys?: KeyboardEvent['key'][];
+}
+
+export function newInstance(
+  initialValues?: IKeyboardCameraManipulatorInitialValues
+): vtkKeyboardCameraManipulator;
+
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IKeyboardCameraManipulatorInitialValues
+): void;
+
+export const vtkKeyboardCameraManipulator: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+
+export default vtkKeyboardCameraManipulator;

package/Rendering/Core/Actor.d.ts

@@ -36,12 +36,6 @@ export interface vtkActor extends vtkProp3D {
    */
   getBackfaceProperty(): vtkProperty;
 
-  /**
-   * Get the bounds for this mapper as [xmin, xmax, ymin, ymax,zmin, zmax].
-   * @return {Bounds} The bounds for the mapper.
-   */
-  getBounds(): Bounds;
-
   /**
    * Check whether the opaque is forced or not.
    */
@@ -63,16 +57,6 @@ export interface vtkActor extends vtkProp3D {
    */
   getMapper(): Nullable<vtkMapper>;
 
-  /**
-   * Get the property object that controls this actors surface
-   * properties. This should be an instance of a vtkProperty object. Every
-   * actor must have a property associated with it. If one isn’t specified,
-   * then one will be generated automatically. Multiple actors can share one
-   * property object.
-   * @return {vtkProperty} The property object
-   */
-  getProperty(): vtkProperty;
-
   /**
    * Check whether if the actor supports selection
    * @return {Boolean} true if the actor support selection.
@@ -111,11 +95,12 @@ export interface vtkActor extends vtkProp3D {
    */
   setMapper(mapper: vtkMapper): boolean;
 
-  /**
-   * Set the property object that controls this actors surface properties.
-   * @param {vtkProperty} property The vtkProperty instance.
-   */
+  // Inherited from vtkProp3D, but takes a vtkProperty instead of a generic vtkObject
+  getProperty(mapperInputPort?: number): vtkProperty;
+  getProperties(): vtkProperty[];
+  setProperty(mapperInputPort: number, property: vtkProperty): boolean;
   setProperty(property: vtkProperty): boolean;
+  setProperties(properties: vtkProperty[]): boolean;
 }
 
 /**

package/Rendering/Core/Actor.js

@@ -1,13 +1,7 @@
-import { mat4, vec3 } from 'gl-matrix';
 import { m as macro } from '../../macros2.js';
-import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkProp3D from './Prop3D.js';
 import vtkProperty from './Property.js';
 
-const {
-  vtkDebugMacro
-} = macro;
-
 // ----------------------------------------------------------------------------
 // vtkActor methods
 // ----------------------------------------------------------------------------
@@ -29,11 +23,11 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (!model.property) {
+    if (!model.properties[0]) {
       // force creation of a property
       publicAPI.getProperty();
     }
-    let isOpaque = model.property.getOpacity() >= 1.0;
+    let isOpaque = model.properties[0].getOpacity() >= 1.0;
 
     // are we using an opaque texture, if any?
     isOpaque = isOpaque && (!model.texture || !model.texture.isTranslucent());
@@ -47,71 +41,17 @@ function vtkActor(publicAPI, model) {
       return false;
     }
     // make sure we have a property
-    if (model.property === null) {
+    if (!model.properties[0]) {
       // force creation of a property
-      publicAPI.setProperty(publicAPI.makeProperty());
+      publicAPI.getProperty();
     }
 
     // is this actor opaque ?
     return !publicAPI.getIsOpaque();
   };
   publicAPI.makeProperty = vtkProperty.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.
-    if (!model.mapperBounds || bds[0] !== model.mapperBounds[0] || bds[1] !== model.mapperBounds[1] || bds[2] !== model.mapperBounds[2] || bds[3] !== model.mapperBounds[3] || bds[4] !== model.mapperBounds[4] || bds[5] !== model.mapperBounds[5] || publicAPI.getMTime() > model.boundsMTime.getMTime()) {
-      vtkDebugMacro('Recomputing bounds...');
-      model.mapperBounds = bds.concat(); // copy the mapper's bounds
-      const bbox = [];
-      vtkBoundingBox.getCorners(bds, bbox);
-      publicAPI.computeMatrix();
-      const tmp4 = new Float64Array(16);
-      mat4.transpose(tmp4, model.matrix);
-      bbox.forEach(pt => vec3.transformMat4(pt, pt, tmp4));
-
-      /* eslint-disable no-multi-assign */
-      model.bounds[0] = model.bounds[2] = model.bounds[4] = Number.MAX_VALUE;
-      model.bounds[1] = model.bounds[3] = model.bounds[5] = -Number.MAX_VALUE;
-      /* eslint-enable no-multi-assign */
-
-      model.bounds = model.bounds.map((d, i) => i % 2 === 0 ? bbox.reduce((a, b) => a > b[i / 2] ? b[i / 2] : a, d) : bbox.reduce((a, b) => a < b[(i - 1) / 2] ? b[(i - 1) / 2] : a, d));
-      model.boundsMTime.modified();
-    }
-    return model.bounds;
-  };
   publicAPI.getMTime = () => {
     let mt = superClass.getMTime();
-    if (model.property !== null) {
-      const time = model.property.getMTime();
-      mt = time > mt ? time : mt;
-    }
     if (model.backfaceProperty !== null) {
       const time = model.backfaceProperty.getMTime();
       mt = time > mt ? time : mt;
@@ -146,11 +86,9 @@ function vtkActor(publicAPI, model) {
 
 const DEFAULT_VALUES = {
   mapper: null,
-  property: null,
   backfaceProperty: null,
   forceOpaque: false,
-  forceTranslucent: false,
-  bounds: [1, -1, 1, -1, 1, -1]
+  forceTranslucent: false
 };
 
 // ----------------------------------------------------------------------------
@@ -167,7 +105,6 @@ function extend(publicAPI, model) {
   macro.obj(model.boundsMTime);
 
   // Build VTK API
-  macro.set(publicAPI, model, ['property']);
   macro.setGet(publicAPI, model, ['backfaceProperty', 'forceOpaque', 'forceTranslucent', 'mapper']);
 
   // Object methods

package/Rendering/Core/ImageCPRMapper.d.ts

@@ -1,5 +1,5 @@
 import { mat3, mat4, quat, vec3 } from 'gl-matrix';
-import { Extent, Nullable } from './../../types';
+import { Nullable } from './../../types';
 import { vtkOutputPort } from './../../interfaces';
 import {
   vtkAbstractMapper3D,
@@ -309,25 +309,6 @@ 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

@@ -283,7 +283,6 @@ const defaultValues = initialValues => ({
   projectionSlabThickness: 1,
   projectionSlabNumberOfSamples: 1,
   projectionMode: ProjectionMode.MAX,
-  updatedExtents: [],
   ...initialValues
 });
 
@@ -304,7 +303,7 @@ function extend(publicAPI, model) {
   });
 
   // Setters and getters
-  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode', 'updatedExtents']);
+  macro.setGet(publicAPI, model, ['width', 'uniformOrientation', 'useUniformOrientation', 'centerPoint', 'preferSizeOverAccuracy', 'orientationArrayName', 'tangentDirection', 'bitangentDirection', 'normalDirection', 'projectionSlabThickness', 'projectionSlabNumberOfSamples', 'projectionMode']);
   CoincidentTopologyHelper.implementCoincidentTopologyMethods(publicAPI, model);
 
   // Object methods

package/Rendering/Core/ImageProperty.d.ts

@@ -1,5 +1,5 @@
 import { vtkObject } from './../../interfaces';
-import { Nullable } from './../../types';
+import { Extent, Nullable } from './../../types';
 import vtkColorTransferFunction from './ColorTransferFunction';
 import vtkPiecewiseFunction from './../../Common/DataModel/PiecewiseFunction';
 import { InterpolationType } from './ImageProperty/Constants';
@@ -231,6 +231,25 @@ export interface vtkImageProperty extends vtkObject {
    * @param {Boolean} useLookupTableScalarRange
    */
   setUseLookupTableScalarRange(useLookupTableScalarRange: boolean): boolean;
+
+  /**
+   * Informs the mapper to only update the specified extents at the next render.
+   *
+   * 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[];
 }
 
 /**