plotboilerplate 1.23.3 → 1.25.0

package/src/ts/Polygon.ts

@@ -32,7 +32,13 @@
  * @modified 2024-10-30 Added the `getEdges` method.
  * @modified 2024-12-02 Added the `elimitateColinearEdges` method.
  * @modified 2025-02-12 Added the `containsVerts` method to test multiple vertices for containment.
- * @version 1.14.0
+ * @modified 2025-03-28 Added the `Polygon.utils.locateLineIntersecion` static helper method.
+ * @modified 2025-03-28 Added the `Polygon.lineIntersectionTangents` method.
+ * @modified 2025-04-09 Added the `Polygon.getCentroid` method.
+ * @modified 2025-05-16 Class `Polygon` now implements `IBounded`.
+ * @modified 2025-05-20 Tweaking `Polygon.getInnerAngleAt` and `Polygo.isAngleAcute` to handle indices out of array bounds as well.
+ * @modified 2025-06-07 Adding `Polygon.closestLineIntersectionIndex` to determine line intersections plus detected edge index.
+ * @version 1.16.0
  *
  * @file Polygon
  * @public
@@ -43,10 +49,11 @@ import { Bounds } from "./Bounds";
 import { Line } from "./Line";
 import { Triangle } from "./Triangle";
 import { UIDGenerator } from "./UIDGenerator";
+import { Vector } from "./Vector";
 import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
 import { geomutils } from "./geomutils";
-import { XYCoords, SVGSerializable, UID } from "./interfaces";
+import { XYCoords, SVGSerializable, UID, Intersectable, IBounded, PolygonIntersectionTuple } from "./interfaces";
 
 /**
  * @classdesc A polygon class. Any polygon consists of an array of vertices; polygons can be open or closed.
@@ -59,7 +66,7 @@ import { XYCoords, SVGSerializable, UID } from "./interfaces";
  * @requires Vertex
  * @requires XYCoords
  */
-export class Polygon implements SVGSerializable {
+export class Polygon implements IBounded, Intersectable, SVGSerializable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -190,7 +197,7 @@ export class Polygon implements SVGSerializable {
    * @returns {boolean} `true` is angle is acute, `false` is obtuse.
    */
   getInnerAngleAt(vertIndex: number): number {
-    const p2: Vertex = this.vertices[vertIndex];
+    const p2: Vertex = this.vertices[vertIndex % this.vertices.length];
     const p1: Vertex = this.vertices[(vertIndex + this.vertices.length - 1) % this.vertices.length].clone();
     const p3: Vertex = this.vertices[(vertIndex + 1) % this.vertices.length].clone();
 
@@ -230,7 +237,7 @@ export class Polygon implements SVGSerializable {
    */
   isAngleAcute(vertIndex: number): boolean {
     const A: Vertex = this.vertices[(vertIndex + this.vertices.length - 1) % this.vertices.length].clone();
-    const B: Vertex = this.vertices[vertIndex];
+    const B: Vertex = this.vertices[vertIndex % this.vertices.length];
     const C: Vertex = this.vertices[(vertIndex + 1) % this.vertices.length].clone();
 
     // Find local winding number for triangle A B C
@@ -302,7 +309,9 @@ export class Polygon implements SVGSerializable {
         yj: number = this.vertices[j].y;
 
       var intersect: boolean = yi > vert.y != yj > vert.y && vert.x < ((xj - xi) * (vert.y - yi)) / (yj - yi) + xi;
-      if (intersect) inside = !inside;
+      if (intersect) {
+        inside = !inside;
+      }
     }
     return inside;
   }
@@ -459,11 +468,11 @@ export class Polygon implements SVGSerializable {
    * @memberof Polygon
    * @return {Vertex|null} `null` is no vertices are available.
    */
-  getMeanCenter() {
+  getMeanCenter(): Vertex | null {
     if (this.vertices.length === 0) {
       return null;
     }
-    const center = this.vertices[0].clone();
+    const center: Vertex = this.vertices[0].clone();
     for (var i = 1; i < this.vertices.length; i++) {
       center.add(this.vertices[i]);
     }
@@ -472,9 +481,45 @@ export class Polygon implements SVGSerializable {
     return center;
   }
 
+  /**
+   * Get centroid.
+   * Centroids define the barycenter of any non self-intersecting convex polygon.
+   *
+   * If the polygon is self intersecting or non konvex then the barycenter is not well defined.
+   *
+   * https://mathworld.wolfram.com/PolygonCentroid.html
+   *
+   * @method getCentroid
+   * @instance
+   * @memberof Polygon
+   * @returns {Vertex|null}
+   */
+  getCentroid(): Vertex | null {
+    if (this.vertices.length === 0) {
+      return null;
+    }
+    const center: Vertex = new Vertex(0.0, 0.0);
+    const n = this.vertices.length;
+    for (var i = 0; i < n; i++) {
+      // center.add(this.vertices[i]);
+      const cur: Vertex = this.vertices[i];
+      const next: Vertex = this.vertices[(i + 1) % n];
+      var factor: number = cur.x * next.y - next.x * cur.y;
+      center.x += (cur.x + next.x) * factor;
+      center.y += (cur.y + next.y) * factor;
+    }
+    const area = this.area();
+    center.x *= 1 / (6 * area);
+    center.y *= 1 / (6 * area);
+    return center;
+  }
+
+  //--- BEGIN --- Implement interface `Intersectable`
   /**
    * Get all line intersections with this polygon.
    *
+   * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.
+   *
    * See demo `47-closest-vector-projection-on-polygon` for how it works.
    *
    * @param {VertTuple} line - The line to find intersections with.
@@ -483,22 +528,50 @@ export class Polygon implements SVGSerializable {
    */
   lineIntersections(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vertex> {
     // Find the intersections of all lines inside the edge bounds
-    const intersectionPoints: Array<Vertex> = [];
-    for (var i = 0; i < this.vertices.length; i++) {
-      const polyLine = new Line(this.vertices[i], this.vertices[(i + 1) % this.vertices.length]);
-      const intersection = polyLine.intersection(line);
-      // true => only inside bounds
-      // ignore last edge if open
-      if (
-        (!this.isOpen || i + 1 !== this.vertices.length) &&
-        intersection !== null &&
-        polyLine.hasPoint(intersection, true) &&
-        (!inVectorBoundsOnly || line.hasPoint(intersection, inVectorBoundsOnly))
-      ) {
-        intersectionPoints.push(intersection);
-      }
-    }
-    return intersectionPoints;
+    return Polygon.utils
+      .locateLineIntersecion(line, this.vertices, this.isOpen, inVectorBoundsOnly)
+      .map(intersectionTuple => intersectionTuple.intersection);
+  }
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @param line
+   * @param inVectorBoundsOnly
+   * @returns
+   */
+  lineIntersectionTangents(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vector> {
+    // Find the intersection tangents of all lines inside the edge bounds
+    return Polygon.utils.locateLineIntersecion(line, this.vertices, this.isOpen, inVectorBoundsOnly).map(intersectionTuple => {
+      const polyLine = this.getEdgeAt(intersectionTuple.edgeIndex);
+      return new Vector(polyLine.a.clone(), polyLine.b.clone()).moveTo(intersectionTuple.intersection) as Vector;
+    });
+  }
+  //--- END --- Implement interface `Intersectable`
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @param line
+   * @param inVectorBoundsOnly
+   * @returns
+   */
+  lineIntersectionTangentsIndices(
+    line: VertTuple<any>,
+    inVectorBoundsOnly: boolean = false
+  ): Array<PolygonIntersectionTuple<Vector>> {
+    // Find the intersection tangents of all lines inside the edge bounds
+    return Polygon.utils.locateLineIntersecion(line, this.vertices, this.isOpen, inVectorBoundsOnly).map(intersectionTuple => {
+      const polyLine = this.getEdgeAt(intersectionTuple.edgeIndex);
+      return {
+        intersection: new Vector(polyLine.a.clone(), polyLine.b.clone()).moveTo(intersectionTuple.intersection) as Vector,
+        edgeIndex: intersectionTuple.edgeIndex
+      };
+    });
   }
 
   /**
@@ -508,27 +581,54 @@ export class Polygon implements SVGSerializable {
    *
    * @param {VertTuple} line - The line to find intersections with.
    * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are considered (located strictly between start and end vertex).
-   * @returns {Array<Vertex>} - An array of all intersections within the polygon bounds.
+   * @returns {Vertex | null} - The intersection point within the polygon bounds.
    */
   closestLineIntersection(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Vertex | null {
+    var closestInterSectionIndex: PolygonIntersectionTuple<Vertex> | null = this.closestLineIntersectionIndex(
+      line,
+      inVectorBoundsOnly
+    );
+    if (closestInterSectionIndex) {
+      return closestInterSectionIndex.intersection;
+    } else {
+      return null;
+    }
+  }
+
+  /**
+   * Get the closest line-polygon-intersection point (closest the line point A) plus the edge index..
+   *
+   * See demo `63-measure-angles-on-polygon` for how it works.
+   *
+   * @param {VertTuple} line - The line to find intersections with.
+   * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are considered (located strictly between start and end vertex).
+   * @returns {PolygonIntersectionTuple| null} - A pair containing the intersection point and the affected polygon edge index.
+   */
+  closestLineIntersectionIndex(
+    line: VertTuple<any>,
+    inVectorBoundsOnly: boolean = false
+  ): PolygonIntersectionTuple<Vertex> | null {
     const allIntersections = this.lineIntersections(line, inVectorBoundsOnly);
     if (allIntersections.length <= 0) {
       // Empty polygon -> no intersections
       return null;
     }
     // Find the closest intersection
-    let closestIntersection = new Vertex(Number.MAX_VALUE, Number.MAX_VALUE);
+    let closestIntersection: Vertex = new Vertex(Number.MAX_VALUE, Number.MAX_VALUE);
+    let closestInterSectionIndex: number = -1;
     let curDist = Number.MAX_VALUE;
-    for (var i in allIntersections) {
+    for (var i = 0; i < allIntersections.length; i++) {
       const curVert = allIntersections[i];
       const dist = curVert.distance(line.a);
       if (dist < curDist) {
         // && line.hasPoint(curVert)) {
         curDist = dist;
         closestIntersection = curVert;
+        closestInterSectionIndex = i;
       }
     }
-    return closestIntersection;
+    // return [closestIntersection, closestInterSectionIndex];
+    return { edgeIndex: closestInterSectionIndex, intersection: closestIntersection };
   }
 
   /**
@@ -606,6 +706,7 @@ export class Polygon implements SVGSerializable {
     return result;
   }
 
+  //--- BEGIN --- Implement interface `IBounded`
   /**
    * Get the bounding box (bounds) of this polygon.
    *
@@ -617,6 +718,7 @@ export class Polygon implements SVGSerializable {
   getBounds(): Bounds {
     return Bounds.computeFromVertices(this.vertices);
   }
+  //--- END --- Implement interface `IBounded`
 
   /**
    * Create a deep copy of this polygon.
@@ -676,7 +778,6 @@ export class Polygon implements SVGSerializable {
       // -> delete all vertices in between
       if (j - i > 2) {
         // Means: there have been 'colinear vertices' in between
-        // console.log("Splice", "i", i, "j", j, i + 1, j - i - 1);
         verts.splice(i + 1, j - i - 2);
       }
       i++;
@@ -886,6 +987,40 @@ export class Polygon implements SVGSerializable {
         sum += (vertices[j].x - vertices[i].x) * (vertices[i].y + vertices[j].y);
       }
       return sum;
+    },
+
+    /**
+     * Find intersections of a line with a polygon (vertices).
+     *
+     * @param {VertTuple<any>} line - The line to find intersections with.
+     * @param {Array<Vertex>} vertices - The polygon's vertices.
+     * @param {boolean} isOpen - True if the polygon is open, false otherwise.
+     * @param {boolean} inVectorBoundsOnly - If only intersections in strict vector bounds should be returned.
+     * @returns
+     */
+    locateLineIntersecion(
+      line: VertTuple<any>,
+      vertices: Array<Vertex>,
+      isOpen: boolean,
+      inVectorBoundsOnly: boolean
+    ): Array<PolygonIntersectionTuple<Vertex>> {
+      // Find the intersections of all lines inside the edge bounds
+      const intersectionPoints: Array<PolygonIntersectionTuple<Vertex>> = [];
+      var n = isOpen ? vertices.length - 1 : vertices.length;
+      for (var i = 0; i < n; i++) {
+        const polyLine = new Line(vertices[i % n], vertices[(i + 1) % n]);
+        const intersection = polyLine.intersection(line);
+        // true => only inside bounds
+        // ignore last edge if open
+        if (
+          intersection !== null &&
+          polyLine.hasPoint(intersection, true) &&
+          (!inVectorBoundsOnly || line.hasPoint(intersection, inVectorBoundsOnly))
+        ) {
+          intersectionPoints.push({ edgeIndex: i, intersection: intersection });
+        }
+      }
+      return intersectionPoints;
     }
   };
 }

package/src/ts/Triangle.ts

@@ -23,7 +23,11 @@
  * @modified  2022-02-02 Cleared the `Triangle.toSVGString` function (deprecated). Use `drawutilssvg` instead.
  * @modified  2024-11-22 Added static utility function Triangle.utils.determinant; adapted method `determinant`.
  * @modified  2024-11-22 Changing visibility of `Triangle.utils` from `private` to `public`.
- * @version   2.8.0
+ * @modified  2025-14-16 Class `Triangle` now implements interface `Intersectable`.
+ * @modified  2025-14-16 Class `Triangle` now implements interface `IBounded`.
+ * @modified  2025-14-16 Class `Triangle` now implements interface `Intersectable`.
+ * @modified  2025-14-16 Added method `Triangle.move`.
+ * @version   2.10.0
  *
  * @file Triangle
  * @fileoverview A simple triangle class: three vertices.
@@ -35,9 +39,11 @@ import { Circle } from "./Circle";
 import { Line } from "./Line";
 import { Polygon } from "./Polygon";
 import { UIDGenerator } from "./UIDGenerator";
+import { Vector } from "./Vector";
+import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
 import { geomutils } from "./geomutils";
-import { SVGSerializable, UID, XYCoords } from "./interfaces";
+import { IBounded, Intersectable, SVGSerializable, UID, XYCoords } from "./interfaces";
 
 /**
  * @classdesc A triangle class for triangulations.
@@ -56,7 +62,7 @@ import { SVGSerializable, UID, XYCoords } from "./interfaces";
  * @requires geomutils
  *
  */
-export class Triangle implements SVGSerializable {
+export class Triangle implements IBounded, SVGSerializable, Intersectable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -215,6 +221,37 @@ export class Triangle implements SVGSerializable {
     return this;
   }
 
+  //--- BEGIN --- Implement interface `IBounded`
+  /**
+   * Get the bounding box (bounds) of this Triangle.
+   *
+   * @method getBounds
+   * @instance
+   * @memberof Triangle
+   * @return {Bounds} The rectangular bounds of this Triangle.
+   **/
+  getBounds(): Bounds {
+    // return Bounds.computeFromVertices([this.a, this.b, this.c]);
+    return this.bounds();
+  }
+  //--- END --- Implement interface `IBounded`
+
+  /**
+   * Move the Triangle's vertices by the given amount.
+   *
+   * @method move
+   * @param {XYCoords} amount - The amount to move.
+   * @instance
+   * @memberof Triangle
+   * @return {Triangle} this for chaining
+   **/
+  move(amount: XYCoords): Triangle {
+    this.a.add(amount);
+    this.b.add(amount);
+    this.c.add(amount);
+    return this;
+  }
+
   /**
    * Get the circumcircle of this triangle.
    *
@@ -352,6 +389,51 @@ export class Triangle implements SVGSerializable {
     );
   }
 
+  //--- BEGIN --- Implement interface `Intersectable`
+  /**
+   * Get all line intersections with this polygon.
+   *
+   * This method returns all intersections (as vertices) with this shape. The returned array of vertices is in no specific order.
+   *
+   * See demo `47-closest-vector-projection-on-polygon` for how it works.
+   *
+   * @param {VertTuple} line - The line to find intersections with.
+   * @param {boolean} inVectorBoundsOnly - If set to true only intersecion points on the passed vector are returned (located strictly between start and end vertex).
+   * @returns {Array<Vertex>} - An array of all intersections within the polygon bounds.
+   */
+  lineIntersections(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vertex> {
+    // Find the intersections of all lines inside the edge bounds
+    return Polygon.utils
+      .locateLineIntersecion(line, [this.a, this.b, this.c], false, inVectorBoundsOnly)
+      .map(intersectionTuple => intersectionTuple.intersection);
+  }
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @param line
+   * @param inVectorBoundsOnly
+   * @returns
+   */
+  lineIntersectionTangents(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vector> {
+    // Find the intersection tangents of all lines inside the edge bounds
+    return Polygon.utils
+      .locateLineIntersecion(line, [this.a, this.b, this.c], false, inVectorBoundsOnly)
+      .map(intersectionTuple => {
+        // const polyLine = this.getEdgeAt(intersectionTuple.edgeIndex);
+        const polyLine = this.getEdgeAt(intersectionTuple.edgeIndex);
+        return new Vector(polyLine.a.clone(), polyLine.b.clone()).moveTo(intersectionTuple.intersection) as Vector;
+      });
+  }
+  //--- END --- Implement interface `Intersectable`
+
+  getEdgeAt(edgeIndex: number): Line {
+    var modIndex = edgeIndex % 3;
+    return modIndex === 0 ? new Line(this.a, this.b) : modIndex === 1 ? new Line(this.b, this.c) : new Line(this.c, this.a);
+  }
+
   /**
    * Convert this triangle to a polygon instance.
    *