@kitware/vtk.js 30.8.0 → 30.9.0

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/package.json

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