plotboilerplate 1.23.2 → 1.24.0

package/src/ts/Polygon.ts

@@ -28,7 +28,15 @@
  * @modified 2023-09-25 Added the `Polygon.lineIntersections(Line,boolean)` function.
  * @modified 2023-09-29 Added the `Polygon.closestLineIntersection(Line,boolean)` function.
  * @modified 2023-11-24 Added the `Polygon.containsPolygon(Polygon)' function.
- * @version 1.12.0
+ * @modified 2024-10-12 Added the `getEdgeAt` method.
+ * @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.
+ * @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
@@ -37,10 +45,13 @@
 import { BezierPath } from "./BezierPath";
 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 { XYCoords, SVGSerializable, UID } from "./interfaces";
+import { geomutils } from "./geomutils";
+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.
@@ -53,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.
    **/
@@ -103,7 +114,9 @@ export class Polygon implements SVGSerializable {
    **/
   constructor(vertices?: Array<Vertex>, isOpen?: boolean) {
     this.uid = UIDGenerator.next();
-    if (typeof vertices == "undefined") vertices = [];
+    if (typeof vertices == "undefined") {
+      vertices = [];
+    }
     this.vertices = vertices;
     this.isOpen = isOpen || false;
   }
@@ -111,7 +124,7 @@ export class Polygon implements SVGSerializable {
   /**
    * Add a vertex to the end of the `vertices` array.
    *
-   * @method addVert
+   * @method addVertex
    * @param {Vertex} vert - The vertex to add.
    * @instance
    * @memberof Polygon
@@ -120,6 +133,117 @@ export class Polygon implements SVGSerializable {
     this.vertices.push(vert);
   }
 
+  /**
+   * Add a vertex at a particular position of the `vertices` array.
+   *
+   * @method addVertexAt
+   * @param {Vertex} vert - The vertex to add.
+   * @param {number} index - The position to add the vertex at. Will be handled modulo.
+   * @instance
+   * @memberof Polygon
+   **/
+  addVertexAt(vert: Vertex, index: number): void {
+    // var moduloIndex = index % (this.vertices.length + 1);
+    this.vertices.splice(index, 0, vert);
+  }
+
+  /**
+   * Get a new instance of the line at the given start index. The returned line will consist
+   * of the vertex at `vertIndex` and `vertIndex+1` (will be handled modulo).
+   *
+   * @method getEdgeAt
+   * @param {number} vertIndex - The vertex index of the line to start.
+   * @instance
+   * @memberof Polygon
+   * @return {Line}
+   **/
+  getEdgeAt(vertIndex: number): Line {
+    return new Line(this.getVertexAt(vertIndex), this.getVertexAt(vertIndex + 1));
+  }
+
+  /**
+   * Converts this polygon into a sequence of lines. Please note that each time
+   * this method is called new lines are created. The underlying line vertices are no clones
+   * (instances).
+   *
+   * @method getEdges
+   * @instance
+   * @memberof Polygon
+   * @return {Array<Line>}
+   */
+  getEdges(): Array<Line> {
+    const lines: Array<Line> = [];
+    for (var i = 0; i + 1 < this.vertices.length; i++) {
+      // var line = this.getLineAt(i).clone();
+      lines.push(this.getEdgeAt(i));
+    }
+    if (!this.isOpen && this.vertices.length > 0) {
+      lines.push(this.getEdgeAt(this.vertices.length - 1));
+    }
+    return lines;
+  }
+
+  /**
+   * Checks if the angle at the given polygon vertex (index) is acute. Please not that this is
+   * only working for clockwise polygons. If this polygon is not clockwise please use the
+   * `isClockwise` method and reverse polygon vertices if needed.
+   *
+   * @method isAngleAcute
+   * @instance
+   * @memberof Polygon
+   * @param {number} vertIndex - The index of the polygon vertex to check.
+   * @returns {boolean} `true` is angle is acute, `false` is obtuse.
+   */
+  getInnerAngleAt(vertIndex: number): number {
+    const p2: Vertex = this.vertices[vertIndex];
+    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();
+
+    // See
+    //    https://math.stackexchange.com/questions/149959/how-to-find-the-interior-angle-of-an-irregular-pentagon-or-polygon
+    // π−arccos((P2−P1)⋅(P3−P2)|P2−P1||P3−P2|)
+
+    // Check if triangle is acute (will be used later)
+    // Acute angles and obtuse angles need to be handled differently.
+    const isAcute: boolean = this.isAngleAcute(vertIndex);
+
+    // Differences
+    const zero: Vertex = new Vertex(0, 0);
+    const p2mp1: Vertex = new Vertex(p2.x - p1.x, p2.y - p1.y);
+    const p3mp2: Vertex = new Vertex(p3.x - p2.x, p3.y - p2.y);
+    const p2mp1_len: number = zero.distance(p2mp1);
+    const p3mp2_len: number = zero.distance(p3mp2);
+
+    // Dot products
+    const dotProduct: number = geomutils.dotProduct(p2mp1, p3mp2);
+    const lengthProduct: number = p2mp1_len * p3mp2_len;
+    if (isAcute) {
+      return Math.PI - Math.acos(dotProduct / lengthProduct);
+    } else {
+      return Math.PI + Math.acos(dotProduct / lengthProduct);
+    }
+  }
+
+  /**
+   * Checks if the angle at the given polygon vertex (index) is acute.
+   *
+   * @method isAngleAcute
+   * @instance
+   * @memberof Polygon
+   * @param {number} vertIndex - The index of the polygon vertex to check.
+   * @returns {boolean} `true` is angle is acute, `false` is obtuse.
+   */
+  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 C: Vertex = this.vertices[(vertIndex + 1) % this.vertices.length].clone();
+
+    // Find local winding number for triangle A B C
+    const windingNumber: number = Triangle.utils.determinant(A, B, C);
+    // console.log("vertIndex", vertIndex, "windingNumber", windingNumber);
+    return windingNumber < 0;
+  }
+
   /**
    * Get the polygon vertex at the given position (index).
    *
@@ -130,15 +254,18 @@ export class Polygon implements SVGSerializable {
    *  - getVertexAt( vertices.length + k ) == getVertexAt( k )
    *  - getVertexAt( -k )                  == getVertexAt( vertices.length -k )
    *
-   * @metho getVertexAt
+   * @method getVertexAt
    * @param {number} index - The index of the desired vertex.
    * @instance
    * @memberof Polygon
    * @return {Vertex} At the given index.
    **/
   getVertexAt(index: number): Vertex {
-    if (index < 0) return this.vertices[this.vertices.length - (Math.abs(index) % this.vertices.length)];
-    else return this.vertices[index % this.vertices.length];
+    if (index < 0) {
+      return this.vertices[this.vertices.length - (Math.abs(index) % this.vertices.length)];
+    } else {
+      return this.vertices[index % this.vertices.length];
+    }
   }
 
   /**
@@ -164,7 +291,7 @@ export class Polygon implements SVGSerializable {
    *    https://stackoverflow.com/questions/22521982/check-if-point-inside-a-polygon
    *
    * @method containsVert
-   * @param {XYCoords} vert - The vertex to check. The new x-component.
+   * @param {XYCoords} vert - The vertex to check.
    * @return {boolean} True if the passed vertex is inside this polygon. The polygon is considered closed.
    * @instance
    * @memberof Polygon
@@ -185,6 +312,21 @@ export class Polygon implements SVGSerializable {
     return inside;
   }
 
+  /**
+   * Check if all given vertices are inside this polygon.<br>
+   * <br>
+   * This method just uses the `Polygon.containsVert` method.
+   *
+   * @method containsVerts
+   * @param {XYCoords[]} verts - The vertices to check.
+   * @return {boolean} True if all passed vertices are inside this polygon. The polygon is considered closed.
+   * @instance
+   * @memberof Polygon
+   **/
+  containsVerts(verts: XYCoords[]): boolean {
+    return verts.every((vert: XYCoords) => this.containsVert(vert));
+  }
+
   /**
    * Check if the passed polygon is completly contained inside this polygon.
    *
@@ -250,7 +392,8 @@ export class Polygon implements SVGSerializable {
    * @return {boolean}
    */
   isClockwise(): boolean {
-    return Polygon.utils.signedArea(this.vertices) < 0;
+    // return Polygon.utils.signedArea(this.vertices) < 0;
+    return Polygon.utils.isClockwise(this.vertices);
   }
 
   /**
@@ -311,9 +454,68 @@ export class Polygon implements SVGSerializable {
     return this;
   }
 
+  /**
+   * Get the mean `center` of this polygon by calculating the mean value of all vertices.
+   *
+   * Mean: (v[0] + v[1] + ... v[n-1]) / n
+   *
+   * @method getMeanCenter
+   * @instance
+   * @memberof Polygon
+   * @return {Vertex|null} `null` is no vertices are available.
+   */
+  getMeanCenter(): Vertex | null {
+    if (this.vertices.length === 0) {
+      return null;
+    }
+    const center: Vertex = this.vertices[0].clone();
+    for (var i = 1; i < this.vertices.length; i++) {
+      center.add(this.vertices[i]);
+    }
+    center.x /= this.vertices.length;
+    center.y /= this.vertices.length;
+    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.
@@ -322,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).
@@ -445,6 +652,7 @@ export class Polygon implements SVGSerializable {
     return result;
   }
 
+  //--- BEGIN --- Implement interface `IBounded`
   /**
    * Get the bounding box (bounds) of this polygon.
    *
@@ -456,10 +664,14 @@ export class Polygon implements SVGSerializable {
   getBounds(): Bounds {
     return Bounds.computeFromVertices(this.vertices);
   }
+  //--- END --- Implement interface `IBounded`
 
   /**
    * Create a deep copy of this polygon.
    *
+   * @method clone
+   * @instance
+   * @memberof Polygon
    * @return {Polygon} The cloned polygon.
    */
   clone(): Polygon {
@@ -469,6 +681,56 @@ export class Polygon implements SVGSerializable {
     );
   }
 
+  /**
+   * Create a new polygon without colinear adjacent edges. This method does not midify the current polygon
+   * but creates a new one.
+   *
+   * Please note that this method does NOT create deep clones of the vertices. Use Polygon.clone() if you need to.
+   *
+   * Please also note that the `tolerance` may become really large here, as the denominator of two closely
+   * parallel lines is usually pretty large. See the demo `57-eliminate-colinear-polygon-edges` to get
+   * an impression of how denominators work.
+   *
+   * @method elimitateColinearEdges
+   * @instance
+   * @memberof Polygon
+   * @param {number?} tolerance - (default is 1.0) The epsilon to detect co-linear edges.
+   * @return {Polygon} A new polygon without co-linear adjacent edges – respective the given epsilon.
+   */
+  elimitateColinearEdges(tolerance?: number): Polygon {
+    const eps: number = typeof tolerance === "undefined" ? 1.0 : tolerance;
+    const verts: Array<Vertex> = this.vertices.slice(); // Creates a shallow copy
+    let i: number = 0;
+    var lineA: Line = new Line(new Vertex(), new Vertex());
+    var lineB: Line = new Line(new Vertex(), new Vertex());
+    while (i + 1 < verts.length && verts.length > 2) {
+      const vertA = verts[i];
+      const vertB = verts[(i + 1) % verts.length];
+      lineA.a = vertA;
+      lineA.b = vertB;
+      lineB.a = vertB;
+      let areColinear: boolean = false;
+      let j = i + 2;
+      do {
+        let vertC: Vertex = verts[j % verts.length];
+        lineB.b = vertC;
+        areColinear = lineA.colinear(lineB, eps);
+        // console.log("are colinear?", i, i + 1, j, areColinear);
+        if (areColinear) {
+          j++;
+        }
+      } while (areColinear);
+      // Now j points to the first vertex that's NOT colinear to the current lineA
+      // -> delete all vertices in between
+      if (j - i > 2) {
+        // Means: there have been 'colinear vertices' in between
+        verts.splice(i + 1, j - i - 2);
+      }
+      i++;
+    }
+    return new Polygon(verts, this.isOpen);
+  }
+
   /**
    * Convert this polygon to a sequence of quadratic Bézier curves.<br>
    * <br>
@@ -572,7 +834,9 @@ export class Polygon implements SVGSerializable {
    **/
   toCubicBezierSVGString(threshold: number): string {
     var qdata: Array<Vertex> = this.toCubicBezierData(threshold);
-    if (qdata.length == 0) return "";
+    if (qdata.length == 0) {
+      return "";
+    }
     var buffer = ["M " + qdata[0].x + " " + qdata[0].y];
     for (var i = 1; i < qdata.length; i += 3) {
       buffer.push(
@@ -650,6 +914,10 @@ export class Polygon implements SVGSerializable {
       return Math.abs(total);
     },
 
+    isClockwise(vertices: Array<XYCoords>): boolean {
+      return Polygon.utils.signedArea(vertices) < 0;
+    },
+
     /**
      * Calulate the signed polyon area by interpreting the polygon as a matrix
      * and calculating its determinant.
@@ -665,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

@@ -21,7 +21,13 @@
  * @modified  2021-01-22 Always updating circumcircle when retieving it.
  * @modified  2022-02-02 Added the `destroy` method.
  * @modified  2022-02-02 Cleared the `Triangle.toSVGString` function (deprecated). Use `drawutilssvg` instead.
- * @version   2.6.0
+ * @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`.
+ * @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.
@@ -33,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 } from "./interfaces";
+import { IBounded, Intersectable, SVGSerializable, UID, XYCoords } from "./interfaces";
 
 /**
  * @classdesc A triangle class for triangulations.
@@ -54,7 +62,7 @@ import { SVGSerializable, UID } 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.
    **/
@@ -213,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.
    *
@@ -350,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.
    *
@@ -374,7 +458,8 @@ export class Triangle implements SVGSerializable {
    */
   determinant(): number {
     // (b.y - a.y)*(c.x - b.x) - (c.y - b.y)*(b.x - a.x);
-    return (this.b.y - this.a.y) * (this.c.x - this.b.x) - (this.c.y - this.b.y) * (this.b.x - this.a.x);
+    // return (this.b.y - this.a.y) * (this.c.x - this.b.x) - (this.c.y - this.b.y) * (this.b.x - this.a.x);
+    return Triangle.utils.determinant(this.a, this.b, this.c);
   }
 
   /**
@@ -464,7 +549,7 @@ export class Triangle implements SVGSerializable {
     this.isDestroyed = true;
   }
 
-  private static utils = {
+  public static utils = {
     // Used in the bounds() function.
     max3(a: number, b: number, c: number): number {
       return a >= b && a >= c ? a : b >= a && b >= c ? b : c;
@@ -500,6 +585,17 @@ export class Triangle implements SVGSerializable {
       var t: number = (1 / (2 * area)) * (p0x * p1y - p0y * p1x + (p0y - p1y) * px + (p1x - p0x) * py);
 
       return s > 0 && t > 0 && 1 - s - t > 0;
+    },
+
+    /**
+     * Calculate the determinant of the three vertices a, b and c (in this order).
+     * @param {XYCords} a - The first vertex.
+     * @param {XYCords} b - The first vertex.
+     * @param {XYCords} c - The first vertex.
+     * @returns {nmber}
+     */
+    determinant(a: XYCoords, b: XYCoords, c: XYCoords): number {
+      return (b.y - a.y) * (c.x - b.x) - (c.y - b.y) * (b.x - a.x);
     }
   };
 }