plotboilerplate 1.29.0 → 1.31.0

package/src/ts/utils/algorithms/delaunay2voronoi.ts

@@ -3,7 +3,8 @@
  * @date     2018-04-07
  * @modified 2018-04-11 Using VoronoiCells now (was array before).
  * @modified 2020-08-15 Ported from vanilla JS to TypeScript.
- * @version  1.0.2
+ * @modified 2026-09-15 Added the `sharedVertexIndex` attribute to each Voronoi cell.
+ * @version  1.1.0
  **/
 
 import { Triangle } from "../../Triangle";
@@ -17,97 +18,89 @@ import { VoronoiCell } from "../datastructures/VoronoiCell";
  * @requires Triangle
  */
 export class delaunay2voronoi {
+  public failedTriangleSets: Array<Triangle>;
+  public hasErrors: boolean;
 
-    public failedTriangleSets : Array<Triangle>;
-    public hasErrors: boolean;
+  private pointList: Array<Vertex>;
+  private triangles: Array<Triangle>;
 
-    private pointList: Array<Vertex>;
-    private triangles: Array<Triangle>;
-    
-    constructor( pointList:Array<Vertex>, triangles:Array<Triangle> ) {
+  constructor(pointList: Array<Vertex>, triangles: Array<Triangle>) {
+    this.failedTriangleSets = [];
+    this.hasErrors = false;
 
-	this.failedTriangleSets = [];
-	this.hasErrors          = false;
+    this.pointList = pointList;
+    this.triangles = triangles;
+  }
 
-	this.pointList = pointList;
-	this.triangles = triangles;
-    };
+  // +---------------------------------------------------------------------------------
+  // | Convert the triangle set to the Voronoi diagram.
+  // +-------------------------------
+  build(): Array<VoronoiCell> {
+    const voronoiDiagram: Array<VoronoiCell> = [];
+    for (var p = 0; p < this.pointList.length; p++) {
+      var point: Vertex = this.pointList[p];
+      // Find adjacent triangles for first point
+      var adjacentSubset: Array<Triangle> = [];
+      for (var t in this.triangles) {
+        if (this.triangles[t].a.equals(point) || this.triangles[t].b.equals(point) || this.triangles[t].c.equals(point))
+          adjacentSubset.push(this.triangles[t]);
+      }
+      var path: Array<Triangle> = this.subsetToPath(adjacentSubset);
+      if (path)
+        // There may be errors
+        voronoiDiagram.push(new VoronoiCell(path, point, p));
+    }
+    return voronoiDiagram;
+  }
 
-    // +---------------------------------------------------------------------------------
-    // | Convert the triangle set to the Voronoi diagram.
-    // +-------------------------------
-    build() : Array<VoronoiCell> {
-	const voronoiDiagram : Array<VoronoiCell>= [];	    
-	for( var p in this.pointList ) {
-	    var point : Vertex = this.pointList[p];
-	    // Find adjacent triangles for first point
-	    var adjacentSubset : Array<Triangle> = []; 
-	    for( var t in this.triangles ) {
-		if( this.triangles[t].a.equals(point) || this.triangles[t].b.equals(point) || this.triangles[t].c.equals(point) ) 
-		    adjacentSubset.push( this.triangles[t] );
-		
-	    }
-	    var path : Array<Triangle> = this.subsetToPath(adjacentSubset);
-	    if( path ) // There may be errors
-		voronoiDiagram.push( new VoronoiCell(path,point) ); 
-	}
-	return voronoiDiagram;
-    };
+  // +---------------------------------------------------------------------------------
+  // | Re-order a tiangle subset so the triangle define a single path.
+  // |
+  // | It is required that all passed triangles are connected to a
+  // | path. Otherwise this function will RAISE AN EXCEPTION.
+  // |
+  // | The function has a failsafe recursive call for the case the first
+  // | element in the array is inside the path (no border element).
+  // +-------------------------------
+  private subsetToPath(triangleSet: Array<Triangle>, startPosition?: number, tryOnce?: boolean): Array<Triangle> {
+    if (triangleSet.length == 0) return [];
 
+    if (typeof startPosition === "undefined") startPosition = 0;
 
-    // +---------------------------------------------------------------------------------
-    // | Re-order a tiangle subset so the triangle define a single path.
-    // |
-    // | It is required that all passed triangles are connected to a
-    // | path. Otherwise this function will RAISE AN EXCEPTION.
-    // |
-    // | The function has a failsafe recursive call for the case the first
-    // | element in the array is inside the path (no border element).
-    // +-------------------------------
-    private subsetToPath( triangleSet: Array<Triangle>,
-			  startPosition?:number,
-			  tryOnce?:boolean ) : Array<Triangle> {
-	if( triangleSet.length == 0 )
-	    return [];
-
-	if( typeof startPosition === 'undefined' )
-	    startPosition = 0;
-	
-	let t : number = startPosition;
-	const result : Array<Triangle> = [ triangleSet[t] ];
-	const visited : Array<number> = [ t ];
-	let i : number = 0;
-	while( result.length < triangleSet.length && i < triangleSet.length ) {
-	    let u : number = (startPosition+i)%triangleSet.length;
-	    if( t != u && visited.indexOf(u) == -1 && triangleSet[t].isAdjacent(triangleSet[u]) ) {
-		result.push(triangleSet[u]);
-		visited.push(u);
-		t = u;
-		i = 0;
-	    } else {
-		i++;
-	    }
-	}
-	// If not all triangles were used the passed set is NOT CIRCULAR.
-	// But in this case the triangle at position t is at one end of the path :)
-	// -> Restart with t.
-	if( result.length < triangleSet.length ) {
-	    if( tryOnce ) {
-		// Possibility A (try to fix this): split the triangle set into two arrays and restart with each.
-		// Possibility B (no fix for this): throw an error and terminate.
-		// Possibility C (temp solution): Store the error for later reporting and continue.
-		// this.failedTriangleSets.push( triangleSet );
-		this.failedTriangleSets = triangleSet;
-		this.hasErrors = true;
-		// throw "Error: this triangle set is not connected: " + JSON.stringify(triangleSet);
-		return null;
-	    } else {
-		// Triangle inside path found. Rearrange.
-		return this.subsetToPath( triangleSet, t, true );
-	    }
-	} else {	    
-	    return result;
-	}
-    };
-
-}; // END delaunay2voronoi
+    let t: number = startPosition;
+    const result: Array<Triangle> = [triangleSet[t]];
+    const visited: Array<number> = [t];
+    let i: number = 0;
+    while (result.length < triangleSet.length && i < triangleSet.length) {
+      let u: number = (startPosition + i) % triangleSet.length;
+      if (t != u && visited.indexOf(u) == -1 && triangleSet[t].isAdjacent(triangleSet[u])) {
+        result.push(triangleSet[u]);
+        visited.push(u);
+        t = u;
+        i = 0;
+      } else {
+        i++;
+      }
+    }
+    // If not all triangles were used the passed set is NOT CIRCULAR.
+    // But in this case the triangle at position t is at one end of the path :)
+    // -> Restart with t.
+    if (result.length < triangleSet.length) {
+      if (tryOnce) {
+        // Possibility A (try to fix this): split the triangle set into two arrays and restart with each.
+        // Possibility B (no fix for this): throw an error and terminate.
+        // Possibility C (temp solution): Store the error for later reporting and continue.
+        // this.failedTriangleSets.push( triangleSet );
+        this.failedTriangleSets = triangleSet;
+        this.hasErrors = true;
+        // throw "Error: this triangle set is not connected: " + JSON.stringify(triangleSet);
+        return null;
+      } else {
+        // Triangle inside path found. Rearrange.
+        return this.subsetToPath(triangleSet, t, true);
+      }
+    } else {
+      return result;
+    }
+  }
+} // END delaunay2voronoi

package/src/ts/utils/datastructures/PointSet.ts

@@ -0,0 +1,135 @@
+/**
+ * A mutable point set datastructure for holding a finite but variable set of vertices.
+ *
+ * @date    2026-09-12
+ * @author  Ikaros Kappler
+ * @version 1.0.0
+ */
+
+import PlotBoilerplate from "../../PlotBoilerplate";
+import { Vertex } from "../../Vertex";
+
+export class PointSet {
+  private readonly pb: PlotBoilerplate;
+  public points: Array<Vertex>;
+  readonly dragListeners: Array<Function> = [];
+
+  constructor(pb: PlotBoilerplate) {
+    this.pb = pb;
+    this.points = [];
+  }
+
+  private fireDragEvent() {
+    this.dragListeners.forEach(listener => {
+      listener();
+    });
+  }
+
+  /**
+   * Adds a random point to the point list.
+   *
+   * @name addRandomPoint
+   * @instance
+   * @override
+   * @memberof PointSet
+   * @return {void}
+   */
+  addRandomPoint(horizontalSafeArea: number = 0, verticalSafeArea: number = 0) {
+    // this.addVertex(Vertex.randomVertex(this.pb.viewport()).scale(0.5));
+    this.addVertex(this.pb.viewport().randomPoint(horizontalSafeArea, verticalSafeArea));
+  }
+
+  /**
+   * Adds the given point/vertex to the point list.
+   *
+   * @name addVertex
+   * @instance
+   * @override
+   * @memberof PointSet
+   * @param {Vertex} vert - The vertex to add.
+   * @return {void}
+   */
+  addVertex(vert: Vertex) {
+    this.points.push(vert);
+    this.pb.add(vert, false); // redraw=false
+    var _self = this;
+    vert.listeners.addDragListener(function () {
+      _self.fireDragEvent();
+    });
+    // vert.listeners.addDragListener(_self.fireDragEvent);
+  }
+
+  /**
+   * Remove all vertices from this set and from the plotboilerplate instance.
+   *
+   * @name clear
+   * @instance
+   * @override
+   * @memberof PointSet
+   * @return {void}
+   */
+  clear() {
+    for (var i = 0; i < this.points.length; i++) {
+      this.pb.remove(this.points[i], false);
+      // TODO: How to remove drag listener?
+      //   this.points[i].listeners.removeDragListener(this.fireDragEvent);
+    }
+    this.points = [];
+  }
+
+  /**
+   * Add or remove n random points; depends on the config settings.
+   *
+   * I have no idea how tired I was when I wrote this function but it seems working pretty well.
+   */
+  randomPoints(pointCount: number, horizontalSafeArea: number = 0, verticalSafeArea: number = 0) {
+    // Generate random points.
+    for (var i = this.points.length; i < pointCount; i++) {
+      this.addRandomPoint(horizontalSafeArea, verticalSafeArea);
+    }
+  }
+
+  /**
+   * Add random points and be sure they cover the whole viewport.
+   *
+   * I have no idea how tired I was when I wrote this function but it seems working pretty well.
+   */
+  randomFullCover(pointCount: number) {
+    this.clear();
+    this.randomPoints(pointCount - 4, 0.0, 0.0); //, true, true);
+    // Add 4 more points in the corners.
+    var viewport = this.pb.viewport();
+    this.addVertex(viewport.getNorthWestPoint());
+    this.addVertex(viewport.getNorthEastPoint());
+    this.addVertex(viewport.getSouthWestPoint());
+    this.addVertex(viewport.getSouthEastPoint());
+  }
+
+  /**
+   * Call when the desired number of points changes.
+   **/
+  updatePointCount(newPointCount: number, horizontalSafeArea: number = 0, verticalSafeArea: number = 0) {
+    if (newPointCount > this.points.length) {
+      this.randomPoints(newPointCount, horizontalSafeArea, verticalSafeArea);
+    }
+    // Do not clear ; no full cover ; do rebuild
+    else if (newPointCount < this.points.length) {
+      // Remove n-m points
+      for (var i = newPointCount; i < this.points.length; i++) {
+        this.pb.remove(this.points[i]);
+      }
+      // TODO: MOVE THIS TO THE PointSet class.
+      this.points = this.points.slice(0, newPointCount);
+      // TODO: also remove listeners?
+      //   updateAnimator();
+      //   rebuild();
+    }
+  }
+
+  // +---------------------------------------------------------------------------------
+  // | Generates a random int value between 0 and max (both inclusive).
+  // +-------------------------------
+  //   private randomInt(max: number): number {
+  //     return Math.round(Math.random() * max);
+  //   }
+}