@kitware/vtk.js 34.5.0 → 34.7.0

package/Common/Core/CellArray.d.ts

@@ -39,6 +39,9 @@ export interface vtkCellArray extends vtkDataArray {
 
   /**
    * Insert a cell to this array in the next available slot.
+   * This may re-allocate a new typed array if the current one is not large enough.
+   * If the final size of the array is known up-front, it is more efficient to call
+   * `allocate()` before calling `insertNextCell()` multiple times.
    * @param {Number[]} cellPointIds The list of point ids (NOT prefixed with the number of points)
    * @returns {Number} Idx of where the cell was inserted
    */

package/Common/Core/CellArray.js

@@ -2,6 +2,9 @@ import { m as macro } from '../../macros2.js';
 import vtkDataArray from './DataArray.js';
 import { VtkDataTypes } from './DataArray/Constants.js';
 
+const {
+  isVtkObject
+} = macro;
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
@@ -65,6 +68,8 @@ function vtkCellArray(publicAPI, model) {
 
   /**
    * When `resize()` is being used, you then MUST use `insertNextCell()`.
+   * @see vtkCellArray#insertNextCell
+   * @see vtkDataArray#allocate
    */
   publicAPI.resize = requestedNumTuples => {
     const oldNumTuples = publicAPI.getNumberOfTuples();
@@ -92,7 +97,13 @@ function vtkCellArray(publicAPI, model) {
     const numberOfPoints = model.values[cellLoc++];
     return model.values.subarray(cellLoc, cellLoc + numberOfPoints);
   };
-  publicAPI.insertNextCell = cellPointIds => {
+  publicAPI.insertNextCell = cell => {
+    let cellPointIds;
+    if (isVtkObject(cell)) {
+      cellPointIds = cell.getPointsIds();
+    } else {
+      cellPointIds = cell;
+    }
     const cellId = publicAPI.getNumberOfCells();
     publicAPI.insertNextTuples([cellPointIds.length, ...cellPointIds]);
     // By computing the number of cells earlier, we made sure that numberOfCells is defined

package/Common/Core/DataArray.d.ts

@@ -168,6 +168,7 @@ export interface vtkDataArray extends vtkObject {
    *
    * @see insertNextTuple
    * @see getNumberOfTuples
+   * @see allocate
    *
    * @param {Number} idx
    * @param {Array<Number>|TypedArray} tuple
@@ -189,6 +190,7 @@ export interface vtkDataArray extends vtkObject {
    * NOTE: May resize the data values array. "Safe" version of setTuple.
    *
    * @see insertTuple
+   * @see allocate
    *
    * @param {Array<Number>|TypedArray} tuple
    * @returns {Number} Index of the inserted tuple.
@@ -303,6 +305,18 @@ export interface vtkDataArray extends vtkObject {
     t: float
   ): void;
 
+  /**
+   * Resize the array to the requested number of extra tuples
+   * (added to the current number of tuples) and preserve data.
+   * model.size WILL NOT be modified.
+   * This is useful before multiple calls to `insertNextTuple()` or `insertNextTuples()`.
+   * @param {Number} extraNumTuples Number of tuples to allocate memory wise.
+   * @see insertNextTuple
+   * @see insertNextTuples
+   * @see allocate
+   */
+  allocate(extraNumTuples: number): void;
+
   /**
    * Resize the array to the requested number of tuples and preserve data.
    * Increasing the array size may allocate extra memory beyond what was
@@ -318,6 +332,7 @@ export interface vtkDataArray extends vtkObject {
    * @see insertNextTuple
    * @see insertNextTuples
    * @see initialize
+   * @see allocate
    */
   resize(requestedNumTuples: number): boolean;
 

package/Common/Core/DataArray.js

@@ -156,17 +156,18 @@ function vtkDataArray(publicAPI, model) {
       return false;
     }
     const numComps = publicAPI.getNumberOfComponents();
-    const curNumTuples = model.values.length / (numComps > 0 ? numComps : 1);
-    if (requestedNumTuples === curNumTuples) {
+    const numAllocatedTuples = model.values.length / (numComps > 0 ? numComps : 1);
+    if (requestedNumTuples === numAllocatedTuples) {
       return true;
     }
-    if (requestedNumTuples > curNumTuples) {
+    if (requestedNumTuples > numAllocatedTuples) {
       // Requested size is bigger than current size.  Allocate enough
       // memory to fit the requested size and be more than double the
       // currently allocated memory.
       const oldValues = model.values;
-      model.values = newTypedArray(model.dataType, (requestedNumTuples + curNumTuples) * numComps);
+      model.values = newTypedArray(model.dataType, (requestedNumTuples + numAllocatedTuples) * numComps);
       model.values.set(oldValues);
+      // The actual number of tuples is not increased, only memory is allocated.
       return true;
     }
 
@@ -181,6 +182,9 @@ function vtkDataArray(publicAPI, model) {
     model.ranges = null;
     publicAPI.modified();
   };
+  publicAPI.allocate = extraNumTuples => {
+    resize(publicAPI.getNumberOfTuples() + extraNumTuples);
+  };
   publicAPI.resize = requestedNumTuples => {
     resize(requestedNumTuples);
     const newSize = requestedNumTuples * publicAPI.getNumberOfComponents();

package/Common/Core/Math/index.js

@@ -258,6 +258,16 @@ function normalize(x) {
   }
   return den;
 }
+function normalize4D(x) {
+  const den = norm(x, 3);
+  if (den !== 0.0) {
+    x[0] /= den;
+    x[1] /= den;
+    x[2] /= den;
+    x[3] /= den;
+  }
+  return den;
+}
 function perpendiculars(x, y, z, theta) {
   const x2 = x[0] * x[0];
   const y2 = x[1] * x[1];
@@ -2171,6 +2181,7 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   cross: cross,
   norm: norm,
   normalize: normalize,
+  normalize4D: normalize4D,
   perpendiculars: perpendiculars,
   projectVector: projectVector,
   dot2D: dot2D,
@@ -2256,4 +2267,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { ceil as $, degreesFromRadians as A, ldexp as B, xyz2rgb as C, areEquals as D, clampValue as E, arrayRange as F, getMajorAxisIndex as G, createUninitializedBounds as H, identity as I, multiplyMatrix as J, floor as K, isInf as L, rgb2hsv as M, rgb2lab as N, lab2rgb as O, round as P, normalize2D as Q, nearestPowerOfTwo as R, multiply3x3_vect3 as S, getSparseOrthogonalMatrix as T, areBoundsInitialized as U, floatRGB2HexCode as V, isPowerOfTwo as W, angleBetweenVectors as X, signedAngleBetweenVectors as Y, createArray as Z, Pi as _, areMatricesEqual as a, floatToHex2 as a$, min as a0, max as a1, arrayMin as a2, arrayMax as a3, ceilLog2 as a4, factorial as a5, binomial as a6, beginCombination as a7, nextCombination as a8, randomSeed as a9, matrix3x3ToQuaternion as aA, multiplyQuaternion as aB, orthogonalize3x3 as aC, diagonalize3x3 as aD, singularValueDecomposition3x3 as aE, luFactorLinearSystem as aF, luSolveLinearSystem as aG, invertMatrix as aH, estimateMatrixCondition as aI, solveHomogeneousLeastSquares as aJ, solveLeastSquares as aK, hex2float as aL, lab2xyz as aM, xyz2lab as aN, rgb2xyz as aO, computeBoundsFromPoints as aP, clampAndNormalizeValue as aQ, getScalarTypeFittingRange as aR, getAdjustedScalarRange as aS, extentIsWithinOtherExtent as aT, boundsIsWithinOtherBounds as aU, pointIsWithinBounds as aV, solve3PointCircle as aW, inf as aX, negInf as aY, isFinite as aZ, isNaN as a_, getSeed as aa, gaussian as ab, multiplyScalar2D as ac, multiplyAccumulate2D as ad, outer as ae, projectVector as af, dot2D as ag, projectVector2D as ah, gaussianAmplitude as ai, gaussianWeight as aj, outer2D as ak, norm2D as al, rowsToMat4 as am, columnsToMat4 as an, columnsToMat3 as ao, LUFactor3x3 as ap, LUSolve3x3 as aq, linearSolve3x3 as ar, multiply3x3_mat3 as as, transpose3x3 as at, invert3x3 as au, identity3x3 as av, isIdentity as aw, isIdentity3x3 as ax, quaternionToMatrix3x3 as ay, roundNumber as az, roundVector as b, float2CssRGBA as b0, 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 { createArray as $, rowsToMat3 as A, degreesFromRadians as B, ldexp as C, xyz2rgb as D, areEquals as E, clampValue as F, arrayRange as G, getMajorAxisIndex as H, createUninitializedBounds as I, normalize4D as J, identity as K, multiplyMatrix as L, floor as M, isInf as N, rgb2hsv as O, rgb2lab as P, lab2rgb as Q, round as R, normalize2D as S, nearestPowerOfTwo as T, multiply3x3_vect3 as U, getSparseOrthogonalMatrix as V, areBoundsInitialized as W, floatRGB2HexCode as X, isPowerOfTwo as Y, angleBetweenVectors as Z, signedAngleBetweenVectors as _, areMatricesEqual as a, isNaN as a$, Pi as a0, ceil as a1, min as a2, max as a3, arrayMin as a4, arrayMax as a5, ceilLog2 as a6, factorial as a7, binomial as a8, beginCombination as a9, quaternionToMatrix3x3 as aA, roundNumber as aB, matrix3x3ToQuaternion as aC, multiplyQuaternion as aD, orthogonalize3x3 as aE, diagonalize3x3 as aF, singularValueDecomposition3x3 as aG, luFactorLinearSystem as aH, luSolveLinearSystem as aI, estimateMatrixCondition as aJ, solveHomogeneousLeastSquares as aK, solveLeastSquares as aL, hex2float as aM, lab2xyz as aN, xyz2lab as aO, rgb2xyz as aP, computeBoundsFromPoints as aQ, clampAndNormalizeValue as aR, getScalarTypeFittingRange as aS, getAdjustedScalarRange as aT, extentIsWithinOtherExtent as aU, boundsIsWithinOtherBounds as aV, pointIsWithinBounds as aW, solve3PointCircle as aX, inf as aY, negInf as aZ, isFinite as a_, nextCombination as aa, randomSeed as ab, getSeed as ac, gaussian as ad, multiplyScalar2D as ae, multiplyAccumulate2D as af, outer as ag, projectVector as ah, dot2D as ai, projectVector2D as aj, gaussianAmplitude as ak, gaussianWeight as al, outer2D as am, norm2D as an, rowsToMat4 as ao, columnsToMat4 as ap, columnsToMat3 as aq, LUFactor3x3 as ar, LUSolve3x3 as as, linearSolve3x3 as at, multiply3x3_mat3 as au, transpose3x3 as av, invert3x3 as aw, identity3x3 as ax, isIdentity as ay, isIdentity3x3 as az, roundVector as b, floatToHex2 as b0, float2CssRGBA as b1, 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, invertMatrix as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };

package/Common/Core/Math.d.ts

@@ -203,7 +203,7 @@ export function getSeed(): number;
 export function random(minValue: number, maxValue: number): number;
 
 /**
- * Addition of two 3-vectors.
+ * Add two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -215,7 +215,7 @@ export function random(minValue: number, maxValue: number): number;
 export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- * Subtraction of two 3-vectors.
+ * Substract two 3-vectors.
  * @param {Vector3} a The first 3D vector.
  * @param {Vector3} b The second 3D vector.
  * @param {Vector3} out The output 3D vector.
@@ -227,7 +227,7 @@ export function add(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector3} vec
  * @param {Number} scalar
  * @example
@@ -238,7 +238,7 @@ export function subtract(a: Vector3, b: Vector3, out: Vector3): Vector3;
 export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 
 /**
- *
+ * Multiply a 3-vector by a scalar.
  * @param {Vector2} vec
  * @param {Number} scalar
  * @example
@@ -249,7 +249,7 @@ export function multiplyScalar(vec: Vector3, scalar: number): Vector3;
 export function multiplyScalar2D(vec: Vector2, scalar: number): Vector2;
 
 /**
- *
+ * Multiply two 3-vectors.
  * @param {Vector3} a
  * @param {Vector3} b
  * @param {Number} scalar
@@ -267,7 +267,7 @@ export function multiplyAccumulate(
 ): Vector3;
 
 /**
- *
+ * Multiply two 2-vectors.
  * @param {Vector2} a
  * @param {Vector2} b
  * @param {Number} scalar
@@ -285,7 +285,7 @@ export function multiplyAccumulate2D(
 ): Vector2;
 
 /**
- *
+ * Dot product of two 3-vectors.
  * @param {Vector3} x
  * @param {Vector3} y
  * @example
@@ -312,17 +312,23 @@ export function outer(x: Vector3, y: Vector3, out_3x3: Matrix3x3): void;
 export function cross(x: Vector3, y: Vector3, out: Vector3): Vector3;
 
 /**
- *
- * @param {Number[]} x
- * @param {Number} n
+ * Compute the norm of a vector.
+ * @param {Number[]} x The vector to compute the norm of.
+ * @param {Number} [n] The number of components to consider (default is 3).
  */
-export function norm(x: number[], n: number): number;
+export function norm(x: number[], n?: number): number;
 
 /**
  * Normalize in place. Returns norm.
- * @param {Vector3} x The vector to normlize.
+ * @param {Number[]} x The vector to normalize.
  */
-export function normalize(x: Vector3): number;
+export function normalize(x: number[]): number;
+
+/**
+ * Normalize in place. Returns norm.
+ * @param {Number[]} x The vector to normalize.
+ */
+export function normalize4D(x: number[]): number;
 
 /**
  * Given a unit vector v1, find two unit vectors v2 and v3 such that v1 cross v2 = v3
@@ -339,10 +345,10 @@ export function perpendiculars(
 ): void;
 
 /**
- *
- * @param {Vector3} a
- * @param {Vector3} b
- * @param {Vector3} projection
+ * Project vector `a` onto vector `b` and returns the result in projection vector.
+ * @param {Vector3} a The first 3D vector.
+ * @param {Vector3} b The second 3D vector.
+ * @param {Vector3} projection The projection 3D vector.
  */
 export function projectVector(
   a: Vector3,
@@ -351,7 +357,7 @@ export function projectVector(
 ): boolean;
 
 /**
- *
+ * Compute the dot product of two 2D vectors.
  * @param {Vector2} x
  * @param {Vector2} y
  */

package/Common/Core/Math.js

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

package/Common/DataModel/Triangle.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from './../../types';
+import { Vector2, Vector3 } from './../../types';
 import vtkCell, { ICellInitialValues } from './Cell';
 
 export interface ITriangleInitialValues extends ICellInitialValues {}
@@ -11,6 +11,14 @@ export interface IIntersectWithLine {
   betweenPoints?: boolean;
 }
 
+export interface IIntersectWithTriangle {
+  intersect: boolean;
+  coplanar: boolean;
+  pt1: Vector3;
+  pt2: Vector3;
+  surfaceId: number;
+}
+
 export interface vtkTriangle extends vtkCell {
   /**
    * Get the topological dimensional of the cell (0, 1, 2 or 3).
@@ -48,23 +56,36 @@ export interface vtkTriangle extends vtkCell {
   ): IIntersectWithLine;
 
   /**
-   * Evaluate the position of x in relation with triangle.
-   *
-   * Compute the closest point in the cell.
-   * - pccords parametric coordinate (computed in function)
-   * - weights Interpolation weights in cell.
-   * - the number of weights is equal to the number of points defining the
-   *   cell (computed in function).
-   *
-   * A javascript object is returned :
-   *
-   * ```js
-   * {
-   *   evaluation: 1 = inside 0 = outside -1 = problem during execution
-   *   subId: always set to 0
-   *   dist2: squared distance from x to cell
-   * }
-   * ```
+   * Get the nearest cell boundary to the specified parametric
+   * coordinates and whether the point is inside or outside the cell.
+   * @param {Number} subId The sub-id of the cell.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector2} pts The points of the cell.
+   */
+  cellBoundary(subId: number, pcoords: Vector3, pts: Vector2): boolean;
+
+  /**
+   * Get the derivatives of the triangle at the specified parametric
+   * coordinates.
+   * @param {Number} subId - The sub-id of the triangle.
+   * @param {Vector3} pcoords - The parametric coordinates.
+   * @param {Number[]} values - The values at the points.
+   * @param {Number} dim - The dimension.
+   * @param {Number[]} derivs - The derivatives.
+   */
+  derivatives(
+    subId: number,
+    pcoords: Vector3,
+    values: any,
+    dim: number,
+    derivs: number[]
+  ): void;
+
+  /**
+   * Evaluates whether the specified point is inside (1), outside (0), or
+   * indeterminate (-1) for the cell; computes parametric coordinates, sub-cell
+   * ID (if applicable), squared distance to the cell (and closest point if
+   * requested), and interpolation weights for the cell.
    *
    * @param {Vector3} x The x point coordinate.
    * @param {Vector3} closestPoint The closest point coordinate.
@@ -79,7 +100,8 @@ export interface vtkTriangle extends vtkCell {
   ): IIntersectWithLine;
 
   /**
-   * Determine global coordinate (x]) from subId and parametric coordinates.
+   * Determine global coordinates (x) from the given subId and parametric
+   * coordinates.
    * @param {Vector3} pcoords The parametric coordinates.
    * @param {Vector3} x The x point coordinate.
    * @param {Number[]} weights The number of weights.
@@ -144,6 +166,31 @@ export function computeNormal(
   n: Vector3
 ): void;
 
+/**
+ * Compute the interpolation functions/derivatives
+ * @param {Number[]} derivs - The derivatives.
+ */
+export function interpolationDerivs(derivs: number[]): void;
+
+/**
+ * Compute the intersection between two triangles.
+ * @param {Vector3} p1 The first point coordinate of the first triangle.
+ * @param {Vector3} q1 The second point coordinate of the first triangle.
+ * @param {Vector3} r1 The third point coordinate of the first triangle.
+ * @param {Vector3} p2 The first point coordinate of the second triangle.
+ * @param {Vector3} q2 The second point coordinate of the second triangle.
+ * @param {Vector3} r2 The third point coordinate of the second triangle.
+ */
+export function intersectWithTriangle(
+  p1: Vector3,
+  q1: Vector3,
+  r1: Vector3,
+  p2: Vector3,
+  q2: Vector3,
+  r2: Vector3,
+  tolerance?: number
+): IIntersectWithTriangle;
+
 /**
  * vtkTriangle is a cell which representant a triangle. It contains static
  * method to make some computations directly link to triangle.
@@ -155,5 +202,7 @@ export declare const vtkTriangle: {
   extend: typeof extend;
   computeNormalDirection: typeof computeNormalDirection;
   computeNormal: typeof computeNormal;
+  interpolationDerivs: typeof interpolationDerivs;
+  intersectWithTriangle: typeof intersectWithTriangle;
 };
 export default vtkTriangle;

package/Common/DataModel/Triangle.js

@@ -1,6 +1,6 @@
-import { m as macro } from '../../macros2.js';
+import { m as macro, T as TYPED_ARRAYS } from '../../macros2.js';
 import vtkCell from './Cell.js';
-import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, e as distance2BetweenPoints, o as determinant2x2 } from '../Core/Math/index.js';
+import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, e as distance2BetweenPoints, o as determinant2x2, s as subtract, p as invertMatrix } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 
@@ -29,6 +29,18 @@ function computeNormal(v1, v2, v3, n) {
     n[2] /= length;
   }
 }
+function interpolationDerivs(derivs) {
+  // Order: [dN1/dr, dN2/dr, dN3/dr, dN1/ds, dN2/ds, dN3/ds]
+  // r-derivatives
+  derivs[0] = -1.0;
+  derivs[1] = 1.0;
+  derivs[2] = 0.0;
+
+  // s-derivatives
+  derivs[3] = -1.0;
+  derivs[4] = 0.0;
+  derivs[5] = 1.0;
+}
 function intersectWithTriangle(p1, q1, r1, p2, q2, r2) {
   let tolerance = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 1e-6;
   let coplanar = false;
@@ -242,6 +254,7 @@ function intersectWithTriangle(p1, q1, r1, p2, q2, r2) {
 const STATIC = {
   computeNormalDirection,
   computeNormal,
+  interpolationDerivs,
   intersectWithTriangle
 };
 
@@ -343,6 +356,18 @@ function vtkTriangle(publicAPI, model) {
     outObj.intersect = 0;
     return outObj;
   };
+
+  /**
+   * Evaluates whether the specified point is inside (1), outside (0), or
+   * indeterminate (-1) for the cell; computes parametric coordinates, sub-cell
+   * ID (if applicable), squared distance to the cell (and closest point if
+   * requested), and interpolation weights for the cell.
+   *
+   * @param {Vector3} x The x point coordinate.
+   * @param {Vector3} closestPoint The closest point coordinate.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Number[]} weights The number of weights.
+   */
   publicAPI.evaluatePosition = (x, closestPoint, pcoords, weights) => {
     // will return obj
     const outObj = {
@@ -505,6 +530,14 @@ function vtkTriangle(publicAPI, model) {
     }
     return outObj;
   };
+
+  /**
+   * Determine global coordinates (x) from the given subId and parametric
+   * coordinates.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector3} x The x point coordinate.
+   * @param {Number[]} weights The number of weights.
+   */
   publicAPI.evaluateLocation = (pcoords, x, weights) => {
     const p0 = [];
     const p1 = [];
@@ -520,6 +553,11 @@ function vtkTriangle(publicAPI, model) {
     weights[1] = pcoords[0];
     weights[2] = pcoords[1];
   };
+
+  /**
+   * Get the distance of the parametric coordinate provided to the cell.
+   * @param {Vector3} pcoords The parametric coordinates.
+   */
   publicAPI.getParametricDistance = pcoords => {
     let pDist;
     let pDistMax = 0.0;
@@ -542,6 +580,102 @@ function vtkTriangle(publicAPI, model) {
     }
     return pDistMax;
   };
+
+  /**
+   * Get the derivatives of the triangle strip.
+   * @param {Number} subId - The sub-id of the triangle.
+   * @param {Vector3} pcoords - The parametric coordinates.
+   * @param {Number[]} values - The values at the points.
+   * @param {Number} dim - The dimension.
+   * @param {Number[]} derivs - The derivatives.
+   */
+  publicAPI.derivatives = (subId, pcoords, values, dim, derivs) => {
+    const x0 = model.points.getPoint(0);
+    const x1 = model.points.getPoint(1);
+    const x2 = model.points.getPoint(2);
+    const n = [];
+    const v10 = [];
+    const v20 = [];
+    const v = [];
+    computeNormal(x0, x1, x2, n);
+    subtract(x1, x0, v10);
+    subtract(x2, x0, v);
+    cross(n, v10, v20);
+    const lenX = normalize(v10); // check for degenerate triangle
+
+    if (lenX <= 0.0 || normalize(v20) <= 0.0) {
+      // degenerate
+      for (let j = 0; j < dim; j++) {
+        for (let i = 0; i < 3; i++) {
+          derivs[j * dim + i] = 0.0;
+        }
+      }
+      return;
+    }
+
+    // 2D coordinates
+    const v0 = [0, 0];
+    const v1 = [lenX, 0];
+    const v2 = [dot(v, v10), dot(v, v20)];
+    const functionDerivs = new Array(6);
+    interpolationDerivs(functionDerivs);
+
+    // Compute Jacobian: Jacobian is constant for a triangle.
+    const J = [v1[0] - v0[0], v1[1] - v0[1], v2[0] - v0[0], v2[1] - v0[1]];
+
+    // Compute inverse Jacobian (expects flat array)
+    const JI = macro.newTypedArray(TYPED_ARRAYS.Float64Array, 4);
+    invertMatrix(J, JI, 2); // returns flat array [JI00, JI01, JI10, JI11]
+
+    // Compute derivatives
+    for (let j = 0; j < dim; j++) {
+      let sum0 = 0.0;
+      let sum1 = 0.0;
+      for (let i = 0; i < 3; i++) {
+        sum0 += functionDerivs[i] * values[dim * i + j];
+        sum1 += functionDerivs[3 + i] * values[dim * i + j];
+      }
+      const dBydx = sum0 * JI[0] + sum1 * JI[1];
+      const dBydy = sum0 * JI[2] + sum1 * JI[3];
+
+      // Transform into global system (dot product with global axes)
+      derivs[3 * j] = dBydx * v10[0] + dBydy * v20[0];
+      derivs[3 * j + 1] = dBydx * v10[1] + dBydy * v20[1];
+      derivs[3 * j + 2] = dBydx * v10[2] + dBydy * v20[2];
+    }
+  };
+
+  /**
+   * Get the nearest cell boundary to the specified parametric
+   * coordinates and whether the point is inside or outside the cell.
+   * @param {Number} subId The sub-id of the cell.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector2} pts The points of the cell.
+   */
+  publicAPI.cellBoundary = (subId, pcoords, pts) => {
+    const t1 = pcoords[0] - pcoords[1];
+    const t2 = 0.5 * (1.0 - pcoords[0]) - pcoords[1];
+    const t3 = 2.0 * pcoords[0] + pcoords[1] - 1.0;
+
+    // compare against three lines in parametric space that divide element
+    // into three pieces
+    if (t1 >= 0.0 && t2 >= 0.0) {
+      pts[0] = model.pointsIds[0];
+      pts[1] = model.pointsIds[1];
+    } else if (t2 < 0.0 && t3 >= 0.0) {
+      pts[0] = model.pointsIds[1];
+      pts[1] = model.pointsIds[2];
+    } // ( t1 < 0.0 && t3 < 0.0 )
+    else {
+      pts[0] = model.pointsIds[2];
+      pts[1] = model.pointsIds[0];
+    }
+    if (pcoords[0] < 0.0 || pcoords[1] < 0.0 || pcoords[0] > 1.0 || pcoords[1] > 1.0 || 1.0 - pcoords[0] - pcoords[1] < 0.0) {
+      return false; // outside of triangle
+    }
+
+    return true; // inside triangle
+  };
 }
 
 // ----------------------------------------------------------------------------