feat(TriangleStrip): add vtkTriangleStrip

Author: daker

Sources/Common/Core/CellArray/index.js

@@ -2,6 +2,7 @@ import macro from 'vtk.js/Sources/macros';
 import vtkDataArray from 'vtk.js/Sources/Common/Core/DataArray';
 import { VtkDataTypes } from 'vtk.js/Sources/Common/Core/DataArray/Constants';
 
+const { isVtkObject } = macro;
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
@@ -100,7 +101,13 @@ function vtkCellArray(publicAPI, model) {
     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

Sources/Common/DataModel/Triangle/index.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;

Sources/Common/DataModel/Triangle/index.js

@@ -32,6 +32,19 @@ function computeNormal(v1, v2, v3, n) {
   }
 }
 
+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, tolerance = 1e-6) {
   let coplanar = false;
   const pt1 = [];
@@ -228,6 +241,7 @@ function intersectWithTriangle(p1, q1, r1, p2, q2, r2, tolerance = 1e-6) {
 export const STATIC = {
   computeNormalDirection,
   computeNormal,
+  interpolationDerivs,
   intersectWithTriangle,
 };
 
@@ -240,6 +254,7 @@ function vtkTriangle(publicAPI, model) {
   model.classHierarchy.push('vtkTriangle');
 
   publicAPI.getCellDimension = () => 2;
+
   publicAPI.intersectWithLine = (p1, p2, tol, x, pcoords) => {
     const outObj = {
       subId: 0,
@@ -338,6 +353,17 @@ function vtkTriangle(publicAPI, model) {
     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 = { subId: 0, dist2: 0, evaluation: -1 };
@@ -526,6 +552,13 @@ 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 = [];
@@ -544,6 +577,10 @@ function vtkTriangle(publicAPI, model) {
     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;
@@ -567,6 +604,119 @@ 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];
+    }
+
+    vtkMath.cross(n, v10, v20);
+
+    const lenX = vtkMath.normalize(v10); // check for degenerate triangle
+
+    if (lenX <= 0.0 || vtkMath.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 = [vtkMath.dot(v, v10), vtkMath.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);
+    vtkMath.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
+  };
 }
 
 // ----------------------------------------------------------------------------