@kitware/vtk.js 29.5.0 → 29.6.0

package/Common/Core/Math/index.js

@@ -544,7 +544,7 @@ function multiply3x3_mat3(a_3x3, b_3x3, out_3x3) {
     out_3x3[i + 6] = copyA[6] * copyB[i] + copyA[7] * copyB[i + 3] + copyA[8] * copyB[i + 6];
   }
 }
-function multiplyMatrix(a, b, rowA, colA, rowB, colB, out_rowXcol) {
+function multiplyMatrix(a, b, rowA, colA, rowB, colB, outRowAColB) {
   // we need colA == rowB
   if (colA !== rowB) {
     vtkErrorMacro('Number of columns of A must match number of rows of B.');
@@ -558,10 +558,10 @@ function multiplyMatrix(a, b, rowA, colA, rowB, colB, out_rowXcol) {
   for (let i = 0; i < rowA; i++) {
     // output col
     for (let j = 0; j < colB; j++) {
-      out_rowXcol[i * colB + j] = 0;
+      outRowAColB[i * colB + j] = 0;
       // sum for this point
       for (let k = 0; k < colA; k++) {
-        out_rowXcol[i * colB + j] += copyA[i * colA + k] * copyB[j + colB * k];
+        outRowAColB[i * colB + j] += copyA[i * colA + k] * copyB[j + colB * k];
       }
     }
   }
@@ -2245,4 +2245,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { arrayMax as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, isIdentity3x3 as G, floor as H, isInf as I, rgb2hsv as J, rgb2lab as K, lab2rgb as L, round as M, normalize2D as N, nearestPowerOfTwo as O, multiply3x3_vect3 as P, getSparseOrthogonalMatrix as Q, areBoundsInitialized as R, isPowerOfTwo as S, angleBetweenVectors as T, signedAngleBetweenVectors as U, createArray as V, Pi as W, ceil as X, min as Y, max as Z, arrayMin as _, areMatricesEqual as a, float2CssRGBA as a$, ceilLog2 as a0, factorial as a1, binomial as a2, beginCombination as a3, nextCombination as a4, randomSeed as a5, getSeed as a6, gaussian as a7, multiplyScalar2D as a8, multiplyAccumulate2D as a9, diagonalize3x3 as aA, singularValueDecomposition3x3 as aB, luFactorLinearSystem as aC, luSolveLinearSystem as aD, invertMatrix as aE, estimateMatrixCondition as aF, solveHomogeneousLeastSquares as aG, solveLeastSquares as aH, hex2float as aI, lab2xyz as aJ, xyz2lab as aK, xyz2rgb as aL, rgb2xyz as aM, computeBoundsFromPoints as aN, clampAndNormalizeValue as aO, getScalarTypeFittingRange as aP, getAdjustedScalarRange as aQ, extentIsWithinOtherExtent as aR, boundsIsWithinOtherBounds as aS, pointIsWithinBounds as aT, solve3PointCircle as aU, inf as aV, negInf as aW, isFinite as aX, isNaN as aY, floatToHex2 as aZ, floatRGB2HexCode as a_, outer as aa, projectVector as ab, dot2D as ac, projectVector2D as ad, gaussianAmplitude as ae, gaussianWeight as af, outer2D as ag, norm2D as ah, rowsToMat4 as ai, columnsToMat4 as aj, columnsToMat3 as ak, LUFactor3x3 as al, LUSolve3x3 as am, linearSolve3x3 as an, multiply3x3_mat3 as ao, multiplyMatrix as ap, transpose3x3 as aq, invert3x3 as ar, identity3x3 as as, identity as at, isIdentity as au, quaternionToMatrix3x3 as av, roundNumber as aw, matrix3x3ToQuaternion as ax, multiplyQuaternion as ay, orthogonalize3x3 as az, roundVector as b, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };
+export { max as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, createUninitializedBounds as F, isIdentity3x3 as G, identity as H, multiplyMatrix as I, floor as J, isInf as K, rgb2hsv as L, rgb2lab as M, lab2rgb as N, round as O, normalize2D as P, nearestPowerOfTwo as Q, multiply3x3_vect3 as R, getSparseOrthogonalMatrix as S, areBoundsInitialized as T, isPowerOfTwo as U, angleBetweenVectors as V, signedAngleBetweenVectors as W, createArray as X, Pi as Y, ceil as Z, min as _, areMatricesEqual as a, float2CssRGBA as a$, arrayMin as a0, arrayMax as a1, ceilLog2 as a2, factorial as a3, binomial as a4, beginCombination as a5, nextCombination as a6, randomSeed as a7, getSeed as a8, gaussian as a9, diagonalize3x3 as aA, singularValueDecomposition3x3 as aB, luFactorLinearSystem as aC, luSolveLinearSystem as aD, invertMatrix as aE, estimateMatrixCondition as aF, solveHomogeneousLeastSquares as aG, solveLeastSquares as aH, hex2float as aI, lab2xyz as aJ, xyz2lab as aK, xyz2rgb as aL, rgb2xyz as aM, computeBoundsFromPoints as aN, clampAndNormalizeValue as aO, getScalarTypeFittingRange as aP, getAdjustedScalarRange as aQ, extentIsWithinOtherExtent as aR, boundsIsWithinOtherBounds as aS, pointIsWithinBounds as aT, solve3PointCircle as aU, inf as aV, negInf as aW, isFinite as aX, isNaN as aY, floatToHex2 as aZ, floatRGB2HexCode as a_, multiplyScalar2D as aa, multiplyAccumulate2D as ab, outer as ac, projectVector as ad, dot2D as ae, projectVector2D as af, gaussianAmplitude as ag, gaussianWeight as ah, outer2D as ai, norm2D as aj, rowsToMat4 as ak, columnsToMat4 as al, columnsToMat3 as am, LUFactor3x3 as an, LUSolve3x3 as ao, linearSolve3x3 as ap, multiply3x3_mat3 as aq, transpose3x3 as ar, invert3x3 as as, identity3x3 as at, isIdentity as au, quaternionToMatrix3x3 as av, roundNumber as aw, matrix3x3ToQuaternion as ax, multiplyQuaternion as ay, orthogonalize3x3 as az, roundVector as b, clampVector as c, dot as d, distance2BetweenPoints as e, vtkMath as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, jacobi as t, uninitializeBounds as u, vtkMath$1 as v, multiplyScalar as w, random as x, determinant3x3 as y, rowsToMat3 as z };

package/Common/Core/Math.d.ts

@@ -471,9 +471,9 @@ export function multiply3x3_mat3(a_3x3: Matrix3x3, b_3x3: Matrix3x3, out_3x3: Ma
  * @param {Number} colA 
  * @param {Number} rowB 
  * @param {Number} colB 
- * @param {Matrix} out_rowXcol 
+ * @param {Matrix} outRowAColB 
  */
-export function multiplyMatrix(a: Matrix, b: Matrix, rowA: number, colA: number, rowB: number, colB: number, out_rowXcol: Matrix): void;
+export function multiplyMatrix(a: Matrix, b: Matrix, rowA: number, colA: number, rowB: number, colB: number, outRowAColB: Matrix): void;
 
 /**
  * Transpose a 3x3 matrix.

package/Common/Core/Math.js

@@ -1,4 +1,4 @@
 import 'seedrandom';
 import '../../macros2.js';
 import './Math/Constants.js';
-export { al as LUFactor3x3, am as LUSolve3x3, W as Pi, k as add, T as angleBetweenVectors, R as areBoundsInitialized, B as areEquals, a as areMatricesEqual, $ as arrayMax, _ as arrayMin, D as arrayRange, a3 as beginCombination, a2 as binomial, aS as boundsIsWithinOtherBounds, X as ceil, a0 as ceilLog2, aO as clampAndNormalizeValue, C as clampValue, c as clampVector, ak as columnsToMat3, aj as columnsToMat4, aN as computeBoundsFromPoints, V as createArray, F as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aA as diagonalize3x3, e as distance2BetweenPoints, d as dot, ac as dot2D, aF as estimateMatrixCondition, aR as extentIsWithinOtherExtent, a1 as factorial, a$ as float2CssRGBA, a_ as floatRGB2HexCode, aZ as floatToHex2, H as floor, a7 as gaussian, ae as gaussianAmplitude, af as gaussianWeight, aQ as getAdjustedScalarRange, E as getMajorAxisIndex, aP as getScalarTypeFittingRange, a6 as getSeed, Q as getSparseOrthogonalMatrix, aI as hex2float, h as hsv2rgb, at as identity, as as identity3x3, aV as inf, ar as invert3x3, aE as invertMatrix, aX as isFinite, au as isIdentity, G as isIdentity3x3, I as isInf, aY as isNaN, i as isNan, S as isPowerOfTwo, t as jacobi, p as jacobiN, L as lab2rgb, aJ as lab2xyz, an as linearSolve3x3, aC as luFactorLinearSystem, aD as luSolveLinearSystem, ax as matrix3x3ToQuaternion, Z as max, Y as min, ao as multiply3x3_mat3, P as multiply3x3_vect3, m as multiplyAccumulate, a9 as multiplyAccumulate2D, ap as multiplyMatrix, ay as multiplyQuaternion, w as multiplyScalar, a8 as multiplyScalar2D, O as nearestPowerOfTwo, aW as negInf, a4 as nextCombination, n as norm, ah as norm2D, l as normalize, N as normalize2D, az as orthogonalize3x3, aa as outer, ag as outer2D, q as perpendiculars, aT as pointIsWithinBounds, ab as projectVector, ad as projectVector2D, av as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a5 as randomSeed, J as rgb2hsv, K as rgb2lab, aM as rgb2xyz, M as round, aw as roundNumber, b as roundVector, z as rowsToMat3, ai as rowsToMat4, U as signedAngleBetweenVectors, aB as singularValueDecomposition3x3, aU as solve3PointCircle, aG as solveHomogeneousLeastSquares, aH as solveLeastSquares, g as solveLinearSystem, s as subtract, aq as transpose3x3, u as uninitializeBounds, aK as xyz2lab, aL as xyz2rgb } from './Math/index.js';
+export { an as LUFactor3x3, ao as LUSolve3x3, Y as Pi, k as add, V as angleBetweenVectors, T as areBoundsInitialized, B as areEquals, a as areMatricesEqual, a1 as arrayMax, a0 as arrayMin, D as arrayRange, a5 as beginCombination, a4 as binomial, aS as boundsIsWithinOtherBounds, Z as ceil, a2 as ceilLog2, aO as clampAndNormalizeValue, C as clampValue, c as clampVector, am as columnsToMat3, al as columnsToMat4, aN as computeBoundsFromPoints, X as createArray, F as createUninitializedBounds, j as cross, f as default, A as degreesFromRadians, o as determinant2x2, y as determinant3x3, aA as diagonalize3x3, e as distance2BetweenPoints, d as dot, ae as dot2D, aF as estimateMatrixCondition, aR as extentIsWithinOtherExtent, a3 as factorial, a$ as float2CssRGBA, a_ as floatRGB2HexCode, aZ as floatToHex2, J as floor, a9 as gaussian, ag as gaussianAmplitude, ah as gaussianWeight, aQ as getAdjustedScalarRange, E as getMajorAxisIndex, aP as getScalarTypeFittingRange, a8 as getSeed, S as getSparseOrthogonalMatrix, aI as hex2float, h as hsv2rgb, H as identity, at as identity3x3, aV as inf, as as invert3x3, aE as invertMatrix, aX as isFinite, au as isIdentity, G as isIdentity3x3, K as isInf, aY as isNaN, i as isNan, U as isPowerOfTwo, t as jacobi, p as jacobiN, N as lab2rgb, aJ as lab2xyz, ap as linearSolve3x3, aC as luFactorLinearSystem, aD as luSolveLinearSystem, ax as matrix3x3ToQuaternion, $ as max, _ as min, aq as multiply3x3_mat3, R as multiply3x3_vect3, m as multiplyAccumulate, ab as multiplyAccumulate2D, I as multiplyMatrix, ay as multiplyQuaternion, w as multiplyScalar, aa as multiplyScalar2D, Q as nearestPowerOfTwo, aW as negInf, a6 as nextCombination, n as norm, aj as norm2D, l as normalize, P as normalize2D, az as orthogonalize3x3, ac as outer, ai as outer2D, q as perpendiculars, aT as pointIsWithinBounds, ad as projectVector, af as projectVector2D, av as quaternionToMatrix3x3, r as radiansFromDegrees, x as random, a7 as randomSeed, L as rgb2hsv, M as rgb2lab, aM as rgb2xyz, O as round, aw as roundNumber, b as roundVector, z as rowsToMat3, ak as rowsToMat4, W as signedAngleBetweenVectors, aB as singularValueDecomposition3x3, aU as solve3PointCircle, aG as solveHomogeneousLeastSquares, aH as solveLeastSquares, g as solveLinearSystem, s as subtract, ar as transpose3x3, u as uninitializeBounds, aK as xyz2lab, aL as xyz2rgb } from './Math/index.js';

package/Filters/General/ScalarToRGBA.js

@@ -35,7 +35,7 @@ function vtkScalarToRGBA(publicAPI, model) {
     }
     const rgba = [0, 0, 0, 0];
     const data = scalars.getData();
-    const rgbaArray = new Uint8Array(data.length * 4);
+    const rgbaArray = new Uint8ClampedArray(data.length * 4);
     let offset = 0;
     for (let idx = 0; idx < data.length; idx++) {
       const x = data[idx];

package/Rendering/Core/AxesActor.js

@@ -24,7 +24,7 @@ function shiftDataset(ds, axis) {
 
 function addColor(ds, r, g, b) {
   const size = ds.getPoints().getData().length;
-  const rgbArray = new Uint8Array(size);
+  const rgbArray = new Uint8ClampedArray(size);
   let offset = 0;
   while (offset < size) {
     rgbArray[offset++] = r;

package/Rendering/Core/ColorTransferFunction/CssFilters.d.ts

@@ -0,0 +1,109 @@
+/**
+ * A helper file to transform RGBA points using CSS filters equivalent
+ * The equivalents of CSS filters using SVG filters can be found here:
+ * https://www.w3.org/TR/filter-effects-1/#ShorthandEquivalents
+ * For each SVG filter, you can look for the maths behind it on the same page:
+ * https://www.w3.org/TR/filter-effects-1/#FilterPrimitivesOverview
+ *
+ * For example, the saturate filter equivalent is here:
+ * https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+ * And the maths behind the feColorMatrix of type saturate is here:
+ * https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+ *
+ * The transforms are done using matrices of size 5 by 5. They are row major
+ * as in vtkMath. The vectors representing the RGBA points uses
+ * [R, G, B, A, 1] vectors, with each channel between 0 and 1.
+ */
+
+import { Matrix, Vector3 } from '../../../types';
+
+export const luminanceWeights: Vector3;
+export type FilterMatrix = Matrix;
+
+/**
+ * Create a new filter matrix
+ * This is a 5x5 row major array
+ * Use applyFilter() function to use it
+ * It is NOT the identity
+ */
+export function createCSSFilter(): FilterMatrix;
+
+/**
+ * Convert a filter to an identity matrix or create a new identity filter
+ * @param outFilter If specified, the outFilter is converted to identity filter
+ */
+export function createIdentityFilter(outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * Combine two filters into a single filter
+ * Warning: it is NOT an operation inspired by CSS filters
+ * For this, apply filters one by one using applyFilter
+ * The clamping step is not applied between each filter when the filters are combined
+ * The order of the filters matters
+ * @param baseFilter The first filter that will be applied
+ * @param newFilter The second filter that will be applied
+ * @param outFilter An optional filter that will contain the combined filter
+ */
+export function combineFilters(baseFilter: FilterMatrix, newFilter: FilterMatrix, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * Apply a filter to a rgb(a) point
+ * It is a multiplication by the matrix and a clamping
+ * @param filter The filter
+ * @param r The red channel (between 0 and 1)
+ * @param g The green channel (between 0 and 1)
+ * @param b The blue channel (between 0 and 1)
+ * @param a The optional alpha channel (between 0 and 1), defaults to 1
+ * @returns A vector of size 4 [r, g, b, a]
+ */
+export function applyFilter(filter: FilterMatrix, r: number, g: number, b: number, a?: number): [number, number, number, number];
+
+/**
+ * A generic linear filter
+ * See svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+ * @param slope 
+ * @param intercept 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createLinearFilter(slope: number, intercept: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * A contrast filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#contrastEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+ * @param contrast 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createContrastFilter(contrast: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * A saturate filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+ * @param saturate 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createSaturateFilter(saturate: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * A brightness filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#brightnessEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+ * @param brightness 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createBrightnessFilter(brightness: number, outFilter?: FilterMatrix): FilterMatrix;
+
+/**
+ * An invert filter
+ * See css/svg equivalent for parameters and a specification
+ * https://www.w3.org/TR/filter-effects-1/#invertEquivalent
+ * https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-table
+ * @param invert 
+ * @param outFilter Optional output, a new filter is created if not specified
+ */
+export function createInvertFilter(invert: number, outFilter?: FilterMatrix): FilterMatrix;

package/Rendering/Core/ColorTransferFunction/CssFilters.js

@@ -0,0 +1,103 @@
+import { H as identity, I as multiplyMatrix } from '../../../Common/Core/Math/index.js';
+
+/**
+ * A helper file to transform RGBA points using CSS filters equivalent
+ * The equivalents of CSS filters using SVG filters can be found here:
+ * https://www.w3.org/TR/filter-effects-1/#ShorthandEquivalents
+ * For each SVG filter, you can look for the maths behind it on the same page:
+ * https://www.w3.org/TR/filter-effects-1/#FilterPrimitivesOverview
+ *
+ * For example, the saturate filter equivalent is here:
+ * https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+ * And the maths behind the feColorMatrix of type saturate is here:
+ * https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+ *
+ * The transforms are done using matrices of size 5 by 5. They are row major
+ * as in vtkMath. The vectors representing the RGBA points uses
+ * [R, G, B, A, 1] vectors, with each channel between 0 and 1.
+ */
+const luminanceWeights = [0.213, 0.715, 0.072];
+function createCSSFilter() {
+  return new Array(25);
+}
+function createIdentityFilter() {
+  let outFilter = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : createCSSFilter();
+  return identity(5, outFilter);
+}
+function combineFilters(baseFilter, newFilter) {
+  let outFilter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : createCSSFilter();
+  multiplyMatrix(newFilter, baseFilter, 5, 5, 5, 5, outFilter);
+  return outFilter;
+}
+function applyFilter(filter, r, g, b) {
+  let a = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1;
+  const vec = [r, g, b, a, 1];
+  multiplyMatrix(filter, vec, 5, 5, 5, 1, vec);
+  // Clamp R, G, B, A
+  const output = new Array(4);
+  for (let i = 0; i < 4; ++i) {
+    const value = vec[i];
+    if (value < 0) {
+      output[i] = 0;
+    } else if (value > 1) {
+      output[i] = 1;
+    } else {
+      output[i] = value;
+    }
+  }
+  return output;
+}
+function createLinearFilter(slope, intercept) {
+  let outFilter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : createCSSFilter();
+  createIdentityFilter(outFilter);
+  for (let row = 0; row < 3; ++row) {
+    outFilter[row * 5 + row] = slope;
+    outFilter[row * 5 + 4] = intercept;
+  }
+  return outFilter;
+}
+
+// https://www.w3.org/TR/filter-effects-1/#contrastEquivalent
+// https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+function createContrastFilter(contrast) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  const slope = contrast;
+  const intercept = -(0.5 * contrast) + 0.5;
+  return createLinearFilter(slope, intercept, outFilter);
+}
+
+// https://www.w3.org/TR/filter-effects-1/#saturateEquivalent
+// https://www.w3.org/TR/filter-effects-1/#ref-for-attr-valuedef-type-saturate
+function createSaturateFilter(saturate) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  createIdentityFilter(outFilter);
+  for (let col = 0; col < 3; ++col) {
+    const columnLuminance = luminanceWeights[col];
+    const diagonalValue = columnLuminance + (1 - columnLuminance) * saturate;
+    const nonDiagonalValue = columnLuminance - columnLuminance * saturate;
+    for (let row = 0; row < 3; ++row) {
+      outFilter[row * 5 + col] = row === col ? diagonalValue : nonDiagonalValue;
+    }
+  }
+  return outFilter;
+}
+
+// https://www.w3.org/TR/filter-effects-1/#brightnessEquivalent
+// https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-linear
+function createBrightnessFilter(brightness) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  const slope = brightness;
+  const intercept = 0;
+  return createLinearFilter(slope, intercept, outFilter);
+}
+
+// https://www.w3.org/TR/filter-effects-1/#invertEquivalent
+// https://www.w3.org/TR/filter-effects-1/#attr-valuedef-type-table
+function createInvertFilter(invert) {
+  let outFilter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : createCSSFilter();
+  const slope = 1 - 2 * invert;
+  const intercept = invert;
+  return createLinearFilter(slope, intercept, outFilter);
+}
+
+export { applyFilter, combineFilters, createBrightnessFilter, createCSSFilter, createContrastFilter, createIdentityFilter, createInvertFilter, createLinearFilter, createSaturateFilter, luminanceWeights };

package/Rendering/Core/ColorTransferFunction.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { h as hsv2rgb, i as isNan, H as floor, I as isInf, J as rgb2hsv, K as rgb2lab, L as lab2rgb } from '../../Common/Core/Math/index.js';
+import { h as hsv2rgb, i as isNan, J as floor, K as isInf, L as rgb2hsv, M as rgb2lab, N as lab2rgb } from '../../Common/Core/Math/index.js';
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors.js';
 import Constants from './ColorTransferFunction/Constants.js';
 

package/Rendering/Core/Coordinate.js

@@ -1,6 +1,6 @@
 import { m as macro } from '../../macros2.js';
 import Constants from './Coordinate/Constants.js';
-import { M as round, H as floor } from '../../Common/Core/Math/index.js';
+import { O as round, J as floor } from '../../Common/Core/Math/index.js';
 
 const {
   Coordinate

package/Rendering/Core/CubeAxesActor.js

@@ -1,6 +1,6 @@
 import { vec3, mat4 } from 'gl-matrix';
 import * as d3 from 'd3-scale';
-import { N as normalize2D, O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { P as normalize2D, Q as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';

package/Rendering/Core/ImageMapper.js

@@ -2,7 +2,7 @@ import Constants from './ImageMapper/Constants.js';
 import { m as macro } from '../../macros2.js';
 import vtkAbstractImageMapper from './AbstractImageMapper.js';
 import { intersectWithLineForPointPicking, intersectWithLineForCellPicking } from './AbstractImageMapper/helper.js';
-import { C as clampValue, P as multiply3x3_vect3, F as createUninitializedBounds, Q as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
+import { C as clampValue, R as multiply3x3_vect3, F as createUninitializedBounds, S as getSparseOrthogonalMatrix } from '../../Common/Core/Math/index.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 
 const {

package/Rendering/Core/Renderer.js

@@ -2,7 +2,7 @@ import { mat4, vec3 } from 'gl-matrix';
 import { n as newInstance$1, g as get, e as setGet, k as getArray, l as setGetArray, i as moveToProtected, c as macro } from '../../macros2.js';
 import vtkCamera from './Camera.js';
 import vtkLight from './Light.js';
-import { R as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
+import { T as areBoundsInitialized, u as uninitializeBounds, r as radiansFromDegrees, d as dot, F as createUninitializedBounds } from '../../Common/Core/Math/index.js';
 import vtkViewport from './Viewport.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 

package/Rendering/Core/ScalarBarActor.js

@@ -1,5 +1,5 @@
 import * as d3 from 'd3-scale';
-import { O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { Q as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import { m as macro } from '../../macros2.js';
 import vtkActor from './Actor.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';

package/Rendering/Core/VolumeMapper.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { F as createUninitializedBounds, C as clampValue, H as floor } from '../../Common/Core/Math/index.js';
+import { F as createUninitializedBounds, C as clampValue, J as floor } from '../../Common/Core/Math/index.js';
 import Constants from './VolumeMapper/Constants.js';
 import vtkAbstractMapper from './AbstractMapper.js';
 import vtkPiecewiseFunction from '../../Common/DataModel/PiecewiseFunction.js';

package/Rendering/OpenGL/ImageCPRMapper.js

@@ -188,7 +188,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (model.colorTextureString !== cfunToString) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       let cfun = ppty.getRGBTransferFunction();
       if (cfun) {
         const tmpTable = new Float32Array(cWidth * 3);
@@ -228,7 +228,7 @@ function vtkOpenGLImageCPRMapper(publicAPI, model) {
     if (model.pwfTextureString !== pwfunToString) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
-      const pwfTable = new Uint8Array(pwfSize);
+      const pwfTable = new Uint8ClampedArray(pwfSize);
       let pwfun = ppty.getPiecewiseFunction();
       // support case where pwfun is added/removed
       model.pwfTexture.releaseGraphicsResources(model._openGLRenderWindow);

package/Rendering/OpenGL/ImageMapper.js

@@ -582,7 +582,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       if (!model.colorTexture) {
         model.colorTexture = vtkOpenGLTexture.newInstance({
           resizable: true
@@ -645,7 +645,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
-      const pwfTable = new Uint8Array(pwfSize);
+      const pwfTable = new Uint8ClampedArray(pwfSize);
       if (!model.pwfTexture) {
         model.pwfTexture = vtkOpenGLTexture.newInstance({
           resizable: true
@@ -745,6 +745,8 @@ function vtkOpenGLImageMapper(publicAPI, model) {
         });
         model.openGLTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
       }
+      // Use norm16 for scalar texture if the extension is available
+      model.openGLTexture.setOglNorm16Ext(model.context.getExtension('EXT_texture_norm16'));
       if (iType === InterpolationType.NEAREST) {
         if (new Set([1, 3, 4]).has(numComp) && dataType === VtkDataTypes.UNSIGNED_CHAR && !iComps) {
           model.openGLTexture.setGenerateMipmap(true);

package/Rendering/OpenGL/ImageResliceMapper.js

@@ -213,7 +213,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * textureHeight * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       if (!model.colorTexture) {
         model.colorTexture = vtkOpenGLTexture.newInstance();
         model.colorTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
@@ -268,7 +268,7 @@ function vtkOpenGLImageResliceMapper(publicAPI, model) {
     if (reBuildPwf) {
       const pwfWidth = 1024;
       const pwfSize = pwfWidth * textureHeight;
-      const pwfTable = new Uint8Array(pwfSize);
+      const pwfTable = new Uint8ClampedArray(pwfSize);
       if (!model.pwfTexture) {
         model.pwfTexture = vtkOpenGLTexture.newInstance();
         model.pwfTexture.setOpenGLRenderWindow(model._openGLRenderWindow);

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -8,7 +8,7 @@ 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 { M as round } from '../../Common/Core/Math/index.js';
+import { O as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 

package/Rendering/OpenGL/RenderWindow.js

@@ -319,18 +319,22 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
             default:
               return oglNorm16Ext.RGBA16_SNORM_EXT;
           }
+        case VtkDataTypes.UNSIGNED_SHORT:
+        case VtkDataTypes.SHORT:
         case VtkDataTypes.FLOAT:
         default:
+          // useHalfFloat tells us if the texture can be accurately
+          // rendered with 16 bits or not.
           switch (numComps) {
             case 1:
-              return model.context.R16F;
+              return useHalfFloat ? model.context.R16F : model.context.R32F;
             case 2:
-              return model.context.RG16F;
+              return useHalfFloat ? model.context.RG16F : model.context.RG32F;
             case 3:
-              return model.context.RGB16F;
+              return useHalfFloat ? model.context.RGB16F : model.context.RGB32F;
             case 4:
             default:
-              return model.context.RGBA16F;
+              return useHalfFloat ? model.context.RGBA16F : model.context.RGBA32F;
           }
       }
     }

package/Rendering/OpenGL/Texture.js

@@ -2,7 +2,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { n as newInstance$1, o as obj, s as set, e as setGet, g as get, i as moveToProtected, a as newTypedArray, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { S as isPowerOfTwo, O as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { U as isPowerOfTwo, Q as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
@@ -275,6 +275,9 @@ function vtkOpenGLTexture(publicAPI, model) {
     if (!model.internalFormat) {
       vtkDebugMacro(`Unable to find suitable internal format for T=${vtktype} NC= ${numComps}`);
     }
+    if ([model.context.R32F, model.context.RG32F, model.context.RGB32F, model.context.RGBA32F].includes(model.internalFormat) && !model.context.getExtension('OES_texture_float_linear')) {
+      vtkWarningMacro('Failed to load OES_texture_float_linear. Texture filtering is not available for *32F internal formats.');
+    }
     return model.internalFormat;
   };
 

package/Rendering/OpenGL/VolumeMapper.js

@@ -1006,7 +1006,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
       if (model._openGLRenderWindow.getWebgl2() || model.context.getExtension('OES_texture_float') && model.context.getExtension('OES_texture_float_linear')) {
         model.opacityTexture.create2DFromRaw(oWidth, 2 * numIComps, 1, VtkDataTypes.FLOAT, ofTable);
       } else {
-        const oTable = new Uint8Array(oSize);
+        const oTable = new Uint8ClampedArray(oSize);
         for (let i = 0; i < oSize; ++i) {
           oTable[i] = 255.0 * ofTable[i];
         }
@@ -1029,7 +1029,7 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (reBuildC) {
       const cWidth = 1024;
       const cSize = cWidth * 2 * numIComps * 3;
-      const cTable = new Uint8Array(cSize);
+      const cTable = new Uint8ClampedArray(cSize);
       const tmpTable = new Float32Array(cWidth * 3);
       for (let c = 0; c < numIComps; ++c) {
         const cfun = vprop.getRGBTransferFunction(c);

package/Rendering/WebGPU/ImageMapper.js

@@ -230,7 +230,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
     const cfunToString = computeFnToString(actorProperty, actorProperty.getRGBTransferFunction, numIComps);
     if (model.colorTextureString !== cfunToString) {
       model.numRows = numIComps;
-      const colorArray = new Uint8Array(model.numRows * 2 * model.rowLength * 4);
+      const colorArray = new Uint8ClampedArray(model.numRows * 2 * model.rowLength * 4);
       let cfun = actorProperty.getRGBTransferFunction();
       if (cfun) {
         const tmpTable = new Float32Array(model.rowLength * 3);

package/Rendering/WebGPU/SphereMapper.js

@@ -245,7 +245,7 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
           if (colorComponents !== 4) {
             vtkErrorMacro('this should be 4');
           }
-          const tmpVBO = new Uint8Array(3 * numPoints * 4);
+          const tmpVBO = new Uint8ClampedArray(3 * numPoints * 4);
           let vboIdx = 0;
           const colorData = c.getData();
           for (let id = 0; id < numPoints; ++id) {

package/Rendering/WebGPU/StickMapper.js

@@ -362,7 +362,7 @@ function vtkWebGPUStickMapper(publicAPI, model) {
           if (colorComponents !== 4) {
             vtkErrorMacro('this should be 4');
           }
-          const tmpVBO = new Uint8Array(numPoints * 4);
+          const tmpVBO = new Uint8ClampedArray(numPoints * 4);
           let vboIdx = 0;
           const colorData = c.getData();
           for (let id = 0; id < numPoints; ++id) {

package/Rendering/WebGPU/VolumePassFSQ.js

@@ -484,7 +484,7 @@ function vtkWebGPUVolumePassFSQ(publicAPI, model) {
     }
 
     // allocate the image array
-    const colorArray = new Uint8Array(model.numRows * 2 * model.rowLength * 4);
+    const colorArray = new Uint8ClampedArray(model.numRows * 2 * model.rowLength * 4);
     const opacityArray = new Float32Array(model.numRows * 2 * model.rowLength);
     let imgRow = 0;
     const tmpTable = new Float32Array(model.rowLength * 3);

package/Widgets/Widgets3D/AngleWidget.js

@@ -3,7 +3,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { s as subtract, T as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, V as angleBetweenVectors } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './AngleWidget/behavior.js';
 import generateState from './AngleWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../../macros2.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
-import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, U as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, W as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import { getLineNames, getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
 import { InteractionMethodsName, ScrollingMethods, planeNameToViewType } from './Constants.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -2,7 +2,7 @@ import vtkBoundingBox, { STATIC } from '../../../Common/DataModel/BoundingBox.js
 import vtkCubeSource from '../../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
-import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, U as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, W as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 

package/index.d.ts

@@ -150,6 +150,7 @@
 /// <reference path="./Rendering/Core/CellPicker.d.ts" />
 /// <reference path="./Rendering/Core/ColorTransferFunction/ColorMaps.d.ts" />
 /// <reference path="./Rendering/Core/ColorTransferFunction/Constants.d.ts" />
+/// <reference path="./Rendering/Core/ColorTransferFunction/CssFilters.d.ts" />
 /// <reference path="./Rendering/Core/ColorTransferFunction.d.ts" />
 /// <reference path="./Rendering/Core/Coordinate/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Coordinate.d.ts" />

package/package.json

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