delaunay.js 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johan Karlsson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bowyer-watson.js

@@ -0,0 +1,73 @@
+import Triangle from './triangle.js';
+
+export default function bowyerWatson (superTriangle, pointList) {
+  // pointList is a set of coordinates defining the 
+  // points to be triangulated
+  let triangulation = [];
+
+  // add super-triangle to triangulation 
+  // must be large enough to completely contain all 
+  // the points in pointList
+  triangulation.push(superTriangle);
+
+  // add all the points one at a time to the triangulation
+  pointList.forEach(point => {
+    let badTriangles = [];
+    
+    // first find all the triangles that are no 
+    // longer valid due to the insertion
+    triangulation.forEach(triangle => { 
+      if(triangle.pointIsInsideCircumcircle(point)) {
+        badTriangles.push(triangle); 
+      }
+    });
+    let polygon = [];
+    
+    // find the boundary of the polygonal hole
+    badTriangles.forEach(triangle => {
+      triangle.edges().forEach(edge => {
+        let edgeIsShared = false;
+        badTriangles.forEach(otherTriangle => {
+          if(triangle !== otherTriangle &&  otherTriangle.hasEdge(edge)) {
+            edgeIsShared = true;
+          }
+        });
+        if(!edgeIsShared) {
+          //edge is not shared by any other 
+          // triangles in badTriangles
+          polygon.push(edge);
+        }
+      });
+    });
+    
+    // remove them from the data structure
+    badTriangles.forEach(triangle => {
+      let index = triangulation.indexOf(triangle);
+      if (index > -1) {
+        triangulation.splice(index, 1);
+      }
+    });
+    
+    // re-triangulate the polygonal hole
+    polygon.forEach(edge => {
+      //form a triangle from edge to point
+      let newTri = new Triangle(edge[0], edge[1], point);
+      triangulation.push(newTri);
+    });
+  });
+  
+  // done inserting points, now clean up
+  let i = triangulation.length;
+  while(i--) {
+    let triangle = triangulation[i];
+    if(triangle.sharesAVertexWith(superTriangle)) {
+      //remove triangle from triangulation
+      let index = triangulation.indexOf(triangle);
+      if (index > -1) {
+        triangulation.splice(index, 1);
+      }
+    }  
+  }
+  
+  return triangulation;
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "delaunay.js",
+  "version": "1.0.0",
+  "description": "Delaunay triangulation using the Bowyer-Watson algorithm, in JavaScript ",
+  "keywords": [
+    "triangulation",
+    "delaunay",
+    "bowyer-watson"
+  ],
+  "homepage": "https://github.com/DonKarlssonSan/Delaunay.js#readme",
+  "bugs": {
+    "url": "https://github.com/DonKarlssonSan/Delaunay.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DonKarlssonSan/Delaunay.js.git"
+  },
+  "license": "MIT",
+  "author": "Johan Karlsson (DonKarlssonSan)",
+  "type": "module",
+  "main": "bowyer-watson.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "vectory-lib": "^0.0.7"
+  }
+}

package/readme.md

@@ -0,0 +1,52 @@
+# Installation
+
+```
+npm install delaunay
+```
+
+# Usage
+
+The `bowyerWatson` function takes two parameters:
+- superTriangle is a triangle that encloses all the points in the list, an instance of Triangle
+- pointList is a list of points, instances of Vector
+
+```
+let triangles = bowyerWatson(superTriangle, pointList);
+```
+
+A more complete example:
+
+```JavaScript
+import bowyerWatson from './bowyer-watson.js';
+import Triangle from './triangle.js';
+import Vector from 'vectory-lib';
+
+function getRandomPoints() {
+  let points = [];
+  let nrOfPoints = 10;
+  for(let i = 0; i < nrOfPoints; i++) {
+    points.push(new Vector(
+      Math.random() * 100,
+      Math.random() * 100
+    ));
+  }
+  return points;
+}
+
+let pointList = getRandomPoints();
+
+let superTriangle = new Triangle(
+    new Vector(-1000, 1000),
+    new Vector(1000, 1000),
+    new Vector(0, -1000)
+);
+
+let triangles = bowyerWatson(superTriangle, pointList);
+```
+
+# Referenses
+https://en.wikipedia.org/wiki/Delaunay_triangulation
+
+https://en.wikipedia.org/wiki/Bowyer%E2%80%93Watson_algorithm  
+
+https://en.wikipedia.org/wiki/Circumscribed_circle

package/test.js

@@ -0,0 +1,29 @@
+import bowyerWatson from './bowyer-watson.js';
+import Triangle from './triangle.js';
+import Vector from 'vectory-lib';
+
+function getRandomPoints() {
+  let points = [];
+  let nrOfPoints = 10;
+  for(let i = 0; i < nrOfPoints; i++) {
+    points.push(new Vector(
+      Math.random() * 100,
+      Math.random() * 100
+    ));
+  }
+  return points;
+}
+
+let pointList = getRandomPoints();
+
+let superTriangle = new Triangle(
+    new Vector(-1000, 1000),
+    new Vector(1000, 1000),
+    new Vector(0, -1000)
+);
+
+let triangles = bowyerWatson(superTriangle, pointList);
+
+triangles.forEach(triangle => {
+  console.log(triangle.vertexes());
+});

package/triangle.js

@@ -0,0 +1,86 @@
+import Vector from 'vectory-lib';
+
+export default class Triangle {
+  constructor(a, b, c) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+  }
+  
+  vertexes() {
+    return [this.a, this.b, this.c];
+  }
+  
+  edges() {
+    return [
+      [this.a, this.b],
+      [this.b, this.c],
+      [this.c, this.a]
+    ];
+  }
+  
+  sharesAVertexWith(triangle) {
+    // TODO: optimize me please!
+    for(let i = 0; i < 3; i++) {
+      for(let j = 0; j < 3; j++) {
+        let v = this.vertexes()[i];
+        let vv = triangle.vertexes()[j];
+        if(v.equals(vv)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  hasEdge(edge) {
+    for(let i = 0; i < 3; i++) {
+      let e = this.edges()[i];
+      if(e[0].equals(edge[0]) && e[1].equals(edge[1]) || 
+         e[1].equals(edge[0]) && e[0].equals(edge[1])) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  get circumcenter() {
+    if(!this._circumcenter) {
+      let d = 2 * (this.a.x * (this.b.y - this.c.y) + 
+                   this.b.x * (this.c.y - this.a.y) + 
+                   this.c.x * (this.a.y - this.b.y));
+
+      let x = 1 / d * ((this.a.x * this.a.x + this.a.y * this.a.y) * (this.b.y - this.c.y) +
+                       (this.b.x * this.b.x + this.b.y * this.b.y) * (this.c.y - this.a.y) + 
+                       (this.c.x * this.c.x + this.c.y * this.c.y) * (this.a.y - this.b.y));
+
+      let y = 1 / d * ((this.a.x * this.a.x + this.a.y * this.a.y) * (this.c.x - this.b.x) + 
+                       (this.b.x * this.b.x + this.b.y * this.b.y) * (this.a.x - this.c.x) + 
+                       (this.c.x * this.c.x + this.c.y * this.c.y) * (this.b.x - this.a.x));
+      this._circumcenter = new Vector(x, y);
+    }
+ 
+    return this._circumcenter;
+   
+  }
+  
+  get centroid() {
+    if(!this._centroid) {
+      this._centroid = this.a.add(this.b).add(this.c).div(3);
+    }
+    return this._centroid;
+  }
+  
+  get circumradius() {
+    if(!this._circumradius) {
+      this._circumradius = this.circumcenter.sub(this.a).getLength(); 
+    }
+    return this._circumradius;
+  }
+
+  pointIsInsideCircumcircle(point) {
+    let dist = point.sub(this.circumcenter).getLength();
+    
+    return dist < this.circumradius;
+  }
+}