Pith. sign in

REVIEW 2 major objections 5 minor 70 references

PaMO: Parallel Mesh Optimization for Intersection-Free Low-Poly Modeling on the GPU

T0 review · 2 major / 5 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read A three-stage GPU pipeline converts any input 3D mesh — including non-manifold, self-intersecting triangle soups — into a watertight, manifold, intersection-free low-poly mesh in seconds.

desk verdict PaMO is a strong GPU mesh-optimization pipeline with real speed wins, but the 'intersection-free guarantee' is not actually established because Algorithm 3 deliberately suppresses short intersection segments for shared-vertex pairs. read the letter →

arxiv 2509.05595 v1 pith:JHB5ZAU4 submitted 2025-09-06 cs.GR

Seonghun Oh , Xiaodi Yuan , Xinyue Wei , Ruoxi Shi , Fanbo Xiang , Minghua Liu , Hao Su This is my paper · ORCID
classification cs.GR MSC 68U0565D18
keywords meshsimplificationGPUparallelismself-intersectiondetectionlow-polymodelingremeshingdualmarchingcubessafeprojectionintersection-freeguarantee
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that mesh simplification with a self-intersection guarantee — for decades a slow, sequential, CPU-bound operation — can be moved entirely onto the GPU and run fast enough for interactive use. PaMO takes any input mesh, including non-manifold triangle soups and meshes that already self-intersect, and produces a watertight, manifold, intersection-free low-poly approximation through three GPU stages: parallel remeshing, parallel edge-collapse simplification that rolls back any collapse which creates a self-intersection, and a collision-aware projection that pulls vertices back toward the original surface and recovers sharp features. If the claims hold, the practical cost of the guarantee all but disappears: a two-million-face mesh is decimated to 20,000 triangles in about three seconds on a single consumer GPU, and 98% of the Thingi10K test corpus is reduced to 1% of its faces in under two seconds. That matters because the downstream consumers of low-poly meshes — 3D printing, boolean operations, soft-body and cloth simulation — typically reject self-intersecting geometry outright, so speed combined with the guarantee is what makes the output directly usable.

What carries the argument

The load-bearing object is the GPU self-intersection detector used in the simplification stage and inherited by the other stages' guarantees. It pairs a parallel LBVH acceleration structure with a triangle-pair test that splits intersections into genuinely three-dimensional cases, handled by a determinant-based sign test, and coplanar cases, subdivided by how many vertices the two triangles share: no shared vertex, one shared vertex (an angle-overlap test), and two shared vertices (a same-side-of-the-edge test). Because coplanar vertex- or edge-sharing between neighboring triangles is legitimate and must not be flagged, this case analysis is what lets the algorithm promise intersection-free output while still collapsing aggressively. The same guarantee thread runs through the other two stages: Dual Marching Cubes patched with an envelope-based quad-division rule and smoothed interpolation to avoid isosurface self-intersections, and a Newton-type optimizer with a barrier energy plus additive continuous collision detection that certifies every projection step is intersection-free.

What would settle it

Run the simplification stage on meshes seeded with adversarial coplanar configurations that the curated set does not obviously cover — near-degenerate shared-vertex overlaps and edge-sharing pairs a few machine-epsilons from the separating case — then verify the entire output mesh with an independent exact-arithmetic triangle-intersection library; also sweep the mixed-precision detector against a double-precision reference on all Thingi10K outputs and count discrepancies. A single false negative that survives the undo loop contradicts the stated guarantee.

Watch

Extended reading notes

Core claim

On its own terms, the paper's discovery is that the three properties users want from low-poly meshing — manifoldness, freedom from self-intersection, and fidelity to the input — can each be enforced by a GPU-parallel stage that complements the others. The remeshing stage converts arbitrary inputs into a manifold, intersection-free surface with well-shaped triangles, which removes the need for the simplification stage to repair topology and makes its intersection check cheap and reliable. The simplification stage collapses edges in cost-propagated independent regions and then, after every iteration, detects every triangle pair that intersects using a case-based test that distinguishes genuine self-intersections from legitimate vertex- and edge-sharing; colliding collapses are undone until the mesh is clean. The final projection stage solves a constrained optimization, borrowing the barrier-function and continuous-collision machinery of deformable-body simulation, to move vertices back toward the input and recover sharp features without ever crossing into intersection. The paper's headline evidence is the speed — 2.75 seconds to decimate a two-million-face mesh to 2,000 triangles on an RTX 4090 — plus 100% manifold, intersection-free, and success rates across 100 difficult Thingi10K meshes.

Load-bearing premise

The paper's promised intersection-free property rests entirely on the GPU self-intersection detector never missing a real intersection, and that completeness is demonstrated empirically — on 10,100 curated triangle pairs and three meshes — rather than proven, so a single undetected configuration during any collapse iteration would silently break the guarantee.

Editorial extensions

If this is right

  • Mesh decimation that used to take tens of minutes and require a separate CPU remeshing pass now runs in seconds on a single GPU, so intersection-free low-poly generation can sit inside real-time content pipelines.
  • Applications that reject self-intersecting geometry — 3D printing validation, boolean operations, soft-body and cloth simulation — can accept the output of this pipeline directly without a repair stage.
  • The pipeline handles meshes in the wild (non-manifold, self-intersecting, triangle soups) without a preprocessing repair step, since the remeshing stage normalizes topology before simplification.
  • Larger decimation ratios (10–20% of faces) keep the intersection-free and manifold guarantees while matching baseline geometry-accuracy numbers, so the method covers both aggressive low-poly and moderate level-of-detail settings.
  • Sharp-feature recovery comes from the projection stage rather than from feature-aware decimation, so features survive aggressive simplification as long as the projection can see them in the input.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper's intersection-free guarantee is only as strong as its detector's completeness: the coplanar case analysis is validated empirically (10,100 curated triangle pairs and three meshes, 0% false negatives) rather than proven, and a formal argument or adversarial randomized generator would convert the guarantee from statistical to certified.
  • The authors' stated limitation — that simplification cannot see the input mesh and projection cannot change connectivity — suggests an immediate extension: interleaving collapse and projection so feature recovery and decimation inform each other, an integration the paper itself floats as future work.
  • The remeshing stage is topology-agnostic and processes meshes of 100k vertices in about three milliseconds, which makes the same UDF-plus-DualMC kernel a candidate for per-interaction watertight repair of scanned or generative-model outputs, not just a preprocessing step for simplification.
  • The 64-bit integer encoding that lets edge costs be compared exactly under GPU atomic operations is a transferable pattern for other parallel priority-based geometry algorithms beyond mesh decimation.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. The paper proposes PaMO, a GPU-based pipeline for converting arbitrary triangle meshes into low-poly, watertight, manifold, intersection-free meshes. Stage 1 computes a narrow-band unsigned distance field with a voxel-grid hierarchy and extracts a surface with dual marching cubes, with corrections for self-intersections and numerical instability. Stage 2 performs parallel QEM-based edge collapses in independent regions, then detects self-intersections with a BVH and a custom triangle-pair test and undoes collapses that introduce intersections. Stage 3 projects simplified vertices toward the input while minimizing a Chamfer-distance-inspired energy plus elastic and bending energies, using an IPC-style barrier and continuous collision detection to keep the trajectory intersection-free. The paper claims this is the first fully GPU-based mesh optimization method with intersection-free guarantees, and reports strong speed and geometric-quality results on a 100-mesh subset of Thingi10K and on the full dataset.

Significance. The engineering contribution is substantial: the method is reportedly one to two orders of magnitude faster than prior intersection-aware simplification (e.g., RoLoPM) while achieving competitive or better Chamfer/Hausdorff distances, and the ablations for edge costs, energy terms, and undo iterations are careful and informative. If the intersection-free guarantee is made rigorous, the paper would be a strong contribution to practical low-poly modeling. The evaluation is extensive and the presentation is generally clear. However, the central guarantee is currently not established because of the detector's deliberately suppressed small-intersection cases and the absence of a correctness proof; the empirical FNR=0 result is not a substitute. With the guarantee downgraded to a practical/empirical claim, the contribution remains valuable but would be weaker than advertised.

major comments (2)
  1. [§5.2, Algorithm 3, line 20] The 'intersection-free guarantee' stated in the Abstract and Contribution (b) is not established. For a non-coplanar triangle pair sharing exactly one vertex (s=1), Algorithm 3 reports an intersection only when ||l||>0 AND NOT(||l||≤ε AND s=1); consequently every positive-length intersection segment of length at most ε is classified as non-intersecting, even when that segment is a genuine crossing and not merely the shared vertex. An edge collapse can plausibly create such a configuration by folding a vertex slightly through a nearby triangle, and the paper gives no argument that this configuration class is empty. The value of ε is never defined, and the 0% FNR in Table 7 cannot cover this boundary class because randomly generated shared-vertex pairs rarely fall in the band 0<||l||≤ε. Since the safe-projection stage (Section 6) starts from the stage-2 mesh and its barrier/ACCD machinery assumes a non-intersecting input, a missed intersection here propagates to the final output. Please either prove that the suppressed case cannot be a genuine intersection, remove the ε suppression with exact predicates for the s=1 branch, or revise the guarantee to an empirical claim and add the restriction to Section 9.
  2. [§5.2 and Table 7] Even setting aside the ε branch, the guarantee depends on the completeness and numerical robustness of the GPU self-intersection detector. Algorithm 3's case analysis (s=0,1,2 and coplanar vs non-coplanar) is validated empirically on 10,100 curated triangle pairs and three meshes, but no proof shows that every self-intersecting configuration falls into one of the enumerated cases or that the mixed-precision floating-point checks never miss an intersection. Table 7's FNR=0 is strong evidence but not a guarantee, especially because the dataset is curated and may not cover degenerate configurations such as exactly coplanar partial overlaps with zero-area intersection or very small dihedral angles. If the word 'guarantee' is retained, the paper should either provide a formal correctness argument (e.g., exact predicates and exhaustive case analysis) or replace 'guarantee' with 'empirically robust' throughout the claims.
minor comments (5)
  1. [Abstract, §1, Figure 1] The reported timings for the large-mesh example are inconsistent: the abstract says a 2-million-face mesh is reduced to 20k triangles in 3 seconds, the introduction says 2k triangles in 2.75 seconds, and Figure 1 says 2M faces to 0.1% in 2.29 seconds; please unify these numbers.
  2. [§4.2] The text contains a stray '𝜀𝜀' and the sentence 'We first turn the UDF generated by the mesh-to-volume algorithm it into SDF' is grammatically broken; please fix this passage.
  3. [§7] The metric name 'Hausdroff' should be 'Hausdorff'.
  4. [Algorithm 1, lines 6–8] It is not stated how the triangle cost C_t is initialized before the min-propagation loop; please specify the initialization explicitly.
  5. [Figure 16 caption] The caption contains unresolved equation markup in the manuscript text; please check the rendered version.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: PaMO's derivation is self-contained, with no fitted parameter or definitional step that reduces a prediction to its input.

full rationale

I traced the claimed derivation chain through all three stages. The remeshing stage converts the input to a UDF/SDF and extracts a mesh via DualMC; its manifold/watertight/intersection-free properties are inherited from the isosurface-extraction construction, and no parameter is fitted to the evaluation metrics. The simplification stage uses QEM costs plus edge-length and skinny-triangle costs, then reverts collapses flagged by an external intersection test (Devillers/DG02, with BVH acceleration); the target face count is a user input and the 'intersection-free' property is enforced by detecting and undoing intersections, not defined into existence. The safe projection stage minimizes a Chamfer-distance-to-input energy with hyperelastic and bending regularizers plus an IPC-style barrier; although the distance energy resembles the downstream CD metric, it is an optimization objective evaluated against the external input surface, not a predicted quantity that was fitted from the metric, so there is no reduction of the paper's out-of-sample fidelity claim to its inputs. The one substantive weakness is a soundness gap, not circularity: Algorithm 3 line 20 suppresses 3D shared-vertex intersections with intersection-segment length at most epsilon, so the stated intersection-free guarantee is not fully established for that boundary class, and the Limitations section does not disclose this. That is an unsupported guarantee/correctness concern, not a circular derivation. Self-citations (e.g., WXB*23, LSC*23) appear only as related-work background and are not load-bearing for the central pipeline. I found no equation-level reduction, no fitted parameter renamed as a prediction, and no definitional dependence of the claimed output properties on the pipeline's own detector: score 0.

Assumptions & free parameters 8 free parameters · 6 assumptions · 0 invented entities

The pipeline relies on standard geometry-processing algorithms, plus several hand-set hyperparameters and an unproven but empirically tested intersection-detection case analysis. No new physical entities are introduced.

free parameters (8)
  • SDF band epsilon = 0.9 / R_DMC
    Threshold subtracted from UDF to define the signed field for DualMC; value borrowed from [CPW*23] and stated as required to avoid skipping sign changes.
  • Sigmoid smoothing beta = 5
    Chosen based on experimental observations (Appendix 12.1) to stabilize DualMC patch vertex interpolation.
  • Edge cost weights w_e, w_s = 0.001, 0.005
    Weights on edge length and skinny-triangle penalties in Eq. 1.
  • Safe projection energy weights = k_dis=1000, k_elas=0.1, k_bend=0.01
    Weights of distance, elastic, and bending energies in Eq. 8; fixed across all experiments.
  • Barrier parameters = k_bar=100, d_hat=1e-3
    Strength and activation distance for the IPC barrier in Eq. 10-11.
  • M2S sample count m = 16384
    Number of uniform samples of the input surface approximating the second Chamfer direction in Eq. 4.
  • Newton iterations T = 50
    Max iterations for safe projection; authors observe 30-50 sufficient (Sec. 8.4).
  • DualMC grid resolution R = 256 (128 for <1k target faces, 64 for <50)
    Grid resolution for the SDF volume; chosen based on target face count (Sec. 7).
assumptions (6)
  • standard math Devillers' triangle-triangle intersection test is correct for non-coplanar triangles
    Taken from [DG02]; central to the intersection checker in Algorithm 3.
  • domain assumption Envelope-based quad division from [JU06, Wan09] eliminates DualMC quad-division self-intersections
    Adopted without formal re-proof; validated empirically on 10k random grids (Sec. 8.2).
  • domain assumption The angle-overlap and same-side tests correctly classify coplanar vertex/edge-sharing configurations
    Proposed by the authors in Appendix 13 without a proof of exhaustiveness; validated on 10,100 curated triangle pairs (Table 7).
  • standard math Link condition guarantees the mesh remains manifold after edge collapses
    Standard result [DEGN99], invoked in Sec. 5.1.
  • domain assumption The IPC barrier method keeps the trajectory intersection-free when combined with ACCD line search
    Taken from [LFS*20] and [LKJ21]; the paper relies on this for the safe projection guarantee.
  • domain assumption Input meshes are normalized into [0,1]^3 and all distances are computed in this space
    Sec. 3; affects reported HD/CD magnitudes and SDF resolution choices.

how reviews work

0 comments
Cite this review

Pith. "Pith review of PaMO: Parallel Mesh Optimization for Intersection-Free Low-Poly Modeling on the GPU." pith.science (2026). https://pith.science/paper/JHB5ZAU4

@misc{pith2026250905595,
  author       = {Pith},
  title        = {Pith review of: PaMO: Parallel Mesh Optimization for Intersection-Free Low-Poly Modeling on the GPU},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JHB5ZAU4}},
  note         = {Machine review of arXiv:2509.05595}
}
read the original abstract

Reducing the triangle count in complex 3D models is a basic geometry preprocessing step in graphics pipelines such as efficient rendering and interactive editing. However, most existing mesh simplification methods exhibit a few issues. Firstly, they often lead to self-intersections during decimation, a major issue for applications such as 3D printing and soft-body simulation. Second, to perform simplification on a mesh in the wild, one would first need to perform re-meshing, which often suffers from surface shifts and losses of sharp features. Finally, existing re-meshing and simplification methods can take minutes when processing large-scale meshes, limiting their applications in practice. To address the challenges, we introduce a novel GPU-based mesh optimization approach containing three key components: (1) a parallel re-meshing algorithm to turn meshes in the wild into watertight, manifold, and intersection-free ones, and reduce the prevalence of poorly shaped triangles; (2) a robust parallel simplification algorithm with intersection-free guarantees; (3) an optimization-based safe projection algorithm to realign the simplified mesh with the input, eliminating the surface shift introduced by re-meshing and recovering the original sharp features. The algorithm demonstrates remarkable efficiency, simplifying a 2-million-face mesh to 20k triangles in 3 seconds on RTX4090. We evaluated the approach on the Thingi10K dataset and showcased its exceptional performance in geometry preservation and speed.

Figures

Figures reproduced from arXiv: 2509.05595 by the authors.

Figure 1
Figure 1. We propose a novel GPU-based mesh optimization method to convert meshes in the wild into low-poly, intersection-free, manifold meshes. Our algorithm efficiently processes large-scale meshes in seconds, preserving self-intersection-free and manifold properties with high quality. Left: Reducing the 2M-face “crab” to 0.1% in 2.29s. Right: Reducing the 7M-face “dragon” to 0.1% in 5.32s. (Only the output meshes are shown… view at source ↗
Figure 2
Figure 2. Overall pipeline of our method. Taking an arbitrary mesh as input, our GPU-based method first remeshes it into a manifold, intersection-free mesh. It is then simplified into a low-poly mesh with the desired face count. Finally, we project the surface vertices back towards the original mesh to mitigate surface shifts and recover sharp features. CD denotes the chamfer distance between the input mesh and the generated … view at source ↗
Figure 4
Figure 4. DualMC generates meshes containing much fewer skinny triangles compared with other iso-surface extraction algorithms. sized triangles and edges, enabling faster BVH querying for in￾tersection checks. Parallel Mesh Simplification performs parallel edge collapsing to reduce Mr into a low-poly mesh Ms with the desired face count. This stage also prevents the introduction of any self-intersections. Parallel Safe Project… view at source ↗
Figures from the paper (17 more)
Figure 5
Figure 5. Figure 5: Patches (in yellow) and a quad (in purple) in DualMC. (v+e, v−e) is a valid edge. Next, we proceed to con￾struct patches within each voxel by utilizing the look-up table once more. The vertex positions of these patches are determined through linear interpolation be￾twe…
Figure 7
Figure 7. Figure 7: Coplanar self-intersection cases. We have to distin￾guish between self-intersection (1)(2)(4) and vertex/edge sharing between neighboring triangles (3) and (5). the region consisting of these triangles is defined as an independent region associated with the edge (see …
Figure 6
Figure 6. Figure 6: Independent regions. The yellow and pink areas mark two independent regions (R1 and R2) associated with E1 and E2, respectively. E3 does not have an associated independent region since it has neighboring triangles that do not share the same cost with it. triangle ∆i jk…
Figure 8
Figure 8. Figure 8: Qualitative comparison with baseline methods. We visualize both the front and back of an object. Our method guarantees intersection-free output meshes, whereas baseline models cannot avoid producing self-intersecting triangles (marked in red). RoLoPM Ours Input [PITH_…
Figure 9
Figure 9. Figure 9: Qualitative comparison between Ours and RoLoPM. The original shape is preserved better in our output mesh, with fewer spike artifacts. number of vertices is 361,632. All methods tested are required to reduce the number of faces to 1% of the original mesh’s count. We ev…
Figure 10
Figure 10. Figure 10: Runtime distribution of our pipeline over the entire Thingi10K dataset. Note that we exclude 5 corrupted input meshes in the dataset. 8.1.0.1. Execution time distribution We evaluate the speed of our algorithm over the entire Thingi10K dataset and summarize the runtim…
Figure 11
Figure 11. Figure 11: Ablation study on the extra metrics in the edge com￾putation. Both edge length and skinny cost metrics can effectively reduce the appearance of skinny triangles. We assess their improve￾ments by calculating the minimum angle of triangles on the output mesh. 8.3.0.2. I…
Figure 12
Figure 12. Figure 12: Impact of remeshing on simplification performance. Left: number of edge collapses reversed by undo operation each iteration. Right: Number of edges remaining after each parallel edge collapse iteration. 8.3.0.3. Robustness of self-intersection check algorithm We evalu…
Figure 13
Figure 13. Figure 13: Level of detail. We examined the results of Chamfer Distance (CD) and Hausdorff Distance (HD) by applying different levels of detail to the same mesh. 8.4. Safe Projection w/o Safe Projection w/ Safe Projection [PITH_FULL_IMAGE:figures/full_fig_p012_13.png]
Figure 14
Figure 14. Figure 14: Effectiveness of safe projection. Safe projection recov￾ers sharp corners and edges from our simplified mesh, matching input geometry more closely. 8.4.0.1. Effectiveness of safe projection We have quantitatively shown in [PITH_FULL_IMAGE:figures/full_fig_p012_14.png]
Figure 15
Figure 15. Figure 15: Change of distances during optimization [PITH_FULL_IMAGE:figures/full_fig_p013_15.png]
Figure 16
Figure 16. Figure 16: Ablation study on the energies in safe projection. The absence of specific energies results in distinct artifacts in the output: absence of Ebend leads to large bending angles; absence of Eelas produces more skinny triangles; without EM2S, there is insufficient recove…
Figure 17
Figure 17. Figure 17: Look-Up table of DualMC cases. Figure adapted from [Nie04]. Here we show the look-up table for building DualMC patches. The original DualMC [Nie04] may introduce non-manifold struc￾tures in very rare cases, we follow the solution in [Wen13] to solve the problematic C1…
Figure 18
Figure 18. Figure 18: Patches (in yellow) and a quad (in purple) in DualMC. (v+e, v−e) is a valid edge. 12.1.0.1. Handling numerical instability In DualMC, the patch vertex v is determined through linear interpolation between the cor￾responding edge vertices (v 0 e , v 1 e ) based on their…
Figure 19
Figure 19. Figure 19: Single￾vertex-sharing cases. 13.1.0.2. Single vertex sharing case When there is one shared vertex, we propose angle-overlap test. We begin by designating a shared vertex as A from triangles △ABC and △ADE, as shown in [PITH_FULL_IMAGE:figures/full_fig_p018_19.png]
Figure 21
Figure 21. Figure 21: Edge-sharing cases. If C and D lie on opposite sides of the line AB, it indicates a simple edge sharing. Otherwise, if they are on the same side, it indicates a self-intersection. 13.2. 3D triangle intersection analysis Drawing on the capabilities of [DG02], which all…
Figure 20
Figure 20. Figure 20: Zero cross￾product cases. For vectors ⃗u and ⃗v, if |⃗u×⃗v| = 0, we further compare the signs of the dot products to ensure accurate intersection checks. The edge case handling can be described as follows: If |⃗u ×⃗v| = 0, then compare sign(⃗u · ⃗w) and sign(⃗v ·⃗w) f…

Review history (2 revisions) →

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

70 extracted references · 44 canonical work pages

  1. [1]

    write newline

    " write newline "" before.all 'output.state := FUNCTION fin.entry add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 if FUNCTIO...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION fin.entry.original add.period write newline FUNCTION new.block output.state before.all = 'skip after.block 'output.state := if FUNCTION new.sentence output.state after.block = 'skip output.state before.all = 'skip after.sentence 'output.state := if if FUNCTION not #0 #1 if FUNCTION and 'skip pop #0 i...

  3. [3]

    : A lightweight approach to repairing digitized polygon meshes

    Attene M. : A lightweight approach to repairing digitized polygon meshes. The visual computer 26 (2010), 1393--1406

    work page 2010

  4. [4]

    : Direct repair of self-intersecting meshes

    Attene M. : Direct repair of self-intersecting meshes. Graph. Models 76, 6 (nov 2014), 658–668. URL: https://doi.org/10.1016/j.gmod.2014.09.002, https://doi.org/10.1016/j.gmod.2014.09.002 doi:10.1016/j.gmod.2014.09.002

    doi:10.1016/j.gmod.2014.09.002 2014

  5. [5]

    Borouchaki H., Frey P. J. : Simplification of surface mesh using hausdorff envelope. Computer Methods in Applied Mechanics and Engineering 194, 48-49 (2005), 4864--4884. https://doi.org/10.1016/j.cma.2004.11.016 doi:10.1016/j.cma.2004.11.016

    work page doi:10.1016/j.cma.2004.11.016 2005

  6. [6]

    : Structure preserving cad model repair

    Bischoff S., Kobbelt L. : Structure preserving cad model repair. Computer Graphics Forum 24 (2005). URL: https://api.semanticscholar.org/CorpusID:7341662

    work page 2005

  7. [7]

    Stichting Blender Foundation, Amsterdam, 2018

    Blender Foundation : Blender - a 3D modelling and rendering package. Stichting Blender Foundation, Amsterdam, 2018. URL: http://www.blender.org

    work page 2018

  8. [8]

    : Robust low-poly meshing for general 3d models

    Chen Z., Pan Z., Wu K., Vouga E., Gao X. : Robust low-poly meshing for general 3d models. ACM Transactions on Graphics (TOG) 42, 4 (2023), 1--20

    work page 2023

Show all 70 references
  1. [10]

    Calli B., Walsman A., Singh A., Srinivasa S., Abbeel P., Dollar A. M. : Benchmarking in manipulation research: The ycb object and model set and benchmarking protocols. IEEE Robotics & Automation Magazine, 22 (2015) 36 - 52 22, 3 (Sept. 2015), 36--52. http://arxiv.org/abs/1502....

    2015 arXiv

  2. [11]

    : Neural marching cubes

    Chen Z., Zhang H. : Neural marching cubes. ACM Trans. Graph. 40, 6, Article 251 (December 2021), 15 pages 40, 6 (Dec. 2021), 1--15. http://arxiv.org/abs/2106.11272 arXiv:2106.11272 , https://doi.org/10.1145/3478513.3480518 doi:10.1145/3478513.3480518

    2021 arXiv

  3. [12]

    : trimesh, 2019

    Dawson-Haggerty et al. : trimesh, 2019. URL: https://trimesh.org/

    2019

  4. [13]

    : Topology preserving edge contraction

    Dey T., Edelsbrunner H., Guha S., Nekhayev D. : Topology preserving edge contraction. Publications de l'Institut Math \'e matique 66 (1999)

    1999

  5. [14]

    B., Vanhoucke V

    Downs L., Francis A., Koenig N., Kinman B., Hickman R., Reymann K., McHugh T. B., Vanhoucke V. : Google scanned objects: A high-quality dataset of 3d scanned household items. http://arxiv.org/abs/2204.11918 arXiv:2204.11918 , https://doi.org/10.48550/ARXIV.2204.11918 doi:10.48...

    doi arXiv

  6. [15]

    : Faster triangle-triangle intersection tests

    Devillers O., Guigue P. : Faster triangle-triangle intersection tests. PhD thesis, INRIA, 2002

    2002

  7. [16]

    : An efficient method of triangulating equi-valued surfaces by using tetrahedral cells

    Doi A., Koide A. : An efficient method of triangulating equi-valued surfaces by using tetrahedral cells. IEICE TRANSACTIONS on Information and Systems 74, 1 (1991), 214--224

    1991

  8. [17]

    : Real-time mesh simplification using the gpu

    DeCoro C., Tatarchuk N. : Real-time mesh simplification using the gpu. In Proceedings of the 2007 symposium on Interactive 3D graphics and games (2007), pp. 161--166

    2007

  9. [18]

    : Cgal: The computational geometry algorithms library

    Fabri A., Pion S. : Cgal: The computational geometry algorithms library. In Proceedings of the 17th ACM SIGSPATIAL international conference on advances in geographic information systems (2009), pp. 538--539

    2009

  10. [19]

    : Intersection free simplification

    Gumhold S., Borodin P., Klein R. : Intersection free simplification. Int. J. Shape Model. 9 (2003), 155--176. URL: https://api.semanticscholar.org/CorpusID:3080587

    2003

  11. [20]

    Garland M., Heckbert P. S. : Surface simplification using quadric error metrics. In Proceedings of the 24th annual conference on Computer graphics and interactive techniques (1997), pp. 209--216

    1997

  12. [21]

    N., Desbrun M., Schr\" o der P

    Grinspun E., Hirani A. N., Desbrun M., Schr\" o der P. : Discrete shells. In Proceedings of the 2003 ACM SIGGRAPH/Eurographics Symposium on Computer Animation (Goslar, DEU, 2003), SCA '03, Eurographics Association, p. 62–67

    2003

  13. [22]

    : Interactive gpu-based decimation of large meshes

    Gautron P., Kubisch C. : Interactive gpu-based decimation of large meshes. In ACM SIGGRAPH 2023 Talks. 2023, pp. 1--2

    2023

  14. [23]

    : Progressive meshes, 1996

    Hoppe H. : Progressive meshes, 1996. https://doi.org/10.1145/237170.237216 doi:10.1145/237170.237216

    1996

  15. [24]

    : Robust watertight manifold surface generation method for shapenet models

    Huang J., Su H., Guibas L. : Robust watertight manifold surface generation method for shapenet models. arXiv preprint arXiv:1802.01698 (2018)

    2018 arXiv

  16. [25]

    : Fast tetrahedral meshing in the wild

    Hu Y., Schneider T., Wang B., Zorin D., Panozzo D. : Fast tetrahedral meshing in the wild. ACM Trans. Graph. 39, 4 (July 2020). URL: https://doi.org/10.1145/3386569.3392385, https://doi.org/10.1145/3386569.3392385 doi:10.1145/3386569.3392385

    2020

  17. [26]

    : Tetrahedral meshing in the wild

    Hu Y., Zhou Q., Gao X., Jacobson A., Zorin D., Panozzo D. : Tetrahedral meshing in the wild. ACM Trans. Graph. 37, 4 (July 2018), 60:1--60:14. URL: http://doi.acm.org/10.1145/3197517.3201353, https://doi.org/10.1145/3197517.3201353 doi:10.1145/3197517.3201353

    2018

  18. [27]

    : Manifoldplus: A robust and scalable watertight manifold surface generation method for triangle soups

    Huang J., Zhou Y., Guibas L. : Manifoldplus: A robust and scalable watertight manifold surface generation method for triangle soups. arXiv preprint arXiv:2005.11621 (2020)

    2020 arXiv

  19. [28]

    S., Zorin D., Panozzo D., Schneider T

    Jiang Z., Dai J., Hu Y., Zhou Y., Dumas J., Zhou Q., Bajwa G. S., Zorin D., Panozzo D., Schneider T. : Declarative specification for unstructured mesh editing algorithms. ACM Transactions on Graphics (TOG) 41, 6 (2022), 1--14

    2022

  20. [29]

    : Dual contouring of hermite data, 2002

    Ju T., Losasso F., Schaefer S., Warren J. : Dual contouring of hermite data, 2002. https://doi.org/10.1145/566570.566586 doi:10.1145/566570.566586

    2002

  21. [30]

    : libigl: A simple c++ geometry processing library

    Jacobson A., Panozzo D., Sch \"u ller C., Diamanti O., Zhou Q., Pietroni N., et al. : libigl: A simple c++ geometry processing library. Google Scholar (2013)

    2013

  22. [31]

    : Intersection-free contouring on an octree grid

    Ju T., Udeshi T. : Intersection-free contouring on an octree grid. In Proceedings of Pacific graphics (2006), vol. 2006, Citeseer

    2006

  23. [32]

    : Maximizing parallelism in the construction of bvhs, octrees, and k-d trees

    Karras T. : Maximizing parallelism in the construction of bvhs, octrees, and k-d trees. In Proceedings of the Fourth ACM SIGGRAPH/Eurographics conference on High-Performance Graphics (2012), pp. 33--37

    2012

  24. [33]

    P., Botsch M., Schwanecke U., Seidel H.-P

    Kobbelt L. P., Botsch M., Schwanecke U., Seidel H.-P. : Feature sensitive surface extraction from volume data, 2001. https://doi.org/10.1145/383259.383265 doi:10.1145/383259.383265

    2001

  25. [34]

    : Gpu-based multiple-choice scheme for mesh simplification

    Koh N., Zhang W., Zheng J., Cai Y. : Gpu-based multiple-choice scheme for mesh simplification. In Proceedings of Computer Graphics International 2018. 2018, pp. 195--200

    2018

  26. [35]

    : Morton integrals for high speed geometry simplification

    Legrand H., Boubekeur T. : Morton integrals for high speed geometry simplification. In Proceedings of the 7th Conference on High-Performance Graphics (2015), pp. 105--112

    2015

  27. [36]

    E., Cline H

    Lorensen W. E., Cline H. E. : Marching cubes: A high resolution 3d surface construction algorithm. ACM SIGGRAPH Computer Graphics 21, 4 (1987), 163--169. https://doi.org/10.1145/37402.37422 doi:10.1145/37402.37422

    1987

  28. [37]

    : Deep marching cubes: Learning explicit surface representations, 2018

    Liao Y., Donne S., Geiger A. : Deep marching cubes: Learning explicit surface representations, 2018. https://doi.org/10.1109/cvpr.2018.00308 doi:10.1109/cvpr.2018.00308

    2018

  29. [38]

    Li M., Ferguson Z., Schneider T., Langlois T., Zorin D., Panozzo D., Jiang C., Kaufman D. M. : Incremental potential contact: Intersection- and inversion-free large deformation dynamics. ACM Trans. Graph. (SIGGRAPH) 39, 4 (2020)

    2020

  30. [39]

    : Magic3d: High-resolution text-to-3d content creation

    Lin C.-H., Gao J., Tang L., Takikawa T., Zeng X., Huang X., Kreis K., Fidler S., Liu M.-Y., Lin T.-Y. : Magic3d: High-resolution text-to-3d content creation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (2023), pp. 300--309

    2023

  31. [40]

    : Parallel mesh simplification using embedded tree collapsing

    Lee H., Kyung M.-H. : Parallel mesh simplification using embedded tree collapsing. The Visual Computer 32 (2016), 967--976

    2016

  32. [41]

    D., Kim V

    Liu H.-T. D., Kim V. G., Chaudhuri S., Aigerman N., Jacobson A. : Neural subdivision. arXiv preprint arXiv:2005.01819 (2020)

    2020 arXiv

  33. [42]

    M., Jiang C

    Li M., Kaufman D. M., Jiang C. : Codimensional incremental potential contact. ACM Trans. Graph. (SIGGRAPH) 40, 4 (2021)

    2021

  34. [43]

    D., Thiery J.-M., Jacobson A., Boubekeur T., Ovsjanikov M

    Lescoat T., Liu H.-T. D., Thiery J.-M., Jacobson A., Boubekeur T., Ovsjanikov M. : Spectral mesh simplification. Computer Graphics Forum 39 (2020). URL: https://api.semanticscholar.org/CorpusID:219161648

    2020

  35. [44]

    : One-2-3-45++: Fast single image to 3d objects with consistent multi-view generation and 3d diffusion

    Liu M., Shi R., Chen L., Zhang Z., Xu C., Wei X., Chen H., Zeng C., Gu J., Su H. : One-2-3-45++: Fast single image to 3d objects with consistent multi-view generation and 3d diffusion. arXiv preprint arXiv:2311.07885 (2023)

    2023 arXiv

  36. [45]

    : Model simplification using vertex-clustering, 1997

    Low K.-L., Tan T.-S. : Model simplification using vertex-clustering, 1997. https://doi.org/10.1145/253284.253310 doi:10.1145/253284.253310

    1997

  37. [46]

    : Image-driven simplification

    Lindstrom P., Turk G. : Image-driven simplification. ACM Trans. Graph. 19, 3 (jul 2000), 204–241. URL: https://doi.org/10.1145/353981.353995, https://doi.org/10.1145/353981.353995 doi:10.1145/353981.353995

    2000

  38. [47]

    H., Hussein M

    Mousa M. H., Hussein M. K. : High-performance simplification of triangular surfaces using a gpu. PloS one 16, 8 (2021), e0255832

    2021

  39. [48]

    : Openvdb: an open-source data structure and toolkit for high-resolution volumes

    Museth K., Lait J., Johanson J., Budsberg J., Henderson R., Alden M., Cucka P., Hill D., Pearce A. : Openvdb: an open-source data structure and toolkit for high-resolution volumes. In Acm siggraph 2013 courses. 2013, pp. 1--1

    2013

  40. [49]

    : A fast triangle-triangle intersection test

    M \"o ller T. : A fast triangle-triangle intersection test. Journal of graphics tools 2, 2 (1997), 25--30

    1997

  41. [50]

    Natarajan B. K. : On generating topologically consistent isosurfaces from uniform samples. Vis. Comput. 11, 1 (jan 1994), 52–62. URL: https://doi.org/10.1007/BF01900699, https://doi.org/10.1007/BF01900699 doi:10.1007/BF01900699

    1994 doi

  42. [51]

    Nielson G. M. : Dual marching cubes. In IEEE visualization 2004 (2004), IEEE, pp. 489--496

    2004

  43. [52]

    Nocedal J., Wright S. J. : Numerical optimization, 2nd ed ed. Springer series in operations research. Springer, New York, 2006

    2006

  44. [53]

    : Gpu-accelerated triangle mesh simplification using parallel vertex removal

    Odaker T., Kranzlmueller D., Volkert J. : Gpu-accelerated triangle mesh simplification using parallel vertex removal. International Journal of Computer and Information Engineering 10, 1 (2016), 160--166

    2016

  45. [54]

    : Triangular mesh simplification on the gpu

    Papageorgiou A., Platis N. : Triangular mesh simplification on the gpu. The Visual Computer 31 (2015), 235--244

    2015

  46. [55]

    : Atomic volumes for mesh completion

    Podolak J., Rusinkiewicz S. : Atomic volumes for mesh completion. In Symposium on Geometry Processing (2005), vol. 33, p. 41

    2005

  47. [56]

    : Alpha wrapping with an offset

    Portaneri C., Rouxel-Labb\' e M., Hemmer M., Cohen-Steiner D., Alliez P. : Alpha wrapping with an offset. ACM Trans. Graph. 41, 4 (jul 2022). URL: https://doi.org/10.1145/3528223.3530152, https://doi.org/10.1145/3528223.3530152 doi:10.1145/3528223.3530152

    2022

  48. [57]

    : Multi-resolution 3d approximations for rendering complex scenes, 1993

    Rossignac J., Borrel P. : Multi-resolution 3d approximations for rendering complex scenes, 1993. https://doi.org/10.1007/978-3-642-78114-8_29 doi:10.1007/978-3-642-78114-8_29

    1993 doi

  49. [58]

    : Fem simulation of 3d deformable solids: a practitioner's guide to theory, discretization and model reduction

    Sifakis E., Barbic J. : Fem simulation of 3d deformable solids: a practitioner's guide to theory, discretization and model reduction. In ACM SIGGRAPH 2012 Courses (New York, NY, USA, 2012), SIGGRAPH '12, Association for Computing Machinery. URL: https://doi.org/10.1145/2343483...

    2012

  50. [59]

    : Deep marching tetrahedra: a hybrid representation for high-resolution 3d shape synthesis

    Shen T., Gao J., Yin K., Liu M.-Y., Fidler S. : Deep marching tetrahedra: a hybrid representation for high-resolution 3d shape synthesis. http://arxiv.org/abs/2111.04276 arXiv:2111.04276 , https://doi.org/10.48550/ARXIV.2111.04276 doi:10.48550/ARXIV.2111.04276

    doi arXiv

  51. [60]

    : Flexible isosurface extraction for gradient-based mesh optimization

    Shen T., Munkberg J., Hasselgren J., Yin K., Wang Z., Chen W., Gojcic Z., Fidler S., Sharp N., Gao J. : Flexible isosurface extraction for gradient-based mesh optimization. ACM Transactions on Graphics 42, 4 (2023), 1--16. https://doi.org/10.1145/3592430 doi:10.1145/3592430

    2023 doi

  52. [61]

    : Dual marching cubes: Primal contouring of dual grids

    Schaefer S., Warren J. : Dual marching cubes: Primal contouring of dual grids. Computer Graphics Forum 24, 2 (2005), 195--201. https://doi.org/10.1111/j.1467-8659.2005.00843.x doi:10.1111/j.1467-8659.2005.00843.x

    2005

  53. [62]

    : Marching cubes 33: Construction of topologically correct isosurfaces

    Tcherniaev E. : Marching cubes 33: Construction of topologically correct isosurfaces

  54. [63]

    : Discrete bending forces and their Jacobians

    Tamstorf R., Grinspun E. : Discrete bending forces and their Jacobians . Graphical Models 75, 6 (Nov. 2013), 362--370. URL: https://linkinghub.elsevier.com/retrieve/pii/S1524070313000209, https://doi.org/10.1016/j.gmod.2013.07.001 doi:10.1016/j.gmod.2013.07.001

    2013 doi

  55. [64]

    : Delicate textured mesh recovery from nerf via adaptive surface refinement

    Tang J., Zhou H., Chen X., Hu T., Ding E., Wang J., Zeng G. : Delicate textured mesh recovery from nerf via adaptive surface refinement. arXiv preprint arXiv:2303.02091 (2022)

    2022 arXiv

  56. [65]

    Wang C. C. : Intersection-free dual contouring on uniform grids: an approach based on convex/concave analysis. Tech. rep., Technical Report, 2009, http://www2. mae. cuhk. edu. hk/\ cwang/pubs …, 2009

    2009

  57. [66]

    : Isosurfaces: geometry, topology, and algorithms

    Wenger R. : Isosurfaces: geometry, topology, and algorithms. CRC Press, 2013

    2013

  58. [67]

    : Feature preserving mesh simplification using feature sensitive metric

    Wei J., Lou Y. : Feature preserving mesh simplification using feature sensitive metric. Journal of Computer Science and Technology 25, 3 (2010), 595--605. https://doi.org/10.1007/s11390-010-9348-7 doi:10.1007/s11390-010-9348-7

    2010 doi

  59. [68]

    S., Ernst M

    Wald I., Woop S., Benthin C., Johnson G. S., Ernst M. : Embree: a kernel framework for efficient cpu ray tracing. ACM Transactions on Graphics (TOG) 33, 4 (2014), 1--8

    2014

  60. [69]

    : Neumanifold: Neural watertight manifold reconstruction with efficient and high-quality rendering support

    Wei X., Xiang F., Bi S., Chen A., Sunkavalli K., Xu Z., Su H. : Neumanifold: Neural watertight manifold reconstruction with efficient and high-quality rendering support. http://arxiv.org/abs/2305.17134 arXiv:2305.17134 , https://doi.org/10.48550/ARXIV.2305.17134 doi:10.48550/A...

    doi arXiv

  61. [70]

    : Thingi10k: A dataset of 10,000 3d-printing models

    Zhou Q., Jacobson A. : Thingi10k: A dataset of 10,000 3d-printing models. arXiv preprint arXiv:1605.04797 (2016)

    2016 arXiv

  62. [71]

    : Open3d: A modern library for 3d data processing

    Zhou Q.-Y., Park J., Koltun V. : Open3d: A modern library for 3d data processing. arXiv preprint arXiv:1801.09847 (2018)

    2018 arXiv

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.