feat(polygon, testPolygon): add functions to polygon

Translation from cpp implementation and add test to those functions
Create functions as static functions and in publicAPI
Updated ts definition

Author: joannacirillo

Sources/Common/DataModel/Cell/index.js

@@ -104,8 +104,12 @@ function vtkCell(publicAPI, model) {
     cell.initialize(model.points, model.pointsIds);
   };
 
-  publicAPI.getCellDimension = () => {}; // virtual
-  publicAPI.intersectWithLine = (p1, p2, tol, t, x, pcoords, subId) => {}; // virtual
+  publicAPI.getCellDimension = () => {
+    macro.vtkErrorMacro('vtkCell.getCellDimension is not implemented.');
+  }; // virtual
+  publicAPI.intersectWithLine = (p1, p2, tol, t, x, pcoords, subId) => {
+    macro.vtkErrorMacro('vtkCell.intersectWithLine is not implemented.');
+  }; // virtual
   publicAPI.evaluatePosition = (
     x,
     closestPoint,

Sources/Common/DataModel/Polygon/Constants.js

@@ -9,3 +9,12 @@ export const PolygonWithPointIntersectionState = {
   INTERSECTION: 2,
   ON_LINE: 3,
 };
+export const VTK_DBL_EPSILON = 2.2204460492503131e-16;
+
+export const INTERSECTION = {
+  NO_INTERSECTION,
+  POINT_INTERSECTION,
+  LINE_INTERSECTION,
+}
+
+export default { INTERSECTION, PolygonWithPointIntersectionState };

Sources/Common/DataModel/Polygon/index.d.ts

@@ -2,9 +2,9 @@ import { vtkObject } from "../../../interfaces";
 import { Bounds, Vector3 } from "../../../types";
 
 export interface IPolygonInitialValues {
-	firstPoint?: Vector3,
-	pointCount?: number,
-	tris?: Vector3[],
+  firstPoint?: Vector3,
+  pointCount?: number,
+  tris?: Vector3[],
 }
 
 /**
@@ -18,26 +18,46 @@ export enum POINT_IN_POLYGON {
 	ON_LINE,
 }
 
+export enum INTERSECTION {
+  NO_INTERSECTION,
+  LINE_INTERSECTION,
+  POINT_INTERSECTION,
+};
+
+interface IIntersectWithLine {
+	intersection: boolean;
+	betweenPoints: boolean;
+	t: number;
+	x: Vector3;
+}
+
+export const INTERSECTION = {
+  NO_INTERSECTION: 0,
+  LINE_INTERSECTION: 1,
+  POINT_INTERSECTION: 2,
+}
+
 export interface vtkPolygon extends vtkObject {
 
 	/**
-	 * Get the array of triangles that triangulate the polygon.
-	 */
-	getPointArray(): Vector3[];
+   * Get the array of triangles that triangulate the polygon.
+   */
+  getPointArray(): Vector3[];
 
-	/**
-	 * Set the polygon's points.
-	 * @param {Vector3[]} points The polygon's points.
-	 */
-	setPoints(points: Vector3[]): void;
+  /**
+   * Set the polygon's points
+   * Points must be ordered in counterclockwise order
+   * @param {Vector3[]} points The polygon's points.
+   */
+  setPoints(points: Vector3[]): void;
 
-	/**
-	 * Triangulate this polygon. 
-	 * The output data must be accessed through `getPointArray`.
-	 * The output data contains points by group of three: each three-group
-	 * defines one triangle.
-	 */
-	triangulate(): void;
+  /**
+   * Triangulate this polygon.
+   * The output data must be accessed through `getPointArray`.
+   * The output data contains points by group of three: each three-group
+   * defines one triangle.
+   */
+  triangulate(): void;
 
 	/**
 	 * Determine whether a point is inside a polygon. The function uses a winding
@@ -56,7 +76,57 @@ export interface vtkPolygon extends vtkObject {
 	  vertices: Vector3[],
 	  bounds: Bounds,
 	  normal: Vector3
-	): number;
+  ): number;
+  
+  /**
+   * Compute ear triangulation of current polygon
+   * The polygon must be convex and have at least 3 points
+   * @return {boolean} whether triangulation failed or not
+   */
+  triangulate(): boolean;
+
+  /**
+   * Returns the centroid of this polygon
+   * @return {Vector3} centroid
+   */
+  computeCentroid(): Vector3;
+
+  /**
+   * Returns the area of the polygon
+   * @return {number} area
+   */
+  computeArea(): number;
+
+  /**
+   * Returns whether the polygon is convex or not
+   * Returns false for degenerate polygon
+   * @return {boolean} is convex or not
+   */
+  isConvex(): boolean;
+
+  /**
+   * Interpolates functions with polygon points
+   * @param point point to compute the interpolation on
+   * @param useMVCInterpolation 
+   * @return weights corresponding to each point of polygon parametrizing the given point
+   */
+  interpolateFunctions(point: Vector3, useMVCInterpolation: boolean): Number[]
+
+  /**
+   * Computes intersection of polygon with a line defined by two points
+   * @param p1 first point of line
+   * @param p2 second point of line
+   * @return intersection point coordinates
+   */
+  intersectWithLine(p1: Vector3, p2: Vector3): IIntersectWithLine
+
+  /**
+   * Computes the intersection between two polygons
+   * The two points p0 and p1 describe the intersection. If no intersection is found, p0 and p1 are left null.
+   * If the intersection is only one point, p1 is left null
+   * @return {INTERSECTION} type of intersection (no, one point or line)
+   */
+  intersectConvex2DCells(polygon: vtkPolygon, tol: number, p0: Vector3, p1: Vector3): INTERSECTION
 }
 
 /**
@@ -97,15 +167,13 @@ export function newInstance(initialValues?: IPolygonInitialValues): vtkPolygon;
 
 /**
  * vtkPolygon represents a 2D n-sided polygon.
- * 
+ *
  * The polygons cannot have any internal holes, and cannot self-intersect.
  * Define the polygon with n-points ordered in the counter-clockwise direction.
  * Do not repeat the last point.
  */
 export declare const vtkPolygon: {
-	newInstance: typeof newInstance,
-	extend: typeof extend;
-	// static
-
+  newInstance: typeof newInstance,
+  extend: typeof extend;
 };
 export default vtkPolygon;