earcut vs polygon-clipping vs clipper-lib
Geometric Clipping Libraries Comparison
Search packages..
1 Year
earcutpolygon-clippingclipper-libSimilar Packages:
What's Geometric Clipping Libraries?

These libraries provide functionalities for geometric operations such as clipping, triangulation, and polygon manipulation. They are essential in applications involving graphics rendering, spatial analysis, and geographic information systems (GIS). Each library has its unique strengths and use cases, making them suitable for different types of geometric computations and visualizations.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
earcut2,899,0722,28257.4 kB244 months agoISC
polygon-clipping448,425578350 kB44a year agoMIT
clipper-lib16,403187215 kB7-BSL
Feature Comparison: earcut vs polygon-clipping vs clipper-lib

Clipping Operations

  • earcut:

    earcut does not perform clipping operations; instead, it focuses solely on triangulating polygons. It efficiently converts a polygon into a set of triangles, which is essential for rendering in graphics applications but does not handle clipping.

  • polygon-clipping:

    polygon-clipping provides basic clipping operations such as intersection and union. It is suitable for applications that require simple geometric manipulations without the complexity of handling intricate shapes.

  • clipper-lib:

    clipper-lib supports a wide range of clipping operations including union, intersection, difference, and XOR. It can handle complex polygons with holes and overlapping shapes, making it ideal for applications that require precise geometric manipulations.

Performance

  • earcut:

    earcut is known for its exceptional speed in triangulating polygons. It is designed to be lightweight and fast, making it an excellent choice for real-time applications where performance is critical, such as in gaming or interactive graphics.

  • polygon-clipping:

    polygon-clipping is generally slower than clipper-lib and earcut due to its simpler algorithms. It is best suited for applications where performance is not the primary concern and where ease of use is more important.

  • clipper-lib:

    clipper-lib is optimized for performance, especially when dealing with complex polygons. It uses an efficient algorithm that minimizes the number of operations required for clipping, making it suitable for high-performance applications.

Ease of Use

  • earcut:

    earcut is very easy to use, with a straightforward API that allows developers to quickly implement polygon triangulation. It is designed for simplicity and can be integrated with minimal effort into existing projects.

  • polygon-clipping:

    polygon-clipping offers a user-friendly API that is easy to understand and implement. It is suitable for developers who need basic polygon operations without the overhead of complex configurations.

  • clipper-lib:

    clipper-lib has a steeper learning curve due to its comprehensive feature set and complexity. It requires a good understanding of geometric concepts to utilize effectively, making it less beginner-friendly.

Library Size

  • earcut:

    earcut is lightweight and has a small footprint, making it an excellent choice for performance-sensitive applications where minimizing bundle size is crucial.

  • polygon-clipping:

    polygon-clipping is also lightweight, but it may not be as optimized as earcut. It strikes a balance between functionality and size, making it suitable for applications that need basic clipping without significant overhead.

  • clipper-lib:

    clipper-lib is relatively large due to its extensive functionality and support for various geometric operations. This may impact the overall bundle size of applications that include it.

Use Cases

  • earcut:

    earcut is perfect for real-time graphics applications, such as games and interactive visualizations, where fast triangulation of polygons is needed for rendering.

  • polygon-clipping:

    polygon-clipping is suitable for simpler applications that need basic geometric operations, such as web mapping tools or simple graphic editors.

  • clipper-lib:

    clipper-lib is ideal for applications requiring complex polygon operations, such as CAD software, GIS applications, and any scenario where precise geometric calculations are necessary.

How to Choose: earcut vs polygon-clipping vs clipper-lib
  • earcut:

    Choose earcut if your primary focus is on fast and efficient polygon triangulation. It is particularly useful for rendering 2D shapes in WebGL or canvas, where performance is critical, and you need a lightweight solution for converting polygons into triangles.

  • polygon-clipping:

    Choose polygon-clipping if you require a straightforward library for basic polygon operations like intersection, union, and difference. It is user-friendly and ideal for simpler applications where advanced features are not necessary.

  • clipper-lib:

    Choose clipper-lib if you need a robust solution for polygon clipping and boolean operations. It excels in handling complex shapes and is suitable for applications requiring precise geometric calculations, such as CAD software or GIS applications.

Similar Npm Packages to earcut

earcut is a fast and efficient ear clipping triangulation library for 2D polygons. It is widely used in graphics programming, game development, and geographic information systems (GIS) for converting complex polygon shapes into a series of triangles, which can be rendered more efficiently by graphics hardware. Earcut is particularly known for its speed and simplicity, making it a popular choice among developers looking for a lightweight solution for polygon triangulation.

While earcut is a solid option for triangulation, there are several alternatives in the ecosystem that provide similar functionalities. Here are a few noteworthy alternatives:

  • clipper-lib is a robust library for polygon clipping and offsetting. It provides advanced features for performing operations like union, intersection, and difference on polygons. Clipper-lib is particularly useful when you need to handle complex polygon shapes and perform operations beyond simple triangulation. If your project requires extensive polygon manipulation, including clipping and offsetting, clipper-lib is an excellent choice.
  • delaunator is a library specifically designed for Delaunay triangulation. Unlike earcut, which focuses on general polygon triangulation, delaunator is optimized for creating triangulations from a set of points in a 2D space. This library is particularly useful in scenarios where you need to generate a triangulated mesh from scattered points, such as in terrain modeling or spatial analysis. If your application requires Delaunay triangulation, delaunator is the go-to solution.
  • polylabel is a library that focuses on finding the optimal label position for polygons. While it does not perform triangulation directly, it is often used in conjunction with triangulation libraries to improve the placement of labels on complex shapes. If your project involves rendering polygons with labels and you need to ensure that the labels are placed optimally, polylabel can complement your triangulation solution effectively.

To see how earcut compares with clipper-lib, delaunator, and polylabel, check out the comparison: Comparing clipper-lib vs delaunator vs earcut vs polylabel.

Similar Npm Packages to polygon-clipping

polygon-clipping is a JavaScript library designed for performing polygon clipping operations, which include intersection, union, difference, and XOR operations on polygons. This library is particularly useful in applications involving geographic information systems (GIS), computer graphics, and any scenario where complex polygon manipulations are required. By providing a straightforward API for polygon operations, polygon-clipping enables developers to efficiently manage and manipulate polygonal shapes.

However, there are several alternatives in the JavaScript ecosystem that also provide polygon manipulation capabilities. Here are a few noteworthy options:

  • clipper-lib is a powerful library for polygon clipping and offsetting. It is based on the Clipper algorithm, which is known for its efficiency and accuracy in handling complex polygon operations. clipper-lib supports a wide range of operations, including union, intersection, difference, and offsetting, making it suitable for applications that require high-performance polygon manipulation. If you need advanced features and robust performance, clipper-lib is an excellent choice.

  • d3-polygon is part of the D3.js library, which is widely used for data visualization. The d3-polygon module provides utilities for working with polygons, including functions for calculating area, centroid, and convex hull. While it does not focus solely on clipping operations, it can be useful for basic polygon manipulations and calculations in conjunction with other D3 modules. If you're already using D3 for data visualization, integrating d3-polygon can be a natural fit for your project.

  • earcut is a fast and efficient library for triangulating polygons. It is particularly useful for converting complex polygon shapes into a series of triangles, which can then be rendered in WebGL or other graphics contexts. While earcut does not provide clipping operations directly, it can be used in scenarios where triangulation is required after performing clipping operations with other libraries. If your primary need is for triangulation, earcut is a great option.

  • turf is a comprehensive geospatial analysis library that provides a wide range of functions for working with geographic data. It includes capabilities for polygon manipulation, such as clipping, union, and intersection, making it suitable for GIS applications. If you are working with geospatial data and require a robust set of tools for analysis and manipulation, turf is a powerful choice.

To see how these libraries compare, check out the comparison: Comparing clipper-lib vs d3-polygon vs earcut vs polygon-clipping vs turf.

Similar Npm Packages to clipper-lib

clipper-lib is a powerful JavaScript library designed for polygon clipping and boolean operations on polygons. It allows developers to perform complex geometric operations such as union, intersection, difference, and XOR on 2D polygons. This library is particularly useful in applications that require advanced geometric manipulations, such as CAD software, GIS applications, and game development. With its robust algorithms, clipper-lib can handle a wide range of polygon shapes and sizes efficiently.

While clipper-lib is a strong choice for polygon operations, there are alternatives that may better suit specific needs:

  • earcut is a fast and efficient library for triangulating polygons. It is particularly useful when you need to convert complex polygon shapes into triangles for rendering in WebGL or other graphics contexts. earcut is lightweight and focuses solely on the triangulation process, making it a great choice for applications that require quick and straightforward polygon triangulation without the overhead of additional features.
  • polygon-clipping is another library that specializes in polygon clipping operations. It provides a simple API for performing boolean operations on polygons, similar to clipper-lib. However, polygon-clipping is designed to be lightweight and easy to use, making it suitable for applications that require basic polygon clipping functionalities without the complexity of more advanced libraries.

To see how clipper-lib compares with earcut and polygon-clipping, check out the comparison: Comparing clipper-lib vs earcut vs polygon-clipping.

README for earcut

Earcut

The fastest and smallest JavaScript polygon triangulation library. 3KB gzipped.

Node Average time to resolve an issue Percentage of issues still open

The algorithm

The library implements a modified ear slicing algorithm, optimized by z-order curve hashing and extended to handle holes, twisted polygons, degeneracies and self-intersections in a way that doesn't guarantee correctness of triangulation, but attempts to always produce acceptable results for practical data.

It's based on ideas from FIST: Fast Industrial-Strength Triangulation of Polygons by Martin Held and Triangulation by Ear Clipping by David Eberly.

Why another triangulation library?

The aim of this project is to create a JS triangulation library that is fast enough for real-time triangulation in the browser, sacrificing triangulation quality for raw speed and simplicity, while being robust enough to handle most practical datasets without crashing or producing garbage. Some benchmarks using Node 0.12:

(ops/sec) | pts | earcut | libtess | poly2tri | pnltri | polyk ------------------| ---- | --------- | -------- | -------- | --------- | ------ OSM building | 15 | 795,935 | 50,640 | 61,501 | 122,966 | 175,570 dude shape | 94 | 35,658 | 10,339 | 8,784 | 11,172 | 13,557 holed dude shape | 104 | 28,319 | 8,883 | 7,494 | 2,130 | n/a complex OSM water | 2523 | 543 | 77.54 | failure | failure | n/a huge OSM water | 5667 | 95 | 29.30 | failure | failure | n/a

The original use case it was created for is Mapbox GL, WebGL-based interactive maps.

If you want to get correct triangulation even on very bad data with lots of self-intersections and earcut is not precise enough, take a look at libtess.js.

Usage

const triangles = earcut([10,0, 0,50, 60,60, 70,10]); // returns [1,0,3, 3,2,1]

Signature: earcut(vertices[, holes, dimensions = 2]).

  • vertices is a flat array of vertex coordinates like [x0,y0, x1,y1, x2,y2, ...].
  • holes is an array of hole indices if any (e.g. [5, 8] for a 12-vertex input would mean one hole with vertices 5–7 and another with 8–11).
  • dimensions is the number of coordinates per vertex in the input array (2 by default). Only two are used for triangulation (x and y), and the rest are ignored.

Each group of three vertex indices in the resulting array forms a triangle.

// triangulating a polygon with a hole
earcut([0,0, 100,0, 100,100, 0,100,  20,20, 80,20, 80,80, 20,80], [4]);
// [3,0,4, 5,4,0, 3,4,7, 5,0,1, 2,3,7, 6,5,1, 2,7,6, 6,1,2]

// triangulating a polygon with 3d coords
earcut([10,0,1, 0,50,2, 60,60,3, 70,10,4], null, 3);
// [1,0,3, 3,2,1]

If you pass a single vertex as a hole, Earcut treats it as a Steiner point.

Note that Earcut is a 2D triangulation algorithm, and handles 3D data as if it was projected onto the XY plane (with Z component ignored).

If your input is a multi-dimensional array (e.g. GeoJSON Polygon), you can convert it to the format expected by Earcut with earcut.flatten:

const data = earcut.flatten(geojson.geometry.coordinates);
const triangles = earcut(data.vertices, data.holes, data.dimensions);

After getting a triangulation, you can verify its correctness with earcut.deviation:

const deviation = earcut.deviation(vertices, holes, dimensions, triangles);

Returns the relative difference between the total area of triangles and the area of the input polygon. 0 means the triangulation is fully correct.

Install

Install with NPM: npm install earcut, then import as a module:

import earcut from 'earcut';

Or use as a module directly in the browser with jsDelivr:

<script type="module">
    import earcut from 'https://cdn.jsdelivr.net/npm/earcut/+esm';
</script>

Alternatively, there's a UMD browser bundle with an earcut global variable (exposing the main function as earcut.default):

<script src="https://cdn.jsdelivr.net/npm/earcut/dist/earcut.min.js"></script>

Ports to other languages

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc or npmjs.com, the official website for the npm registry. Please note that npm is a registered trademark of npm, Inc. For more details, please refer to our Terms & Privacy.