@kitware/vtk.js 30.7.1 → 30.9.0

package/Interaction/Style/InteractorStyleImage.js

@@ -15,7 +15,7 @@ function vtkInteractorStyleImage(publicAPI, model) {
   publicAPI.superHandleMouseMove = publicAPI.handleMouseMove;
   publicAPI.handleMouseMove = callData => {
     const pos = callData.position;
-    const renderer = callData.pokedRenderer;
+    const renderer = model.getRenderer(callData);
     switch (model.state) {
       case States.IS_WINDOW_LEVEL:
         publicAPI.windowLevel(renderer, pos);
@@ -94,7 +94,7 @@ function vtkInteractorStyleImage(publicAPI, model) {
 
   //--------------------------------------------------------------------------
   publicAPI.handleMouseWheel = callData => {
-    const camera = callData.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(callData).getActiveCamera();
     let distance = camera.getDistance();
     distance += callData.spinY;
 
@@ -107,7 +107,7 @@ function vtkInteractorStyleImage(publicAPI, model) {
       distance = range[1];
     }
     camera.setDistance(distance);
-    const props = callData.pokedRenderer.getViewProps().filter(prop => prop.isA('vtkImageSlice'));
+    const props = model.getRenderer(callData).getViewProps().filter(prop => prop.isA('vtkImageSlice'));
     props.forEach(prop => {
       if (prop.getMapper().isA('vtkImageResliceMapper')) {
         const p = prop.getMapper().getSlicePlane();

package/Interaction/Style/InteractorStyleManipulator.js

@@ -251,7 +251,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     if (manipulator) {
       // register the manipulator for this device
       model.currentVRManipulators.set(ed.device, manipulator);
-      manipulator.onButton3D(publicAPI, ed.pokedRenderer, model.state, ed);
+      manipulator.onButton3D(publicAPI, model.getRenderer(ed), model.state, ed);
       if (ed.pressed) {
         publicAPI.startCameraPose();
       } else {
@@ -271,7 +271,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   publicAPI.handleMove3D = ed => {
     const manipulator = model.currentVRManipulators.get(ed.device);
     if (manipulator && model.state === States.IS_CAMERA_POSE) {
-      manipulator.onMove3D(publicAPI, ed.pokedRenderer, model.state, ed);
+      manipulator.onMove3D(publicAPI, model.getRenderer(ed), model.state, ed);
     }
   };
 
@@ -292,7 +292,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
         model.currentManipulator.setRotationFactor(model.rotationFactor);
       }
       model.currentManipulator.startInteraction();
-      model.currentManipulator.onButtonDown(model._interactor, callData.pokedRenderer, callData.position);
+      model.currentManipulator.onButtonDown(model._interactor, model.getRenderer(callData), callData.position);
       model._interactor.requestAnimation(publicAPI.onButtonDown);
       publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
     } else {
@@ -373,7 +373,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     }
     if (manipulator) {
       model.currentWheelManipulator = manipulator;
-      model.currentWheelManipulator.onStartScroll(model._interactor, callData.pokedRenderer, callData.spinY);
+      model.currentWheelManipulator.onStartScroll(model._interactor, model.getRenderer(callData), callData.spinY);
       model.currentWheelManipulator.startInteraction();
       model._interactor.requestAnimation(publicAPI.handleStartMouseWheel);
       publicAPI.invokeStartInteractionEvent(START_INTERACTION_EVENT);
@@ -399,7 +399,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleMouseWheel = callData => {
     if (model.currentWheelManipulator && model.currentWheelManipulator.onScroll) {
-      model.currentWheelManipulator.onScroll(model._interactor, callData.pokedRenderer, callData.spinY, model.cachedMousePosition);
+      model.currentWheelManipulator.onScroll(model._interactor, model.getRenderer(callData), callData.spinY, model.cachedMousePosition);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };
@@ -408,7 +408,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   publicAPI.handleMouseMove = callData => {
     model.cachedMousePosition = callData.position;
     if (model.currentManipulator && model.currentManipulator.onMouseMove) {
-      model.currentManipulator.onMouseMove(model._interactor, callData.pokedRenderer, callData.position);
+      model.currentManipulator.onMouseMove(model._interactor, model.getRenderer(callData), callData.position);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     }
   };
@@ -418,7 +418,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleKeyPress = callData => {
     model.keyboardManipulators.filter(m => m.onKeyPress).forEach(manipulator => {
-      manipulator.onKeyPress(model._interactor, callData.pokedRenderer, callData.key);
+      manipulator.onKeyPress(model._interactor, model.getRenderer(callData), callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
   };
@@ -426,7 +426,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleKeyDown = callData => {
     model.keyboardManipulators.filter(m => m.onKeyDown).forEach(manipulator => {
-      manipulator.onKeyDown(model._interactor, callData.pokedRenderer, callData.key);
+      manipulator.onKeyDown(model._interactor, model.getRenderer(callData), callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
   };
@@ -434,7 +434,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
   //-------------------------------------------------------------------------
   publicAPI.handleKeyUp = callData => {
     model.keyboardManipulators.filter(m => m.onKeyUp).forEach(manipulator => {
-      manipulator.onKeyUp(model._interactor, callData.pokedRenderer, callData.key);
+      manipulator.onKeyUp(model._interactor, model.getRenderer(callData), callData.key);
       publicAPI.invokeInteractionEvent(INTERACTION_EVENT);
     });
   };
@@ -539,7 +539,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     while (count--) {
       const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPinchEnabled()) {
-        manipulator.onPinch(model._interactor, callData.pokedRenderer, callData.scale);
+        manipulator.onPinch(model._interactor, model.getRenderer(callData), callData.scale);
         actionCount++;
       }
     }
@@ -555,7 +555,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     while (count--) {
       const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isPanEnabled()) {
-        manipulator.onPan(model._interactor, callData.pokedRenderer, callData.translation);
+        manipulator.onPan(model._interactor, model.getRenderer(callData), callData.translation);
         actionCount++;
       }
     }
@@ -571,7 +571,7 @@ function vtkInteractorStyleManipulator(publicAPI, model) {
     while (count--) {
       const manipulator = model.gestureManipulators[count];
       if (manipulator && manipulator.isRotateEnabled()) {
-        manipulator.onRotate(model._interactor, callData.pokedRenderer, callData.rotation);
+        manipulator.onRotate(model._interactor, model.getRenderer(callData), callData.rotation);
         actionCount++;
       }
     }

package/Interaction/Style/InteractorStyleTrackballCamera.js

@@ -21,7 +21,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
   // Public API methods
   publicAPI.handleMouseMove = callData => {
     const pos = callData.position;
-    const renderer = callData.pokedRenderer;
+    const renderer = model.getRenderer(callData);
     switch (model.state) {
       case States.IS_ROTATE:
         publicAPI.handleMouseRotate(renderer, pos);
@@ -73,7 +73,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
   publicAPI.updateCameraPose = ed => {
     // move the world in the direction of the
     // controller
-    const camera = ed.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(ed).getActiveCamera();
     const oldTrans = camera.getPhysicalTranslation();
 
     // look at the y axis to determine how fast / what direction to move
@@ -169,25 +169,25 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.handlePinch = callData => {
-    publicAPI.dollyByFactor(callData.pokedRenderer, callData.scale / model.previousScale);
+    publicAPI.dollyByFactor(model.getRenderer(callData), callData.scale / model.previousScale);
     model.previousScale = callData.scale;
   };
 
   //----------------------------------------------------------------------------
   publicAPI.handlePan = callData => {
-    const camera = callData.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(callData).getActiveCamera();
 
     // Calculate the focal depth since we'll be using it a lot
     let viewFocus = camera.getFocalPoint();
-    viewFocus = publicAPI.computeWorldToDisplay(callData.pokedRenderer, viewFocus[0], viewFocus[1], viewFocus[2]);
+    viewFocus = publicAPI.computeWorldToDisplay(model.getRenderer(callData), viewFocus[0], viewFocus[1], viewFocus[2]);
     const focalDepth = viewFocus[2];
     const trans = callData.translation;
     const lastTrans = model.previousTranslation;
-    const newPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth);
+    const newPickPoint = publicAPI.computeDisplayToWorld(model.getRenderer(callData), viewFocus[0] + trans[0] - lastTrans[0], viewFocus[1] + trans[1] - lastTrans[1], focalDepth);
 
     // Has to recalc old mouse point since the viewport has moved,
     // so can't move it outside the loop
-    const oldPickPoint = publicAPI.computeDisplayToWorld(callData.pokedRenderer, viewFocus[0], viewFocus[1], focalDepth);
+    const oldPickPoint = publicAPI.computeDisplayToWorld(model.getRenderer(callData), viewFocus[0], viewFocus[1], focalDepth);
 
     // Camera motion is reversed
     const motionVector = [];
@@ -199,7 +199,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
     camera.setFocalPoint(motionVector[0] + viewFocus[0], motionVector[1] + viewFocus[1], motionVector[2] + viewFocus[2]);
     camera.setPosition(motionVector[0] + viewPoint[0], motionVector[1] + viewPoint[1], motionVector[2] + viewPoint[2]);
     if (model._interactor.getLightFollowCamera()) {
-      callData.pokedRenderer.updateLightsGeometryToFollowCamera();
+      model.getRenderer(callData).updateLightsGeometryToFollowCamera();
     }
     camera.orthogonalizeViewUp();
     model.previousTranslation = callData.translation;
@@ -207,7 +207,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
 
   //----------------------------------------------------------------------------
   publicAPI.handleRotate = callData => {
-    const camera = callData.pokedRenderer.getActiveCamera();
+    const camera = model.getRenderer(callData).getActiveCamera();
     camera.roll(callData.rotation - model.previousRotation);
     camera.orthogonalizeViewUp();
     model.previousRotation = callData.rotation;
@@ -306,7 +306,7 @@ function vtkInteractorStyleTrackballCamera(publicAPI, model) {
   //----------------------------------------------------------------------------
   publicAPI.handleMouseWheel = callData => {
     const dyf = 1 - callData.spinY / model.zoomFactor;
-    publicAPI.dollyByFactor(callData.pokedRenderer, dyf);
+    publicAPI.dollyByFactor(model.getRenderer(callData), dyf);
   };
 
   //----------------------------------------------------------------------------

package/Interaction/Widgets/OrientationMarkerWidget.d.ts

@@ -145,6 +145,13 @@ export interface vtkOrientationMarkerWidget extends vtkObject {
    * Updates the orientation widget viewport size.
    */
   updateViewport(): void;
+
+  /**
+   * An instance of this class will spawn its own renderer, by default non interactive.
+   * This behavior is configurable through the interactiveRenderer property when initializing the instance.
+   * @returns true if the renderer was created as interactive, false otherwise.
+   */
+  getInteractiveRenderer(): boolean;
 }
 
 /**

package/Interaction/Widgets/OrientationMarkerWidget.js

@@ -123,7 +123,7 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       }
       // Highest number is foreground
       selfRenderer.setLayer(renderWindow.getNumberOfLayers() - 1);
-      selfRenderer.setInteractive(false);
+      selfRenderer.setInteractive(model.interactiveRenderer);
       selfRenderer.addViewProp(model.actor);
       model.actor.setVisibility(true);
       onCameraChangedSub = ren.onEvent(event => {
@@ -236,7 +236,8 @@ const DEFAULT_VALUES = {
   viewportSize: 0.2,
   minPixelSize: 50,
   maxPixelSize: 200,
-  parentRenderer: null
+  parentRenderer: null,
+  interactiveRenderer: false
 };
 
 // ----------------------------------------------------------------------------
@@ -247,7 +248,7 @@ function extend(publicAPI, model) {
 
   // Build VTK API
   macro.obj(publicAPI, model);
-  macro.get(publicAPI, model, ['enabled', 'viewportCorner', 'viewportSize']);
+  macro.get(publicAPI, model, ['enabled', 'viewportCorner', 'viewportSize', 'interactiveRenderer']);
 
   // NOTE: setting these while the widget is enabled will
   // not update the widget.

package/Rendering/Core/InteractorStyle.d.ts

@@ -1,5 +1,7 @@
 import { EventHandler, vtkSubscription } from './../../interfaces';
+import { Nullable } from './../../types';
 import vtkInteractorObserver from './InteractorObserver';
+import vtkRenderer from './Renderer';
 
 export interface vtkInteractorStyle extends vtkInteractorObserver {
   /**
@@ -210,6 +212,19 @@ export interface vtkInteractorStyle extends vtkInteractorObserver {
    * Handles a keypress.
    */
   handleKeyPress(callData: unknown): void;
+
+  /**
+   * Explicitly defines a renderer to be used for event handling.
+   * If never called or called with null, the pokedRenderer of the event will be used.
+   *
+   * @param {Nullable<vtkRenderer>} renderer
+   */
+  setFocusedRenderer(renderer: Nullable<vtkRenderer>): boolean;
+
+  /**
+   * Get the renderer used for event handling, returns null if not set.
+   */
+  getFocusedRenderer(): Nullable<vtkRenderer>;
 }
 
 export interface IInteractorStyleInitialValues {

package/Rendering/Core/InteractorStyle.js

@@ -64,6 +64,7 @@ function vtkInteractorStyle(publicAPI, model) {
       model._interactor.render();
     };
   });
+  model.getRenderer = callData => model.focusedRenderer || callData.pokedRenderer;
 
   //----------------------------------------------------------------------------
   publicAPI.handleKeyPress = callData => {
@@ -72,12 +73,12 @@ function vtkInteractorStyle(publicAPI, model) {
     switch (callData.key) {
       case 'r':
       case 'R':
-        callData.pokedRenderer.resetCamera();
+        model.getRenderer(callData).resetCamera();
         rwi.render();
         break;
       case 'w':
       case 'W':
-        ac = callData.pokedRenderer.getActors();
+        ac = model.getRenderer(callData).getActors();
         ac.forEach(anActor => {
           const prop = anActor.getProperty();
           if (prop.setRepresentationToWireframe) {
@@ -88,7 +89,7 @@ function vtkInteractorStyle(publicAPI, model) {
         break;
       case 's':
       case 'S':
-        ac = callData.pokedRenderer.getActors();
+        ac = model.getRenderer(callData).getActors();
         ac.forEach(anActor => {
           const prop = anActor.getProperty();
           if (prop.setRepresentationToSurface) {
@@ -99,7 +100,7 @@ function vtkInteractorStyle(publicAPI, model) {
         break;
       case 'v':
       case 'V':
-        ac = callData.pokedRenderer.getActors();
+        ac = model.getRenderer(callData).getActors();
         ac.forEach(anActor => {
           const prop = anActor.getProperty();
           if (prop.setRepresentationToPoints) {
@@ -130,6 +131,7 @@ function extend(publicAPI, model) {
 
   // Inheritance
   vtkInteractorObserver.extend(publicAPI, model, initialValues);
+  macro.setGet(publicAPI, model, ['focusedRenderer']);
 
   // Object specific methods
   vtkInteractorStyle(publicAPI, model);

package/Rendering/Core/Mapper.d.ts

@@ -3,6 +3,7 @@ import vtkAbstractMapper3D, {
   IAbstractMapper3DInitialValues,
 } from './AbstractMapper3D';
 import { ColorMode, GetArray, ScalarMode } from './Mapper/Constants';
+import vtkDataArray from './../../Common/Core/DataArray';
 
 interface IPrimitiveCount {
   points: number;
@@ -13,6 +14,7 @@ interface IPrimitiveCount {
 
 interface IAbstractScalars {
   cellFlag: boolean;
+  scalars: Nullable<vtkDataArray>;
 }
 
 interface ICoincidentTopology {
@@ -54,9 +56,13 @@ export interface vtkMapper extends vtkAbstractMapper3D {
    * When rendering multiblock datasets, if any 2 blocks provide different
    * lookup tables for the scalars, then also we cannot use textures. This case
    * can be handled if required.
-   * @param input
+   * @param scalars
+   * @param cellFlag True when the scalars are per cell instead of per point
    */
-  canUseTextureMapForColoring(input: any): boolean;
+  canUseTextureMapForColoring(
+    scalars: vtkDataArray,
+    cellFlag: boolean
+  ): boolean;
 
   /**
    * Call to force a rebuild of color result arrays on next MapScalars.
@@ -77,26 +83,18 @@ export interface vtkMapper extends vtkAbstractMapper3D {
   /**
    *
    * @param input
-   * @param output
-   * @param numScalars
-   * @param numComps
    * @param component
    * @param range
-   * @param tableRange
    * @param tableNumberOfColors
    * @param useLogScale
    */
   createColorTextureCoordinates(
-    input: any,
-    output: any,
-    numScalars: number,
-    numComps: number,
+    input: vtkDataArray,
     component: number,
     range: any,
-    tableRange: any,
     tableNumberOfColors: number,
     useLogScale: boolean
-  ): void;
+  ): vtkDataArray;
 
   /**
    * Create default lookup table. Generally used to create one when
@@ -120,6 +118,17 @@ export interface vtkMapper extends vtkAbstractMapper3D {
     arrayName: any
   ): IAbstractScalars;
 
+  /**
+   * When scalars are mapped from cells,
+   * there is one color coordinate per cell instead of one per point
+   * in the vtkDataArray getColorCoordinates().
+   * It means that when getAreScalarsMappedFromCells() is true,
+   * the number of tuples in getColorCoordinates() is the number of points,
+   * and when getAreScalarsMappedFromCells() is false,
+   * the number of tuples in getColorCoordinates() is the number of cells.
+   */
+  getAreScalarsMappedFromCells(): boolean;
+
   /**
    *
    */

package/Rendering/Core/Mapper.js

@@ -132,7 +132,11 @@ function vtkMapper(publicAPI, model) {
     };
   };
   publicAPI.mapScalars = (input, alpha) => {
-    const scalars = publicAPI.getAbstractScalars(input, model.scalarMode, model.arrayAccessMode, model.arrayId, model.colorByArrayName).scalars;
+    const {
+      scalars,
+      cellFlag
+    } = publicAPI.getAbstractScalars(input, model.scalarMode, model.arrayAccessMode, model.arrayId, model.colorByArrayName);
+    model.areScalarsMappedFromCells = cellFlag;
     if (!scalars) {
       model.colorCoordinates = null;
       model.colorTextureMap = null;
@@ -150,7 +154,7 @@ function vtkMapper(publicAPI, model) {
     // Decide between texture color or vertex color.
     // Cell data always uses vertex color.
     // Only point data can use both texture and vertex coloring.
-    if (publicAPI.canUseTextureMapForColoring(input)) {
+    if (publicAPI.canUseTextureMapForColoring(scalars, cellFlag)) {
       publicAPI.mapScalarsToTexture(scalars, alpha);
     } else {
       model.colorCoordinates = null;
@@ -205,50 +209,56 @@ function vtkMapper(publicAPI, model) {
   };
 
   //-----------------------------------------------------------------------------
-  publicAPI.createColorTextureCoordinates = (input, output, numScalars, numComps, component, range, tableRange, tableNumberOfColors, useLogScale) => {
+  publicAPI.createColorTextureCoordinates = (input, component, range, tableNumberOfColors, useLogScale) => {
     // We have to change the range used for computing texture
     // coordinates slightly to accommodate the special above- and
     // below-range colors that are the first and last texels,
     // respectively.
     const scalarTexelWidth = (range[1] - range[0]) / tableNumberOfColors;
-    const paddedRange = [];
-    paddedRange[0] = range[0] - scalarTexelWidth;
-    paddedRange[1] = range[1] + scalarTexelWidth;
+    const paddedRange = [range[0] - scalarTexelWidth, range[1] + scalarTexelWidth];
     const invRangeWidth = 1.0 / (paddedRange[1] - paddedRange[0]);
-    const outputV = output.getData();
     const inputV = input.getData();
-    let count = 0;
-    let outputCount = 0;
+    const numScalars = input.getNumberOfTuples();
+    const numComps = input.getNumberOfComponents();
+    const output = vtkDataArray.newInstance({
+      numberOfComponents: 2,
+      values: new Float32Array(numScalars * 2)
+    });
+    const outputV = output.getData();
     if (component < 0 || component >= numComps) {
+      // Convert the magnitude of all components to texture coordinates
+      let inputIdx = 0;
+      let outputIdx = 0;
       for (let scalarIdx = 0; scalarIdx < numScalars; ++scalarIdx) {
         let sum = 0;
         for (let compIdx = 0; compIdx < numComps; ++compIdx) {
-          sum += inputV[count] * inputV[count];
-          count++;
+          sum += inputV[inputIdx] * inputV[inputIdx];
+          inputIdx++;
         }
         let magnitude = Math.sqrt(sum);
         if (useLogScale) {
-          magnitude = vtkLookupTable.applyLogScale(magnitude, tableRange, range);
+          magnitude = vtkLookupTable.applyLogScale(magnitude, range, range);
         }
         const outputs = publicAPI.scalarToTextureCoordinate(magnitude, paddedRange[0], invRangeWidth);
-        outputV[outputCount] = outputs.texCoordS;
-        outputV[outputCount + 1] = outputs.texCoordT;
-        outputCount += 2;
+        outputV[outputIdx++] = outputs.texCoordS;
+        outputV[outputIdx++] = outputs.texCoordT;
       }
     } else {
-      count += component;
+      // Convert one of the components to texture coordinates
+      let inputIdx = component;
+      let outputIdx = 0;
       for (let scalarIdx = 0; scalarIdx < numScalars; ++scalarIdx) {
-        let inputValue = inputV[count];
+        let inputValue = inputV[inputIdx];
         if (useLogScale) {
-          inputValue = vtkLookupTable.applyLogScale(inputValue, tableRange, range);
+          inputValue = vtkLookupTable.applyLogScale(inputValue, range, range);
         }
         const outputs = publicAPI.scalarToTextureCoordinate(inputValue, paddedRange[0], invRangeWidth);
-        outputV[outputCount] = outputs.texCoordS;
-        outputV[outputCount + 1] = outputs.texCoordT;
-        outputCount += 2;
-        count += numComps;
+        outputV[outputIdx++] = outputs.texCoordS;
+        outputV[outputIdx++] = outputs.texCoordT;
+        inputIdx += numComps;
       }
     }
+    return output;
   };
   publicAPI.mapScalarsToTexture = (scalars, alpha) => {
     const range = model.lookupTable.getRange();
@@ -274,28 +284,23 @@ function vtkMapper(publicAPI, model) {
       // Create a dummy ramp of scalars.
       // In the future, we could extend vtkScalarsToColors.
       model.lookupTable.build();
-      let numberOfColors = model.lookupTable.getNumberOfAvailableColors();
-      if (numberOfColors > 4094) {
-        numberOfColors = 4094;
-      }
-      if (numberOfColors < 64) {
-        numberOfColors = 64;
-      }
-      numberOfColors += 2;
-      const k = (range[1] - range[0]) / (numberOfColors - 2);
-      const newArray = new Float64Array(numberOfColors * 2);
-      for (let i = 0; i < numberOfColors; ++i) {
-        newArray[i] = range[0] + i * k - k / 2.0; // minus k / 2 to start at below range color
+      const numberOfColorsInRange = Math.min(Math.max(model.lookupTable.getNumberOfAvailableColors(), 64), 4094);
+      // Texel width is computed before min and max colors that are out of range
+      const scalarTexelWidth = (range[1] - range[0]) / numberOfColorsInRange;
+      // Add two colors for special min and max colors
+      const totalNumberOfColors = numberOfColorsInRange + 2;
+      const newArray = new Float64Array(totalNumberOfColors * 2);
+      for (let i = 0; i < totalNumberOfColors; ++i) {
+        // minus 0.5 to start at below range color
+        newArray[i] = range[0] + (i - 0.5) * scalarTexelWidth;
         if (useLogScale) {
           newArray[i] = 10.0 ** newArray[i];
         }
       }
       // Dimension on NaN.
-      for (let i = 0; i < numberOfColors; ++i) {
-        newArray[i + numberOfColors] = NaN;
-      }
+      newArray.fill(NaN, totalNumberOfColors);
       model.colorTextureMap = vtkImageData.newInstance();
-      model.colorTextureMap.setExtent(0, numberOfColors - 1, 0, 1, 0, 0);
+      model.colorTextureMap.setExtent(0, totalNumberOfColors - 1, 0, 1, 0, 0);
       const tmp = vtkDataArray.newInstance({
         numberOfComponents: 1,
         values: newArray
@@ -304,28 +309,20 @@ function vtkMapper(publicAPI, model) {
       model.lookupTable.setAlpha(origAlpha);
     }
 
-    // Create new coordinates if necessary.
-    // Need to compare lookup table in case the range has changed.
-    if (!model.colorCoordinates || publicAPI.getMTime() > model.colorCoordinates.getMTime() || publicAPI.getInputData(0).getMTime() > model.colorCoordinates.getMTime() || model.lookupTable.getMTime() > model.colorCoordinates.getMTime()) {
-      // Get rid of old colors
-      model.colorCoordinates = null;
+    // Although I like the feature of applying magnitude to single component
+    // scalars, it is not how the old MapScalars for vertex coloring works.
+    const scalarComponent = model.lookupTable.getVectorMode() === VectorMode.MAGNITUDE && scalars.getNumberOfComponents() > 1 ? -1 : model.lookupTable.getVectorComponent();
 
-      // Now create the color texture coordinates.
-      const numComps = scalars.getNumberOfComponents();
-      const num = scalars.getNumberOfTuples();
+    // Reverse the computation of numberOfColorsInRange that is used to compute model.colorTextureMap
+    const textureMapTuples = model.colorTextureMap.getPointData().getScalars().getNumberOfTuples();
+    const totalNumberOfColors = textureMapTuples / 2;
+    const numberOfColorsInRange = totalNumberOfColors - 2;
 
-      // const fArray = new FloatArray(num * 2);
-      model.colorCoordinates = vtkDataArray.newInstance({
-        numberOfComponents: 2,
-        values: new Float32Array(num * 2)
-      });
-      let scalarComponent = model.lookupTable.getVectorComponent();
-      // Although I like the feature of applying magnitude to single component
-      // scalars, it is not how the old MapScalars for vertex coloring works.
-      if (model.lookupTable.getVectorMode() === VectorMode.MAGNITUDE && scalars.getNumberOfComponents() > 1) {
-        scalarComponent = -1;
-      }
-      publicAPI.createColorTextureCoordinates(scalars, model.colorCoordinates, num, numComps, scalarComponent, range, model.lookupTable.getRange(), model.colorTextureMap.getPointData().getScalars().getNumberOfTuples() / 2 - 2, useLogScale);
+    // Create new coordinates if necessary.
+    const colorCoordinatesString = `${scalars.getMTime()}/${scalarComponent}/${range}/${numberOfColorsInRange}/${useLogScale}`;
+    if (colorCoordinatesString !== model.colorCoordinatesString) {
+      model.colorCoordinates = publicAPI.createColorTextureCoordinates(scalars, scalarComponent, range, numberOfColorsInRange, useLogScale);
+      model.colorCoordinatesString = colorCoordinatesString;
     }
   };
   publicAPI.getIsOpaque = () => {
@@ -344,7 +341,11 @@ function vtkMapper(publicAPI, model) {
     }
     return true;
   };
-  publicAPI.canUseTextureMapForColoring = input => {
+  publicAPI.canUseTextureMapForColoring = (scalars, cellFlag) => {
+    if (cellFlag) {
+      return true; // cell data always use textures.
+    }
+
     if (!model.interpolateScalarsBeforeMapping) {
       return false; // user doesn't want us to use texture maps at all.
     }
@@ -353,16 +354,10 @@ function vtkMapper(publicAPI, model) {
     if (model.lookupTable && model.lookupTable.getIndexedLookup()) {
       return false;
     }
-    const gasResult = publicAPI.getAbstractScalars(input, model.scalarMode, model.arrayAccessMode, model.arrayId, model.colorByArrayName);
-    const scalars = gasResult.scalars;
     if (!scalars) {
       // no scalars on this dataset, we don't care if texture is used at all.
       return false;
     }
-    if (gasResult.cellFlag) {
-      return false; // cell data colors, don't use textures.
-    }
-
     if (model.colorMode === ColorMode.DEFAULT && scalars.getDataType() === VtkDataTypes.UNSIGNED_CHAR || model.colorMode === ColorMode.DIRECT_SCALARS) {
       // Don't use texture is direct coloring using RGB unsigned chars is
       // requested.
@@ -464,7 +459,7 @@ function vtkMapper(publicAPI, model) {
 const DEFAULT_VALUES = {
   colorMapColors: null,
   // Same as this->Colors
-
+  areScalarsMappedFromCells: false,
   static: false,
   lookupTable: null,
   scalarVisibility: true,
@@ -497,7 +492,7 @@ function extend(publicAPI, model) {
 
   // Inheritance
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['colorCoordinates', 'colorMapColors', 'colorTextureMap', 'selectionWebGLIdsToVTKIds']);
+  macro.get(publicAPI, model, ['areScalarsMappedFromCells', 'colorCoordinates', 'colorMapColors', 'colorTextureMap', 'selectionWebGLIdsToVTKIds']);
   macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'populateSelectionSettings', 'renderTime', 'scalarMode', 'scalarVisibility', 'static', 'useLookupTableScalarRange', 'customShaderAttributes' // point data array names that will be transferred to the VBO
   ]);
 

package/Rendering/OpenGL/CellArrayBufferObject.js

@@ -104,52 +104,52 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
     let addAPoint;
     const cellBuilders = {
       // easy, every input point becomes an output point
-      anythingToPoints(numPoints, cellPts, offset) {
+      anythingToPoints(numPoints, cellPts, offset, cellId) {
         for (let i = 0; i < numPoints; ++i) {
-          addAPoint(cellPts[offset + i]);
+          addAPoint(cellPts[offset + i], cellId);
         }
       },
-      linesToWireframe(numPoints, cellPts, offset) {
+      linesToWireframe(numPoints, cellPts, offset, cellIdx) {
         // for lines we add a bunch of segments
         for (let i = 0; i < numPoints - 1; ++i) {
-          addAPoint(cellPts[offset + i]);
-          addAPoint(cellPts[offset + i + 1]);
+          addAPoint(cellPts[offset + i], cellIdx);
+          addAPoint(cellPts[offset + i + 1], cellIdx);
         }
       },
-      polysToWireframe(numPoints, cellPts, offset) {
+      polysToWireframe(numPoints, cellPts, offset, cellIdx) {
         // for polys we add a bunch of segments and close it
         if (numPoints > 2) {
           for (let i = 0; i < numPoints; ++i) {
-            addAPoint(cellPts[offset + i]);
-            addAPoint(cellPts[offset + (i + 1) % numPoints]);
+            addAPoint(cellPts[offset + i], cellIdx);
+            addAPoint(cellPts[offset + (i + 1) % numPoints], cellIdx);
           }
         }
       },
-      stripsToWireframe(numPoints, cellPts, offset) {
+      stripsToWireframe(numPoints, cellPts, offset, cellIdx) {
         if (numPoints > 2) {
           // for strips we add a bunch of segments and close it
           for (let i = 0; i < numPoints - 1; ++i) {
-            addAPoint(cellPts[offset + i]);
-            addAPoint(cellPts[offset + i + 1]);
+            addAPoint(cellPts[offset + i], cellIdx);
+            addAPoint(cellPts[offset + i + 1], cellIdx);
           }
           for (let i = 0; i < numPoints - 2; i++) {
-            addAPoint(cellPts[offset + i]);
-            addAPoint(cellPts[offset + i + 2]);
+            addAPoint(cellPts[offset + i], cellIdx);
+            addAPoint(cellPts[offset + i + 2], cellIdx);
           }
         }
       },
-      polysToSurface(npts, cellPts, offset) {
+      polysToSurface(npts, cellPts, offset, cellIdx) {
         for (let i = 0; i < npts - 2; i++) {
-          addAPoint(cellPts[offset + 0]);
-          addAPoint(cellPts[offset + i + 1]);
-          addAPoint(cellPts[offset + i + 2]);
+          addAPoint(cellPts[offset + 0], cellIdx);
+          addAPoint(cellPts[offset + i + 1], cellIdx);
+          addAPoint(cellPts[offset + i + 2], cellIdx);
         }
       },
-      stripsToSurface(npts, cellPts, offset) {
+      stripsToSurface(npts, cellPts, offset, cellIdx) {
         for (let i = 0; i < npts - 2; i++) {
-          addAPoint(cellPts[offset + i]);
-          addAPoint(cellPts[offset + i + 1 + i % 2]);
-          addAPoint(cellPts[offset + i + 1 + (i + 1) % 2]);
+          addAPoint(cellPts[offset + i], cellIdx);
+          addAPoint(cellPts[offset + i + 1 + i % 2], cellIdx);
+          addAPoint(cellPts[offset + i + 1 + (i + 1) % 2], cellIdx);
         }
       }
     };
@@ -264,16 +264,16 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
       }
     }
     let pointCount = options.vertexOffset;
-    addAPoint = function addAPointFunc(i) {
+    addAPoint = function addAPointFunc(pointId, cellId) {
       // Keep track of original point and cell ids, for selection
       if (selectionMaps) {
-        selectionMaps.points[pointCount] = i;
+        selectionMaps.points[pointCount] = pointId;
         selectionMaps.cells[pointCount] = cellCount + options.cellOffset;
       }
       ++pointCount;
 
       // Vertices
-      pointIdx = i * 3;
+      pointIdx = pointId * 3;
       if (!model.coordShiftAndScaleEnabled) {
         packedVBO[vboidx++] = pointData[pointIdx++];
         packedVBO[vboidx++] = pointData[pointIdx++];
@@ -288,20 +288,24 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
         if (options.haveCellNormals) {
           normalIdx = (cellCount + options.cellOffset) * 3;
         } else {
-          normalIdx = i * 3;
+          normalIdx = pointId * 3;
         }
         packedVBO[vboidx++] = normalData[normalIdx++];
         packedVBO[vboidx++] = normalData[normalIdx++];
         packedVBO[vboidx++] = normalData[normalIdx++];
       }
       model.customData.forEach(attr => {
-        custIdx = i * attr.components;
+        custIdx = pointId * attr.components;
         for (let j = 0; j < attr.components; ++j) {
           packedVBO[vboidx++] = attr.data[custIdx++];
         }
       });
       if (tcoordData !== null) {
-        tcoordIdx = i * textureComponents;
+        if (options.useTCoordsPerCell) {
+          tcoordIdx = cellId * textureComponents;
+        } else {
+          tcoordIdx = pointId * textureComponents;
+        }
         for (let j = 0; j < textureComponents; ++j) {
           packedVBO[vboidx++] = tcoordData[tcoordIdx++];
         }
@@ -310,7 +314,7 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
         if (options.haveCellScalars) {
           colorIdx = (cellCount + options.cellOffset) * colorComponents;
         } else {
-          colorIdx = i * colorComponents;
+          colorIdx = pointId * colorComponents;
         }
         packedUCVBO[ucidx++] = colorData[colorIdx++];
         packedUCVBO[ucidx++] = colorData[colorIdx++];
@@ -318,10 +322,11 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
         packedUCVBO[ucidx++] = colorComponents === 4 ? colorData[colorIdx++] : 255;
       }
     };
-    for (let index = 0; index < size;) {
-      func(array[index], array, index + 1);
-      index += array[index] + 1;
-      cellCount++;
+
+    // Browse the cell array: the index is at the beginning of a cell
+    // The value of 'array' at the position 'index' is the number of points in the cell
+    for (let index = 0; index < size; index += array[index] + 1, cellCount++) {
+      func(array[index], array, index + 1, cellCount);
     }
     model.elementCount = caboCount;
     publicAPI.upload(packedVBO, ObjectType.ARRAY_BUFFER);

package/Rendering/OpenGL/PolyDataMapper.js

@@ -147,7 +147,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     if (model.lastBoundBO.getCABO().getColorComponents() !== 0 && !model.drawingEdges) {
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', colorImpl.concat(['  diffuseColor = vertexColorVSOutput.rgb;', '  ambientColor = vertexColorVSOutput.rgb;', '  opacity = opacity*vertexColorVSOutput.a;'])).result;
     } else {
-      if (model.renderable.getInterpolateScalarsBeforeMapping() && model.renderable.getColorCoordinates() && !model.drawingEdges) {
+      if ((model.renderable.getAreScalarsMappedFromCells() || model.renderable.getInterpolateScalarsBeforeMapping()) && model.renderable.getColorCoordinates() && !model.drawingEdges) {
         FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', colorImpl.concat(['  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);', '  diffuseColor = texColor.rgb;', '  ambientColor = texColor.rgb;', '  opacity = opacity*texColor.a;'])).result;
       } else {
         if (actor.getBackfaceProperty() && !model.drawingEdges) {
@@ -993,9 +993,12 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       tcoords = null;
     }
 
+    // Flag to check if tcoords are per cell instead of per point
+    let useTCoordsPerCell = false;
     // handle color mapping via texture
     if (model.renderable.getColorCoordinates()) {
       tcoords = model.renderable.getColorCoordinates();
+      useTCoordsPerCell = model.renderable.getAreScalarsMappedFromCells();
       if (!model.internalColorTexture) {
         model.internalColorTexture = vtkOpenGLTexture.newInstance({
           resizable: true
@@ -1028,6 +1031,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         cellOffset: 0,
         vertexOffset: 0,
         // Used to keep track of vertex ids across primitives for selection
+        useTCoordsPerCell,
         haveCellScalars: model.haveCellScalars,
         haveCellNormals: model.haveCellNormals,
         customAttributes: model.renderable.getCustomShaderAttributes().map(arrayName => poly.getPointData().getArrayByName(arrayName))
@@ -1085,9 +1089,9 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         model.renderable.setSelectionWebGLIdsToVTKIds(model.selectionWebGLIdsToVTKIds);
         publicAPI.updateMaximumPointCellIds();
       }
-      model.VBOBuildTime.modified();
       model.VBOBuildString = toString;
     }
+    model.VBOBuildTime.modified();
   };
   publicAPI.getAllocatedGPUMemoryInBytes = () => {
     let memUsed = 0;

package/Widgets/Widgets3D/InteractiveOrientationWidget/helpers.d.ts

@@ -0,0 +1,73 @@
+import vtkAbstractWidget from '../../../Widgets/Core/AbstractWidget';
+import vtkCamera from '../../../Rendering/Core/Camera';
+import vtkInteractiveOrientationWidget from '../InteractiveOrientationWidget';
+import vtkOrientationMarkerWidget from '../../../Interaction/Widgets/OrientationMarkerWidget';
+import vtkRenderer from '../../../Rendering/Core/Renderer';
+import vtkRenderWindowInteractor from '../../../Rendering/Core/RenderWindowInteractor';
+import vtkWidgetManager from '../../../Widgets/Core/WidgetManager';
+import { vtkSubscription } from '../../../interfaces';
+import { Bounds, Vector3 } from '../../../types';
+
+export function majorAxis(
+  vec3: Vector3,
+  idxA: number,
+  idxB: number
+): [number, number, number];
+
+/**
+ * Create a new vtkOrientationMarkerWidget instance from the provided interactor and parentRenderer and sensible defaults.
+ *
+ * @param {vtkRenderWindowInteractor} interactor
+ * @param {vtkRenderer} parentRenderer
+ * @returns {vtkOrientationMarkerWidget}
+ */
+export function createOrientationMarkerWidget(
+  interactor: vtkRenderWindowInteractor,
+  parentRenderer: vtkRenderer
+): vtkOrientationMarkerWidget;
+
+/**
+ * Create a new vtkInteractiveOrientationWidget instance and place it at the given bounds.
+ *
+ * @param {Bounds} bounds
+ * @returns {vtkInteractiveOrientationWidget}
+ */
+export function createInteractiveOrientationWidget(
+  bounds: Bounds
+): vtkInteractiveOrientationWidget;
+
+/**
+ * Create a new vtkOrientationMarkerWidget alongside with a new vtkInteractiveOrientationWidget with sensible defaults.
+ *
+ * @param {vtkWidgetManager} widgetManager
+ * @param {vtkRenderWindowInteractor} interactor
+ * @param {vtkRenderer} mainRenderer
+ * @returns {Object} the constructed widget instances
+ */
+export function createInteractiveOrientationMarkerWidget(
+  widgetManager: vtkWidgetManager,
+  interactor: vtkRenderWindowInteractor,
+  mainRenderer: vtkRenderer
+): {
+  interactiveOrientationWidget: vtkInteractiveOrientationWidget;
+  orientationMarkerWidget: vtkOrientationMarkerWidget;
+};
+
+/**
+ * Listen to OrientationChange events on the given view widget.
+ * The event handler will align the provided camera and update the provided vtkOrientationMarkerWidget instance.
+ *
+ * @param {vtkAbstractWidget} viewWidget Must be a vtkInteractiveOrientationWidget view widget
+ * @param {vtkCamera} camera The camera instance to upate when orientation changes
+ * @param {vtkOrientationMarkerWidget} orientationMarkerWidget The instance to update when orientation changes
+ * @param {vtkWidgetManager} widgetManager
+ * @param {Function} render A callback that should render the view
+ * @returns {vtkSubscription} the corresponding event subscription, can be used to unsubscribe from the event
+ */
+export function alignCameraOnViewWidgetOrientationChange(
+  viewWidget: vtkAbstractWidget,
+  camera: vtkCamera,
+  orientationMarkerWidget: vtkOrientationMarkerWidget,
+  widgetManager: vtkWidgetManager,
+  render: () => void
+): vtkSubscription;

package/Widgets/Widgets3D/InteractiveOrientationWidget/helpers.js

@@ -0,0 +1,71 @@
+import * as vtkMath from '@kitware/vtk.js/Common/Core/Math';
+import vtkOrientationMarkerWidget from '@kitware/vtk.js/Interaction/Widgets/OrientationMarkerWidget';
+import vtkAxesActor from '@kitware/vtk.js/Rendering/Core/AxesActor';
+import vtkInteractiveOrientationWidget from '@kitware/vtk.js/Widgets/Widgets3D/InteractiveOrientationWidget';
+
+function majorAxis(vec3, idxA, idxB) {
+  const axis = [0, 0, 0];
+  const idx = Math.abs(vec3[idxA]) > Math.abs(vec3[idxB]) ? idxA : idxB;
+  const value = vec3[idx] > 0 ? 1 : -1;
+  axis[idx] = value;
+  return axis;
+}
+function createOrientationMarkerWidget(interactor, parentRenderer) {
+  const axes = vtkAxesActor.newInstance();
+  const orientationWidget = vtkOrientationMarkerWidget.newInstance({
+    actor: axes,
+    interactor,
+    interactiveRenderer: true,
+    viewportSize: 0.1,
+    minPixelSize: 100,
+    maxPixelSize: 300,
+    parentRenderer
+  });
+  orientationWidget.setEnabled(true);
+  orientationWidget.setViewportCorner(vtkOrientationMarkerWidget.Corners.BOTTOM_LEFT);
+  return orientationWidget;
+}
+function createInteractiveOrientationWidget(bounds) {
+  const widget = vtkInteractiveOrientationWidget.newInstance();
+  widget.placeWidget(bounds);
+  widget.setBounds(bounds.map(v => v * 0.45));
+  return widget;
+}
+function createInteractiveOrientationMarkerWidget(widgetManager, interactor, mainRenderer) {
+  const orientationMarkerWidget = createOrientationMarkerWidget(interactor, mainRenderer);
+  interactor.getInteractorStyle().setFocusedRenderer(mainRenderer);
+  widgetManager.setRenderer(orientationMarkerWidget.getRenderer());
+  const widget = createInteractiveOrientationWidget(orientationMarkerWidget.getActor().getBounds());
+  return {
+    interactiveOrientationWidget: widget,
+    orientationMarkerWidget
+  };
+}
+function alignCameraOnViewWidgetOrientationChange(viewWidget, camera, orientationMarkerWidget, widgetManager, render) {
+  return viewWidget.onOrientationChange(_ref => {
+    let {
+      up,
+      direction,
+      action,
+      event
+    } = _ref;
+    const focalPoint = camera.getFocalPoint();
+    const position = camera.getPosition();
+    const viewUp = camera.getViewUp();
+    const distance = Math.sqrt(vtkMath.distance2BetweenPoints(position, focalPoint));
+    camera.setPosition(focalPoint[0] + direction[0] * distance, focalPoint[1] + direction[1] * distance, focalPoint[2] + direction[2] * distance);
+    if (direction[0]) {
+      camera.setViewUp(majorAxis(viewUp, 1, 2));
+    }
+    if (direction[1]) {
+      camera.setViewUp(majorAxis(viewUp, 0, 2));
+    }
+    if (direction[2]) {
+      camera.setViewUp(majorAxis(viewUp, 0, 1));
+    }
+    orientationMarkerWidget.updateMarkerOrientation();
+    render();
+  });
+}
+
+export { alignCameraOnViewWidgetOrientationChange, createInteractiveOrientationMarkerWidget, createInteractiveOrientationWidget, createOrientationMarkerWidget, majorAxis };

package/index.d.ts

@@ -234,6 +234,7 @@
 /// <reference path="./Widgets/Manipulators/PlaneManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/TrackballManipulator.d.ts" />
 /// <reference path="./Widgets/Representations/WidgetRepresentation.d.ts" />
+/// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget/helpers.d.ts" />
 /// <reference path="./Widgets/Widgets3D/InteractiveOrientationWidget.d.ts" />
 /// <reference path="./Widgets/Widgets3D/ResliceCursorWidget/Constants.d.ts" />
 /// <reference path="./Widgets/Widgets3D/ResliceCursorWidget/behavior.d.ts" />

package/package.json

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