plotboilerplate 1.23.3 → 1.24.0

package/src/ts/Line.ts

@@ -16,15 +16,19 @@
  * @modified 2022-10-09 Changed the actual return value of the `intersection` function to null (was undefined before).
  * @modified 2022-10-17 Adding these methods from the `PathSegment` interface: getStartPoint, getEndPoint, revert.
  * @modified 2023-09-25 Changed param type of `intersection()` from Line to VertTuple.
- * @version  2.3.0
+ * @modified 2025-04-15 Class `Line` now implements interface `Intersectable`.
+ * @modified 2025-04-16 Class `Line` now implements interface `IBounded`.
+ * @version  2.4.0
  *
  * @file Line
  * @public
  **/
 
+import { Bounds } from "./Bounds";
+import { Vector } from "./Vector";
 import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
-import { PathSegment, SVGSerializable } from "./interfaces";
+import { IBounded, Intersectable, PathSegment, SVGSerializable } from "./interfaces";
 
 /**
  * @classdesc A line consists of two vertices a and b.<br>
@@ -34,7 +38,7 @@ import { PathSegment, SVGSerializable } from "./interfaces";
  *
  * @requires Vertex
  */
-export class Line extends VertTuple<Line> implements SVGSerializable, PathSegment {
+export class Line extends VertTuple<Line> implements IBounded, Intersectable, PathSegment, SVGSerializable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -87,6 +91,20 @@ export class Line extends VertTuple<Line> implements SVGSerializable, PathSegmen
     return new Vertex(x, y);
   }
 
+  //--- BEGIN --- Implement interface `IBounded`
+  /**
+   * Get the bounding box (bounds) of this Line.
+   *
+   * @method getBounds
+   * @instance
+   * @memberof Line
+   * @return {Bounds} The rectangular bounds of this Line.
+   **/
+  getBounds(): Bounds {
+    return Bounds.computeFromVertices([this.a, this.b]);
+  }
+  //--- END --- Implement interface `IBounded`
+
   //--- Implement PathSegment ---
   /**
    * Get the start point of this path segment.
@@ -146,4 +164,49 @@ export class Line extends VertTuple<Line> implements SVGSerializable, PathSegmen
     return this;
   }
   //--- END Implement PathSegment ---
+
+  //--- 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
+    const intersection: Vertex | null = this.intersection(line);
+    if (!intersection) {
+      return []; // Both lines parallel
+    }
+    if (this.hasPoint(intersection, true) && (!inVectorBoundsOnly || line.hasPoint(intersection, inVectorBoundsOnly))) {
+      return [intersection];
+    } else {
+      return [];
+    }
+  }
+
+  /**
+   * 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
+    const intersections: Vertex[] = this.lineIntersections(line, inVectorBoundsOnly);
+    if (intersections.length === 0) {
+      return [];
+    }
+    const intrsctn = intersections[0];
+    return [new Vector(this.a.clone(), this.b.clone()).moveTo(intrsctn) as Vector];
+  }
+  //--- END --- Implement interface `Intersectable`
 }

package/src/ts/PlotBoilerplate.ts

@@ -1302,16 +1302,16 @@ export class PlotBoilerplate {
       }
     } else if (d instanceof Triangle) {
       draw.polyline([d.a, d.b, d.c], false, this.drawConfig.triangle.color, this.drawConfig.triangle.lineWidth);
-      if (!this.drawConfig.drawHandlePoints) d.a.attr.renderTime = d.b.attr.renderTime = d.c.attr.renderTime = renderTime;
+      if (!this.drawConfig.drawHandlePoints) {
+        d.a.attr.renderTime = d.b.attr.renderTime = d.c.attr.renderTime = renderTime;
+      }
     } else if (d instanceof VEllipse) {
       if (this.drawConfig.drawHandleLines) {
         draw.setCurrentId(`${d.uid}_e0`);
         draw.setCurrentClassName(`${d.className}-v-line`);
-        // draw.line( d.center.clone().add(0,d.axis.y-d.center.y), d.axis, '#c8c8c8' );
         draw.handleLine(d.center.clone().add(0, d.signedRadiusV()).rotate(d.rotation, d.center), d.axis); // , "#c8c8c8");
         draw.setCurrentId(`${d.uid}_e1`);
         draw.setCurrentClassName(`${d.className}-h-line`);
-        // draw.line( d.center.clone().add(d.axis.x-d.center.x,0), d.axis, '#c8c8c8' );
         draw.handleLine(d.center.clone().add(d.signedRadiusH(), 0).rotate(d.rotation, d.center), d.axis); // , "#c8c8c8");
       }
       draw.setCurrentId(d.uid);
@@ -1332,12 +1332,6 @@ export class PlotBoilerplate {
     } else if (d instanceof VEllipseSector) {
       draw.setCurrentId(d.uid);
       draw.setCurrentClassName(`${d.className}`);
-      /* draw.ellipse( d.center,
-			  // Math.abs(d.axis.x-d.center.x), Math.abs(d.axis.y-d.center.y),
-			  d.radiusH(), d.radiusV(),
-			  this.drawConfig.ellipse.color,
-			  this.drawConfig.ellipse.lineWidth,
-			  d.rotation ); */
       const data: SVGPathParams = VEllipseSector.ellipseSectorUtils.describeSVGArc(
         d.ellipse.center.x,
         d.ellipse.center.y,

package/src/ts/Polygon.ts

@@ -32,7 +32,11 @@
  * @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`.
+ * @version 1.15.0
  *
  * @file Polygon
  * @public
@@ -43,10 +47,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 } from "./interfaces";
 
 /**
  * @classdesc A polygon class. Any polygon consists of an array of vertices; polygons can be open or closed.
@@ -59,7 +64,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.
    **/
@@ -459,11 +464,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 +477,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,23 +524,28 @@ 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.intersectionPoint);
+  }
+
+  /**
+   * 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.intersectionPoint) as Vector;
+    });
   }
+  //--- END --- Implement interface `Intersectable`
 
   /**
    * Get the closest line-polygon-intersection point (closest the line point A).
@@ -606,6 +652,7 @@ export class Polygon implements SVGSerializable {
     return result;
   }
 
+  //--- BEGIN --- Implement interface `IBounded`
   /**
    * Get the bounding box (bounds) of this polygon.
    *
@@ -617,6 +664,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 +724,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 +933,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<{ edgeIndex: number; intersectionPoint: Vertex }> {
+      // Find the intersections of all lines inside the edge bounds
+      const intersectionPoints: Array<{ edgeIndex: number; intersectionPoint: 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, intersectionPoint: 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.intersectionPoint);
+  }
+
+  /**
+   * 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.intersectionPoint) 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.
    *