Sooner than earcut: triangulating 3.7M map polygons in 489 ms

The naive row is shorter than
Delaunay in each dimension class however the final. The 1,123 largest polygons,
with 257 vertices or extra, take 199 ms to clip and 90 ms with Delaunay. Each ear check there walks lots of of
vertices, and a polygon wants lots of of assessments, so the price grows with the sq. of its dimension. The remainder of this
publish is about making the ear check cheaper and wanted much less usually.

Test solely the dents (−237 ms)​

Look at which vertices can truly cease a convex nook from being an ear. Say some vertices lie inside its
triangle, and take the one closest to the nook itself. Its two edges cannot cross the edges of the triangle, so
each run again, away from the nook, and the polygon wraps round that vertex from the nook’s aspect. That makes
it a reflex vertex, a dent. So if something is contained in the triangle, a dent is inside it
too, and the check solely has to have a look at the dents.

The engine retains an inventory of them. A dent leaves the listing when reducing its neighbour makes it convex, and a convex
nook by no means turns right into a dent, so the listing solely shrinks. The check turns into:

bool isEar(uint32_t v) const
{
    const Node &b = _nodes[v];
    if (b.reflex)
        return false;
    const Node &a = _nodes[b.prev], &c = _nodes[b.next];
    for (uint32_t i = 0; i < _live; ++i) 
    return true;
}

The 28.1 million ear assessments now have a look at 185 million factors as a substitute of 353 million, and the overall drops to
882 ms. That is lower than you would possibly count on, as a result of constructing outlines
have a whole lot of dents.
The constructing with the arch above has 15 of them amongst its 27 vertices. And the smallest polygons get slower, from
34 to 54 ms: for a triangle or a quad, sorting the corners into dents and the remainder prices greater than the stroll it
saves.

Skip assessments on convex polygons (−2 ms)​

A polygon with out dents is convex, and each nook of a convex polygon is an ear, so it may be reduce and not using a
single check. Checking for that wants care. “Every nook turns left” isn’t sufficient:

The star turns left in any respect 5 corners, as a result of it goes round its
centre twice. The engine provides yet another situation. Walking round a convex ring, the sides go proper alongside the
backside and left alongside the highest, so their x route modifications precisely twice, on the leftmost and the rightmost
level. The pentagon passes; the star modifications route 4 instances, at
the circled corners, and goes to the unusual ear assessments. Both counts come out of the identical
loop that marks the dents, so the test prices nearly nothing. Triangles and quads get their very own shortcut earlier than
that loop.

The shortcut removes 4.4 million of the 28.1 million ear assessments, however these have been the most cost effective ones: a hoop with out
dents has nothing to scan. On its personal it barely strikes the overall, 880 ms,
although the polygons with 4 vertices or fewer win again a part of what the dents price them, from 54 to 48 ms. It
issues extra within the subsequent step, the place a convex ring turns into a single strip.

Write strips (−118 ms)​

So far each triangle prices three indices. A GPU may also draw a triangle strip, the place every new index provides a
triangle product of it and the 2 earlier than. A convex ring makes one strip should you zig-zag throughout it:

The ear clipper can write strips too. Cutting an ear makes the corners of its two neighbours sharper, so that they
are good candidates for the following ear, and reducing one in every of them extends the strip by a single index. The engine
tries them first and retains alternating between the 2 ends whereas the ears final. In its code the neighbours of
the reduce vertex are a and b:

whereas (true) {
    if (sideA) {
        const uint32_t z = n[a].prev;
        _strips.push_back(n[z].index);
        unlink(a);
        a = z;
    } else {
        const uint32_t z = n[b].subsequent;
        _strips.push_back(n[z].index);
        unlink(b);
        b = z;
    }
    rely--;
    sideA = !sideA;
    if (rely < 3 || !isEar(sideA ? a : b))
        break;
}

When the following nook isn’t an ear, the strip ends and the stroll goes on from the place it stopped. The 21.5 million
triangles now take 35.8 million indices as a substitute of 64.5 million. The ear assessments do not get fewer: the naive stroll
already went on on the subsequent nook after a reduce, and now each strip additionally ends on a check that fails, 25.0 million
as a substitute of 23.7 million. Still, the overall falls to 762 ms, and the
largest polygons drop from 146 to 103 ms.

Sort the dents into buckets (−65 ms)​

A forest or a lake can have hundreds of vertices and lots of of dents, and every ear check nonetheless reads each one
of them. When a polygon has greater than 32 dents, the engine kinds them into buckets alongside the longer aspect of their
bounding field, about two dents per bucket. An ear check appears to be like solely on the buckets that its triangle spans. As dents
flip convex and go away, the index is rebuilt as soon as half of it’s gone.

Points scanned fall from 181 million to 101 million, nearly all of it on the big polygons: the polygons with
257 vertices or extra go from 103 to 57 ms. Total: 697 ms.

Count with out branches (−178 ms)​

The loop within the dent check exits on the first dent contained in the triangle. Most of the time there may be none: the check
reads all of the dents and says sure. An early exit then buys nothing, and the three comparisons per level are
branches the CPU has to foretell. The engine first runs a go that solely counts dents contained in the triangle, with no
branches in any respect:

const double abx = b.x - a.x, aby = b.y - a.y;
const double bcx = c.x - b.x, bcy = c.y - b.y;
const double cax = a.x - c.x, cay = a.y - c.y;
uint32_t hits = 0;
for (uint32_t i = start; i < finish; ++i) {
    const Item &p = gadgets[i];
    const double aspect = std::min(
        std::min(abx * (p.y - a.y) - aby * (p.x - a.x),
                 bcx * (p.y - b.y) - bcy * (p.x - b.x)),
        cax * (p.y - c.y) - cay * (p.x - c.x));
    hits += (uint32_t)(aspect >= 0) & (uint32_t)(p.node != ia)
          & (uint32_t)(p.node != ic);
}
if (hits == 0)
    return true;

The smallest of the three determinants is non-negative precisely when the purpose is contained in the closed triangle. Only
when the rely isn’t zero does the precise loop from earlier than run, to rule out dents that sit on a nook. The
bucket model does the identical with a bounding-box check, 64 factors at a time right into a bit masks. The whole falls to
519 ms, and the center sizes achieve probably the most: polygons with 33 to 256
vertices go from 327 to 216 ms.

Test solely the marked dents (−30 ms)​

When the rely isn’t zero, the precise loop reads all of the dents once more, though the primary go has already seen
which of them have been inside. The bucket model retains that in its bit masks. The brief listing, as much as 32 dents, can do the
identical: the primary go units one bit per hit as a substitute of counting, and the precise check appears to be like solely at these dents:

    hits |= ((uint32_t)(aspect >= 0) & (uint32_t)(p.node != ia)
             & (uint32_t)(p.node != ic)) << (i - start);
}
whereas (hits) {
    const Item &p = gadgets[begin + lowestBit(hits)];
    hits &= hits - 1;
}

Points learn fall from 128 million to 120 million. This is the final step, and it’s the code of earstrip as
printed: 489 ms, 6.0 instances lower than Delaunay on the identical polygons.

When there are not any ears​

Meisters’ theorem is about easy polygons. Map information is rounded to a tile grid, and rounding can break a easy
polygon. Here is the define of Warszawa Śródmieście, a railway
station lower than a kilometre from the blocks above, rounded to grids of various dimension. The orange rings mark
vertices that land on the identical level as their neighbour:

At 14 bits per tile aspect, the grid our map information use, a grid step is eighteen
cm. Even there 31 of the 154 vertices merge with a neighbour, as a result of mappers usually place factors a number of centimetres
aside, and the define survives. At 12 bits almost
half of the vertices merge, and the clipper nonetheless cuts it.
At 11 bits the rounded define touches itself in a approach that leaves no ear
in any respect, and at 10 bits it occurs to work once more.

When the clipper walks all the best way across the boundary with out discovering an ear, it drops the corners that haven’t any
space and walks as soon as extra. If that fails too, it offers up, and the engine triangulates that polygon with the
Delaunay code, which nonetheless exists for this. In the Masovian information 76 polygons find yourself there. They come from a map
constructed earlier than the final change on the opposite finish: our map generator now rounds each polygon to the ultimate grid with
GEOS’s snap rounding and checks that ear clipping can reduce it. In a recent construct of the Masovian map that repaired 273
polygons, and ear clipping can reduce each polygon within the file.

Delaunay has yet another job. Every gap wants its personal bridge, and discovering one scans the entire boundary, so a polygon
with hundreds of holes pays for hundreds of scans. Our international stage map has a polygon with 11,675 holes: ear clipping
takes 606 ms on it, Delaunay 17 ms. The engine now sends each polygon with 128 holes or extra to Delaunay. In the
Masovian information that’s two polygons.

The library retains each of those fallbacks inside. earstrip covers a polygon with a constrained Delaunay
triangulation of its ring edges when the ears run out, when the triangles they go away cowl the improper space, and when
it has greater than 128 rings; run() in C++ and lastStatus() in JavaScript say which approach a polygon went. On the
56,472 polygons of our international stage map tiles, with as much as 11,675 holes in a single, earstrip takes 459 ms and earcut.hpp 2,892
ms. On the zoom 13 polygons that the ears cannot reduce precisely, earcut’s triangles differ from an even-odd fill of the
rings on 31% of the pixels on common, earstrip’s on 0.15%.

In the browser​

Before the brand new clipper went into the app, I in contrast it with earcut, the ear
clipper behind MapLibre and Mapbox GL, in its C++ model earcut.hpp 3.2.4. Natively the 2 are shut, and that
may have been the top of it. But we’re engaged on an internet renderer that runs the identical C++ engine compiled to
WebAssembly, so I went additional and in contrast the browser aspect too: each clippers compiled to WebAssembly, and
earcut.js 3.2.4, the JavaScript authentic that internet maps run right now. For that I took the clipper out of the engine
into earstrip. On all 5.8 million polygons of our check units it writes precisely the engine’s strips, and its
repository has these polygons and the code behind each quantity on this part. Its native benchmark is the one
behind the chart above, and the native row beneath is the final step run in opposition to earcut.hpp. Every WebAssembly construct offers precisely the identical triangles as its native model on all 4.4
million polygons of zoom ranges 13 and 9. Milliseconds for the three.74 million polygons of zoom 13, finest of seven, one
thread, V8 in Node and JavaScriptCore in Bun:

Natively earcut.hpp is 14% slower than earstrip. Compiled to WebAssembly and run in V8, earstrip loses 23% and
earcut.hpp loses 67%, nearly all of it in its important loop that searches for ears. It is not the allocator: builds with
mimalloc and emmalloc give the identical time. I have never dug additional. In V8, earcut.hpp in WebAssembly finally ends up solely 19%
sooner than plain earcut.js, and 10% as soon as every polygon is a separate name from JavaScript.

The bundle rows are what an internet web page will get, and the earcut column there may be earcut.js. The name that replaces
earcut takes the coordinates as JavaScript numbers and returns a brand new array of triangle indices each time: 1.4
instances as quick as earcut.js in V8 and 1.6 instances in JavaScriptCore. About half of what it loses in opposition to the loop
contained in the module goes into copying the coordinates in and turning the strips into an inventory, the remainder into calling
into WebAssembly as soon as per polygon. The direct calls skip all of that: the
polygons go straight into the module’s reminiscence and are available again as one index buffer of strips for WebGL 2 or WebGPU,
1.7 and a couple of.1 instances as quick as earcut.js.

Some of the concepts above are in earcut too. It additionally depends on the truth that solely a dent can block an ear, however it
checks that final, for each vertex that passes the bounding field and triangle assessments, as a substitute of retaining an inventory of
dents. Above 80 vertices it hyperlinks them in z-order and scans solely the stretch of that curve the triangle’s bounding
field covers, which does the job of the buckets. What it does not have are the shortcut for convex polygons, the strips
and the rely with out branches: it writes three indices per triangle and stops on the first level inside.

earstrip is on GitHub and npm, with
the polygons from this publish and the code to time it in opposition to earcut by yourself machine.