polygon-clipping vs clipper-lib vs earcut
Geometric Clipping Libraries
Search packages..
polygon-clippingclipper-libearcutSimilar Packages:

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.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
polygon-clipping410,564619350 kB452 years agoMIT
clipper-lib48,029210215 kB7-BSL
earcut02,43157.3 kB258 months agoISC

Feature Comparison: polygon-clipping vs clipper-lib vs earcut

Clipping Operations

  • 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.

  • 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.

Performance

  • 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.

  • 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.

Ease of Use

  • 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.

  • 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.

Library Size

  • 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.

  • earcut:

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

Use Cases

  • 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.

  • earcut:

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

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

  • 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.

  • 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.

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.

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.

README for polygon-clipping

polygon-clipping

Apply boolean Polygon clipping operations (intersection, union, difference, xor) to your Polygons & MultiPolygons.

CI codecov License: MIT npm

Quickstart

const polygonClipping = require('polygon-clipping')

const poly1 = [[[0,0],[2,0],[0,2],[0,0]]]
const poly2 = [[[-1,0],[1,0],[0,1],[-1,0]]]

polygonClipping.union       (poly1, poly2 /* , poly3, ... */)
polygonClipping.intersection(poly1, poly2 /* , poly3, ... */)
polygonClipping.xor         (poly1, poly2 /* , poly3, ... */)
polygonClipping.difference  (poly1, poly2 /* , poly3, ... */)

API

/* All functions take one or more [multi]polygon(s) as input */

polygonClipping.union       (<geom>, ...<geoms>)
polygonClipping.intersection(<geom>, ...<geoms>)
polygonClipping.xor         (<geom>, ...<geoms>)

/* The clipGeoms will be subtracted from the subjectGeom */
polygonClipping.difference(<subjectGeom>, ...<clipGeoms>)

Input

Each positional argument (<geom>) may be either a Polygon or a MultiPolygon. The GeoJSON spec is followed, with the following notes/modifications:

  • MultiPolygons may contain touching or overlapping Polygons.
  • rings are not required to be self-closing.
  • rings may contain repeated points, which are ignored.
  • rings may be self-touching and/or self-crossing. Self-crossing rings will be interpreted using the non-zero rule.
  • winding order of rings does not matter.
  • inner rings may extend outside their outer ring. The portion of inner rings outside their outer ring is dropped.
  • inner rings may touch or overlap each other.

Output

For non-empty results, output will always be a MultiPolygon containing one or more non-overlapping, non-edge-sharing Polygons. The GeoJSON spec is followed, with the following notes/modifications:

  • outer rings will be wound counter-clockwise, and inner rings clockwise.
  • inner rings will not extend outside their outer ring.
  • rings will not overlap, nor share an edge with each other.
  • rings will be self-closing.
  • rings will not contain repeated points.
  • rings will not contain superfluous points (intermediate points along a straight line).
  • rings will not be self-touching nor self-crossing.
  • rings may touch each other, but may not cross each other.

In the event that the result of the operation is the empty set, output will be a MultiPolygon with no Polygons: [].

Correctness

Run: npm test

The tests are broken up into unit tests and end-to-end tests. The end-to-end tests are organized as GeoJSON files, to make them easy to visualize thanks to GitHub's helpful rendering of GeoJSON files. Browse those tests here.

Performance

The Martinez-Rueda-Feito polygon clipping algorithm is used to compute the result in O((n+k)*log(n)) time, where n is the total number of edges in all polygons involved and k is the number of intersections between edges.

Settings

Global settings are set via environment variables.

  • POLYGON_CLIPPING_MAX_QUEUE_SIZE and POLYGON_CLIPPING_MAX_SWEEPLINE_SEGMENTS: Aims to prevent infinite loops - usually caused by floating-point math round-off errors. Defaults are 1,000,000.

Changelog

This project adheres to Semantic Versioning.

The full changelog is available at CHANGELOG.md.

Authors

Sponsors

Please contact Mike Fogel if you or your company is interested in sponsoring work on specific bug fixes or feature requests.

Based on

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