@kitware/vtk.js 25.4.0 → 25.7.0

package/Common/DataModel/Triangle.d.ts

@@ -3,84 +3,94 @@ import vtkCell, { ICellInitialValues } from './Cell';
 
 export interface ITriangleInitialValues extends ICellInitialValues {}
 
-interface IIntersectWithLine {
-	intersect: number;
-	t: number;
-	subId: number;
-	evaluation?: number;
-	betweenPoints?: boolean;
+export interface IIntersectWithLine {
+  intersect: number;
+  t: number;
+  subId: number;
+  evaluation?: number;
+  betweenPoints?: boolean;
 }
 
 export interface vtkTriangle extends vtkCell {
+  /**
+   * Get the topological dimensional of the cell (0, 1, 2 or 3).
+   */
+  getCellDimension(): number;
 
-	/**
-	 * Get the topological dimensional of the cell (0, 1, 2 or 3).
-	 */
-	getCellDimension(): number;
+  /**
+   * Compute the intersection point of the intersection between triangle and
+   * line defined by p1 and p2. tol Tolerance use for the position evaluation
+   * x is the point which intersect triangle (computed in function) pcoords
+   * parametric coordinates (computed in function) A javascript object is
+   * returned :
+   *
+   * ```js
+   * {
+   *    evaluation: define if the triangle has been intersected or not
+   *    subId: always set to 0
+   *    t: parametric coordinate along the line.
+   *    betweenPoints: Define if the intersection is between input points
+   * }
+   * ```
+   *
+   * @param {Vector3} p1 The first point coordinate.
+   * @param {Vector3} p2 The second point coordinate.
+   * @param {Number} tol The tolerance to use.
+   * @param {Vector3} x The point which intersect triangle.
+   * @param {Vector3} pcoords The parametric coordinates.
+   */
+  intersectWithLine(
+    p1: Vector3,
+    p2: Vector3,
+    tol: number,
+    x: Vector3,
+    pcoords: Vector3
+  ): IIntersectWithLine;
 
-	/**
-	 * Compute the intersection point of the intersection between triangle and
-	 * line defined by p1 and p2. tol Tolerance use for the position evaluation
-	 * x is the point which intersect triangle (computed in function) pcoords
-	 * parametric coordinates (computed in function) A javascript object is
-	 * returned :
-	 *
-	 * ```js
-	 * {
-	 *    evaluation: define if the triangle has been intersected or not
-	 *    subId: always set to 0
-	 *    t: parametric coordinate along the line.
-	 *    betweenPoints: Define if the intersection is between input points
-	 * }
-	 * ```
-	 * 
-	 * @param {Vector3} p1 The first point coordinate.
-	 * @param {Vector3} p2 The second point coordinate.
-	 * @param {Number} tol The tolerance to use.
-	 * @param {Vector3} x The point which intersect triangle.
-	 * @param {Vector3} pcoords The parametric coordinates.
-	 */
-	intersectWithLine(p1: Vector3, p2: Vector3, tol: number, x: Vector3, pcoords: Vector3): 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
+   * }
+   * ```
+   *
+   * @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.
+   */
+  evaluatePosition(
+    x: Vector3,
+    closestPoint: Vector3,
+    pcoords: Vector3,
+    weights: number[]
+  ): 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
-	 * }
-	 * ```
-	 * 
-	 * @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.
-	 */
-	evaluatePosition(x: Vector3, closestPoint: Vector3, pcoords: Vector3, weights: number[]): IIntersectWithLine
+  /**
+   * Determine global coordinate (x]) from subId and parametric coordinates.
+   * @param {Vector3} pcoords The parametric coordinates.
+   * @param {Vector3} x The x point coordinate.
+   * @param {Number[]} weights The number of weights.
+   */
+  evaluateLocation(pcoords: Vector3, x: Vector3, weights: number[]): void;
 
-	/**
-	 * Determine global coordinate (x]) from subId and parametric coordinates.
-	 * @param {Vector3} pcoords The parametric coordinates.
-	 * @param {Vector3} x The x point coordinate.
-	 * @param {Number[]} weights The number of weights.
-	 */
-	evaluateLocation(pcoords: Vector3, x: Vector3, weights: number[]): void;
-
-	/**
-	 * Get the distance of the parametric coordinate provided to the cell.
-	 * @param {Vector3} pcoords The parametric coordinates.
-	 */
-	getParametricDistance(pcoords: Vector3): number;
+  /**
+   * Get the distance of the parametric coordinate provided to the cell.
+   * @param {Vector3} pcoords The parametric coordinates.
+   */
+  getParametricDistance(pcoords: Vector3): number;
 }
 
 /**
@@ -90,14 +100,19 @@ export interface vtkTriangle extends vtkCell {
  * @param model object on which data structure will be bounds (protected)
  * @param {ITriangleInitialValues} [initialValues] (default: {})
  */
-export function extend(publicAPI: object, model: object, initialValues?: ITriangleInitialValues): void;
+export function extend(
+  publicAPI: object,
+  model: object,
+  initialValues?: ITriangleInitialValues
+): void;
 
 /**
  * Method used to create a new instance of vtkTriangle.
  * @param {ITriangleInitialValues} [initialValues] for pre-setting some of its content
  */
-export function newInstance(initialValues?: ITriangleInitialValues): vtkTriangle;
-
+export function newInstance(
+  initialValues?: ITriangleInitialValues
+): vtkTriangle;
 
 /**
  * Compute the normal direction according to the three vertex which composed a
@@ -107,7 +122,12 @@ export function newInstance(initialValues?: ITriangleInitialValues): vtkTriangle
  * @param {Vector3} v3 The third point coordinate.
  * @param {Vector3} n The normal coordinate.
  */
-export function computeNormalDirection(v1: Vector3, v2: Vector3, v3: Vector3, n: Vector3): void;
+export function computeNormalDirection(
+  v1: Vector3,
+  v2: Vector3,
+  v3: Vector3,
+  n: Vector3
+): void;
 
 /**
  * Compute the normalized normal of a triangle composed of three points. The
@@ -117,18 +137,23 @@ export function computeNormalDirection(v1: Vector3, v2: Vector3, v3: Vector3, n:
  * @param {Vector3} v3 The third point coordinate.
  * @param {Vector3} n The normal coordinate.
  */
-export function computeNormal(v1: Vector3, v2: Vector3, v3: Vector3, n: Vector3): void;
+export function computeNormal(
+  v1: Vector3,
+  v2: Vector3,
+  v3: Vector3,
+  n: Vector3
+): void;
 
 /**
  * vtkTriangle is a cell which representant a triangle. It contains static
  * method to make some computations directly link to triangle.
- * 
+ *
  * @see vtkCell
  */
 export declare const vtkTriangle: {
-	newInstance: typeof newInstance,
-	extend: typeof extend;
-	computeNormalDirection: typeof computeNormalDirection;
-	computeNormal: typeof computeNormal;
+  newInstance: typeof newInstance;
+  extend: typeof extend;
+  computeNormalDirection: typeof computeNormalDirection;
+  computeNormal: typeof computeNormal;
 };
 export default vtkTriangle;

package/Common/DataModel/Triangle.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkCell from './Cell.js';
-import { d as dot, j as cross, l as normalize, m as multiplyAccumulate, f as distance2BetweenPoints, o as determinant2x2 } from '../Core/Math/index.js';
+import { d as dot, k as cross, m as normalize, o as multiplyAccumulate, f as distance2BetweenPoints, p as determinant2x2 } from '../Core/Math/index.js';
 import vtkLine from './Line.js';
 import vtkPlane from './Plane.js';
 

package/Common/Transform/LandmarkTransform.js

@@ -2,7 +2,7 @@ import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { mat4, mat3 } from 'gl-matrix';
 import Constants from './LandmarkTransform/Constants.js';
 import macro from '../../macros.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';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 

package/Filters/Core/PolyDataNormals.js

@@ -1,7 +1,7 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import macro from '../../macros.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { t as vtkMath } from '../../Common/Core/Math/index.js';
+import { g as vtkMath } from '../../Common/Core/Math/index.js';
 import vtkPolyData from '../../Common/DataModel/PolyData.js';
 import vtkTriangle from '../../Common/DataModel/Triangle.js';
 

package/Filters/General/ClipClosedSurface/Constants.js

@@ -0,0 +1,10 @@
+var ScalarMode = {
+  NONE: 0,
+  COLORS: 1,
+  LABELS: 2
+};
+var Constants = {
+  ScalarMode: ScalarMode
+};
+
+export { ScalarMode, Constants as default };

package/Filters/General/ClipClosedSurface/ccsEdgeLocator.js

@@ -0,0 +1,40 @@
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+
+var CCSEdgeLocator = /*#__PURE__*/function () {
+  function CCSEdgeLocator() {
+    _classCallCheck(this, CCSEdgeLocator);
+
+    this._edgeMap = new Map();
+  }
+
+  _createClass(CCSEdgeLocator, [{
+    key: "initialize",
+    value: function initialize() {
+      this._edgeMap.clear();
+    }
+  }, {
+    key: "insertUniqueEdge",
+    value: function insertUniqueEdge(i0, i1) {
+      // Generate key, which is unique, since we order the edges
+      var key = i1 < i0 ? "".concat(i1, "-").concat(i0) : "".concat(i0, "-").concat(i1);
+
+      var node = this._edgeMap.get(key);
+
+      if (!node) {
+        // Didn't find key, so add a new edge entry
+        node = {
+          edgeId: -1
+        };
+
+        this._edgeMap.set(key, node);
+      }
+
+      return node;
+    }
+  }]);
+
+  return CCSEdgeLocator;
+}();
+
+export { CCSEdgeLocator as default };

package/Filters/General/ClipClosedSurface.d.ts

@@ -0,0 +1,95 @@
+import { vtkAlgorithm, vtkObject } from './../../interfaces';
+import { Vector3 } from './../../types';
+import vtkPlane from './../../Common/DataModel/Plane';
+
+/**
+ *
+ */
+export enum ScalarMode {
+	NONE,
+	COLORS,
+	LABELS,
+}
+
+/**
+ *
+ */
+export interface IClipClosedSurfaceInitialValues {
+	clippingPlanes?: vtkPlane[];
+	tolerance?: number;
+	passPointData?: boolean;
+	triangulatePolys?: boolean;
+	scalarMode?: ScalarMode;
+	generateOutline?: boolean;
+	generateFaces?: boolean;
+	activePlaneId?: number;
+	baseColor?: Vector3;
+	clipColor?: Vector3;
+	activePlaneColor?: Vector3;
+	triangulationErrorDisplay?: boolean;
+}
+
+type vtkClipClosedSurfaceBase = vtkObject & vtkAlgorithm;
+
+export interface vtkClipClosedSurface extends vtkClipClosedSurfaceBase {
+	/**
+	 *
+	 * @param {any} inData
+	 * @param {any} outData
+	 */
+	requestData(inData: any, outData: any): void;
+
+	/**
+	 * Set scalarMode to NONE.
+	 */
+	setScalarModeToNone(): void;
+
+	/**
+	 * Set scalarMode to COLOR.
+	 */
+	setScalarModeToColor(): void;
+
+	/**
+	 * Set scalarMode to LABEL.
+	 */
+	setScalarModeToLabel(): void;
+}
+
+// ----------------------------------------------------------------------------
+// Static API
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkClipClosedSurface characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {object} [initialValues] (default: {})
+ */
+export function extend(
+	publicAPI: object,
+	model: object,
+	initialValues?: IClipClosedSurfaceInitialValues
+): void;
+
+// ----------------------------------------------------------------------------
+
+/**
+ * Method use to create a new instance of vtkClipClosedSurface
+ * @param {IClipClosedSurfaceInitialValues} [initialValues] for pre-setting some of its content
+ */
+export function newInstance(
+	initialValues?: IClipClosedSurfaceInitialValues
+): vtkClipClosedSurface;
+
+/**
+ * vtkClipClosedSurface
+ */
+export declare const vtkClipClosedSurface: {
+	newInstance: typeof newInstance;
+	extend: typeof extend;
+	// constants
+	ScalarMode: typeof ScalarMode;
+};
+
+export default vtkClipClosedSurface;