delaunay.js 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delaunay.js",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Delaunay triangulation using the Bowyer-Watson algorithm, in JavaScript ",
   "keywords": [
     "triangulation",
@@ -26,9 +26,11 @@
     "src/"
   ],
   "scripts": {
-    "test": "node test/test.js"
+    "test": "node test/test.js 10",
+    "prof": "node --prof test/test.js 20000",
+    "cpu-prof": "node --cpu-prof --cpu-prof-dir=./cpu-prof test/test.js 20000"
   },
   "dependencies": {
-    "vectory-lib": "^0.0.7"
+    "vectory-lib": "^0.0.9"
   }
 }

package/src/bowyer-watson.js

@@ -1,45 +1,42 @@
 import Triangle from './triangle.js';
 
 export default function bowyerWatson (superTriangle, pointList) {
-  // pointList is a set of coordinates defining the 
+  // 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 
+  // 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 
+
+    // first find all the triangles that are no
     // longer valid due to the insertion
-    triangulation.forEach(triangle => { 
+    triangulation.forEach(triangle => {
       if(triangle.pointIsInsideCircumcircle(point)) {
-        badTriangles.push(triangle); 
+        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;
-          }
+        let edgeIsShared = badTriangles.some(otherTriangle => {
+          return triangle !== otherTriangle && otherTriangle.hasEdge(edge);
         });
         if(!edgeIsShared) {
-          //edge is not shared by any other 
+          // 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);
@@ -47,27 +44,27 @@ export default function bowyerWatson (superTriangle, pointList) {
         triangulation.splice(index, 1);
       }
     });
-    
+
     // re-triangulate the polygonal hole
     polygon.forEach(edge => {
-      //form a triangle from edge to point
+      // 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
+      // remove triangle from triangulation
       let index = triangulation.indexOf(triangle);
       if (index > -1) {
         triangulation.splice(index, 1);
       }
-    }  
+    }
   }
-  
+
   return triangulation;
 }

package/src/triangle.js

@@ -6,15 +6,11 @@ export default class Triangle {
     this.b = b;
     this.c = c;
   }
-  
+
   vertexes() {
     return [this.a, this.b, this.c];
   }
 
-  vertexesAsString() {
-    return this.vertexes().map(vertex => `${vertex.x}, ${vertex.y}`).join(", ");
-  }
-  
   edges() {
     return [
       [this.a, this.b],
@@ -22,7 +18,7 @@ export default class Triangle {
       [this.c, this.a]
     ];
   }
-  
+
   sharesAVertexWith(triangle) {
     // TODO: optimize me please!
     for(let i = 0; i < 3; i++) {
@@ -40,51 +36,74 @@ export default class Triangle {
   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]) || 
+      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) + 
+      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.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) + 
+      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(); 
+
+  get circumradiusSq() {
+    if(!this._circumradiusSq) {
+      this._circumradiusSq = this.circumcenter.sub(this.a).getLengthSq();
     }
-    return this._circumradius;
+    return this._circumradiusSq;
   }
 
   pointIsInsideCircumcircle(point) {
-    let dist = point.sub(this.circumcenter).getLength();
-    
-    return dist < this.circumradius;
+    let dist = point.sub(this.circumcenter).getLengthSq();
+
+    return dist < this.circumradiusSq;
+  }
+
+  // Methods below are not needed for Delaunay triangulation, but useful for drawing.
+  vertexesAsString() {
+    return this.vertexes().map(vertex => `${vertex.x}, ${vertex.y}`).join(", ");
+  }
+
+  edgeLengths() {
+    return this.edges().map(v => v[0].sub(v[1]).getLength());
+  }
+  
+  heights() {
+    let [a, b, c] = this.edgeLengths();
+    function height(a, b, c) {
+      const s = (a + b + c) / 2;
+      const h = 2 * Math.sqrt(s * (s - a) * (s - b) * (s - c)) / b;
+      return h;
+    }
+    return [height(a, b, c), height(b, c, a), height(c, a, b)];
+  }
+  
+  shortestHeight() {
+    return Math.min(...this.heights());
   }
 }