plotboilerplate 1.20.1 → 1.21.0

package/src/ts/Polygon.ts

@@ -24,7 +24,10 @@
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-02-02 Cleared the `Polygon.toSVGString` function (deprecated). Use `drawutilssvg` instead.
  * @modified 2022-03-08 Added the `Polygon.clone()` function.
- * @version 1.10.0
+ * @modified 2023-09-25 Added the `Polygon.getInterpolationPolygon(number)` function.
+ * @modified 2023-09-25 Added the `Polygon.lineIntersections(Line,boolean)` function.
+ * @modified 2023-09-29 Added the `Polygon.closestLineIntersection(Line,boolean)` function.
+ * @version 1.11.0
  *
  * @file Polygon
  * @public
@@ -32,7 +35,9 @@
 
 import { BezierPath } from "./BezierPath";
 import { Bounds } from "./Bounds";
+import { Line } from "./Line";
 import { UIDGenerator } from "./UIDGenerator";
+import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
 import { XYCoords, SVGSerializable, UID } from "./interfaces";
 
@@ -276,6 +281,91 @@ export class Polygon implements SVGSerializable {
     return this;
   }
 
+  /**
+   * Get all line intersections with this polygon.
+   *
+   * 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 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;
+  }
+
+  /**
+   * Get the closest line-polygon-intersection point (closest the line point A).
+   *
+   * 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 considered (located strictly between start and end vertex).
+   * @returns {Array<Vertex>} - An array of all intersections within the polygon bounds.
+   */
+  closestLineIntersection(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): 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 curDist = Number.MAX_VALUE;
+    for (var i in allIntersections) {
+      const curVert = allIntersections[i];
+      const dist = curVert.distance(line.a);
+      if (dist < curDist) {
+        // && line.hasPoint(curVert)) {
+        curDist = dist;
+        closestIntersection = curVert;
+      }
+    }
+    return closestIntersection;
+  }
+
+  /**
+   * Construct a new polygon from this polygon with more vertices on each edge. The
+   * interpolation count determines the number of additional vertices on each edge.
+   * An interpolation count of `0` will return a polygon that equals the source
+   * polygon.
+   *
+   * @param {number} interpolationCount
+   * @returns {Polygon} A polygon with `interpolationCount` more vertices (as as factor).
+   */
+  getInterpolationPolygon(interpolationCount: number): Polygon {
+    const verts: Array<Vertex> = [];
+    for (var i = 0; i < this.vertices.length; i++) {
+      const curVert = this.vertices[i];
+      const nextVert = this.vertices[(i + 1) % this.vertices.length];
+      verts.push(curVert.clone());
+      // Add interpolation points
+      if (!this.isOpen || i + 1 !== this.vertices.length) {
+        const lerpAmount = 1.0 / (interpolationCount + 1);
+        for (var j = 1; j <= interpolationCount; j++) {
+          verts.push(curVert.clone().lerp(nextVert, lerpAmount * j));
+        }
+      }
+    }
+    return new Polygon(verts, this.isOpen);
+  }
+
   /**
    * Convert this polygon into a new polygon with n evenly distributed vertices.
    *

package/src/ts/Triangle.ts

@@ -404,7 +404,8 @@ export class Triangle implements SVGSerializable {
 
     const bisector1 = geomutils.nsectAngle(this.b, this.a, this.c, 2)[0]; // bisector of first angle (in b)
     const bisector2 = geomutils.nsectAngle(this.c, this.b, this.a, 2)[0]; // bisector of second angle (in c)
-    const intersection = bisector1.intersection(bisector2);
+    // Cast to non-null here because we know there _is_ an intersection
+    const intersection = bisector1.intersection(bisector2) as Vertex;
 
     // Find the closest points on one of the polygon lines (all have same distance by construction)
     const circleIntersA = lineA.getClosestPoint(intersection);

package/src/ts/VEllipse.ts

@@ -392,8 +392,8 @@ export class VEllipse implements SVGSerializable {
         let startTangent: Vector = this.tangentAt(curAngle);
         let endTangent: Vector = this.tangentAt(nextAngle);
 
-        // Find intersection
-        let intersection: Vertex | undefined = startTangent.intersection(endTangent);
+        // Find intersection (ignore that the result might be null in some extreme cases)
+        let intersection: Vertex = startTangent.intersection(endTangent) as Vertex;
         // What if intersection is undefined?
         // --> This *can* not happen if segmentCount > 2 and height and width of the ellipse are not zero.
 

package/src/ts/Vector.ts

@@ -20,7 +20,7 @@
 
 import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
-import { SVGSerializable } from "./interfaces";
+import { SVGSerializable, XYCoords } from "./interfaces";
 
 /**
  * @classdesc A vector (Vertex,Vertex) is a line with a visible direction.<br>
@@ -156,13 +156,13 @@ export class Vector extends VertTuple<Vector> implements SVGSerializable {
      * Example:
      *    buildArrowHead( new Vertex(0,0), new Vertex(50,100), 8, 1.0, 1.0 )
      *
-     * @param {Vertex} zA - The start vertex of the vector to calculate the arrow head for.
-     * @param {Vertex} zB - The end vertex of the vector.
+     * @param {XYCoords} zA - The start vertex of the vector to calculate the arrow head for.
+     * @param {XYCoords} zB - The end vertex of the vector.
      * @param {number} headlen - The length of the arrow head (along the vector direction. A good value is 12).
      * @param {number} scaleX  - The horizontal scaling during draw.
      * @param {number} scaleY  - the vertical scaling during draw.
      **/
-    buildArrowHead: (zA: Vertex, zB: Vertex, headlen: number, scaleX: number, scaleY: number) => {
+    buildArrowHead: (zA: XYCoords, zB: XYCoords, headlen: number, scaleX: number, scaleY: number): Array<Vertex> => {
       const angle = Math.atan2((zB.y - zA.y) * scaleY, (zB.x - zA.x) * scaleX);
       const vertices: Array<Vertex> = [];
       vertices.push(new Vertex(zB.x * scaleX - headlen * Math.cos(angle), zB.y * scaleY - headlen * Math.sin(angle)));

package/src/ts/VertTuple.ts

@@ -9,7 +9,8 @@
  * @modified 2020-12-04 Added the `hasPoint(XYCoords)` function.
  * @modified 2021-01-20 Added UID.
  * @modified 2022-02-02 Added the `destroy` method.
- * @version 1.2.0
+ * @modified 2023-09-29 Fixed a calculation error in the VertTuple.hasPoint() function; distance measure was broken!
+ * @version 1.2.1
  */
 
 import { Vertex } from "./Vertex";
@@ -277,11 +278,11 @@ export class VertTuple<T extends VertTuple<T>> {
   hasPoint(point: XYCoords, insideBoundsOnly?: boolean): boolean {
     const t: number = this.getClosestT(point);
     // Compare to pointDistance?
+    const distance: number = Math.sqrt(VertTuple.vtutils.dist2(point, this.vertAt(t)));
     if (typeof insideBoundsOnly !== "undefined" && insideBoundsOnly) {
-      const distance: number = Math.sqrt(VertTuple.vtutils.dist2(point, this.vertAt(t)));
       return distance < Vertex.EPSILON && t >= 0 && t <= 1;
     } else {
-      return t >= 0 && t <= 1;
+      return distance < Vertex.EPSILON; // t >= 0 && t <= 1;
     }
   }
 

package/src/ts/Vertex.ts

@@ -29,6 +29,8 @@
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-02-02 Cleared the `Vertex.toSVGString` function (deprecated). Use `drawutilssvg` instead.
  * @modified 2022-11-28 Added the `subXY`, `subX` and `subY` methods to the `Vertex` class.
+ * @modified 2023-09-29 Downgraded types for the `Vertex.utils.buildArrowHead` function (replacing Vertex params by more generic XYCoords type).
+ * @modified 2023-09-29 Added the `Vertex.abs()` method as it seems useful.
  * @version  2.8.0
  *
  * @file Vertex
@@ -607,6 +609,20 @@ export class Vertex implements XYCoords, SVGSerializable {
     return this;
   }
 
+  /**
+   * Set both coordinates of this vertex to their absolute value (abs(x), abs(y)).
+   *
+   * @method abs
+   * @return {Vertex} this
+   * @instance
+   * @memberof Vertex
+   */
+  abs(): Vertex {
+    this.x = Math.abs(this.x);
+    this.y = Math.abs(this.y);
+    return this;
+  }
+
   /**
    * Get a string representation of this vertex.
    *
@@ -662,15 +678,15 @@ export class Vertex implements XYCoords, SVGSerializable {
      * Example:
      *    buildArrowHead( new Vertex(0,0), new Vertex(50,100), 8, 1.0, 1.0 )
      *
-     * @param {Vertex} zA - The start vertex of the vector to calculate the arrow head for.
-     * @param {Vertex} zB - The end vertex of the vector.
+     * @param {XYCoords} zA - The start vertex of the vector to calculate the arrow head for.
+     * @param {XYCoords} zB - The end vertex of the vector.
      * @param {number} headlen - The length of the arrow head (along the vector direction. A good value is 12).
      * @param {number} scaleX  - The horizontal scaling during draw.
      * @param {number} scaleY  - the vertical scaling during draw.
      **/
     // @DEPRECATED: use Vector.utils.buildArrowHead instead!!!
-    buildArrowHead: (zA: Vertex, zB: Vertex, headlen: number, scaleX: number, scaleY: number): Array<Vertex> => {
-      // console.warn('This function is deprecated! Use Vector.utils.buildArrowHead instead!');
+    buildArrowHead: (zA: XYCoords, zB: XYCoords, headlen: number, scaleX: number, scaleY: number): Array<Vertex> => {
+      console.warn("[DEPRECATION] Vertex.utils.buildArrowHead is deprecated. Please use Vector.utils.buildArrowHead instead.");
       var angle: number = Math.atan2((zB.y - zA.y) * scaleY, (zB.x - zA.x) * scaleX);
 
       var vertices: Array<Vertex> = [];