CGAL Mesh Simplification vs MeshLib
As we keep on delving into the mesh simplification domain, our team posts another piece to compare MeshLib with CGAL. CGAL, aka the Computational Geometry Algorithms Library, is undoubtedly a tool that comes to mind when considering options for mesh simplification manipulations. We had no choice but to include CGAL in our broad evaluation of available tools.
Below, our team delves into our CGAL mesh simplification vs MeshLib test, highlighting the strengths and limitations per each alternative.
Examination Guidelines for MeshLib and CGAL Mesh Reduction Capabilities
Our exploration of mesh simplification gets kicked off with a Nefertiti mesh. Take a look, it is a highly detailed model, presenting 2+ million triangles to handle. This tier of complexity turns the mesh into an adequate testing ground.
Our testing ground for the MeshLib and CGAL simplification refinement and remeshing potential
Basics for Mesh Simplification Research
For sure, mesh simplification scenarios vary. Sometimes, one seeks to reduce complexity by 10 times. Reductions of 100 or even 1000 times are not uncommon, too. While it is impossible to cover every and every feasible case, we believe the libraries’ capabilities could be evaluated against two key benchmarks.
Case # 1. Heavy mesh simplification. Our task here is to turn 2 million triangles into 2K;
Case # 2. Moderate mesh simplification. Our next step would be to diminish the complexity by as few as ten times, bringing it to 200,000.
For those who use CGAL to simplify meshes, we compared their choice with two our modes of ours:
- Single-Threaded Simplification, using the power of a single CPU;
- Multi-Threaded Simplification, utilizing multiple threads simultaneously. As far as our examination is concerned, we had a 16-core-strong machine on our end.
- These two modes, as well as the CGAL mesh simplification alternative, will be tested against seven parameters that are associated with mesh simplification and clearly indicate the effectiveness of a particular library. You will find them in the table below. Here is what these figures mean:
- ‘Time’—stands for the actual duration, in seconds, invested in completing our Nefertiti mesh simplification mission.
- ‘Degeneracies’—represent the number of triangles with extreme aspect ratios (those greater than 1:100).
- ‘Self-Intersections’—refer to the total number of areas where geometries overlap or intersect.
- ‘Small Components’—indicate the count of isolated or disconnected elements that would turn our resulting mesh into a source of potential issues.
- ‘Holes’—denote the number of gaps or missing geometries within the mesh, which, again, constitutes a major spoiler.
- ‘Hausdorff Distance (mm)’—means the greatest difference between the original and simplified meshes.
- ‘Average Absolute Distance (mm)’—finally, represents the average discrepancy, offering a general measure of geometric precision.
Nota bene: When putting the MT mode to your personal test, ensure the number of threads matches your system’s cores. Any attempts with 64 threads per 16 cores, for instance, will be a waste of time and resources. On the contrary, 16 per 16 would suffice.
Also note: If you want to learn how to reduce the number of triangles in CGAL, check out how the CGAL simplification, quadric edge collapse decimation, works, by visiting the official CGAL documentation.
Covering Heavy Mesh Simplification
To substantiate our findings, we present the results of our work upfront.
Single-Threaded Technique: MeshLib Library
Multi-Threaded Technique: MeshLib Library
CGAL Mesh Reduction results
As one is free to see, each of the three outcomes seems to be suitable for use. They truly deliver, indeed. To explore the comparison further, we encourage our readers to evaluate their efficiency based on the following results.
MeshLib and CGAL Simplification, Refinement and Remeshing: Heavy Case Rundown
Criterion | Single-Threaded | Multi-Threaded | CGAL |
|---|---|---|---|
Task Time(s) | 3.9 | 0.9 | 43 |
Degeneracies | 0 | 0 | 15 |
Self-Intersections | 0 | 0 | 0 |
Small Components | 0 | 0 | 0 |
Holes | 0 | 0 | 0 |
Hausdorff Distance (mm) | 3.45 | 3.286 | 4.45 |
Average absolute distance (mm) | 0.287 | 0.284 | 0.398 |
Heavy Mesh Simplification Initiated with MeshLib vs. CGAL
Our comparison of MeshLib and CGAL showcases some discrepancies concerning performance and quality:
- Task Times. MT MeshLib was the fastest (0.9 seconds), followed by Single-Threaded MeshLib (3,9 seconds). CGAL took a lot more. 43 seconds do mean something;
- Geometry Integrity. MeshLib (both versions) maintained flawless geometry. CGAL did introduce some degeneracies. As many as 15;
- Exactness. Multi-Threaded MeshLib excelled in accuracy with the lowest Hausdorff Distance and Average Absolute Distance. CGAL showed worse values.
These results demonstrate MeshLib’s efficiency and accuracy, especially the Multi-Threaded mode of ours. That is, here, our remarkable speed, precision, and flawless geometry preservation set a new benchmark in advanced mesh processing solutions.
Covering Moderate Scenario: CGAL Mesh Reduction vs MeshLib
Similar to the previous section, we start with a visual demonstration.
Single-Threaded Technique
Multi-Threaded Technique
CGAL Mesh Reduction Output
Again, the eventual visuals look decent. Concurrently, MeshLib seems to be a higher-quality option. That holds true if you dive deeper. Let’s scrutinize the details.
MeshLib and CGAL Mesh Simplification Boiled Down
Criterion | Single-Threaded | Multi-Threaded | CGAL |
|---|---|---|---|
Task Time(s) | 3.8 | 0.9 | 26.9 |
Degeneracies | 0 | 0 | 290 |
Self-Intersections | 3 | 0 | 14 |
Small Components | 0 | 0 | 0 |
Holes | 0 | 0 | 0 |
Hausdorff Distance (mm) | 0.143 | 0.143 | 0.34 |
Average absolute distance (mm) | 0.018 | 0.018 | 0.026 |
Moderate Mesh Simplification Initiated with MeshLib vs. CGAL
Our comparison of MeshLib with CGAL, again, reveals some important differences:
- Task Times. Multi-Threaded MeshLib was the fastest contestant, followed by our ST. CGAL took a much longer timeframe;
- Geometry Integrity. MeshLib (both versions) maintained perfect geometry, while CGAL caused degeneracies and self-intersections;
- Exactness. Both ST and MR MeshLib showed excellent accuracy, with identical Hausdorff and Average Absolute Distance. CGAL performed worse.
These results highlight MeshLib’s efficiency and precision, particularly in the MT mode. Given the figures in the table, MeshLib’s does set a benchmark in this moderate context.
Conclusion Regarding CGAL vs. MeshLib
When to choose what:
- ST and MT from MeshLib. Choose MeshLib for faster performance, better geometry preservation, and higher accuracy. It is especially so when the Multi-Threaded mode for optimal results is available (that is, when you have enough cores).
- CGAL. You can consider CGAL when time is less critical and geometric accuracy is not the primary concern (yet, MeshLib would generally serve you as a better option).
All in all, MeshLib’s single- and multi-threaded modes do deliver adequate speed, geometry preservation, and accuracy—making us a promising option for numerous applications.
Final Remark
Whenever you feel like you want to put the CGAL mesh reduction feature to test, in contrast with MeshLib, here is our source file to test.