@kitware/vtk.js 34.3.1 → 34.5.0

package/Filters/Sources/DiskSource.d.ts

@@ -0,0 +1,154 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+
+/**
+ *
+ */
+export interface IDiskSourceInitialValues {
+  innerRadius?: number;
+  outerRadius?: number;
+  center?: Vector3;
+  normal?: Vector3;
+  radialResolution?: number;
+  circumferentialResolution?: number;
+  pointType?: string;
+}
+
+type vtkDiskSourceBase = vtkObject &
+  Omit<
+    vtkAlgorithm,
+    | 'getInputData'
+    | 'setInputData'
+    | 'setInputConnection'
+    | 'getInputConnection'
+    | 'addInputConnection'
+    | 'addInputData'
+  >;
+
+export interface vtkDiskSource extends vtkDiskSourceBase {
+  /**
+   * Get the center of the disk.
+   */
+  getCenter(): Vector3;
+
+  /**
+   * Get the circumferential resolution of the disk.
+   */
+  getCircumferentialResolution(): number;
+
+  /**
+   * Get the inner radius of the disk.
+   */
+  getInnerRadius(): number;
+
+  /**
+   * Get the normal of the disk.
+   */
+  getNormal(): Vector3;
+
+  /**
+   * Get the outer radius of the disk.
+   */
+  getOuterRadius(): number;
+
+  /**
+   * Get the point type used for the disk.
+   */
+  getPointType(): string;
+
+  /**
+   * Get the radial resolution of the disk.
+   */
+  getRadialResolution(): number;
+
+  /**
+   * Expose methods
+   * @param inData
+   * @param outData
+   */
+  requestData(inData: any, outData: any): void;
+
+  /**
+   * Set the center of the disk.
+   * @param {Vector3} center
+   */
+  setCenter(center: Vector3): boolean;
+
+  /**
+   * Set the circumferential resolution of the disk.
+   * @param {number} resolution
+   */
+  setCircumferentialResolution(resolution: number): boolean;
+
+  /**
+   * Set the inner radius of the disk.
+   * @param {number} radius
+   */
+  setInnerRadius(radius: number): boolean;
+
+  /**
+   * Set the normal of the disk.
+   * @param {Vector3} normal
+   */
+  setNormal(normal: Vector3): boolean;
+
+  /**
+   * Set the outer radius of the disk.
+   * @param {number} radius
+   */
+  setOuterRadius(radius: number): boolean;
+
+  /**
+   * Set the point type used for the disk.
+   * @param {string} type
+   */
+  setPointType(type: string): boolean;
+
+  /**
+   * Set the radial resolution of the disk.
+   * @param {number} resolution
+   */
+  setRadialResolution(resolution: number): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkDiskSource characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IDiskSourceInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: IDiskSourceInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkDiskSource.
+ * @param {IDiskSourceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: IDiskSourceInitialValues
+): vtkDiskSource;
+
+/**
+ * vtkDiskSource creates a polygonal disk with a hole in the center. The disk
+ * has zero height. The user can specify the inner and outer radius of the disk,
+ * the radial and circumferential resolution of the polygonal representation,
+ * and the center and plane normal of the disk (i.e., the center and disk normal
+ * control the position and orientation of the disk).
+ *
+ * @example
+ * ```js
+ * import vtkDiskSource from '@kitware/vtk.js/Filters/Sources/DiskSource';
+ *
+ * const disk = vtkDiskSource.newInstance({ radius: 1, resolution: 80 });
+ * const polydata = disk.getOutputData();
+ * ```
+ */
+export declare const vtkDiskSource: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+};
+export default vtkDiskSource;

package/Filters/Sources/DiskSource.js

@@ -0,0 +1,137 @@
+import { m as macro } from '../../macros2.js';
+import vtkCellArray from '../../Common/Core/CellArray.js';
+import vtkPolyData from '../../Common/DataModel/PolyData.js';
+import vtkPoints from '../../Common/Core/Points.js';
+import vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// vtkDiskSource methods
+// ----------------------------------------------------------------------------
+
+function vtkDiskSource(publicAPI, model) {
+  // Set our classname
+  model.classHierarchy.push('vtkDiskSource');
+  publicAPI.requestData = (inData, outData) => {
+    const {
+      innerRadius,
+      outerRadius,
+      center,
+      normal,
+      radialResolution,
+      circumferentialResolution,
+      pointType
+    } = model;
+    if (model.deleted) {
+      return;
+    }
+    let dataset = outData[0];
+
+    // Points
+    const points = vtkPoints.newInstance({
+      dataType: pointType
+    });
+    const n = [normal[0], normal[1], normal[2]];
+    const length = Math.hypot(n[0], n[1], n[2]);
+    if (length === 0) {
+      vtkErrorMacro('Normal vector cannot be zero-length');
+      return;
+    }
+    n[0] /= length;
+    n[1] /= length;
+    n[2] /= length;
+    const matrix = vtkMatrixBuilder.buildFromDegree().identity().translate(-center[0], -center[1], -center[2]).rotateFromDirections([0, 0, 1], n).translate(center[0], center[1], center[2]).getMatrix();
+    const polys = vtkCellArray.newInstance();
+
+    // Generate points
+    const deltaR = (outerRadius - innerRadius) / radialResolution;
+    const thetaStep = 2.0 * Math.PI / circumferentialResolution;
+    for (let i = 0; i < circumferentialResolution; i++) {
+      const theta = i * thetaStep;
+      const cosT = Math.cos(theta);
+      const sinT = Math.sin(theta);
+      for (let j = 0; j <= radialResolution; j++) {
+        const r = innerRadius + j * deltaR;
+        // point in XY plane before transform
+        const localPoint = [center[0] + r * cosT, center[1] + r * sinT, center[2]];
+        // apply matrix transform
+        const x = matrix[0] * localPoint[0] + matrix[4] * localPoint[1] + matrix[8] * localPoint[2] + matrix[12];
+        const y = matrix[1] * localPoint[0] + matrix[5] * localPoint[1] + matrix[9] * localPoint[2] + matrix[13];
+        const z = matrix[2] * localPoint[0] + matrix[6] * localPoint[1] + matrix[10] * localPoint[2] + matrix[14];
+        points.insertNextPoint(x, y, z);
+      }
+    }
+
+    // Generate cell connectivity (quads)
+    const cellCount = radialResolution * circumferentialResolution;
+    const cellData = new Uint8Array(cellCount * 5);
+    let offset = 0;
+    for (let i = 0; i < model.circumferentialResolution; i++) {
+      for (let j = 0; j < model.radialResolution; j++) {
+        const p0 = i * (model.radialResolution + 1) + j;
+        const p1 = p0 + 1;
+        const p2 = i < model.circumferentialResolution - 1 ? p1 + (model.radialResolution + 1) : j + 1; // wrap around
+        const p3 = p2 - 1;
+        cellData[offset++] = 4;
+        cellData[offset++] = p0;
+        cellData[offset++] = p1;
+        cellData[offset++] = p2;
+        cellData[offset++] = p3;
+      }
+    }
+    polys.setData(cellData, cellCount, 1);
+    dataset = vtkPolyData.newInstance();
+    dataset.setPoints(points);
+    dataset.setPolys(polys);
+
+    // Update output
+    outData[0] = dataset;
+  };
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+function defaultValues(initialValues) {
+  return {
+    innerRadius: 0.25,
+    outerRadius: 0.5,
+    center: [0, 0, 0],
+    normal: [0, 0, 1],
+    radialResolution: 1,
+    circumferentialResolution: 6,
+    pointType: 'Float64Array',
+    ...initialValues
+  };
+}
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, defaultValues(initialValues));
+
+  // Build VTK API
+  macro.obj(publicAPI, model);
+  macro.setGet(publicAPI, model, ['innerRadius', 'outerRadius', 'radialResolution', 'circumferentialResolution', 'pointType']);
+  macro.setGetArray(publicAPI, model, ['center', 'normal'], 3);
+  macro.algo(publicAPI, model, 0, 1);
+  vtkDiskSource(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkDiskSource');
+
+// ----------------------------------------------------------------------------
+
+var vtkDiskSource$1 = {
+  newInstance,
+  extend
+};
+
+export { vtkDiskSource$1 as default, extend, newInstance };

package/Filters/Sources.js

@@ -5,6 +5,7 @@ import vtkConeSource from './Sources/ConeSource.js';
 import vtkCubeSource from './Sources/CubeSource.js';
 import vtkCursor3D from './Sources/Cursor3D.js';
 import vtkCylinderSource from './Sources/CylinderSource.js';
+import vtkDiskSource from './Sources/DiskSource.js';
 import vtkImageGridSource from './Sources/ImageGridSource.js';
 import vtkLineSource from './Sources/LineSource.js';
 import vtkPlaneSource from './Sources/PlaneSource.js';
@@ -21,6 +22,7 @@ var Sources = {
   vtkCubeSource,
   vtkCursor3D,
   vtkCylinderSource,
+  vtkDiskSource,
   vtkImageGridSource,
   vtkLineSource,
   vtkPlaneSource,

package/Proxy/Representations/GlyphRepresentationProxy.js

@@ -14,6 +14,7 @@ import '../../Filters/Sources/ConeSource.js';
 import '../../Filters/Sources/CubeSource.js';
 import '../../Filters/Sources/Cursor3D.js';
 import '../../Filters/Sources/CylinderSource.js';
+import '../../Filters/Sources/DiskSource.js';
 import '../../Filters/Sources/ImageGridSource.js';
 import '../../Filters/Sources/LineSource.js';
 import '../../Filters/Sources/PlaneSource.js';

package/Rendering/Core/ImageProperty.d.ts

@@ -106,15 +106,21 @@ export interface vtkImageProperty extends vtkObject {
   getUseLabelOutline(): boolean;
 
   /**
-   * Set the 0 to 1 opacity of the label outline.
-   * @param {Number} opacity
+   * Set opacity of the label outline.
+   *
+   * Opacity must be between 0 and 1.
+   * If the given opacity is a number, the opacity will apply to all outline segments.
+   * If the given opacity is an array of numbers, each opacity value will apply to the
+   * label equal to the opacity value's index + 1. (This is the same behavior as setLabelOutlineThickness).
+   *
+   * @param {Number | Number[]} opacity
    */
-  setLabelOutlineOpacity(opacity: number): boolean;
+  setLabelOutlineOpacity(opacity: number | number[]): boolean;
 
   /**
    * Get the 0 to 1 opacity of the label outline.
    */
-  getLabelOutlineOpacity(): number;
+  getLabelOutlineOpacity(): number | number[];
 
   /**
    * gets the label outline thickness

package/Rendering/Core/Mapper2D.js

@@ -1,6 +1,10 @@
 import { m as macro } from '../../macros2.js';
 import vtkAbstractMapper from './AbstractMapper.js';
+import vtkDataArray from '../../Common/Core/DataArray.js';
+import vtkImageData from '../../Common/DataModel/ImageData.js';
 import vtkLookupTable from '../../Common/Core/LookupTable.js';
+import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
+import { i as isNan } from '../../Common/Core/Math/index.js';
 import Constants from './Mapper/Constants.js';
 
 const {
@@ -8,6 +12,237 @@ const {
   ScalarMode,
   GetArray
 } = Constants;
+const {
+  VectorMode
+} = vtkScalarsToColors;
+const {
+  VtkDataTypes
+} = vtkDataArray;
+
+/**
+ * Increase by one the 3D coordinates
+ * It will follow a zigzag pattern so that each coordinate is the neighbor of the next coordinate
+ * This enables interpolation between two texels without issues
+ * Note: texture coordinates can't be interpolated using this pattern
+ * @param {vec3} coordinates The 3D coordinates using integers for each coordinate
+ * @param {vec3} dimensions The 3D dimensions of the volume
+ */
+function updateZigzaggingCoordinates(coordinates, dimensions) {
+  const directionX = coordinates[1] % 2 === 0 ? 1 : -1;
+  coordinates[0] += directionX;
+  if (coordinates[0] >= dimensions[0] || coordinates[0] < 0) {
+    const directionY = coordinates[2] % 2 === 0 ? 1 : -1;
+    coordinates[0] -= directionX;
+    coordinates[1] += directionY;
+    if (coordinates[1] >= dimensions[1] || coordinates[1] < 0) {
+      coordinates[1] -= directionY;
+      coordinates[2]++;
+    }
+  }
+}
+
+/**
+ * Returns the index in the array representing the volume from a 3D coordinate
+ * @param {vec3} coordinates The 3D integer coordinates
+ * @param {vec3} dimensions The 3D dimensions of the volume
+ * @returns The index in a flat array representing the volume
+ */
+function getIndexFromCoordinates(coordinates, dimensions) {
+  return coordinates[0] + dimensions[0] * (coordinates[1] + dimensions[1] * coordinates[2]);
+}
+
+/**
+ * Write texture coordinates for the given `texelIndexPosition` in `textureCoordinate`.
+ * The `texelIndexPosition` is a floating point number that represents the distance in index space
+ * from the center of the first texel to the final output position.
+ * The output is given in texture coordinates and not in index coordinates (this is done at the very end of the function)
+ * @param {vec3} textureCoordinate The output texture coordinates (to avoid allocating a new Array)
+ * @param {Number} texelIndexPosition The floating point distance from the center of the first texel, following a zigzag pattern
+ * @param {vec3} dimensions The 3D dimensions of the volume
+ */
+function getZigZagTextureCoordinatesFromTexelPosition(textureCoordinate, texelIndexPosition, dimensions) {
+  // First compute the integer textureCoordinate
+  const intTexelIndex = Math.floor(texelIndexPosition);
+  const xCoordBeforeWrap = intTexelIndex % (2 * dimensions[0]);
+  let xDirection;
+  let xEndFlag;
+  if (xCoordBeforeWrap < dimensions[0]) {
+    textureCoordinate[0] = xCoordBeforeWrap;
+    xDirection = 1;
+    xEndFlag = textureCoordinate[0] === dimensions[0] - 1;
+  } else {
+    textureCoordinate[0] = 2 * dimensions[0] - 1 - xCoordBeforeWrap;
+    xDirection = -1;
+    xEndFlag = textureCoordinate[0] === 0;
+  }
+  const intRowIndex = Math.floor(intTexelIndex / dimensions[0]);
+  const yCoordBeforeWrap = intRowIndex % (2 * dimensions[1]);
+  let yDirection;
+  let yEndFlag;
+  if (yCoordBeforeWrap < dimensions[1]) {
+    textureCoordinate[1] = yCoordBeforeWrap;
+    yDirection = 1;
+    yEndFlag = textureCoordinate[1] === dimensions[1] - 1;
+  } else {
+    textureCoordinate[1] = 2 * dimensions[1] - 1 - yCoordBeforeWrap;
+    yDirection = -1;
+    yEndFlag = textureCoordinate[1] === 0;
+  }
+  textureCoordinate[2] = Math.floor(intRowIndex / dimensions[1]);
+
+  // Now add the remainder either in x, y or z
+  const remainder = texelIndexPosition - intTexelIndex;
+  if (xEndFlag) {
+    if (yEndFlag) {
+      textureCoordinate[2] += remainder;
+    } else {
+      textureCoordinate[1] += yDirection * remainder;
+    }
+  } else {
+    textureCoordinate[0] += xDirection * remainder;
+  }
+
+  // textureCoordinates are in index space, convert to texture space
+  textureCoordinate[0] = (textureCoordinate[0] + 0.5) / dimensions[0];
+  textureCoordinate[1] = (textureCoordinate[1] + 0.5) / dimensions[1];
+  textureCoordinate[2] = (textureCoordinate[2] + 0.5) / dimensions[2];
+}
+// Associate an input vtkDataArray to an object { stringHash, textureCoordinates }
+// A single dataArray only caches one array of texture coordinates, so this cache is useless when
+// the input data array is used with two different lookup tables (which is very unlikely)
+const colorTextureCoordinatesCache = new WeakMap();
+/**
+ * The minimum of the range is mapped to the center of the first texel excluding min texel (texel at index distance 1)
+ * The maximum of the range is mapped to the center of the last texel excluding max and NaN texels (texel at index distance numberOfColorsInRange)
+ * The result is cached, and is reused if the arguments are the same and the input doesn't change
+ * @param {vtkDataArray} input The input data array used for coloring
+ * @param {Number} component The component of the input data array that is used for coloring (-1 for magnitude of the vectors)
+ * @param {Range} range The range of the scalars
+ * @param {boolean} useLogScale Should the values be transformed to logarithmic scale. When true, the range must already be in logarithmic scale.
+ * @param {Number} numberOfColorsInRange The number of colors that are used in the range
+ * @param {vec3} dimensions The dimensions of the texture
+ * @param {boolean} useZigzagPattern If a zigzag pattern should be used. Otherwise 1 row for colors (including min and max) and 1 row for NaN are used.
+ * @returns A vtkDataArray containing the texture coordinates (2D or 3D)
+ */
+function getOrCreateColorTextureCoordinates(input, component, range, useLogScale, numberOfColorsInRange, dimensions, useZigzagPattern) {
+  // Caching using the "arguments" special object (because it is a pure function)
+  const argStrings = new Array(arguments.length);
+  for (let argIndex = 0; argIndex < arguments.length; ++argIndex) {
+    // eslint-disable-next-line prefer-rest-params
+    const arg = arguments[argIndex];
+    argStrings[argIndex] = arg.getMTime?.() ?? arg;
+  }
+  const stringHash = argStrings.join('/');
+  const cachedResult = colorTextureCoordinatesCache.get(input);
+  if (cachedResult && cachedResult.stringHash === stringHash) {
+    return cachedResult.textureCoordinates;
+  }
+
+  // The range used for computing coordinates have to change
+  // slightly to accommodate the special above- and below-range
+  // colors that are the first and last texels, respectively.
+  const scalarTexelWidth = (range[1] - range[0]) / (numberOfColorsInRange - 1);
+  const [paddedRangeMin, paddedRangeMax] = [range[0] - scalarTexelWidth, range[1] + scalarTexelWidth];
+
+  // Use the center of the voxel
+  const textureSOrigin = paddedRangeMin - 0.5 * scalarTexelWidth;
+  const textureSCoeff = 1.0 / (paddedRangeMax - paddedRangeMin + scalarTexelWidth);
+
+  // Compute in index space first
+  const texelIndexOrigin = paddedRangeMin;
+  const texelIndexCoeff = (numberOfColorsInRange + 1) / (paddedRangeMax - paddedRangeMin);
+  const inputV = input.getData();
+  const numScalars = input.getNumberOfTuples();
+  const numComps = input.getNumberOfComponents();
+  const useMagnitude = component < 0 || component >= numComps;
+  const numberOfOutputComponents = dimensions[2] <= 1 ? 2 : 3;
+  const output = vtkDataArray.newInstance({
+    numberOfComponents: numberOfOutputComponents,
+    values: new Float32Array(numScalars * numberOfOutputComponents)
+  });
+  const outputV = output.getData();
+  const nanTextureCoordinate = [0, 0, 0];
+  // Distance of NaN from the beginning:
+  // min: 0, ...colorsInRange, max: numberOfColorsInRange + 1, NaN = numberOfColorsInRange + 2
+  getZigZagTextureCoordinatesFromTexelPosition(nanTextureCoordinate, numberOfColorsInRange + 2, dimensions);
+
+  // Set a texture coordinate in the output for each tuple in the input
+  let inputIdx = 0;
+  let outputIdx = 0;
+  const textureCoordinate = [0.5, 0.5, 0.5];
+  for (let scalarIdx = 0; scalarIdx < numScalars; ++scalarIdx) {
+    // Get scalar value from magnitude or a single component
+    let scalarValue;
+    if (useMagnitude) {
+      let sum = 0;
+      for (let compIdx = 0; compIdx < numComps; ++compIdx) {
+        const compValue = inputV[inputIdx + compIdx];
+        sum += compValue * compValue;
+      }
+      scalarValue = Math.sqrt(sum);
+    } else {
+      scalarValue = inputV[inputIdx + component];
+    }
+    if (useLogScale) {
+      scalarValue = Math.log10(scalarValue);
+    }
+    inputIdx += numComps;
+
+    // Convert to texture coordinates and update output
+    if (isNan(scalarValue)) {
+      // Last texels are NaN colors (there is at least one NaN color)
+      textureCoordinate[0] = nanTextureCoordinate[0];
+      textureCoordinate[1] = nanTextureCoordinate[1];
+      textureCoordinate[2] = nanTextureCoordinate[2];
+    } else if (useZigzagPattern) {
+      // Texel position is in [0, numberOfColorsInRange + 1]
+      let texelIndexPosition = (scalarValue - texelIndexOrigin) * texelIndexCoeff;
+      if (texelIndexPosition < 1) {
+        // Use min color when smaller than range
+        texelIndexPosition = 0;
+      } else if (texelIndexPosition > numberOfColorsInRange) {
+        // Use max color when greater than range
+        texelIndexPosition = numberOfColorsInRange + 1;
+      }
+
+      // Convert the texel position into texture coordinate following a zigzag pattern
+      getZigZagTextureCoordinatesFromTexelPosition(textureCoordinate, texelIndexPosition, dimensions);
+    } else {
+      // 0.0 in t coordinate means not NaN.  So why am I setting it to 0.49?
+      // Because when you are mapping scalars and you have a NaN adjacent to
+      // anything else, the interpolation everywhere should be NaN.  Thus, I
+      // want the NaN color everywhere except right on the non-NaN neighbors.
+      // To simulate this, I set the t coord for the real numbers close to
+      // the threshold so that the interpolation almost immediately looks up
+      // the NaN value.
+      textureCoordinate[1] = 0.49;
+
+      // Some implementations apparently don't handle relatively large
+      // numbers (compared to the range [0.0, 1.0]) very well. In fact,
+      // values above 1122.0f appear to cause texture wrap-around on
+      // some systems even when edge clamping is enabled. Why 1122.0f? I
+      // don't know. For safety, we'll clamp at +/- 1000. This will
+      // result in incorrect images when the texture value should be
+      // above or below 1000, but I don't have a better solution.
+      const textureS = (scalarValue - textureSOrigin) * textureSCoeff;
+      if (textureS > 1000.0) {
+        textureCoordinate[0] = 1000.0;
+      } else if (textureS < -1000.0) {
+        textureCoordinate[0] = -1000.0;
+      } else {
+        textureCoordinate[0] = textureS;
+      }
+    }
+    for (let i = 0; i < numberOfOutputComponents; ++i) {
+      outputV[outputIdx++] = textureCoordinate[i];
+    }
+  }
+  colorTextureCoordinatesCache.set(input, {
+    stringHash,
+    textureCoordinates: output
+  });
+  return output;
+}
 
 // ---------------------------------------------------------------------------
 // vtkMapper2D methods
@@ -35,7 +270,7 @@ function vtkMapper2D(publicAPI, model) {
     if (!input || !model.scalarVisibility) {
       return {
         scalars: null,
-        cellFLag: false
+        cellFlag: false
       };
     }
     let scalars = null;
@@ -96,8 +331,14 @@ function vtkMapper2D(publicAPI, model) {
     return mt;
   };
   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;
       model.colorMapColors = null;
       return;
     }
@@ -108,14 +349,124 @@ function vtkMapper2D(publicAPI, model) {
     if (!model.useLookupTableScalarRange) {
       publicAPI.getLookupTable().setRange(model.scalarRange[0], model.scalarRange[1]);
     }
-    const lut = publicAPI.getLookupTable();
-    if (lut) {
-      // Ensure that the lookup table is built
-      lut.build();
-      model.colorMapColors = lut.mapScalars(scalars, model.colorMode, model.fieldDataTupleId);
+    if (publicAPI.canUseTextureMapForColoring(scalars, cellFlag)) {
+      model.mapScalarsToTexture(scalars, cellFlag, alpha);
+    } else {
+      model.colorCoordinates = null;
+      model.colorTextureMap = null;
+      const lut = publicAPI.getLookupTable();
+      if (lut) {
+        // Ensure that the lookup table is built
+        lut.build();
+        model.colorMapColors = lut.mapScalars(scalars, model.colorMode, model.fieldDataTupleId);
+      }
     }
     model.colorBuildString = `${publicAPI.getMTime()}${scalars.getMTime()}${alpha}`;
   };
+  publicAPI.canUseTextureMapForColoring = (scalars, cellFlag) => {
+    if (cellFlag && !(model.colorMode === ColorMode.DIRECT_SCALARS)) {
+      return true; // cell data always use textures.
+    }
+
+    // index color does not use textures
+    if (model.lookupTable && model.lookupTable.getIndexedLookup()) {
+      return false;
+    }
+    if (!scalars) {
+      // no scalars on this dataset, we don't care if texture is used at all.
+      return false;
+    }
+    if (model.colorMode === ColorMode.DEFAULT && scalars.getDataType() === VtkDataTypes.UNSIGNED_CHAR || model.colorMode === ColorMode.DIRECT_SCALARS) {
+      // Don't use texture if direct coloring using RGB unsigned chars is
+      // requested.
+      return false;
+    }
+    return true;
+  };
+
+  // Protected method
+  model.mapScalarsToTexture = (scalars, cellFlag, alpha) => {
+    const range = model.lookupTable.getRange();
+    const useLogScale = model.lookupTable.usingLogScale();
+    const origAlpha = model.lookupTable.getAlpha();
+    const scaledRange = useLogScale ? [Math.log10(range[0]), Math.log10(range[1])] : range;
+
+    // Get rid of vertex color array.  Only texture or vertex coloring
+    // can be active at one time.  The existence of the array is the
+    // signal to use that technique.
+    model.colorMapColors = null;
+
+    // If the lookup table has changed, then recreate the color texture map.
+    // Set a new lookup table changes this->MTime.
+    if (model.colorTextureMap == null || publicAPI.getMTime() > model.colorTextureMap.getMTime() || model.lookupTable.getMTime() > model.colorTextureMap.getMTime() || model.lookupTable.getAlpha() !== alpha) {
+      model.lookupTable.setAlpha(alpha);
+      model.colorTextureMap = null;
+
+      // Get the texture map from the lookup table.
+      // Create a dummy ramp of scalars.
+      // In the future, we could extend vtkScalarsToColors.
+      model.lookupTable.build();
+      const numberOfAvailableColors = model.lookupTable.getNumberOfAvailableColors();
+
+      // Maximum dimensions and number of colors in range
+      const maxTextureWidthForCells = 2048;
+      const maxColorsInRangeForCells = maxTextureWidthForCells ** 3 - 3; // 3D but keep a color for min, max and NaN
+      const maxTextureWidthForPoints = 4096;
+      const maxColorsInRangeForPoints = maxTextureWidthForPoints - 2; // 1D but keep a color for min and max (NaN is in a different row)
+      // Minimum number of colors in range (excluding special colors like minColor, maxColor and NaNColor)
+      const minColorsInRange = 2;
+      // Maximum number of colors, limited by the maximum possible texture size
+      const maxColorsInRange = cellFlag ? maxColorsInRangeForCells : maxColorsInRangeForPoints;
+      model.numberOfColorsInRange = Math.min(Math.max(numberOfAvailableColors, minColorsInRange), maxColorsInRange);
+      const numberOfColorsForCells = model.numberOfColorsInRange + 3; // Add min, max and NaN
+      const numberOfColorsInUpperRowForPoints = model.numberOfColorsInRange + 2; // Add min and max ; the lower row will be used for NaN color
+      const textureDimensions = cellFlag ? [Math.min(Math.ceil(numberOfColorsForCells / maxTextureWidthForCells ** 0), maxTextureWidthForCells), Math.min(Math.ceil(numberOfColorsForCells / maxTextureWidthForCells ** 1), maxTextureWidthForCells), Math.min(Math.ceil(numberOfColorsForCells / maxTextureWidthForCells ** 2), maxTextureWidthForCells)] : [numberOfColorsInUpperRowForPoints, 2, 1];
+      const textureSize = textureDimensions[0] * textureDimensions[1] * textureDimensions[2];
+      const scalarsArray = new Float64Array(textureSize);
+
+      // Colors for NaN by default
+      scalarsArray.fill(NaN);
+
+      // Colors in range
+      // Add 2 to also get color for min and max
+      const numberOfNonSpecialColors = model.numberOfColorsInRange;
+      const numberOfNonNaNColors = numberOfNonSpecialColors + 2;
+      const textureCoordinates = [0, 0, 0];
+      const rangeMin = scaledRange[0];
+      const rangeDifference = scaledRange[1] - scaledRange[0];
+      for (let i = 0; i < numberOfNonNaNColors; ++i) {
+        const scalarsArrayIndex = getIndexFromCoordinates(textureCoordinates, textureDimensions);
+
+        // Minus 1 start at min color
+        const intermediateValue = rangeMin + rangeDifference * (i - 1) / (numberOfNonSpecialColors - 1);
+        const scalarValue = useLogScale ? 10.0 ** intermediateValue : intermediateValue;
+        scalarsArray[scalarsArrayIndex] = scalarValue;
+
+        // Colors are zigzagging to allow interpolation between two neighbor colors when coloring cells
+        updateZigzaggingCoordinates(textureCoordinates, textureDimensions);
+      }
+      const scalarsDataArray = vtkDataArray.newInstance({
+        numberOfComponents: 1,
+        values: scalarsArray
+      });
+      const colorsDataArray = model.lookupTable.mapScalars(scalarsDataArray, model.colorMode, 0);
+      model.colorTextureMap = vtkImageData.newInstance();
+      model.colorTextureMap.setDimensions(textureDimensions);
+      model.colorTextureMap.getPointData().setScalars(colorsDataArray);
+      model.lookupTable.setAlpha(origAlpha);
+    }
+
+    // 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();
+
+    // Create new coordinates if necessary, this function uses cache if possible.
+    // A zigzag pattern can't be used with point data, as interpolation of texture coordinates will be wrong
+    // A zigzag pattern can be used with cell data, as there will be no texture coordinates interpolation
+    // The texture generated using a zigzag pattern in one dimension is the same as without zigzag
+    // Therefore, the same code can be used for texture generation of point/cell data but not for texture coordinates
+    model.colorCoordinates = getOrCreateColorTextureCoordinates(scalars, scalarComponent, scaledRange, useLogScale, model.numberOfColorsInRange, model.colorTextureMap.getDimensions(), cellFlag);
+  };
   publicAPI.getPrimitiveCount = () => {
     const input = publicAPI.getInputData();
     const pcount = {
@@ -143,6 +494,9 @@ const DEFAULT_VALUES = {
   arrayAccessMode: 1,
   // By_NAME
 
+  colorMapColors: null,
+  // Same as this->Colors
+  areScalarsMappedFromCells: false,
   renderTime: 0,
   colorByArrayName: null,
   transformCoordinate: null,
@@ -157,7 +511,7 @@ function extend(publicAPI, model) {
 
   // Inheritance
   vtkAbstractMapper.extend(publicAPI, model, initialValues);
-  macro.get(publicAPI, model, ['colorMapColors']);
+  macro.get(publicAPI, model, ['areScalarsMappedFromCells', 'colorCoordinates', 'colorTextureMap', 'colorMapColors']);
   macro.setGet(publicAPI, model, ['arrayAccessMode', 'colorByArrayName', 'colorMode', 'lookupTable', 'renderTime', 'scalarMode', 'scalarVisibility', 'static', 'transformCoordinate', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
   ]);
 

package/Rendering/OpenGL/ImageMapper.js

@@ -54,7 +54,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // The openGLTexture is not shared
     model.openGLTexture.releaseGraphicsResources(renderWindow);
     // All these other resources are shared
-    [model._colorTransferFunc, model._pwFunc, model._labelOutlineThicknessArray].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
+    [model._colorTransferFunc, model._pwFunc, model._labelOutlineThicknessArray, model._labelOutlineOpacity].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
   }
   publicAPI.buildPass = prepass => {
     if (prepass) {
@@ -131,7 +131,14 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // color shift and scale
     'uniform float cshift0;', 'uniform float cscale0;',
     // pwf shift and scale
-    'uniform float pwfshift0;', 'uniform float pwfscale0;', 'uniform sampler2D texture1;', 'uniform sampler2D colorTexture1;', 'uniform sampler2D pwfTexture1;', 'uniform sampler2D labelOutlineTexture1;', 'uniform float opacity;', 'uniform float outlineOpacity;'];
+    'uniform float pwfshift0;', 'uniform float pwfscale0;', 'uniform sampler2D texture1;', 'uniform sampler2D colorTexture1;', 'uniform sampler2D pwfTexture1;', 'uniform float opacity;'];
+    if (actor.getProperty().getUseLabelOutline()) {
+      tcoordDec = tcoordDec.concat([
+      // outline thickness
+      'uniform sampler2D labelOutlineTexture1;',
+      // outline opacity
+      'uniform sampler2D labelOutlineOpacityTexture1;']);
+    }
     if (iComps) {
       for (let comp = 1; comp < tNumComp; comp++) {
         tcoordDec = tcoordDec.concat([
@@ -167,7 +174,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // check for the outline thickness and opacity
     const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
     if (vtkImageLabelOutline === true) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;', 'uniform int sliceAxis;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;', 'uniform int sliceAxis;']).result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ImageLabelOutlineOn', '#define vtkImageLabelOutlineOn').result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', 'vec2 getSliceCoords(vec3 coord, int axis) {', '  if (axis == 0) return coord.yz;', '  if (axis == 1) return coord.xz;', '  if (axis == 2) return coord.xy;', '}', '#endif']).result;
     }
@@ -209,6 +216,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                   int segmentIndex = int(centerValue * 255.0);
                   float textureCoordinate = float(segmentIndex - 1) / 1024.0;
                   float textureValue = texture2D(labelOutlineTexture1, vec2(textureCoordinate, 0.5)).r;
+                  float outlineOpacity = texture2D(labelOutlineOpacityTexture1, vec2(textureCoordinate, 0.5)).r;
                   int actualThickness = int(textureValue * 255.0);
 
                   if (segmentIndex == 0){
@@ -301,7 +309,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (!model.currentRenderPass && model.lastRenderPassShaderReplacement || model.currentRenderPass && model.currentRenderPass.getShaderReplacement() !== model.lastRenderPassShaderReplacement) {
       needRebuild = true;
     }
-    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram()?.getHandle() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram()?.getHandle() === 0 || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime() || cellBO.getShaderSourceTime().getMTime() < actor.getProperty().getMTime() || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -417,8 +425,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     cellBO.getProgram().setUniformi('colorTexture1', texColorUnit);
     const texOpacityUnit = model.pwfTexture.getTextureUnit();
     cellBO.getProgram().setUniformi('pwfTexture1', texOpacityUnit);
-    const outlineThicknessUnit = model.labelOutlineThicknessTexture.getTextureUnit();
-    cellBO.getProgram().setUniformi('labelOutlineTexture1', outlineThicknessUnit);
+    if (actor.getProperty().getUseLabelOutline()) {
+      const outlineThicknessUnit = model.labelOutlineThicknessTexture.getTextureUnit();
+      cellBO.getProgram().setUniformi('labelOutlineTexture1', outlineThicknessUnit);
+      const texOutlineOpacityUnit = model.labelOutlineOpacityTexture.getTextureUnit();
+      cellBO.getProgram().setUniformi('labelOutlineOpacityTexture1', texOutlineOpacityUnit);
+    }
     if (model.renderable.getNumberOfClippingPlanes()) {
       // add all the clipping planes
       let numClipPlanes = model.renderable.getNumberOfClippingPlanes();
@@ -449,13 +461,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       cellBO.getProgram().setUniformi('numClipPlanes', numClipPlanes);
       cellBO.getProgram().setUniform4fv('clipPlanes', planeEquations);
     }
-
-    // outline thickness and opacity
-    const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
-    if (vtkImageLabelOutline === true) {
-      const outlineOpacity = actor.getProperty().getLabelOutlineOpacity();
-      cellBO.getProgram().setUniformf('outlineOpacity', outlineOpacity);
-    }
   };
   publicAPI.setCameraShaderParameters = (cellBO, ren, actor) => {
     const program = cellBO.getProgram();
@@ -516,7 +521,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // activate the texture
     model.openGLTexture.activate();
     model.colorTexture.activate();
-    model.labelOutlineThicknessTexture.activate();
+    if (actor.getProperty().getUseLabelOutline()) {
+      model.labelOutlineThicknessTexture.activate();
+      model.labelOutlineOpacityTexture.activate();
+    }
     model.pwfTexture.activate();
 
     // draw polygons
@@ -528,7 +536,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
     model.openGLTexture.deactivate();
     model.colorTexture.deactivate();
-    model.labelOutlineThicknessTexture.deactivate();
+    if (actor.getProperty().getUseLabelOutline()) {
+      model.labelOutlineThicknessTexture.deactivate();
+      model.labelOutlineOpacityTexture.deactivate();
+    }
     model.pwfTexture.deactivate();
   };
   publicAPI.renderPieceFinish = (ren, actor) => {};
@@ -560,7 +571,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       publicAPI.buildBufferObjects(ren, actor);
     }
   };
-  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => model.VBOBuildTime.getMTime() < publicAPI.getMTime() || model.VBOBuildTime.getMTime() < actor.getMTime() || model.VBOBuildTime.getMTime() < model.renderable.getMTime() || model.VBOBuildTime.getMTime() < actor.getProperty().getMTime() || model.VBOBuildTime.getMTime() < model.currentInput.getMTime() || !model.openGLTexture?.getHandle() || !model.colorTexture?.getHandle() || !model.labelOutlineThicknessTexture?.getHandle() || !model.pwfTexture?.getHandle();
+  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => model.VBOBuildTime.getMTime() < publicAPI.getMTime() || model.VBOBuildTime.getMTime() < actor.getMTime() || model.VBOBuildTime.getMTime() < model.renderable.getMTime() || model.VBOBuildTime.getMTime() < actor.getProperty().getMTime() || model.VBOBuildTime.getMTime() < model.currentInput.getMTime() || !model.openGLTexture?.getHandle() || !model.colorTexture?.getHandle() || actor.getProperty().getUseLabelOutline() && (!model.labelOutlineThicknessTexture?.getHandle() || !model.labelOutlineOpacityTexture?.getHandle()) || !model.pwfTexture?.getHandle();
   publicAPI.buildBufferObjects = (ren, actor) => {
     const image = model.currentInput;
     if (!image) {
@@ -740,9 +751,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     } else {
       model.pwfTexture = pwfTex.oglObject;
     }
-
-    // Build outline thickness buffer
-    publicAPI.updatelabelOutlineThicknessTexture(actor);
+    if (actor.getProperty().getUseLabelOutline()) {
+      // Build outline thickness + opacity buffers
+      publicAPI.updatelabelOutlineThicknessTexture(actor);
+      publicAPI.updateLabelOutlineOpacityTexture(actor);
+    }
 
     // Find what IJK axis and what direction to slice along
     const {
@@ -955,6 +968,63 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.VBOBuildString = toString;
     }
   };
+  publicAPI.updateLabelOutlineOpacityTexture = image => {
+    let labelOutlineOpacity = image.getProperty().getLabelOutlineOpacity();
+
+    // when the labelOutlineOpacity is a number, we use _cachedLabelOutlineOpacityObj
+    // as a stable object reference for `[labelOutlineOpacity]`.
+    if (typeof labelOutlineOpacity === 'number') {
+      if (model._cachedLabelOutlineOpacityObj?.[0] === labelOutlineOpacity) {
+        labelOutlineOpacity = model._cachedLabelOutlineOpacityObj;
+      } else {
+        labelOutlineOpacity = [labelOutlineOpacity];
+      }
+      model._cachedLabelOutlineOpacityObj = labelOutlineOpacity;
+    }
+    const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineOpacity);
+    const toString = `${labelOutlineOpacity.join('-')}`;
+    const reBuildL = !lTex?.oglObject?.getHandle() || lTex?.hash !== toString;
+    if (reBuildL) {
+      let lWidth = model.renderable.getLabelOutlineTextureWidth();
+      if (lWidth <= 0) {
+        lWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
+      const lHeight = 1;
+      const lSize = lWidth * lHeight;
+      const lTable = new Float32Array(lSize);
+      for (let i = 0; i < lWidth; ++i) {
+        // Retrieve the opacity value for the current segment index.
+        // If the value is undefined, use the first element's value as a default, otherwise use the value (even if 0)
+        lTable[i] = labelOutlineOpacity[i] ?? labelOutlineOpacity[0];
+      }
+      model.labelOutlineOpacityTexture = vtkOpenGLTexture.newInstance({
+        resizable: false
+      });
+      model.labelOutlineOpacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      model.labelOutlineOpacityTexture.resetFormatAndType();
+      model.labelOutlineOpacityTexture.setMinificationFilter(Filter.NEAREST);
+      model.labelOutlineOpacityTexture.setMagnificationFilter(Filter.NEAREST);
+
+      // Create a 2D texture (acting as 1D) from the raw data
+      model.labelOutlineOpacityTexture.create2DFromRaw({
+        width: lWidth,
+        height: lHeight,
+        numComps: 1,
+        dataType: VtkDataTypes.FLOAT,
+        data: lTable
+      });
+      if (labelOutlineOpacity) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineOpacity, model.labelOutlineOpacityTexture, toString);
+        if (labelOutlineOpacity !== model._labelOutlineOpacity) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(labelOutlineOpacity, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._labelOutlineOpacity, publicAPI);
+        }
+        model._labelOutlineOpacity = labelOutlineOpacity;
+      }
+    } else {
+      model.labelOutlineOpacityTexture = lTex.oglObject;
+    }
+  };
   publicAPI.updatelabelOutlineThicknessTexture = image => {
     const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThicknessByReference();
     const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineThicknessArray);
@@ -1046,7 +1116,7 @@ const DEFAULT_VALUES = {
   colorTexture: null,
   pwfTexture: null,
   labelOutlineThicknessTexture: null,
-  labelOutlineThicknessTextureString: null,
+  labelOutlineOpacityTexture: null,
   lastHaveSeenDepthRequest: false,
   haveSeenDepthRequest: false,
   lastTextureComponents: 0

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -1,13 +1,13 @@
 import { mat4 } from 'gl-matrix';
 import { n as newInstance$1, e as setGet, o as obj, c as macro } from '../../macros2.js';
 import vtkHelper from './Helper.js';
-import vtkMapper2D from '../Core/Mapper2D.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import { v as vtkPolyData2DFS } from './glsl/vtkPolyData2DFS.glsl.js';
 import { v as vtkPolyData2DVS } from './glsl/vtkPolyData2DVS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
+import vtkOpenGLTexture from './Texture.js';
 import { P as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
@@ -17,8 +17,9 @@ const {
   primTypes
 } = vtkHelper;
 const {
-  ScalarMode
-} = vtkMapper2D;
+  Filter,
+  Wrap
+} = vtkOpenGLTexture;
 const {
   vtkErrorMacro
 } = macro;
@@ -82,6 +83,11 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     if (!model.currentInput.getPoints || !model.currentInput.getPoints().getNumberOfValues()) {
       return;
     }
+
+    // cull back face to avoid double drawing
+    const gl = model.context;
+    model._openGLRenderWindow.enableCullFace();
+    gl.cullFace(gl.BACK);
     publicAPI.renderPieceStart(ren, actor);
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
@@ -94,6 +100,13 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
           model._openGLRenderer.getSelector().renderProp(actor);
       }
     }
+
+    // If we are coloring by texture, then load the texture map.
+    // Use Map as indicator, because texture hangs around.
+    if (model.renderable.getColorTextureMap()) {
+      model.internalColorTexture.activate();
+    }
+
     // make sure the BOs are up to date
     publicAPI.updateBufferObjects(ren, actor);
 
@@ -133,19 +146,44 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     }
     model.renderable.mapScalars(poly, actor.getProperty().getOpacity());
     const c = model.renderable.getColorMapColors();
-    model.haveCellScalars = false;
-    const scalarMode = model.renderable.getScalarMode();
-    if (model.renderable.getScalarVisibility()) {
-      // We must figure out how the scalars should be mapped to the polydata.
-      if ((scalarMode === ScalarMode.USE_CELL_DATA || scalarMode === ScalarMode.USE_CELL_FIELD_DATA || scalarMode === ScalarMode.USE_FIELD_DATA || !poly.getPointData().getScalars()) && scalarMode !== ScalarMode.USE_POINT_FIELD_DATA && c) {
-        model.haveCellScalars = true;
-      }
-    }
     const representation = actor.getProperty().getRepresentation();
     let tcoords = poly.getPointData().getTCoords();
     if (!model.openGLActor2D.getActiveTextures()) {
       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
+        });
+      }
+      const tex = model.internalColorTexture;
+      // the following 4 lines allow for NPOT textures
+      tex.setMinificationFilter(Filter.NEAREST);
+      tex.setMagnificationFilter(Filter.NEAREST);
+      tex.setWrapS(Wrap.CLAMP_TO_EDGE);
+      tex.setWrapT(Wrap.CLAMP_TO_EDGE);
+      tex.setOpenGLRenderWindow(model._openGLRenderWindow);
+      const input = model.renderable.getColorTextureMap();
+      const ext = input.getExtent();
+      const inScalars = input.getPointData().getScalars();
+      tex.create2DFromRaw({
+        width: ext[1] - ext[0] + 1,
+        height: ext[3] - ext[2] + 1,
+        numComps: inScalars.getNumberOfComponents(),
+        dataType: inScalars.getDataType(),
+        data: inScalars.getData()
+      });
+      tex.activate();
+      tex.sendParameters();
+      tex.deactivate();
+    }
     const transformCoordinate = model.renderable.getTransformCoordinate();
     const view = ren.getRenderWindow().getViews()[0];
     const vsize = view.getViewportSize(ren);
@@ -171,7 +209,8 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
         tcoords,
         colors: c,
         cellOffset: 0,
-        haveCellScalars: model.haveCellSCalars,
+        useTCoordsPerCell,
+        haveCellScalars: model.renderable.getAreScalarsMappedFromCells(),
         customAttributes: model.renderable.getCustomShaderAttributes().map(arrayName => poly.getPointData().getArrayByName(arrayName))
       };
       options.cellOffset += model.primitives[primTypes.Points].getCABO().createVBO(poly.getVerts(), 'verts', representation, options);
@@ -201,6 +240,9 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     if (model.lastBoundBO) {
       model.lastBoundBO.getVAO().release();
     }
+    if (model.renderable.getColorTextureMap()) {
+      model.internalColorTexture.deactivate();
+    }
   };
   publicAPI.replaceShaderValues = (shaders, ren, actor) => {
     publicAPI.replaceShaderColor(shaders, ren, actor);
@@ -212,21 +254,28 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     let VSSource = shaders.Vertex;
     let GSSource = shaders.Geometry;
     let FSSource = shaders.Fragment;
-    if (model.haveCellScalars) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', ['uniform samplerBuffer texture1;']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', ['gl_FragData[0] = texelFetchBuffer(texture1, gl_PrimitiveID + PrimitiveIDOffset);']).result;
-    }
+
+    // create the color property declarations
+    // these are always defined
+    let colorDec = ['uniform vec3 diffuseColorUniform;', 'uniform float opacityUniform;'];
+
+    // now handle the more complex fragment shader implementation
+    let colorImpl = ['vec3 diffuseColor = diffuseColorUniform;', 'float opacity = opacityUniform;'];
+
+    // add scalar vertex colors
     if (model.lastBoundBO.getCABO().getColorComponents() !== 0) {
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Dec', ['in vec4 diffuseColor;', 'out vec4 fcolorVSOutput;']).result;
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Impl', ['fcolorVSOutput = diffuseColor;']).result;
-      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Dec', ['in vec4 fcolorVSOutput[];\n', 'out vec4 fcolorGSOutput;']).result;
-      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Impl', ['fcolorGSOutput = fcolorVSOutput[i];']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', ['in vec4 fcolorVSOutput;']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', ['gl_FragData[0] = fcolorVSOutput;']).result;
-    } else {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', ['uniform vec4 diffuseColor;']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', ['gl_FragData[0] = diffuseColor;']).result;
+      colorDec = colorDec.concat(['varying vec4 vertexColorVSOutput;']);
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Dec', ['attribute vec4 scalarColor;', 'varying vec4 vertexColorVSOutput;']).result;
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Impl', ['vertexColorVSOutput =  scalarColor;']).result;
+      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Dec', ['in vec4 vertexColorVSOutput[];', 'out vec4 vertexColorGSOutput;']).result;
+      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Impl', ['vertexColorGSOutput = vertexColorVSOutput[i];']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', colorImpl.concat(['  diffuseColor = vertexColorVSOutput.rgb;', '  opacity = opacity*vertexColorVSOutput.a;'])).result;
+    } else if (model.renderable.getAreScalarsMappedFromCells()) {
+      colorImpl = colorImpl.concat(['  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);', '  diffuseColor = texColor.rgb;', '  opacity = opacity*texColor.a;']);
     }
+    colorImpl = colorImpl.concat(['gl_FragData[0] = vec4(diffuseColor, opacity);']);
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', colorDec).result;
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', colorImpl).result;
     shaders.Vertex = VSSource;
     shaders.Geometry = GSSource;
     shaders.Fragment = FSSource;
@@ -252,7 +301,7 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
         FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Dec', ['in vec2 tcoordVCVSOutput;', 'uniform sampler2D texture1;']).result;
         FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['gl_FragData[0] = gl_FragData[0]*texture2D(texture1, tcoordVCVSOutput.st);']).result;
       }
-      if (model.haveCellScalars) {
+      if (model.renderable.getAreScalarsMappedFromCells()) {
         GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::PrimID::Impl', ['gl_PrimitiveID = gl_PrimitiveIDIn;']).result;
       }
       shaders.Vertex = VSSource;
@@ -303,8 +352,18 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
       } else {
         cellBO.getVAO().removeAttributeArray('tcoordMC');
       }
+      if (cellBO.getProgram().isAttributeUsed('scalarColor') && cellBO.getCABO().getColorComponents()) {
+        if (!cellBO.getVAO().addAttributeArray(cellBO.getProgram(), cellBO.getCABO().getColorBO(), 'scalarColor', cellBO.getCABO().getColorOffset(), cellBO.getCABO().getColorBOStride(), model.context.UNSIGNED_BYTE, 4, true)) {
+          vtkErrorMacro('Error setting scalarColor in shader VAO.');
+        }
+      } else {
+        cellBO.getVAO().removeAttributeArray('scalarColor');
+      }
       if (model.internalColorTexture && cellBO.getProgram().isUniformUsed('texture1')) {
-        cellBO.getProgram().setUniformi('texture1', model.internalColorTexture.getTextureUnit());
+        const texUnit = model.internalColorTexture.getTextureUnit();
+        if (texUnit > -1) {
+          cellBO.getProgram().setUniformi('texture1', model.internalColorTexture.getTextureUnit());
+        }
       }
       const tus = model.openGLActor2D.getActiveTextures();
       if (tus) {
@@ -331,9 +390,9 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
       const program = cellBO.getProgram();
       const ppty = actor.getProperty();
       const opacity = ppty.getOpacity();
+      program.setUniformf('opacityUniform', opacity);
       const dColor = ppty.getColor();
-      const diffuseColor = [dColor[0], dColor[1], dColor[2], opacity];
-      program.setUniform4f('diffuseColor', diffuseColor);
+      program.setUniform3fArray('diffuseColorUniform', dColor);
     }
   };
   publicAPI.setLightingShaderParameters = (cellBO, ren, actor) => {

package/index.d.ts

@@ -75,6 +75,7 @@
 /// <reference path="./Filters/Sources/CubeSource.d.ts" />
 /// <reference path="./Filters/Sources/Cursor3D.d.ts" />
 /// <reference path="./Filters/Sources/CylinderSource.d.ts" />
+/// <reference path="./Filters/Sources/DiskSource.d.ts" />
 /// <reference path="./Filters/Sources/LineSource.d.ts" />
 /// <reference path="./Filters/Sources/PlaneSource.d.ts" />
 /// <reference path="./Filters/Sources/PointSource.d.ts" />

package/package.json

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