plotboilerplate 1.29.0 → 1.31.0

package/src/ts/utils/datastructures/VoronoiCell.ts

@@ -1,5 +1,5 @@
 /**
- * @classdesc A simple voronoi cell (part of a voronoi diagram), stored as an array of 
+ * @classdesc A simple voronoi cell (part of a voronoi diagram), stored as an array of
  * adjacent triangles.
  *
  * @requires Line
@@ -10,13 +10,14 @@
  * @author   Ikaros Kappler
  * @date     2018-04-11
  * @modified 2018-05-04 Added the 'sharedVertex' param to the constructor. Extended open cells into 'infinity'.
- * @modified 2019-10-25 Fixed a serious bug in the toPathArray function; cell with only one vertex (extreme cases) returned invalid arrays which broke the rendering. 
+ * @modified 2019-10-25 Fixed a serious bug in the toPathArray function; cell with only one vertex (extreme cases) returned invalid arrays which broke the rendering.
  * @modified 2019-12-09 Removed an unnecesary if-condition from the _calculateOpenEdgePoint(...) helper function.
  * @modified 2020-05-18 Added function VoronoiCell.toPolygon().
  * @modified 2020-08-12 Ported this class from vanilla JS to TypeScript.
  * @modified 2020-08-17 Added some missing type declarations.
  * @modified 2021-01-20 Members `triangles` and `sharedVertex` are now public.
- * @version  1.1.3
+ * @modified 2026-09-15 Added the `VoronoiCell.sharedVertexIndex` attribute.
+ * @version  1.2.0
  *
  * @file VoronoiCell
  * @public
@@ -28,174 +29,202 @@ import { Triangle } from "../../Triangle";
 import { Vertex } from "../../Vertex";
 
 export class VoronoiCell {
+  /**
+   * @member {Array<Triangle>} triangles
+   * @memberof VoronoiCell
+   * @type {Array<Triangle>}
+   * @instance
+   */
+  triangles: Array<Triangle>;
 
-    /**
-     * @member {Array<Triangle>} triangles
-     * @memberof VoronoiCell
-     * @type {Array<Triangle>}
-     * @instance
-     */
-    triangles: Array<Triangle>;
-
-    /**
-     * @member {Vertex} sharedVertex
-     * @memberof VoronoiCell
-     * @type {Vertex}
-     * @instance
-     */
-    sharedVertex: Vertex;
-    
-    /**
-     * The constructor.
-     *
-     * @constructor
-     * @name VoronoiCell
-     * @param {Triangle[]} triangles    The passed triangle array must contain an ordered sequence of
-     *                                  adjacent triangles.
-     * @param {Vertex}     sharedVertex This is the 'center' of the voronoi cell; all triangles must share
-     *                                  that vertex.
-     **/
-    constructor( triangles:Array<Triangle>, sharedVertex:Vertex ) {
-	if( typeof triangles === 'undefined' )
-	    triangles = [];
-	if( typeof sharedVertex === 'undefined' )
-	    sharedVertex = new Vertex(0,0);
-	this.triangles = triangles;
-	this.sharedVertex = sharedVertex;
-    };
-
-    
-    /**
-     * Check if the first and the last triangle in the path are NOT connected.
-     *
-     * @method isOpen
-     * @instance
-     * @memberof VoronoiCell
-     * @return {boolean}
-     **/
-    isOpen() : boolean {
-	// There must be at least three triangles
-	return this.triangles.length < 3 || !this.triangles[0].isAdjacent(this.triangles[this.triangles.length-1]);	   
-    };
-
-    
-    /**
-     * Convert this Voronoi cell to a path polygon, consisting of all Voronoi cell corner points.
-     *
-     * Note that open Voronoi cell cannot properly converted to Polygons as they are considered
-     * infinite. 'Open' Voronoi edges will be cut off at their innermose vertices.
-     *
-     * @method toPolygon
-     * @instance
-     * @memberof VoronoiCell
-     * @return {Polygon} 
-     **/
-    toPolygon() : Polygon {
-	return new Polygon( this.toPathArray(), this.isOpen() );
-    };
-
-    /**
-     * Convert the voronoi cell path data to an SVG polygon data string.
-     *
-     * "x0,y0 x1,y1 x2,y2 ..." 
-     *
-     * @method toPathSVGString
-     * @instance
-     * @memberof VoronoiCell
-     * @return {string}
-     **/
-    toPathSVGString() : string {
-	if( this.triangles.length == 0 )
-	    return "";	
-	const arr: Array<Vertex>= this.toPathArray();
-	return arr.map( (vert:Vertex) => { return ''+vert.x+','+vert.y; } ).join(' '); 
-    };
-
-
-    /**
-     * Convert the voronoi cell path data to an array.
-     *
-     * [vertex0, vertex1, vertex2, ... ] 
-     *
-     * @method toPathArray
-     * @instance
-     * @memberof VoronoiCell
-     * @return {Vertex[]}
-     **/
-    toPathArray() : Array<Vertex> {	
-	if( this.triangles.length == 0 )
-	    return [];
-	if( this.triangles.length == 1 )
-	    return [ this.triangles[0].getCircumcircle().center ];	
-	const arr : Array<Vertex> = [];
-
-	// Working for path begin
-	if( false && this.isOpen() ) 
-	    arr.push( VoronoiCell._calcOpenEdgePoint( this.triangles[0], this.triangles[1], this.sharedVertex ) );
-	
-	for( var t = 0; t < this.triangles.length; t++ ) {
-	    var cc = this.triangles[t].getCircumcircle();
-	    arr.push( cc.center );
-	}
-
-	// Urgh, this is not working right now.
-	/* if( false && this.isOpen() ) 
+  /**
+   * @member {Vertex} sharedVertex
+   * @memberof VoronoiCell
+   * @type {Vertex}
+   * @instance
+   */
+  sharedVertex: Vertex;
+
+  /**
+   *
+   */
+  sharedVertexIndex: number;
+
+  /**
+   * The constructor.
+   *
+   * @constructor
+   * @name VoronoiCell
+   * @param {Triangle[]} triangles    The passed triangle array must contain an ordered sequence of
+   *                                  adjacent triangles.
+   * @param {Vertex}     sharedVertex This is the 'center' of the voronoi cell; all triangles must share
+   *                                  that vertex.
+   **/
+  constructor(triangles: Array<Triangle>, sharedVertex: Vertex, sharedVertexIndex: number) {
+    if (typeof triangles === "undefined") triangles = [];
+    if (typeof sharedVertex === "undefined") sharedVertex = new Vertex(0, 0);
+    this.triangles = triangles;
+    this.sharedVertex = sharedVertex;
+    this.sharedVertexIndex = sharedVertexIndex;
+  }
+
+  /**
+   * Check if the first and the last triangle in the path are NOT connected.
+   *
+   * @method isOpen
+   * @instance
+   * @memberof VoronoiCell
+   * @return {boolean}
+   **/
+  isOpen(): boolean {
+    // There must be at least three triangles
+    return this.triangles.length < 3 || !this.triangles[0].isAdjacent(this.triangles[this.triangles.length - 1]);
+  }
+
+  /**
+   * Convert this Voronoi cell to a path polygon, consisting of all Voronoi cell corner points.
+   *
+   * Note that open Voronoi cell cannot properly converted to Polygons as they are considered
+   * infinite. 'Open' Voronoi edges will be cut off at their innermose vertices.
+   *
+   * @method toPolygon
+   * @instance
+   * @memberof VoronoiCell
+   * @return {Polygon}
+   **/
+  toPolygon(): Polygon {
+    return new Polygon(this.toPathArray(), this.isOpen());
+  }
+
+  /**
+   * Get all 'umbrella' triangles for this Voronoi cell.
+   *
+   * The 'umbrella' is that sequence of triangles that covers the whole Voronoi cell and
+   * meet in the cell's centroid.
+   *
+   * @method getUmbrellaTriangles
+   * @instance
+   * @memberof VoronoiCell
+   * @return {Array<Triangle>}
+   **/
+  getUmbrellaTriangles(): Array<Triangle> {
+    var tris: Array<Triangle> = [];
+    // for (var i = 0; i < this.triangles.length; i++) {
+    //   var delaunayTri = this.triangles[i];
+    //   var tri = new Triangle(this.sharedVertex, delaunayTri.b, delaunayTri.c);
+    //   tris.push(tri);
+    // }
+    var vertices = this.toPathArray();
+    var n = vertices.length;
+    for (var i = 0; i < n; i++) {
+      var tri = new Triangle(this.sharedVertex, vertices[i], vertices[(i + 1) % n]);
+      tris.push(tri);
+    }
+
+    return tris;
+  }
+
+  /**
+   * Convert the voronoi cell path data to an SVG polygon data string.
+   *
+   * "x0,y0 x1,y1 x2,y2 ..."
+   *
+   * @method toPathSVGString
+   * @instance
+   * @memberof VoronoiCell
+   * @return {string}
+   **/
+  toPathSVGString(): string {
+    if (this.triangles.length == 0) return "";
+    const arr: Array<Vertex> = this.toPathArray();
+    return arr
+      .map((vert: Vertex) => {
+        return "" + vert.x + "," + vert.y;
+      })
+      .join(" ");
+  }
+
+  /**
+   * Convert the voronoi cell path data to an array.
+   *
+   * [vertex0, vertex1, vertex2, ... ]
+   *
+   * @method toPathArray
+   * @instance
+   * @memberof VoronoiCell
+   * @return {Vertex[]}
+   **/
+  toPathArray(): Array<Vertex> {
+    if (this.triangles.length == 0) return [];
+    if (this.triangles.length == 1) return [this.triangles[0].getCircumcircle().center];
+    const arr: Array<Vertex> = [];
+
+    // Working for path begin
+    if (false && this.isOpen()) arr.push(VoronoiCell._calcOpenEdgePoint(this.triangles[0], this.triangles[1], this.sharedVertex));
+
+    for (var t = 0; t < this.triangles.length; t++) {
+      var cc = this.triangles[t].getCircumcircle();
+      arr.push(cc.center);
+    }
+
+    // Urgh, this is not working right now.
+    /* if( false && this.isOpen() ) 
 	    arr.push( VoronoiCell._calcOpenEdgePoint( this.triangles[ this.triangles.length-1 ], this.triangles[ this.triangles.length-2 ], this.sharedVertex ) );
 	*/
-		
-	return arr;
-    }
 
-    
-
-    /**
-     * A helper function.
-     *  
-     * Calculate the 'infinite' open edge point based on the open path triangle
-     * 'tri' and its neighbour 'neigh'.
-     *
-     * This function is used to determine outer hull points.
-     *
-     * @method _calcOpenEdhePoint
-     * @private
-     * @static
-     * @instance
-     * @memberof VoronoiCell
-     * @return {Vertex}
-     **/
-    private static _calcOpenEdgePoint( tri:Triangle, neigh:Triangle, sharedVertex:Vertex ) : Vertex {
-	const center : Vertex = tri.getCircumcircle().center;
-	// Find non-adjacent edge (=outer edge)
-	const edgePoint : Vertex = VoronoiCell._findOuterEdgePoint( tri, neigh, sharedVertex );
-	// const perpendicular : Vertex = VoronoiCell._perpendicularLinePoint( sharedVertex, edgePoint, center );
-	const perpendicular : Vertex = new Line( sharedVertex, edgePoint ).getClosestPoint( center );
-	// It is not necesary to make a difference on the determinant here
-	const openEdgePoint : Vertex = new Vertex( perpendicular.x + (center.x-perpendicular.x)*1000,
-						   perpendicular.y + (center.y-perpendicular.y)*1000 );
-	return openEdgePoint;
-    };
-    
-    /**
-     * A helper function.
-     *
-     * Find the outer (not adjacent) vertex in triangle 'tri' which has triangle 'neighbour'.
-     *
-     * This function is used to determine outer hull points.
-     *
-     * @return {Vertex}
-     **/
-    private static _findOuterEdgePoint( tri: Triangle, neighbour: Triangle, sharedVertex: Vertex ) : Vertex {
-	if( tri.a.equals(sharedVertex) ) {
-	    if( neighbour.a.equals(tri.b) || neighbour.b.equals(tri.b) || neighbour.c.equals(tri.b) ) return tri.c;
-	    else return tri.b;
-	}
-	if( tri.b.equals(sharedVertex) ) {
-	    if( neighbour.a.equals(tri.a) || neighbour.b.equals(tri.a) || neighbour.c.equals(tri.a) ) return tri.c;
-	    else return tri.a;
-	}
-	// Here:
-	//    tri.c.equals(sharedVertex) 
-	if( neighbour.a.equals(tri.a) || neighbour.b.equals(tri.a) || neighbour.c.equals(tri.a) ) return tri.b;
-	else return tri.a;
-    };
+    return arr;
+  }
+
+  /**
+   * A helper function.
+   *
+   * Calculate the 'infinite' open edge point based on the open path triangle
+   * 'tri' and its neighbour 'neigh'.
+   *
+   * This function is used to determine outer hull points.
+   *
+   * @method _calcOpenEdhePoint
+   * @private
+   * @static
+   * @instance
+   * @memberof VoronoiCell
+   * @return {Vertex}
+   **/
+  private static _calcOpenEdgePoint(tri: Triangle, neigh: Triangle, sharedVertex: Vertex): Vertex {
+    const center: Vertex = tri.getCircumcircle().center;
+    // Find non-adjacent edge (=outer edge)
+    const edgePoint: Vertex = VoronoiCell._findOuterEdgePoint(tri, neigh, sharedVertex);
+    // const perpendicular : Vertex = VoronoiCell._perpendicularLinePoint( sharedVertex, edgePoint, center );
+    const perpendicular: Vertex = new Line(sharedVertex, edgePoint).getClosestPoint(center);
+    // It is not necesary to make a difference on the determinant here
+    const openEdgePoint: Vertex = new Vertex(
+      perpendicular.x + (center.x - perpendicular.x) * 1000,
+      perpendicular.y + (center.y - perpendicular.y) * 1000
+    );
+    return openEdgePoint;
+  }
+
+  /**
+   * A helper function.
+   *
+   * Find the outer (not adjacent) vertex in triangle 'tri' which has triangle 'neighbour'.
+   *
+   * This function is used to determine outer hull points.
+   *
+   * @return {Vertex}
+   **/
+  private static _findOuterEdgePoint(tri: Triangle, neighbour: Triangle, sharedVertex: Vertex): Vertex {
+    if (tri.a.equals(sharedVertex)) {
+      if (neighbour.a.equals(tri.b) || neighbour.b.equals(tri.b) || neighbour.c.equals(tri.b)) return tri.c;
+      else return tri.b;
+    }
+    if (tri.b.equals(sharedVertex)) {
+      if (neighbour.a.equals(tri.a) || neighbour.b.equals(tri.a) || neighbour.c.equals(tri.a)) return tri.c;
+      else return tri.a;
+    }
+    // Here:
+    //    tri.c.equals(sharedVertex)
+    if (neighbour.a.equals(tri.a) || neighbour.b.equals(tri.a) || neighbour.c.equals(tri.a)) return tri.b;
+    else return tri.a;
+  }
 }

package/src/ts/utils/renderers/VoronoiRenderer.ts

@@ -0,0 +1,200 @@
+/**
+ * Refactored all Voronoi helper functions for drawing the diagram (demo 07) into this class.
+ *
+ * @author   Ikaros Kappler
+ * @date     2026-09-13
+ * @modified 2026-09-15 Ported to Typescript.
+ * @version  1.0.1
+ */
+
+import { Bounds } from "../../Bounds";
+import { Polygon } from "../../Polygon";
+import { Triangle } from "../../Triangle";
+import { DrawLib } from "../../interfaces";
+import { convexPolygonIncircle } from "../algorithms/convexPolygonIncircle";
+import { sutherlandHodgman } from "../algorithms/sutherlandHodgman";
+import { cloneVertexArray } from "../cloneVertexArray";
+import { PointSet } from "../datastructures/PointSet";
+import { VoronoiCell } from "../datastructures/VoronoiCell";
+
+export interface IVoronoiConfig {
+  makeVoronoiDiagram: boolean;
+  drawPoints: boolean;
+  drawTriangles: boolean;
+  drawCircumCircles: boolean;
+  drawCubicCurves: boolean;
+  fillVoronoiCells: boolean;
+  voronoiOutlineColor: string;
+  voronoiCellColor: string;
+  voronoiCubicThreshold: number;
+  voronoiCellScale: number;
+  clipVoronoiCells: boolean;
+  drawClipBox: boolean;
+  drawUnclippedVoronoiCells: boolean;
+  drawVoronoiIncircles: boolean;
+  drawVoronoiOutlines: boolean;
+  pointCount: number;
+  horizontalSafeArea: number;
+  verticalSafeArea: number;
+  voronoiCellLineWidth: number;
+}
+
+export interface IVoronoiContext {
+  pointSet: PointSet;
+  triangles: Array<Triangle>;
+  voronoiCells: Array<VoronoiCell>;
+  //   cells: Array<VoronoiCell>;
+  config: IVoronoiConfig;
+}
+
+export class VoronoiRenderer {
+  voronoiContext: IVoronoiContext;
+
+  constructor(voronoiContext: IVoronoiContext) {
+    this.voronoiContext = voronoiContext;
+  }
+
+  /**
+   * Draw the given triangle with the specified (CSS-) color.
+   *
+   * @name draw
+   * @instance
+   * @memberof VoronoiRenderer
+   * @param {DrawLib} draw
+   * @param {Triangle} t
+   * @param {string} color
+   * @return {void}
+   */
+  draw(draw: DrawLib<any>, fill: DrawLib<any>) {
+    // Draw circumcircles
+    if (this.voronoiContext.config.drawCircumCircles) {
+      VoronoiRenderer.drawCircumCircles(draw, this.voronoiContext.triangles);
+    }
+
+    // An array of VoronoiCells.
+    var clipBoxPolygon = Bounds.computeFromVertices(this.voronoiContext.pointSet.points).toPolygon();
+    if (this.voronoiContext.config.drawClipBox) {
+      draw.polygon(clipBoxPolygon, "rgba(192,192,192,0.25)");
+    }
+
+    for (var v in this.voronoiContext.voronoiCells) {
+      var cell = this.voronoiContext.voronoiCells[v];
+      this._drawCell(draw, fill, clipBoxPolygon, cell);
+    }
+  }
+
+  /**
+   * Draw the given triangle with the specified (CSS-) color.
+   *
+   * @name _drawCell
+   * @instance
+   * @private
+   * @memberof VoronoiRenderer
+   * @param {DrawLib} draw
+   * @param {Polygon} clipBoxPolygon
+   * @param {VoronoiCell} cell
+   * @return {void}
+   */
+  private _drawCell(draw: DrawLib<any>, fill: DrawLib<any>, clipBoxPolygon: Polygon, cell: VoronoiCell) {
+    var cellPolygon = cell.toPolygon();
+    cellPolygon.scale(this.voronoiContext.config.voronoiCellScale, cell.sharedVertex);
+
+    // Draw large (unclipped) Voronoi cell
+    if (
+      this.voronoiContext.config.drawVoronoiOutlines &&
+      (!this.voronoiContext.config.clipVoronoiCells || this.voronoiContext.config.drawUnclippedVoronoiCells)
+    ) {
+      draw.polyline(
+        cellPolygon.vertices,
+        false,
+        this.voronoiContext.config.clipVoronoiCells ? "rgba(128,128,128,0.333)" : this.voronoiContext.config.voronoiOutlineColor,
+        this.voronoiContext.config.voronoiCellLineWidth ?? 2.0
+      );
+    }
+
+    // Apply clipping?
+    if (this.voronoiContext.config.clipVoronoiCells) {
+      // Clone the array here: convert Array<XYCoords> to Array<Vertex>
+      // polygon = new Polygon(cloneVertexArray(sutherlandHodgman(polygon.vertices, clipBoxPolygon.vertices)), false);
+      cellPolygon = VoronoiRenderer.clipVoronoiPolygon(cellPolygon, clipBoxPolygon);
+    }
+
+    if (this.voronoiContext.config.drawVoronoiOutlines && this.voronoiContext.config.clipVoronoiCells) {
+      draw.polygon(
+        cellPolygon,
+        this.voronoiContext.config.voronoiOutlineColor,
+        this.voronoiContext.config.voronoiCellLineWidth ?? 2.0
+      );
+    }
+
+    if ((!cell.isOpen() || this.voronoiContext.config.clipVoronoiCells) && cell.triangles.length >= 3) {
+      if (this.voronoiContext.config.drawCubicCurves) {
+        var cbezier = cellPolygon.toCubicBezierData(this.voronoiContext.config.voronoiCubicThreshold);
+        if (this.voronoiContext.config.fillVoronoiCells) {
+          fill.cubicBezierPath(cbezier, this.voronoiContext.config.voronoiCellColor);
+        } else {
+          draw.cubicBezierPath(cbezier, this.voronoiContext.config.voronoiCellColor);
+        }
+      }
+      if (this.voronoiContext.config.drawVoronoiIncircles) {
+        var result = convexPolygonIncircle(cellPolygon);
+        var circle = result.circle;
+        // var triangle = result.triangle;
+        // Here we should have found the best inlying circle (and the corresponding triangle)
+        // inside the Voronoi cell.
+        draw.circle(circle.center, circle.radius, "rgba(255,192,0,1.0)", 2);
+      }
+    } // END cell is not open
+  }
+
+  /**
+   * A function for drawing the triangles.
+   *
+   * @static
+   */
+  drawTriangles(draw: DrawLib<any>) {
+    for (var i in this.voronoiContext.triangles) {
+      var t = this.voronoiContext.triangles[i];
+      VoronoiRenderer.drawTriangle(draw, t, this.voronoiContext.config.makeVoronoiDiagram ? "rgba(0,128,224,0.33)" : "#0088d8");
+    }
+  }
+
+  /**
+   * Draw the given triangle with the specified (CSS-) color.
+   *
+   * @static
+   * @name drawTriangle
+   * @memberof VoronoiRenderer
+   * @param {DrawLib} draw
+   * @param {Triangle} tri
+   * @param {string} color
+   * @return {void}
+   */
+  static drawTriangle(draw: DrawLib<any>, tri: Triangle, color: string) {
+    // draw.line(t.a, t.b, color);
+    // draw.line(t.b, t.c, color);
+    // draw.line(t.c, t.a, color);
+    draw.polyline([tri.a, tri.b, tri.c], false, color);
+  }
+
+  /**
+   * Draw the circumcircles of all triangles.
+   */
+  static drawCircumCircles(draw: DrawLib<any>, triangles: Array<Triangle>) {
+    for (var t in triangles) {
+      var cc = triangles[t].getCircumcircle();
+      draw.circle(cc.center, cc.radius, "#e86800");
+    }
+  }
+
+  /**
+   * Clip the convex (!) cell polygon by the convex (!) clipping polygon.
+   *
+   * @param cellPolygon
+   * @param clipBoxPolygon
+   * @returns
+   */
+  static clipVoronoiPolygon(cellPolygon: Polygon, clipBoxPolygon: Polygon) {
+    return new Polygon(cloneVertexArray(sutherlandHodgman(cellPolygon.vertices, clipBoxPolygon.vertices)), false);
+  }
+}