@kitware/vtk.js 34.5.0 → 34.6.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

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

package/Common/DataModel/TriangleStrip.d.ts

@@ -0,0 +1,180 @@
+import { CellType, Vector3 } from './../../types';
+import vtkCellArray from './../Core/CellArray';
+import vtkPoints from './../Core/Points';
+import vtkCell, { ICellInitialValues } from './Cell';
+import vtkLine from './Line';
+import vtkTriangle from './Triangle';
+
+export interface ITriangleStripInitialValues extends ICellInitialValues {
+  line?: vtkLine;
+  triangle?: vtkTriangle;
+}
+
+export interface vtkTriangleStrip extends vtkCell {
+  /**
+   * Get the cell boundary of the triangle strip.
+   * @param {Number} subId The sub-id of the cell.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector3[]} pts The points of the cell.
+   */
+  cellBoundary(subId: number, pcoords: Vector3, pts: Vector3[]): boolean;
+
+  /**
+   * 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.
+   */
+  derivatives(
+    subId: number,
+    pcoords: Vector3,
+    values: number[],
+    dim: number,
+    derivs: number[]
+  ): void;
+
+  /**
+   * Evaluate the location of a point in the triangle strip.
+   * @param {Vector3} pcoords The parametric coordinates of the point.
+   * @param {Vector3} closestPoint The closest point on the triangle strip.
+   * @param {Number[]} weights The interpolation weights.
+   */
+  evaluateLocation(
+    pcoords: Vector3,
+    closestPoint: Vector3,
+    weights: number[]
+  ): number;
+
+  /**
+   * Evaluate the position of a point in the triangle strip.
+   * @param {Vector3} x The point to evaluate.
+   * @param {Vector3} closestPoint The closest point on the triangle strip.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Number[]} dist2 The squared distance from the point to the triangle strip.
+   * @param {Number[]} weights The interpolation weights.
+   */
+  evaluatePosition(
+    x: Vector3,
+    closestPoint: Vector3,
+    pcoords: Vector3,
+    dist2: number[],
+    weights: number[]
+  ): number;
+
+  /**
+   * Get the cell type.
+   */
+  getCellType(): CellType;
+
+  /**
+   * Get the topological dimensional of the cell (0, 1, 2 or 3).
+   */
+  getCellDimension(): number;
+
+  /**
+   * Get the edge of the triangle strip.
+   * @param {Number} edgeId The edge ID to retrieve.
+   * @returns {vtkLine} The edge corresponding to the edge ID.
+   */
+  getEdge(edgeId: number): vtkLine;
+
+  /**
+   * Get the number of edges in the triangle strip.
+   */
+  getNumberOfEdges(): number;
+
+  /**
+   * Get the number of faces in the triangle strip.
+   */
+  getNumberOfFaces(): number;
+
+  /**
+   * Get the parametric center of the triangle strip.
+   * @param {Vector3} pcoords - The parametric coordinates.
+   * @returns {Number} The parametric center.
+   */
+  getParametricCenter(pcoords: Vector3): number;
+
+  /**
+   * Get the point array of the triangle strip.
+   * @returns {Number[]} The point array.
+   */
+  getPointArray(): number[];
+
+  /**
+   * Initialize the triangle strip with points and point IDs.
+   * @param {vtkPoints} points The points of the triangle strip.
+   * @param {Number[]} pointsIds The point IDs of the triangle strip.
+   */
+  initialize(points: vtkPoints, pointsIds: number[]): void;
+
+  /**
+   * Intersects a line with the triangle strip.
+   * @param {Vector3} p1 Start point of the line
+   * @param {Vector3} p2 End point of the line
+   * @param {Number} tol Tolerance for intersection
+   * @param {Vector3} x Intersection point
+   * @param {Vector3} pcoords Parametric coordinates of the intersection
+   * @returns {Boolean} True if the line intersects the triangle strip
+   */
+  intersectWithLine(
+    p1: Vector3,
+    p2: Vector3,
+    tol: number,
+    x: Vector3,
+    pcoords: Vector3
+  ): boolean;
+
+  /**
+   * Triangulate the triangle strip.
+   * @returns {Boolean} True if the triangulation is successful.
+   */
+  triangulate(): boolean;
+}
+
+/**
+ * Method used to decorate a given object (publicAPI+model) with vtkTriangle characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {ITriangleStripInitialValues} [initialValues] (default: {})
+ */
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITriangleStripInitialValues
+): void;
+
+/**
+ * Method used to create a new instance of vtkTriangle.
+ * @param {ITriangleStripInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+  initialValues?: ITriangleStripInitialValues
+): vtkTriangleStrip;
+
+/**
+ * Decomposes a triangle strip into individual triangles.
+ * @param {vtkPoints} pts Points of the triangle strip
+ * @param {vtkCellArray} polys Cell array to store the resulting triangles
+ */
+export function decomposeStrip(pts: vtkPoints, polys: vtkCellArray): void;
+
+/**
+ * vtkTriangleStrip is a concrete implementation of vtkCell to represent a 2D
+ * triangle strip. A triangle strip is a compact representation of triangles
+ * connected edge to edge in strip fashion. The connectivity of a triangle strip
+ * is three points defining an initial triangle, then for each additional
+ * triangle, a single point that, combined with the previous two points, defines
+ * the next triangle.
+ *
+ * @see vtkCell
+ */
+export declare const vtkTriangleStrip: {
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  decomposeStrip: typeof decomposeStrip;
+};
+export default vtkTriangleStrip;