@kitware/vtk.js 34.5.0 → 34.7.0

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;

package/Common/DataModel/TriangleStrip.js

@@ -0,0 +1,396 @@
+import { m as macro } from '../../macros2.js';
+import vtkCell from './Cell.js';
+import vtkLine from './Line.js';
+import vtkTriangle from './Triangle.js';
+import { CellType } from './CellTypes/Constants.js';
+
+const {
+  vtkErrorMacro
+} = macro;
+
+// ----------------------------------------------------------------------------
+// Global methods
+// ----------------------------------------------------------------------------
+
+function notImplemented(method) {
+  return () => vtkErrorMacro(`vtkTriangleStrip.${method} - NOT IMPLEMENTED`);
+}
+
+/**
+ * Decomposes a triangle strip into individual triangles.
+ * @param {*} pts Points of the triangle strip
+ * @param {*} polys Cell array to store the resulting triangles
+ */
+function decomposeStrip(pts, polys) {
+  if (!Array.isArray(pts) || pts.length < 3) {
+    vtkErrorMacro('decomposeStrip - Invalid points array');
+    return;
+  }
+  let p1 = pts[0];
+  let p2 = pts[1];
+  for (let i = 0; i < pts.length - 2; i++) {
+    const p3 = pts[i + 2];
+    if (i % 2) {
+      // Flip ordering to preserve consistency
+      polys.insertNextCell([p2, p1, p3]);
+    } else {
+      polys.insertNextCell([p1, p2, p3]);
+    }
+    p1 = p2;
+    p2 = p3;
+  }
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+const STATIC = {
+  decomposeStrip
+};
+
+// ----------------------------------------------------------------------------
+// vtkTriangleStrip methods
+// ----------------------------------------------------------------------------
+
+function vtkTriangleStrip(publicAPI, model) {
+  // Set our className
+  model.classHierarchy.push('vtkTriangleStrip');
+  const superInitialize = publicAPI.initialize;
+  publicAPI.initialize = (points, pointsIds) => {
+    model.triangle.initialize(points, pointsIds);
+    superInitialize(points, pointsIds);
+  };
+
+  /**
+   * Get the cell type.
+   * @returns {number} Cell type
+   */
+  publicAPI.getCellType = () => CellType.VTK_TRIANGLE_STRIP;
+
+  /**
+   * Get the cell dimension.
+   * The dimension of a triangle strip is always 2.
+   * @returns {number} Cell dimension
+   */
+  publicAPI.getCellDimension = () => 2;
+
+  /**
+   * Get the number of edges.
+   * @returns {number} Number of edges
+   */
+  publicAPI.getNumberOfEdges = () => model.pointsIds.length;
+
+  /**
+   * Get the number of faces.
+   * @returns {number} Number of faces
+   */
+  publicAPI.getNumberOfFaces = () => 0;
+
+  /**
+   * Evaluate the position within the triangle strip.
+   * @param {*} x Intersection point
+   * @param {*} closestPoint Closest point on the triangle
+   * @param {*} pcoords Parametric coordinates
+   * @param {*} dist2 Squared distance to the closest point
+   * @param {*} weights Weights for interpolation
+   * @returns {number} Evaluation status
+   */
+  publicAPI.evaluatePosition = (x, closestPoint, pcoords, dist2, weights) => {
+    const pc = [0, 0, 0];
+    let minDist2 = Number.MAX_VALUE;
+    let returnStatus = 0;
+    const tempWeights = [];
+    const activeWeights = [];
+    const closest = [];
+    pcoords[2] = 0.0;
+    activeWeights[0] = 0.0;
+    activeWeights[1] = 0.0;
+    activeWeights[2] = 0.0;
+    const points = model.triangle.getPoints();
+    points.setNumberOfPoints(3);
+    const pointsIds = model.triangle.getPointsIds();
+    const numPoints = pointsIds.length;
+
+    // Initialize weights
+    for (let i = 0; i < numPoints; i++) {
+      weights[i] = 0.0;
+    }
+
+    // Iterate through triangles in the strip
+    for (let i = 0; i < numPoints - 2; i++) {
+      // Set triangle points
+      const pt0 = [];
+      points.getPoint(i, pt0);
+      const pt1 = [];
+      points.getPoint(i + 1, pt1);
+      const pt2 = [];
+      points.getPoint(i + 2, pt2);
+      points.setData(Float32Array.from([...pt0, ...pt1, ...pt2]), 3);
+
+      // Use dist2 from triangle's evaluatePosition return value
+      const status = model.triangle.evaluatePosition(x, closest, pc, tempWeights);
+      const currentDist2 = status.dist2;
+      if (status.evaluation >= 0 && (currentDist2 < minDist2 || currentDist2 === minDist2 && returnStatus === 0)) {
+        returnStatus = status;
+        if (closestPoint) {
+          closestPoint[0] = closest[0];
+          closestPoint[1] = closest[1];
+          closestPoint[2] = closest[2];
+        }
+        pcoords[0] = pc[0];
+        pcoords[1] = pc[1];
+        minDist2 = currentDist2;
+        activeWeights[0] = tempWeights[0];
+        activeWeights[1] = tempWeights[1];
+        activeWeights[2] = tempWeights[2];
+      }
+    }
+    dist2[0] = minDist2;
+    weights[0] = activeWeights[0];
+    weights[1] = activeWeights[1];
+    weights[2] = activeWeights[2];
+    return returnStatus;
+  };
+
+  /**
+   * Evaluate the location within the triangle strip.
+   * @param {*} subId Sub-Id of the triangle
+   * @param {*} pcoords Parametric coordinates
+   * @param {*} x Intersection point
+   * @param {*} weights Weights for interpolation
+   */
+  publicAPI.evaluateLocation = (subId, pcoords, x, weights) => {
+    const idx = [[0, 1, 2], [1, 0, 2]];
+    const order = subId % 2;
+    const numPoints = model.pointsIds.length;
+
+    // Initialize weights
+    for (let i = 0; i < numPoints; i++) {
+      weights[i] = 0.0;
+    }
+    const u3 = 1.0 - pcoords[0] - pcoords[1];
+    weights[subId] = u3;
+    weights[subId + 1] = pcoords[0];
+    weights[subId + 2] = pcoords[1];
+
+    // Get points
+    const pt1 = [];
+    model.points.getPoint(subId + idx[order][0], pt1);
+    const pt2 = [];
+    model.points.getPoint(subId + idx[order][1], pt2);
+    const pt3 = [];
+    model.points.getPoint(subId + idx[order][2], pt3);
+
+    // Interpolate position
+    for (let i = 0; i < 3; i++) {
+      x[i] = pt1[i] * weights[subId] + pt2[i] * weights[subId + 1] + pt3[i] * weights[subId + 2];
+    }
+  };
+
+  /**
+   * Get the cell boundary of the triangle strip.
+   * @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 idx = [[0, 1, 2], [1, 0, 2]];
+    const order = subId % 2;
+    const pointsIds = model.triangle.getPointsIds();
+    pointsIds[0] = model.pointsIds[idx[order][0]];
+    pointsIds[1] = model.pointsIds[idx[order][1]];
+    pointsIds[2] = model.pointsIds[idx[order][2]];
+    return model.triangle.cellBoundary(0, pcoords, pts);
+  };
+
+  /**
+   * Get the edge of the triangle strip.
+   * @param {Number} edgeId Edge index (0 to n-1)
+   * @returns {vtkLine} The edge as a vtkLine instance
+   */
+  publicAPI.getEdge = edgeId => {
+    let id1;
+    let id2;
+    const numPoints = model.pointsIds.length;
+    if (edgeId === 0) {
+      id1 = 0;
+      id2 = 1;
+    } else if (edgeId === numPoints - 1) {
+      id1 = edgeId - 1;
+      id2 = edgeId;
+    } else {
+      id1 = edgeId - 1;
+      id2 = edgeId + 1;
+    }
+    model.line.getPointsIds()[0] = model.pointsIds[id1];
+    model.line.getPointsIds()[1] = model.pointsIds[id2];
+    model.line.getPoints().setPoint(0, model.points.getPoint(id1));
+    model.line.getPoints().setPoint(1, model.points.getPoint(id2));
+    return model.line;
+  };
+
+  /**
+   * 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
+   */
+  publicAPI.intersectWithLine = (p1, p2, tol, x, pcoords) => {
+    const numTris = model.pointsIds.length - 2;
+    const points = model.triangle.getPoints();
+    points.setNumberOfPoints(3);
+    for (let i = 0; i < numTris; i++) {
+      const pt0 = [];
+      model.points.getPoint(model.pointsIds[i], pt0);
+      const pt1 = [];
+      model.points.getPoint(model.pointsIds[i + 1], pt1);
+      const pt2 = [];
+      model.points.getPoint(model.pointsIds[i + 2], pt2);
+      points.setData(Float32Array.from([...pt0, ...pt1, ...pt2]), 3);
+      const ret = model.triangle.intersectWithLine(p1, p2, tol, x, pcoords);
+      if (ret.intersect) {
+        return ret;
+      }
+    }
+    return false;
+  };
+
+  // Triangulate
+  /**
+   * Triangulate the triangle strip.
+   * @returns {Boolean} True if the triangulation is successful.
+   */
+  publicAPI.triangulate = () => {
+    const numTris = model.points.getNumberOfPoints() - 2;
+    model.tris = new Array(3 * numTris);
+    const idx = [[0, 1, 2], [1, 0, 2]];
+    for (let subId = 0; subId < numTris; subId++) {
+      const order = subId % 2;
+      for (let i = 0; i < 3; i++) {
+        model.tris[subId * 3 + i] = subId + idx[order][i];
+      }
+    }
+    return true;
+  };
+
+  /**
+   * Get the point array of the triangle strip.
+   * @returns {Array} The point array.
+   */
+  publicAPI.getPointArray = () => model.tris;
+
+  // Derivatives
+  /**
+   * 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 pt0 = [];
+    model.points.getPoint(subId, pt0);
+    const pt1 = [];
+    model.points.getPoint(subId + 1, pt1);
+    const pt2 = [];
+    model.points.getPoint(subId + 2, pt2);
+    const points = model.triangle.getPoints();
+    points.setPoint(0, ...pt0);
+    points.setPoint(1, ...pt1);
+    points.setPoint(2, ...pt2);
+    model.triangle.derivatives(0, pcoords, values, dim, derivs);
+  };
+
+  /**
+   * Get the parametric center of the triangle strip.
+   * @param {Vector3} pcoords - The parametric coordinates.
+   * @returns {Number} The parametric center.
+   */
+  publicAPI.getParametricCenter = pcoords => {
+    pcoords[0] = 0.333333;
+    pcoords[1] = 0.333333;
+    pcoords[2] = 0.0;
+    return Math.floor((model.pointsIds.length - 2) / 2);
+  };
+
+  /**
+   * Contour the triangle strip.
+   * @param {*} value
+   * @param {*} cellScalars
+   * @param {*} locator
+   * @param {*} verts
+   * @param {*} lines
+   * @param {*} polys
+   * @param {*} inPd
+   * @param {*} outPd
+   * @param {*} inCd
+   * @param {*} cellId
+   * @param {*} outCd
+   * @returns
+   */
+  publicAPI.contour = (value, cellScalars, locator, verts, lines, polys, inPd, outPd, inCd, cellId, outCd) => notImplemented('contour')();
+
+  /**
+   * Clip the triangle strip.
+   * @param {*} value Clipping value
+   * @param {*} cellScalars Cell scalars
+   * @param {*} locator Locator
+   * @param {*} tris Triangle indices
+   * @param {*} inPd Input point data
+   * @param {*} outPd Output point data
+   * @param {*} inCd
+   * @param {*} cellId
+   * @param {*} outCd
+   * @param {*} insideOut
+   * @returns
+   */
+  publicAPI.clip = (value, cellScalars, locator, tris, inPd, outPd, inCd, cellId, outCd, insideOut) => notImplemented('clip')();
+}
+
+// ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+const DEFAULT_VALUES = {
+  line: null,
+  triangle: null,
+  tris: null
+};
+
+// ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues);
+
+  // Inheritance
+  vtkCell.extend(publicAPI, model, initialValues);
+  if (!model.line) {
+    model.line = vtkLine.newInstance();
+  }
+  if (!model.triangle) {
+    model.triangle = vtkTriangle.newInstance();
+  }
+
+  // Build VTK API
+  vtkTriangleStrip(publicAPI, model);
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkTriangleStrip');
+
+// ----------------------------------------------------------------------------
+
+var vtkTriangleStrip$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
+
+export { STATIC, vtkTriangleStrip$1 as default, extend, newInstance };

package/Common/DataModel.js

@@ -18,6 +18,7 @@ import vtkSelectionNode from './DataModel/SelectionNode.js';
 import vtkSphere from './DataModel/Sphere.js';
 import vtkStructuredData from './DataModel/StructuredData.js';
 import vtkTriangle from './DataModel/Triangle.js';
+import vtkTriangleStrip from './DataModel/TriangleStrip.js';
 
 var DataModel = {
   vtkBoundingBox,
@@ -39,7 +40,8 @@ var DataModel = {
   vtkSelectionNode,
   vtkSphere,
   vtkStructuredData,
-  vtkTriangle
+  vtkTriangle,
+  vtkTriangleStrip
 };
 
 export { DataModel as default };

package/Common/Transform/LandmarkTransform.js

@@ -1,7 +1,7 @@
 import { mat4, mat3 } from 'gl-matrix';
 import Constants from './LandmarkTransform/Constants.js';
 import { m as macro } from '../../macros2.js';
-import { p as jacobiN, q as perpendiculars } from '../Core/Math/index.js';
+import { q as jacobiN, t as perpendiculars } from '../Core/Math/index.js';
 
 const {
   Mode