plotboilerplate 1.27.1 → 1.28.1

package/src/ts/utils/algorithms/HobbyPath.ts

@@ -20,10 +20,9 @@ import { CubicBezierCurve } from "../../CubicBezierCurve";
 import { Vertex } from "../../Vertex";
 
 interface IControlPoints {
-    startControlPoints : Array<Vertex>;
-    endControlPoints : Array<Vertex>;
-};
-
+  startControlPoints: Array<Vertex>;
+  endControlPoints: Array<Vertex>;
+}
 
 /**
  * @classdesc A HobbyCurve/HobbyPath calculation class: compute a set of optimal
@@ -33,281 +32,258 @@ interface IControlPoints {
  * @requires Vertex
  */
 export class HobbyPath {
+  /**
+   * @member {Array<Vertex>} vertices
+   * @memberof HobbyPath
+   * @type {Array<Vertex>}
+   * @instance
+   **/
+  private vertices: Array<Vertex>;
 
-    /**
-     * @member {Array<Vertex>} vertices
-     * @memberof HobbyPath
-     * @type {Array<Vertex>}
-     * @instance
-     **/
-    private vertices : Array<Vertex>;
-
-    /**
-     * @constructor
-     * @name HobbyPath
-     * @param {Array<Vertex>=} vertices? - An optional array of vertices to initialize the path with.
-     **/
-    constructor( vertices?:Array<Vertex> ) {
-	this.vertices = vertices ? vertices : [];
-    };
+  /**
+   * @constructor
+   * @name HobbyPath
+   * @param {Array<Vertex>=} vertices? - An optional array of vertices to initialize the path with.
+   **/
+  constructor(vertices?: Array<Vertex>) {
+    this.vertices = vertices ? vertices : [];
+  }
 
+  /**
+   * Add a new point to the end of the vertex sequence.
+   *
+   * @name addPoint
+   * @memberof HobbyPath
+   * @instance
+   * @param {Vertex} p - The vertex (point) to add.
+   **/
+  addPoint(p: Vertex): void {
+    this.vertices.push(p);
+  }
 
-    /**
-     * Add a new point to the end of the vertex sequence.
-     *
-     * @name addPoint
-     * @memberof HobbyPath
-     * @instance
-     * @param {Vertex} p - The vertex (point) to add.
-     **/
-    addPoint(p: Vertex) : void {
-	this.vertices.push( p );
-    };
+  /**
+   * Generate a sequence of cubic Bézier curves from the point set.
+   *
+   * @name generateCurve
+   * @memberof HobbyPath
+   * @instance
+   * @param {boolean=} circular - Specify if the path should be closed.
+   * @param {number=0} omega - (default=0) An optional tension parameter.
+   * @return Array<CubicBezierCurve>
+   **/
+  generateCurve(circular?: boolean, omega?: number): Array<CubicBezierCurve> {
+    let n: number = this.vertices.length;
+    if (n > 1) {
+      if (n == 2) {
+        // for two points, just draw a straight line
+        return [new CubicBezierCurve(this.vertices[0], this.vertices[1], this.vertices[0], this.vertices[1])];
+      } else {
+        const curves: Array<CubicBezierCurve> = [];
+        let controlPoints = this.hobbyControls(circular, omega);
+        for (let i = 0; i < n - (circular ? 0 : 1); i++) {
+          // if i is n-1, the "next" point is the first one
+          let j: number = (i + 1) % n; // Use a succ function here?
+          curves.push(
+            new CubicBezierCurve(
+              this.vertices[i],
+              this.vertices[j],
+              controlPoints.startControlPoints[i],
+              controlPoints.endControlPoints[i]
+            )
+          );
+        }
+        return curves;
+      }
+    } else {
+      return [];
+    }
+  }
 
+  /**
+   * Computes the control point coordinates for a Hobby curve through
+   * the points given.
+   *
+   * @name hobbyControls
+   * @memberof HobbyPath
+   * @instance
+   * @param {boolean}  circular - If true, then the path will be closed.
+   * @param {number=0} omega    - The 'curl' or the path.
+   * @return {IControlPoints} An object with two members: startControlPoints and endControlPoints (Array<Vertex>).
+   **/
+  private hobbyControls(circular?: boolean, omega?: number): IControlPoints {
+    // This is a version that works for both, closed and non-closed paths.
 
-    /**
-     * Generate a sequence of cubic Bézier curves from the point set.
-     *
-     * @name generateCurve
-     * @memberof HobbyPath
-     * @instance
-     * @param {boolean=} circular - Specify if the path should be closed.
-     * @param {number=0} omega - (default=0) An optional tension parameter.
-     * @return Array<CubicBezierCurve>
-     **/
-    generateCurve( circular?:boolean, omega?:number ) : Array<CubicBezierCurve> {
-	let n : number = this.vertices.length;	
-	if (n > 1) {
-	    if (n == 2) {
-		// for two points, just draw a straight line
-		return [ new CubicBezierCurve(
-		    this.vertices[0],
-		    this.vertices[1],
-		    this.vertices[0],
-		    this.vertices[1] 
-		) ];
-	    } else {
-		const curves : Array<CubicBezierCurve> = [];
-		let controlPoints = this.hobbyControls(circular,omega);
-		for (let i = 0; i < n - (circular?0:1); i++) {
-		    // if i is n-1, the "next" point is the first one
-		    let j : number = (i+1) % n; // Use a succ function here?
-		    curves.push( new CubicBezierCurve(
-			this.vertices[i],
-			this.vertices[j],
-			controlPoints.startControlPoints[i], 
-			controlPoints.endControlPoints[i] 
-		    ) );
-		}
-		return curves;
-	    }
-	} else {
-	    return [];
-	}	
-    };
-    
+    if (typeof omega === "undefined") omega = 0;
 
-    /**
-     * Computes the control point coordinates for a Hobby curve through
-     * the points given.
-     *
-     * @name hobbyControls
-     * @memberof HobbyPath
-     * @instance
-     * @param {boolean}  circular - If true, then the path will be closed.
-     * @param {number=0} omega    - The 'curl' or the path.
-     * @return {IControlPoints} An object with two members: startControlPoints and endControlPoints (Array<Vertex>).
-     **/
-    private hobbyControls(circular?:boolean, omega?:number) : IControlPoints {
-	// This is a version that works for both, closed and non-closed paths.
+    let n: number = this.vertices.length - (circular ? 0 : 1);
+    let D: Array<number> = new Array<number>(n);
 
-	if( typeof omega === 'undefined' )
-	    omega = 0;
-	
-	let n : number = this.vertices.length - (circular ? 0 : 1);
-	let D : Array<number> = new Array<number>(n);
+    let ds: Array<Vertex> = new Array<Vertex>(n);
+    var succ = (i: number): number => {
+      return circular ? (i + 1) % n : i + 1;
+    };
+    var pred = (i: number): number => {
+      return circular ? (i + n - 1) % n : i - 1;
+    };
 
-	let ds : Array<Vertex> = new Array<Vertex>(n);
-	var succ = (i:number) : number => { return circular ? ((i+1)%n) : (i+1) };
-	var pred = (i:number) : number => { return circular ? ((i + n - 1) % n) : (i-1) };
-				 	
-	for (let i = 0; i < n; i++) {
-	    // the "next" point in a modular way
-	    let j : number = succ(i);
-	    ds[i] = this.vertices[i].difference( this.vertices[j] );
-	    D[i] = Math.sqrt(ds[i].x*ds[i].x+ds[i].y*ds[i].y);
-	}
-	let gamma : Array<number> = new Array(n + (circular?0:1));
-	for (let i = (circular?0:1); i < n; i++) {
-	    // the "previous" point in a modular way
-	    let k : number = pred(i);
-	    let sin = ds[k].y / D[k];
-	    let cos = ds[k].x / D[k];
-	    let vec = HobbyPath.utils.rotate(ds[i], -sin, cos);
-	    gamma[i] = Math.atan2(vec.y, vec.x);
-	}
-	if( !circular )
-	    gamma[n] = 0;
-	let a : Array<number> = new Array(n + (circular?0:1));
-	let b : Array<number> = new Array(n + (circular?0:1));
-	let c : Array<number> = new Array(n + (circular?0:1));
-	let d : Array<number> = new Array(n + (circular?0:1));
-	for (let i = (circular?0:1); i < n; i++) {
-	    // j is the "next" point, k the "previous" one
-	    let j : number = succ(i);
-	    let k : number = pred(i);
-	    // see video for the equations
-	    a[i] = 1 / D[k];
-	    b[i] = (2*D[k]+2*D[i])/(D[k]*D[i]);
-	    c[i] = 1 / D[i];
-	    d[i] = -(2*gamma[i]*D[i]+gamma[j]*D[k])/(D[k]*D[i]);
-	} 
-	// make matrix tridiagonal in preparation for the "sherman" function
-	var alpha : Array<number>;
-	var beta : Array<number>;
-	if( circular ) {
-	    let s : number = a[0]*omega; // Use omega here?
-	    a[0] = 0;
-	    let t : number = c[n-1]*omega; // Use omega here?
-	    c[n-1] = 0;
-	    alpha = HobbyPath.utils.sherman(a, b, c, d, s, t);
-	    beta = new Array<number>(n);
-	    for (let i = 0; i < n - (circular?0:1); i++) {
-		// "next" point
-		let j : number = succ(i);
-		beta[i] = -gamma[j]-alpha[j];
-	    }
-	} else {
-	    // see the Jackowski article for the following values; the result
-	    // will be that the curvature at the first point is identical to the
-	    // curvature at the second point (and likewise for the last and
-	    // second-to-last)
-	    b[0] = 2 + omega;
-	    c[0] = 2 * omega + 1;
-	    d[0] = -c[0] * gamma[1];
-	    a[n] = 2 * omega + 1;
-	    b[n] = 2 + omega;
-	    d[n] = 0;
-	    // solve system for the angles called "alpha" in the video
-	    alpha = HobbyPath.utils.thomas(a, b, c, d);
-	    // compute "beta" angles from "alpha" angles
-	    beta = new Array<number>(n);
-	    for (let i = 0; i < n - 1; i++)
-		beta[i] = -gamma[i+1]-alpha[i+1];
-	    // again, see Jackowski article
-	    beta[n-1] = -alpha[n];
-	}
-	let startControlPoints = new Array<Vertex>(n);
-	let endControlPoints = new Array<Vertex>(n);
-	for (let i = 0; i < n; i++) {
-	    let j : number = succ(i);
-	    let a : number = HobbyPath.utils.rho(alpha[i], beta[i]) * D[i] / 3;
-	    let b : number = HobbyPath.utils.rho(beta[i], alpha[i]) * D[i] / 3;
-	    let v : Vertex = HobbyPath.utils.normalize(HobbyPath.utils.rotateAngle(ds[i], alpha[i]));
-	    startControlPoints[i] = new Vertex( this.vertices[i].x + a * v.x, this.vertices[i].y + a * v.y );
-	    v = HobbyPath.utils.normalize(HobbyPath.utils.rotateAngle(ds[i], -beta[i]));
-	    endControlPoints[i] = new Vertex( this.vertices[j].x - b * v.x, this.vertices[j].y - b * v.y );
-	}
-	return { startControlPoints : startControlPoints,
-		 endControlPoints: endControlPoints
-	       };
+    for (let i = 0; i < n; i++) {
+      // the "next" point in a modular way
+      let j: number = succ(i);
+      ds[i] = this.vertices[i].difference(this.vertices[j]);
+      D[i] = Math.sqrt(ds[i].x * ds[i].x + ds[i].y * ds[i].y);
+    }
+    let gamma: Array<number> = new Array(n + (circular ? 0 : 1));
+    for (let i = circular ? 0 : 1; i < n; i++) {
+      // the "previous" point in a modular way
+      let k: number = pred(i);
+      let sin = ds[k].y / D[k];
+      let cos = ds[k].x / D[k];
+      let vec = HobbyPath.utils.rotate(ds[i], -sin, cos);
+      gamma[i] = Math.atan2(vec.y, vec.x);
+    }
+    if (!circular) gamma[n] = 0;
+    let a: Array<number> = new Array(n + (circular ? 0 : 1));
+    let b: Array<number> = new Array(n + (circular ? 0 : 1));
+    let c: Array<number> = new Array(n + (circular ? 0 : 1));
+    let d: Array<number> = new Array(n + (circular ? 0 : 1));
+    for (let i = circular ? 0 : 1; i < n; i++) {
+      // j is the "next" point, k the "previous" one
+      let j: number = succ(i);
+      let k: number = pred(i);
+      // see video for the equations
+      a[i] = 1 / D[k];
+      b[i] = (2 * D[k] + 2 * D[i]) / (D[k] * D[i]);
+      c[i] = 1 / D[i];
+      d[i] = -(2 * gamma[i] * D[i] + gamma[j] * D[k]) / (D[k] * D[i]);
+    }
+    // make matrix tridiagonal in preparation for the "sherman" function
+    var alpha: Array<number>;
+    var beta: Array<number>;
+    if (circular) {
+      let s: number = a[0] * omega; // Use omega here?
+      a[0] = 0;
+      let t: number = c[n - 1] * omega; // Use omega here?
+      c[n - 1] = 0;
+      alpha = HobbyPath.utils.sherman(a, b, c, d, s, t);
+      beta = new Array<number>(n);
+      for (let i = 0; i < n - (circular ? 0 : 1); i++) {
+        // "next" point
+        let j: number = succ(i);
+        beta[i] = -gamma[j] - alpha[j];
+      }
+    } else {
+      // see the Jackowski article for the following values; the result
+      // will be that the curvature at the first point is identical to the
+      // curvature at the second point (and likewise for the last and
+      // second-to-last)
+      b[0] = 2 + omega;
+      c[0] = 2 * omega + 1;
+      d[0] = -c[0] * gamma[1];
+      a[n] = 2 * omega + 1;
+      b[n] = 2 + omega;
+      d[n] = 0;
+      // solve system for the angles called "alpha" in the video
+      alpha = HobbyPath.utils.thomas(a, b, c, d);
+      // compute "beta" angles from "alpha" angles
+      beta = new Array<number>(n);
+      for (let i = 0; i < n - 1; i++) beta[i] = -gamma[i + 1] - alpha[i + 1];
+      // again, see Jackowski article
+      beta[n - 1] = -alpha[n];
     }
+    let startControlPoints = new Array<Vertex>(n);
+    let endControlPoints = new Array<Vertex>(n);
+    for (let i = 0; i < n; i++) {
+      let j: number = succ(i);
+      let a: number = (HobbyPath.utils.rho(alpha[i], beta[i]) * D[i]) / 3;
+      let b: number = (HobbyPath.utils.rho(beta[i], alpha[i]) * D[i]) / 3;
+      let v: Vertex = HobbyPath.utils.normalize(HobbyPath.utils.rotateAngle(ds[i], alpha[i]));
+      startControlPoints[i] = new Vertex(this.vertices[i].x + a * v.x, this.vertices[i].y + a * v.y);
+      v = HobbyPath.utils.normalize(HobbyPath.utils.rotateAngle(ds[i], -beta[i]));
+      endControlPoints[i] = new Vertex(this.vertices[j].x - b * v.x, this.vertices[j].y - b * v.y);
+    }
+    return { startControlPoints: startControlPoints, endControlPoints: endControlPoints };
+  }
 
-    static utils = {
-	// rotates a vector [x, y] about an angle; the angle is implicitly
-	// determined by its sine and cosine
-	rotate : (vert: Vertex,
-		  sin: number,
-		  cos: number) : Vertex => {
-	    return new Vertex( vert.x*cos - vert.y*sin, vert.x*sin + vert.y*cos );
-	},
-	// rotates a vector [x, y] about the angle alpha
-	rotateAngle: (vert: Vertex, alpha: number) : Vertex => {
-	    return HobbyPath.utils.rotate(vert, Math.sin(alpha), Math.cos(alpha));
-	},
-	// returns a normalized version of the vector
-	normalize : (vec: Vertex) : Vertex => {
-	    let n = Math.hypot(vec.x, vec.y);
-	    if (n == 0)
-		return new Vertex(0,0);
-	    else
-		return new Vertex( vec.x/n, vec.y/n ); // TODO: do in-place
-	},
-	// the "velocity function" (also called rho in the video); a and b are
-	// the angles alpha and beta, the return value is the distance between
-	// a control point and its neighboring point; to compute sigma(a,b)
-	// we'll simply use rho(b,a)
-	rho : (a: number ,
-	       b: number) : number => {
-	    // see video for formula
-	    let sa = Math.sin(a);
-	    let sb = Math.sin(b);
-	    let ca = Math.cos(a);
-	    let cb = Math.cos(b);
-	    let s5 = Math.sqrt(5);
-	    let num = 4 + Math.sqrt(8) * (sa - sb/16) * (sb - sa/16) * (ca - cb);
-	    let den = 2 + (s5 - 1) * ca + (3 - s5) * cb;
-	    return num/den;
-	},
-	// Implements the Thomas algorithm for a tridiagonal system with i-th
-	// row a[i]x[i-1] + b[i]x[i] + c[i]x[i+1] = d[i] starting with row
-	// i=0, ending with row i=n-1 and with a[0] = c[n-1] = 0.  Returns the
-	// values x[i] as an array.
-	thomas : (a: Array<number>,
-		  b: Array<number>,
-		  c: Array<number>,
-		  d: Array<number>) : Array<number> => {
-	    let n : number = a.length;
-	    let cc : Array<number> = new Array<number>(n);
-	    let dd : Array<number> = new Array<number>(n);
-	    // forward sweep
-	    cc[0] = c[0] / b[0];
-	    dd[0] = d[0] / b[0];
-	    for (let i = 1; i < n; i++) {
-		let den : number = b[i] - cc[i-1]*a[i];
-		cc[i] = c[i] / den;
-		dd[i] = (d[i] - dd[i-1]*a[i]) / den;
-	    }
-	    let x : Array<number> = new Array<number>(n);
-	    // back substitution
-	    x[n-1] = dd[n-1];
-	    for (let i = n-2; i >= 0; i--)
-		x[i] = dd[i] - cc[i]*x[i+1];
-	    return x;
-	},
-	// Solves an "almost" tridiagonal linear system with i-th row
-	// a[i]x[i-1] + b[i]x[i] + c[i]x[i+1] = d[i] starting with row i=0,
-	// ending with row i=n-1 and with a[0] = c[n-1] = 0.  Returns the
-	// values x[i] as an array.  The system is not really tridiagonal
-	// because the 0-th row is b[0]x[0] + c[0]x[1] + sx[n-1] = d[0] and
-	// row n-1 is tx[0] + a[n-1]x[n-2] + b[n-1]x[n-1] = d[n-1].  The
-	// Sherman-Morrison-Woodbury formula is used so that the function
-	// "thomas" can be called to solve the system.
-	sherman : ( a: Array<number>,
-		    b: Array<number>,
-		    c: Array<number>,
-		    d: Array<number>,
-		    s: number ,
-		    t: number) : Array<number> => {
-	    const n : number = a.length;
-	    const u : Array<number> = new Array<number>(n);
-	    u.fill(0, 1, n-1);
-	    u[0] = 1;
-	    u[n-1] = 1;
-	    let v : Array<number> = new Array<number>(n);
-	    v.fill(0, 1, n-1);
-	    v[0] = t;
-	    v[n-1] = s;
-	    b[0] -= t;
-	    b[n-1] -= s;
-	    // this would be more efficient if computed in parallel, but hey...
-	    const Td : Array<number> = HobbyPath.utils.thomas(a, b, c, d);
-	    const Tu : Array<number> = HobbyPath.utils.thomas(a, b, c, u);
-	    const factor : number = (t*Td[0] + s*Td[n-1]) / (1 + t*Tu[0] + s*Tu[n-1]);
-	    const x = new Array(n);
-	    for (let i = 0; i < n; i++)
-		x[i] = Td[i] - factor * Tu[i];
-	    return x;
-	}
-    };
-}; // END class
+  static utils = {
+    // rotates a vector [x, y] about an angle; the angle is implicitly
+    // determined by its sine and cosine
+    rotate: (vert: Vertex, sin: number, cos: number): Vertex => {
+      return new Vertex(vert.x * cos - vert.y * sin, vert.x * sin + vert.y * cos);
+    },
+    // rotates a vector [x, y] about the angle alpha
+    rotateAngle: (vert: Vertex, alpha: number): Vertex => {
+      return HobbyPath.utils.rotate(vert, Math.sin(alpha), Math.cos(alpha));
+    },
+    // returns a normalized version of the vector
+    normalize: (vec: Vertex): Vertex => {
+      let n = Math.hypot(vec.x, vec.y);
+      if (n == 0) return new Vertex(0, 0);
+      else return new Vertex(vec.x / n, vec.y / n); // TODO: do in-place
+    },
+    // the "velocity function" (also called rho in the video); a and b are
+    // the angles alpha and beta, the return value is the distance between
+    // a control point and its neighboring point; to compute sigma(a,b)
+    // we'll simply use rho(b,a)
+    rho: (a: number, b: number): number => {
+      // see video for formula
+      let sa = Math.sin(a);
+      let sb = Math.sin(b);
+      let ca = Math.cos(a);
+      let cb = Math.cos(b);
+      let s5 = Math.sqrt(5);
+      let num = 4 + Math.sqrt(8) * (sa - sb / 16) * (sb - sa / 16) * (ca - cb);
+      let den = 2 + (s5 - 1) * ca + (3 - s5) * cb;
+      return num / den;
+    },
+    // Implements the Thomas algorithm for a tridiagonal system with i-th
+    // row a[i]x[i-1] + b[i]x[i] + c[i]x[i+1] = d[i] starting with row
+    // i=0, ending with row i=n-1 and with a[0] = c[n-1] = 0.  Returns the
+    // values x[i] as an array.
+    thomas: (a: Array<number>, b: Array<number>, c: Array<number>, d: Array<number>): Array<number> => {
+      let n: number = a.length;
+      let cc: Array<number> = new Array<number>(n);
+      let dd: Array<number> = new Array<number>(n);
+      // forward sweep
+      cc[0] = c[0] / b[0];
+      dd[0] = d[0] / b[0];
+      for (let i = 1; i < n; i++) {
+        let den: number = b[i] - cc[i - 1] * a[i];
+        cc[i] = c[i] / den;
+        dd[i] = (d[i] - dd[i - 1] * a[i]) / den;
+      }
+      let x: Array<number> = new Array<number>(n);
+      // back substitution
+      x[n - 1] = dd[n - 1];
+      for (let i = n - 2; i >= 0; i--) x[i] = dd[i] - cc[i] * x[i + 1];
+      return x;
+    },
+    // Solves an "almost" tridiagonal linear system with i-th row
+    // a[i]x[i-1] + b[i]x[i] + c[i]x[i+1] = d[i] starting with row i=0,
+    // ending with row i=n-1 and with a[0] = c[n-1] = 0.  Returns the
+    // values x[i] as an array.  The system is not really tridiagonal
+    // because the 0-th row is b[0]x[0] + c[0]x[1] + sx[n-1] = d[0] and
+    // row n-1 is tx[0] + a[n-1]x[n-2] + b[n-1]x[n-1] = d[n-1].  The
+    // Sherman-Morrison-Woodbury formula is used so that the function
+    // "thomas" can be called to solve the system.
+    sherman: (a: Array<number>, b: Array<number>, c: Array<number>, d: Array<number>, s: number, t: number): Array<number> => {
+      const n: number = a.length;
+      const u: Array<number> = new Array<number>(n);
+      u.fill(0, 1, n - 1);
+      u[0] = 1;
+      u[n - 1] = 1;
+      let v: Array<number> = new Array<number>(n);
+      v.fill(0, 1, n - 1);
+      v[0] = t;
+      v[n - 1] = s;
+      b[0] -= t;
+      b[n - 1] -= s;
+      // this would be more efficient if computed in parallel, but hey...
+      const Td: Array<number> = HobbyPath.utils.thomas(a, b, c, d);
+      const Tu: Array<number> = HobbyPath.utils.thomas(a, b, c, u);
+      const factor: number = (t * Td[0] + s * Td[n - 1]) / (1 + t * Tu[0] + s * Tu[n - 1]);
+      const x = new Array(n);
+      for (let i = 0; i < n; i++) x[i] = Td[i] - factor * Tu[i];
+      return x;
+    }
+  };
+} // END class