delaunator-5.0.0/docs/diagrams.js 0000664 0000000 0000000 00000016754 14027334066 0016751 0 ustar 00root root 0000000 0000000 /* Diagrams for the page need
1. The Delaunator library
2. The algorithms shown on the page (defined in
It will also be useful to have some helper functions to go from one half-edge to the next and previous half-edges in the same triangle:
Note: the sample code on this page is written for readability, not performance.
Delaunay edges
We can draw all the triangle edges without constructing the triangles themselves. Each edge is two half-edges. A half-edge e starts at points[delaunay.triangles[e]]. Its opposite delaunay.halfedges[e] starts at the other end, so that tells us the two endpoints of the edge. However, the half-edges along the convex hull won’t have an opposite, so delaunay.halfedges[e] will be -1, and points[delaunay.halfedges[e]] will fail. To reliably find the other end of the edge, we need to instead use points[nextHalfedge(e)]. We can loop through the half-edges and pick half of them to draw:
Constructing triangles
A triangle is formed from three consecutive half-edges, 3*t, 3*t + 1, 3*t + 2. Each half-edge e starts at points[e], so we can connect those three points into a triangle.
Adjacent triangles
We can also use the half-edges of a triangle to find the adjacent triangles. Each half-edge's opposite will be in an adjacent triangle, and the edgeIdToTriangleId helper function will tell us which triangle a half-edge is in:
Voronoi cells
A Voronoi diagram is built by connecting the Delaunay triangle circumcenters together using the dual of the Delaunay graph.
Calculate the circumcenters of each triangle
Construct the Voronoi edges from two circumcenters
Connect the edges into Voronoi cells
Triangle circumcenters
The formula for circumcenters can be found on Wikipedia. The circumcenter is often but not always inside the triangle.
This convenience function will go from triangle id to circumcenter:
Voronoi edges
With the circumcenters we can draw the Voronoi edges without constructing the polygons. Each Delaunay triangle half-edge corresponds to one Voronoi polygon half-edge. The Delaunay half-edge connects two points, delaunay.triangles[e] and delaunay.triangles[nextHalfedge(e)]. The Voronoi half-edge connects the circumcenters of two triangles, triangleOfEdge(e) and triangleOfEdge(delaunay.halfedges[e]). We can iterate over the half-edges and construct the line segments:
Constructing Voronoi cells
To build the polygons, we need to find the triangles touching a point. The half-edge structures can give us what we need. Let’s assume we have a starting half-edge that leads into the point. We can alternate two steps to loop around:
Use nextHalfedge(e) to go to the next outgoing half-edge in the current triangle
Use halfedges[e] to go to the incoming half-edge in the adjacent triangle
Note that this requires any incoming half-edge that leads to the point. If you need a quick way to find such a half-edge given a point, it can be useful to build an index of these half-edges. For an example, see the modified version of forEachVoronoiCell at the end of the page.
Drawing Voronoi cells
To draw the Voronoi cells, we can turn a point’s incoming half-edges into triangles, and then find their circumcenters. We can iterate over half-edges, but since many half-edges lead to a point, we need to keep track of which points have already been visited.
Convex hull
There’s a problem with the edgesAroundPoint loop above. Points on the convex hull won’t be completely surrounded by triangles, and the loop will stop partway through, when it hits -1. There are three approaches to this:
Ignore it. Make sure never to circulate around points on the convex hull.
Change the code.
Check for -1 in all code that looks at halfedges.
Change the edgesAroundPoint loop to start at the “leftmost” half-edge so that by the time it reaches -1, it has gone through all the triangles.
Change the data. Remove the convex hull by wrapping the mesh around the “back”. There will no longer be any -1 halfedges.
Add “ghost” half-edges that pair up with the ones that point to -1.
Add a single ghost point at “infinity” that represents the “back side” of the triangulation.
Add ghost triangles to connect these ghost half-edges to the ghost point.
Here’s an example of how to find the “leftmost” half-edge:
However, even with these changes, constructing the Voronoi cell along the convex hull requires projecting the edges outwards and clipping them. The Delaunator library doesn’t provide this functionality; consider using d3-delaunay if you need it.
Summary
The Delaunator library uses half-edges to represent the
relationships between points and triangles. On this page are
sample functions showing how to move between types of
objects:
### Projects based on Delaunator
- [d3-delaunay](https://github.com/d3/d3-delaunay) for Voronoi diagrams, search, traversal and rendering (a part of [D3](https://d3js.org)).
- [d3-geo-voronoi](https://github.com/Fil/d3-geo-voronoi) for Delaunay triangulations and Voronoi diagrams on a sphere (e.g. for geographic locations).
### Ports to other languages
- [delaunator-rs](https://github.com/mourner/delaunator-rs) (Rust)
- [fogleman/delaunay](https://github.com/fogleman/delaunay) (Go)
- [delaunator-cpp](https://github.com/abellgithub/delaunator-cpp) (C++)
- [delaunator-sharp](https://github.com/nol1fe/delaunator-sharp) (C#)
- [delaunator-ruby](https://github.com/hendrixfan/delaunator-ruby) (Ruby)
- [Delaunator-Python](https://github.com/HakanSeven12/Delaunator-Python) (Python)
- [hx-delaunator](https://github.com/dmitryhryppa/hx-delaunator) (Haxe)
- [ricardomatias/delaunator](https://github.com/ricardomatias/delaunator) (Kotlin)
## Example
```js
const points = [[168, 180], [168, 178], [168, 179], [168, 181], [168, 183], ...];
const delaunay = Delaunator.from(points);
console.log(delaunay.triangles);
// [623, 636, 619, 636, 444, 619, ...]
```
## Install
Install with NPM (`npm install delaunator`) or Yarn (`yarn add delaunator`), then:
```js
// import as an ES module
import Delaunator from 'delaunator';
// or require in Node / Browserify
const Delaunator = require('delaunator');
```
Or use a browser build directly:
```html
```
## API Reference
#### Delaunator.from(points[, getX, getY])
Constructs a delaunay triangulation object given an array of points (`[x, y]` by default).
`getX` and `getY` are optional functions of the form `(point) => value` for custom point formats.
Duplicate points are skipped.
#### new Delaunator(coords)
Constructs a delaunay triangulation object given an array of point coordinates of the form:
`[x0, y0, x1, y1, ...]` (use a typed array for best performance).
#### delaunay.triangles
A `Uint32Array` array of triangle vertex indices (each group of three numbers forms a triangle).
All triangles are directed counterclockwise.
To get the coordinates of all triangles, use:
```js
for (let i = 0; i < triangles.length; i += 3) {
coordinates.push([
points[triangles[i]],
points[triangles[i + 1]],
points[triangles[i + 2]]
]);
}
```
#### delaunay.halfedges
A `Int32Array` array of triangle half-edge indices that allows you to traverse the triangulation.
`i`-th half-edge in the array corresponds to vertex `triangles[i]` the half-edge is coming from.
`halfedges[i]` is the index of a twin half-edge in an adjacent triangle
(or `-1` for outer half-edges on the convex hull).
The flat array-based data structures might be counterintuitive,
but they're one of the key reasons this library is fast.
#### delaunay.hull
A `Uint32Array` array of indices that reference points on the convex hull of the input data, counter-clockwise.
#### delaunay.coords
An array of input coordinates in the form `[x0, y0, x1, y1, ....]`,
of the type provided in the constructor (or `Float64Array` if you used `Delaunator.from`).
#### delaunay.update()
Updates the triangulation if you modified `delaunay.coords` values in place, avoiding expensive memory allocations.
Useful for iterative relaxation algorithms such as [Lloyd's](https://en.wikipedia.org/wiki/Lloyd%27s_algorithm).
## Performance
Benchmark results against other Delaunay JS libraries
(`npm run bench` on Macbook Pro Retina 15" 2017, Node v10.10.0):
| uniform 100k | gauss 100k | grid 100k | degen 100k | uniform 1 million | gauss 1 million | grid 1 million | degen 1 million
:-- | --: | --: | --: | --: | --: | --: | --: | --:
**delaunator** | 82ms | 61ms | 66ms | 25ms | 1.07s | 950ms | 830ms | 278ms
[faster‑delaunay](https://github.com/Bathlamos/delaunay-triangulation) | 473ms | 411ms | 272ms | 68ms | 4.27s | 4.62s | 4.3s | 810ms
[incremental‑delaunay](https://github.com/mikolalysenko/incremental-delaunay) | 547ms | 505ms | 172ms | 528ms | 5.9s | 6.08s | 2.11s | 6.09s
[d3‑voronoi](https://github.com/d3/d3-voronoi) | 972ms | 909ms | 358ms | 720ms | 15.04s | 13.86s | 5.55s | 11.13s
[delaunay‑fast](https://github.com/ironwallaby/delaunay) | 3.8s | 4s | 12.57s | timeout | 132s | 138s | 399s | timeout
[delaunay](https://github.com/darkskyapp/delaunay) | 4.85s | 5.73s | 15.05s | timeout | 156s | 178s | 326s | timeout
[delaunay‑triangulate](https://github.com/mikolalysenko/delaunay-triangulate) | 2.24s | 2.04s | OOM | 1.51s | OOM | OOM | OOM | OOM
[cdt2d](https://github.com/mikolalysenko/cdt2d) | 45s | 51s | 118s | 17s | timeout | timeout | timeout | timeout
## Papers
The algorithm is based on ideas from the following papers:
- [A simple sweep-line Delaunay triangulation algorithm](http://www.academicpub.org/jao/paperInfo.aspx?paperid=15630), 2013, Liu Yonghe, Feng Jinming and Shao Yuehong
- [S-hull: a fast radial sweep-hull routine for Delaunay triangulation](http://www.s-hull.org/paper/s_hull.pdf), 2010, David Sinclair
- [A faster circle-sweep Delaunay triangulation algorithm](http://cglab.ca/~biniaz/papers/Sweep%20Circle.pdf), 2011, Ahmad Biniaz and Gholamhossein Dastghaibyfard
delaunator-5.0.0/bench.js 0000664 0000000 0000000 00000004237 14027334066 0015302 0 ustar 00root root 0000000 0000000 /* eslint no-unused-vars: 0 */
import Delaunator from './index.js';
// import fasterDelaunay from 'faster-delaunay';
// import incrementalDelaunay from 'incremental-delaunay';
// import delaunayFast from 'delaunay-fast';
// import delaunaySlow from 'delaunay';
// import {voronoi} from 'd3-voronoi';
// import delaunayTriangulate from 'delaunay-triangulate';
// import cdt2d from 'cdt2d';
function triangulate(points) {
Delaunator.from(points);
// fasterDelaunay(points).triangulate();
// voronoi()(points);
// incrementalDelaunay(points);
// delaunayFast.triangulate(points);
// delaunaySlow.triangulate(points);
// delaunayTriangulate(points);
// cdt2d(points);
}
const distributions = [uniform, gaussian, grid, degenerate];
const counts = [20000, 100000, 200000, 500000, 1000000];
for (const generate of distributions) {
console.log(`${generate.name}:`);
// warmup
triangulate(generate(counts[0]));
triangulate(generate(counts[1]));
for (let i = 0; i < counts.length; i++) {
const c = counts[i];
const points = generate(c);
console.time(c);
triangulate(points);
console.timeEnd(c);
}
}
function uniform(count) {
const points = [];
for (let i = 0; i < count; i++) {
points.push([Math.random() * 1e3, Math.random() * 1e3]);
}
return points;
}
function grid(count) {
const points = [];
const size = Math.sqrt(count);
for (let i = 0; i < size; i++) {
for (let j = 0; j < size; j++) {
points.push([i, j]);
}
}
return points;
}
function gaussian(count) {
const points = [];
for (let i = 0; i < count; i++) {
points.push([pseudoNormal() * 1e3, pseudoNormal() * 1e3]);
}
return points;
}
function degenerate(count) {
const points = [[0, 0]];
for (let i = 0; i < count; i++) {
const angle = 2 * Math.PI * i / count;
points.push([1e10 * Math.sin(angle), 1e10 * Math.cos(angle)]);
}
return points;
}
function pseudoNormal() {
const v = Math.random() + Math.random() + Math.random() + Math.random() + Math.random() + Math.random();
return Math.min(0.5 * (v - 3) / 3, 1);
}
delaunator-5.0.0/delaunator.png 0000664 0000000 0000000 00000562477 14027334066 0016550 0 ustar 00root root 0000000 0000000 PNG
IHDR + n PLTEGpLLtLui}LcLLcjiL\LSLLL~xh|L楽LiLjL泀LLMMMLɡhLL𰖥NLLLحjLLMzL䮸LՕeLkMۍµLLwL|vjwL恕»VLeLL`iLwL斑LVhLfꔟ^LLnLLLL}LlLiLL{eLLzŁLLLLL棟bLjxL`oLLLLLfrwL_rcxLqLLLVNrLL}LML}LpLLLLj}LMoVLLLuLLLLLLYLLLQLLbLjLLLLLLmLLwLfLLLLLL z3 tRNS .EgӄH8| IDATx[H͠RUMhضNS,Fq}}0;guuummm}}}ccssk|Ƕﯯ< ðvvO[EH)}_T0pO
03m'SԀڢ: }C WFY;+ 0O4<6NN0KRJV8U^67ǡ>}ocaG.)bj;I5c{(ۇ =΅