plotboilerplate 1.14.0 → 1.15.0

package/src/ts/Vertex.ts

@@ -24,7 +24,8 @@
  * @modified 2021-03-01 Changed the second param `center` in the `rotate` function from Vertex to XYCoords.
  * @modified 2021-12-01 Changed the type of param of `scale` to XYCoords.
  * @modified 2021-12-01 Added function `scaleXY` for non uniform scaling.
- * @version  2.5.0
+ * @modified 2021-12-17 Added the functions `lerp` and `lerpAbs` for linear interpolations.
+ * @version  2.6.0
  *
  * @file Vertex
  * @public
@@ -421,6 +422,45 @@ export class Vertex implements XYCoords, SVGSerializable {
     return this.scaleXY({ x: factor, y: factor }, center);
   }
 
+  /**
+   * Perform a linear interpolation towards the given target vertex.
+   * The amount value `t` is relative, `t=0.0` means no change, `t=1.0`
+   * means this point will be moved to the exact target position.
+   *
+   * `t=0.5` will move this point to the middle of the connecting
+   * linear segment.
+   *
+   * @param {XYCoords} target - The target position to lerp this vertex to.
+   * @param {number} t - The relative amount, usually in [0..1], but other values will work, too.
+   * @returns
+   */
+  lerp(target: XYCoords, t: number): Vertex {
+    var diff = this.difference(target);
+    // return new Vertex(this.x + diff.x * t, this.y + diff.y * t);
+    this.x += diff.x * t;
+    this.y += diff.y * t;
+    return this;
+  }
+
+  /**
+   * Perform a linear interpolation towards the given target vertex (absolute variant).
+   * The amount value `t` is absolute, which means the lerp amount is a direct distance
+   * value. This point will have move the amount of the passed distance `u`.
+   *
+   * @param {XYCoords} target - The target position to lerp this vertex to.
+   * @param {number} t - The absolute move amount to use to lerping.
+   * @returns
+   */
+  lerpAbs(target: XYCoords, u: number): Vertex {
+    var dist = this.distance(target);
+    var diff = this.difference(target);
+    var step = { x: diff.x / dist, y: diff.y / dist };
+    // return new Vertex(this.x + step.x * u, this.y + step.y * u);
+    this.x += step.x * u;
+    this.y += step.y * u;
+    return this;
+  }
+
   /**
    * This is a vector-like behavior and 'scales' this vertex
    * towards/from a given center by two independent x- and y- scale factors.

package/src/ts/utils/findInVertexArray.ts

@@ -0,0 +1,28 @@
+/**
+ * @author  Ikaros Kappler
+ * @date    2022-01-10
+ * @version 1.0.0
+ */
+
+import { Vertex } from "../Vertex";
+import { XYCoords } from "../interfaces";
+
+/**
+ * In an array of vertices find the first occurence of a specific vertex, using
+ * and epsilon tolerance.
+ *
+ * @param {Array<Vertex>} vertexList - The vertex array to search in.
+ * @param {XYCoords} vertex - A vertex/position to search for. This can be any x-y-tuple and does not
+ *                              necessarily need to be an instance of Vertex.
+ * @param {number} epsilon - The epsilon tolerance to use (should be >= 0). This is a required param to avoid excessive
+ *                              is-undef checking if this function runs in a loop.
+ * @returns {boolean} - The first index of a vertex that matched or -1 if no such vertex could be found.
+ */
+export const findInVertexArray = (vertexList: Array<Vertex>, vertex: XYCoords, epsilon: number): number => {
+  for (var i = 0; i < vertexList.length; i++) {
+    if (vertexList[i].distance(vertex) < epsilon) {
+      return i;
+    }
+  }
+  return -1;
+};

package/src/ts/utils/algorithms/sh-tmp.ts~

@@ -1,59 +0,0 @@
-
-interface XYCoords  {
-    x : number;
-    y : number;
-}
-
-const inside = ( cp1 : XYCoords, cp2 : XYCoords, p : XYCoords) : boolean => {
-    return (cp2.x-cp1.x)*(p.y-cp1.y) > (cp2.y-cp1.y)*(p.x-cp1.x);
-};
-
-const intersection = ( cp1 : XYCoords ,cp2 : XYCoords ,s : XYCoords, e : XYCoords ) : XYCoords => {
-    const dc = {
-	x:  cp1.x - cp2.x,
-	y : cp1.y - cp2.y
-	 },
-    dp = { x: s.x - e.x,
-	   y : s.y - e.y
-	 },
-    n1 = cp1.x * cp2.y - cp1.y * cp2.x,
-    n2 = s.x * e.y - s.y * e.x, 
-    n3 = 1.0 / (dc.x * dp.y - dc.y * dp.x);
-    return { x : (n1*dp.x - n2*dc.x) * n3,
-	     y : (n1*dp.y - n2*dc.y) * n3
-	   };
-};
-
-export const sutherlandHodgman = ( subjectPolygon : Array<XYCoords>,
-				   clipPolygon : Array<XYCoords> ) : Array<XYCoords> => {
-    
-    let cp1 : XYCoords = clipPolygon[clipPolygon.length-1];
-    let cp2 : XYCoords;
-    let s : XYCoords;
-    let e : XYCoords;
-    
-    let outputList : Array<XYCoords> = subjectPolygon;
-    
-    for( var j in clipPolygon ) {
-        cp2 = clipPolygon[j];
-        var inputList = outputList;
-        outputList = [];
-        s = inputList[inputList.length - 1]; // last on the input list
-        for (var i in inputList) {
-	    e = inputList[i];
-	    if (inside(cp1,cp2,e)) {
-                if (!inside(cp1,cp2,s)) {
-		    outputList.push(intersection(cp1,cp2,s,e));
-                }
-                outputList.push(e);
-	    }
-	    else if (inside(cp1,cp2,s)) {
-                outputList.push(intersection(cp1,cp2,s,e));
-	    }
-	    s = e;
-        }
-        cp1 = cp2;
-    }
-    return outputList
-}
-