acceptodds
Under review as a conference paper at ICLR 2027

BVHMesh: Face-First Mesh Generation on a Bounding Volume Hierarchy

Abstract

Artist-style meshes are compact and editable, but generating their continuous geometry and irregular connectivity efficiently remains challenging. Field-based methods extract dense tessellations, whereas autoregressive methods directly generate compact meshes but decode sequentially. Recent flow-based methods generate vertices in parallel and then recover faces from predicted connectivity, where edge errors can propagate into invalid surfaces. We introduce BVHMesh as a face-first flow-based framework that decodes triangles in parallel and stitches them into a mesh. To make triangle prediction tractable, we organize triangles in an octree-aligned bounding volume hierarchy (OctBVH). Its nested boxes provide local coordinate frames for coarse-to-fine geometry prediction, while octree alignment allows sparse convolutions to process the hierarchy. A hierarchical VAE and conditional flow priors generate triangle soups from point clouds or images. EdgeMatch then recovers connectivity through learned half-edge matching with explicit checks against non-manifold edges, duplicate faces, and collapsed triangles. On Toys4K, BVHMesh achieves state-of-the-art VAE reconstruction and artist-mesh generation under both point-cloud and image conditioning. In point-cloud generation, its non-manifold edge ratio is zero versus for MeshFlow, while inference takes about seconds per mesh even beyond faces.

Primary area:
generative models
Keywords:
Flow-based Mesh Generation, Bounding Volume Hierarchy, Topology-constrained stitching

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_mTL3OpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes a new representation for native mesh generation. It first generates a triangle soup of disconnected triangles using a combination of BVH and octree structures, then stitches these triangles together through a post-processing method to obtain the final mesh. During stitching, validity checks, including mesh manifoldness checks, are applied to ensure the quality of the resulting mesh.

Critical strengths
  1. The idea of generating triangles first and then stitching them into a mesh is very interesting. In particular, the triangles are not generated directly in a straightforward manner; instead, the method combines BVH and octree structures. The ablation results in Table 4 also demonstrate the effectiveness of this representation.
  2. I like the rendering style and presentation of the paper, and the diagrams are clear and easy to understand.
  3. The triangle-stitching module appears relatively independent of the main generation pipeline. It seems that it could be packaged as a standalone module for use with other triangle-soup generation methods.
Critical weaknesses
  1. The paper does not describe the detailed design of the VAE or clearly explain its relationship to TRELLIS.2’s SC-VAE and OctFormer. This may make it difficult for the community to reproduce the network architecture.
  2. It is unclear why the authors sort triangle vertices by their coordinates during preprocessing. Since a triangle’s orientation depends on its vertex ordering, this encoding scheme appears to discard face-orientation information.
Questions for authors
  1. Could the authors provide a more detailed description of the VAE architecture? For example, which components from TRELLIS.2 are incorporated into an OctFormer-based architecture, or, conversely, which components from OctFormer are incorporated into TRELLIS.2’s SC-VAE? Additionally, does the flow model use the architecture of the original TRELLIS.1 or TRELLIS.2?
  2. Could the authors explain the rationale for sorting triangle vertices by their coordinates? Could the original vertex order be preserved when generating triangles to ensure correct face orientations in the generated mesh?
  3. The triangle-stitching module appears relatively independent of the main generation pipeline. I believe it could be packaged as a standalone post-processing module for triangle soups, making it applicable to a broader range of triangle-soup generation methods. I would be interested in hearing the authors’ perspective on this possibility.
2 comments
AuthorsOpenReview ↗

Response to Reviewer mTL3

Thank you for recognizing our face-first approach, OctBVH representation, and visual presentation, as well as for your constructive questions on network architecture, face orientation, and standalone stitching.

1. VAE and Flow Model Architectures (W1, Q1)

  • OctBVH VAE: Our VAE uses OctFormer blocks as the backbone at each octree depth, while borrowing TRELLIS.2's spatial-to-channel (S2C) downsampling and channel-to-spatial (C2S) upsampling across depths, implemented on octrees with O-CNN convolutions and 8-child folding/unfolding residual shortcuts.
DepthEncoder (channel / blocks)Decoder (channel / blocks)
996 / 296 / 2
8192 / 4192 / 4
7384 / 4384 / 4
6768 / 8768 / 8
  • Flow generation: We directly adopt TRELLIS.2's flow models (with the identical 1.3B DiT architecture and model size) and fine-tune them on our mesh data—namely, triangle-centroid sparse voxels and OctBVH structured latents. We have included full architectural specifications and hyperparameters in Appendix and will release our code.

2. Vertex Coordinate Sorting and Face Orientation (W2, Q2)

Following previous works, including MeshGPT (Siddiqui et al.), MeshAnything / V2 (Chen et al.), MeshRipple (Lin et al.), and MeshFlow (Sun et al.), we sort triangle corners canonically by coordinates so that the three predicted vertex slots match the ground-truth order one-to-one. This provides deterministic regression targets and prevents inconsistent vertex ordering (or taking the minimum loss over cyclic vertex permutations) from destabilizing triangle coordinate supervision. Preserving cyclic order starting from the lexicographically smallest corner is also a viable option to retain winding, while in our pipeline we recover consistent orientation during stitching as described below.

Prior methods, such as MeshAnything V2, BPT (Weng et al.), DeepMesh (Zhao et al.), and MeshFlow (Sun et al.), recover face orientation in post-processing via Trimesh's fix_normals(). However, fix_normals() only propagates orientation across adjacent faces and cannot resolve Möbius-like non-orientable loops that can form when stitching disconnected triangles.

Motivated by your question, we extend EdgeMatch with a relative winding check during stitching without retraining. Because each shared manifold edge fixes the relative orientation of its two incident faces regardless of input triangle orientation, EdgeMatch rejects merges that would close non-orientable loops. We then apply fix_normals() to unify face winding within each component. Adding ~0.5 s per mesh, this achieves 100% winding-consistent outputs on Toys4K while leaving geometric metrics virtually unchanged:

ModelsMethodCD ↓HD ↓NC ↑Winding (%) ↑
VAE reconstructionfix_normals4.7525.80.97242.83
VAE reconstructionfix_normals + Winding Check4.7525.80.972100.00
Point-cloud generationfix_normals8.2964.70.94118.50
Point-cloud generationfix_normals + Winding Check8.2964.70.941100.00

3. Application of EdgeMatch to Other Face-first Methods (Q3)

Since EdgeMatch operates solely on triangle soup without relying on upstream latents, it can serve directly as a standalone stitcher. Motivated by your suggestion, we applied our frozen EdgeMatch (without retraining or fine-tuning) to raw triangle soups generated by MeshFlow (Sun et al., 2026), comparing against MeshFlow's own post-processing: (1) Vertex Merging (merging quantized coincident vertices), and (2) Denoiser + Vertex Merging (refining coordinates with MeshFlow's pretrained vertex denoiser before vertex merging). Following MeshFlow's ShapeNet evaluation protocol across four categories (bench, chair, lamp, and table; 800 generated meshes), we report topology and distributional quality (1-NNA):

MethodNon-manifold edges (%) ↓Non-manifold vertices ↓Boundary edges (%) ↓Components ↓1-NNA (%)
MeshFlow + Vertex Merging0.008037.9699.88467.4755.35
MeshFlow + Denoiser + Vertex Merging1.7674178.5390.81380.6557.24
MeshFlow + EdgeMatch (Ours)0037.1028.5955.37

EdgeMatch eliminates non-manifold edges and vertices, substantially reduces open boundaries and disconnected components, and preserves generation quality (1-NNA)—whereas vertex merging, even with MeshFlow's denoiser, leaves the mesh largely disconnected and introduces non-manifold defects. This confirms EdgeMatch's effectiveness as a plug-and-play stitcher for external triangle-soup generators.

Reviewer_mTL3OpenReview ↗

Response to rebuttal

I thank the authors for their clarifications and for the additional experiments on face orientation and EdgeMatch. The response addresses my main concerns, so I will maintain my current rating and lean toward acceptance. I encourage the authors to include a discussion of potential extensions of the approach in the camera-ready version.

Reviewer_b5nPOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary
  • paper introduces BVHMESH, as a face-first flow-based framework that decodes triangles in parallel and stitches them into a mesh.
  • triangles are organized in an octree-aligned bounding volume hierarchy (OctBVH).
  • hierarchical VAE + flow matching generate triangle soups from point clouds or images.
  • EdgeMatch recovers connectivity through learned half-edge matching (basically a second stage to make sure a reasonable mesh comes out)
  • additional checks against non-manifold edges, duplicate faces, and collapsed triangles.

Face-first approach trades for complexity to clean up in post. Although the concept of operating in faces is certainly not new. The difference here seems the OctBVH part + EdgeMatch merge/reject.

Critical strengths
  • results are reasonable and comparisons over sota methods.
  • the paper is relatively easy to follow and the method is found
Critical weaknesses
  • I'd challenge the claim that sparse convs are not meant for Oct-tree based data structures. Feel straightforward in particular since generators on Octrees are known.
  • Contribution point 3 is not adding much aside from saying there are results.
  • Would've loved to see a nice video showing the generation process
  • The figures and presentation is sensible, but properly evaluating the mesh quality based on the visualizations is extremely difficult.
  • Could've also seen the meshes being submitted as supplemental material; that would've solved the previous part
  • Novelty is not stunning: most things are known, the new part is the BVH pitch (face-first methods are known; also post-stitching is not a new idea).
Questions for authors

No specific questions; I feel the paper is relatively clear to follow.

3 comments
AuthorsOpenReview ↗

Response to Reviewer b5nP

Thank you for recognizing our results and presentation clarity, as well as for your helpful suggestions on writing, visualization, and positioning.

1. Sparse Convolutions and Octree Compatibility (W1)

We are happy to clarify: our remark in Sec. 1 (Lines 073–078) referred specifically to conventional BVHs, which we described as "irregular trees" to which sparse convolutions are not well suited for generation; we then introduced OctBVH precisely to enable "octree-based sparse convolutions" (see also Abstract and Sec. 3.2).

Unlike an octree, a conventional BVH partitions geometry into irregular subtrees without a fixed spatial grid or neighbor indexing, so standard sparse or octree convolutions cannot be applied directly. By organizing triangle centroids into a regular octree while augmenting each node with its tight subtree bounding box as a local coordinate frame, OctBVH naturally supports established octree convolutions (O-CNN) and OctFormers. We fully agree that octree convolutions and generators are well established, and have revised the wording in Sec. 1 to "conventional irregular BVHs" to make this distinction clearer.

2. Contribution Statement and Writing (W2)

We agree that the original third contribution read mainly as a result summary. We have revised it to highlight how our evaluations and component ablations validate the effectiveness of our proposed OctBVH and EdgeMatch designs.

3. Project Page: Method Video and Mesh Viewer (W3–W5)

We agree that static figures alone cannot fully convey the generation process and mesh quality. We are happy to prepare an anonymous project page featuring (i) an explanatory video visualizing the less intuitive parts of our method—such as OctBVH construction, coarse-to-fine decoding, and EdgeMatch stitching, and (ii) an interactive 3D mesh viewer for freely rotating and zooming in on generated meshes. The project page is coming soon, and we will share the link before the end of the rebuttal period.

4. Novelty over Prior Face-First Methods (W6)

As discussed in Sec. 2.3 (Lines 144–152), prior parallel face-first methods—such as PolyDiff (Alliegro et al., 2023), MeshCraft (He et al., 2025), and MeshFlow (Sun et al., 2026)—also generate triangle soups and merge vertices afterward, but face two key limitations that OctBVH and EdgeMatch specifically overcome:

  • Hierarchical local frames vs. direct global face prediction: Prior generators predict face coordinates directly in global space, making it difficult to jointly model global placement and fine local geometry at scale. OctBVH instead decomposes triangle prediction across scales via quantized parent-relative bounding boxes and continuous leaf-local coordinates: under the identical octree structure and VAE backbone (Table 4), predicting global continuous or discrete coordinates (w/o OctBVH) degrades CD from 4.95 to 35.27 and 42.94, isolating the gain of hierarchical local frames over direct face prediction.
  • Constrained half-edge matching vs. proximity vertex welding: Existing face-first pipelines stitch soups via discrete coordinate deduplication or proximity-based vertex welding, even with coordinate denoising as in MeshFlow (Sun et al., 2026). Merging individual vertices by distance is many-to-many and topology-blind, easily leaving cracks or welding nearby separate surfaces into non-manifold and degenerate faces. Exploiting the fact that each manifold half-edge has at most one partner, EdgeMatch instead performs learned partial one-to-one half-edge matching with explicit checks against non-manifold edges, duplicate faces, and collapsed triangles. It lifts F1 from 47.8% (distance welding) to 95.0% on noisy soups (σ=0.004\sigma=0.004, Table 5), and applied zero-shot to raw soups from MeshFlow, cuts boundary edges from 90.8% to 37.1% while reducing non-manifold edges (1.77% →\rightarrow 0%) and vertices (178.5 →\rightarrow 0) to zero (see Response to mTL3, Q3).

Thanks for the rebuttal.

It didn't add anything substantial to my opinion though; I'm still at my weak accept rating, and I think the paper can be accepted assuming the authors follow up on the proposed changes regarding positioning, contributions, clarity etc.. In particular, I would expect a nicely polished video for the camera ready version (IMO that should be also in the author's interest to encourage follow ups works). Overall, I appreciate the authors commitment to these changes!

AuthorsOpenReview ↗

Anonymous Project Page with Method Video and Interactive Mesh Viewer

Thank you again for your constructive feedback and for your continued support of our paper. As promised, our anonymous project page is now available:

https://bvhmesh.pages.dev

Following your suggestions (W3–W5), the page includes:

  1. Method video. A narrated explanatory video that visualizes the details of our method that are hard to convey with static figures, including OctBVH construction, coarse-to-fine decoding of hierarchical local frames, and EdgeMatch stitching of triangle soups into manifold meshes.
  2. Interactive mesh viewer. Generated meshes can be freely rotated and zoomed with wireframe rendering, so the mesh topology and face quality can be inspected directly.
  3. Side-by-side comparisons. Our results are shown alongside baselines under synchronized views for pointcloud-conditioned generation, image-conditioned generation, and VAE reconstruction.

We hope this addresses your concern that mesh quality is difficult to judge from static visualizations alone. As you suggested, we will further polish the video for the camera-ready version, as we agree it will help encourage follow-up work. We would sincerely welcome any further suggestions you may have on the video or the page.

We will also incorporate all the revisions discussed above regarding positioning, the contribution statement, and clarity. If you feel that the project page and these revisions have resolved your remaining concerns, we would be grateful if you would consider taking them into account in your final assessment.

Thank you again for your time and thoughtful review.

Reviewer_Fn25OpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper presents BVHMesh, a face-first generator of artist-style meshes. It decodes triangles in parallel from an octree-aligned bounding volume hierarchy using quantized parent-relative boxes and continuous leaf triangles. EdgeMatch then stitches the triangles through learned one-to-one half-edge matching, with checks that reject non-manifold, duplicate or collapsed faces. Generation uses TRELLIS-style two-stage flow matching conditioned on point clouds or images. Trained on about 175K meshes and evaluated on Toys4K, it reports state-of-the-art reconstruction and generation, zero non-manifold edges and about 15 s per mesh, with ablations of OctBVH and EdgeMatch.

Critical strengths
  1. Face-first generation with half-edge matching is a good reframing.

    • Vertex-first methods must solve a many-to-many connectivity problem. Here each half-edge has at most one partner, so stitching becomes a partial one-to-one matching problem.
    • The topology checks make the output edge-manifold by construction.
    • OctBVH (quantized boxes relative to their parent, plus continuous triangles in each leaf) is well motivated, and Table 4 ablates it convincingly where CD drops from 42.94 to 4.95.
  2. The method is best on VAE reconstruction and on both point-cloud- and image-conditioned generation, with roughly constant inference of about 15 s.

Critical weaknesses
  1. Topology quality is only measured where the method wins by construction.

    • Holes instead of non-manifold edges. The 0% non-manifold edge rate is enforced by rejecting merges, and the half-edges whose merges are rejected stay as boundaries. The likely trade-off is holes and cracks, but nothing measures it: no boundary-edge ratio, watertightness, or number of connected components.
    • Non-manifold vertices. Union-find vertex merging can also create non-manifold "bowtie" vertices, and only edges are checked.
    • Orientation. Triangle corners are sorted by x-y-z before building the OctBVH (Appendix A), which throws away the winding order, and EdgeMatch scores both endpoint correspondences. So the output may not be consistently oriented.
    • Orientation-blind metrics. Every reported metric ignores orientation: NC uses absolute dot products (Appendix C.1), and FID uses double-sided normal maps (Appendix C.3).

    For a paper whose pitch is artist-style meshes with clean topology, these properties need to be reported for every method:

    • percentage of consistently oriented meshes
    • boundary-edge percentage
    • number of components
    • number of non-manifold vertices
  2. The evaluation protocol favours the representation, and the speed comparison leaves out the direct competitors.

    • Filtered test set. Toys4K is filtered with the method's own leaf-collision budget, keeping only meshes with at most 5% of triangles beyond the one-triangle-per-leaf limit (Sec. 4.1). This keeps meshes the representation can encode, and the baselines are scored on that subset.
    • Possible overlap. Objaverse-XL and Toys4K both draw on public asset repositories, and no deduplication is described.
    • Speed comparison. Fig. 8 times only autoregressive models. The real competitors are the parallel flow models, MeshFlow and LATO.2, and they are not timed.
    • EdgeMatch ablation. Table 5 is computed on ground-truth triangle soups with Gaussian vertex noise, not on decoded or generated soups, whose errors are structured rather than i.i.d.
Questions for authors

Answers to the following questions could change my assessment

  1. What fraction of Toys4K does the leaf-collision filter remove? What are the main results on the unfiltered set?
  2. For each method, what are the boundary-edge percentage, the number of components, the number of non-manifold vertices, and the percentage of consistently oriented meshes?
  3. How is consistent face winding recovered after the corners are sorted?
  4. What are the inference times of MeshFlow and LATO.2 on the same RTX 5090?
  5. Was the training data (TRELLIS-500K / Objaverse-XL) deduplicated against Toys4K?
  6. Report EdgeMatch precision and recall on real decoded soups, for example by assigning ground-truth correspondences through the nearest ground-truth faces.
3 comments
AuthorsOpenReview ↗

Response to Reviewer Fn25 (Part 1/2)

Thank you for recognizing our face-first formulation, OctBVH representation, and generation performance, as well as for your constructive questions on topology and evaluation.

1. Additional Topology Quality Metrics (W1, Q2)

TaskMethodBoundary edges (%) ↓Components ↓Non-manifold vertices ↓Winding-consistent meshes (%) ↑
VAE reconstructionMeshFlow1.7112.16913.5316.02
VAE reconstructionLATO2.478.46878.1599.42
VAE reconstructionOurs5.529.610.00100.00
Point-cloud generationMeshFlow2.197.36102.1822.72
Point-cloud generationLATO.211.4027.971030.980.00
Point-cloud generationOurs22.4428.140.00100.00

All values are averaged per mesh on Toys4K, compared against MeshFlow (Li et al.) and LATO / LATO.2. Components use shared-edge connectivity, and winding consistency checks edges shared by exactly two faces.

  • Boundaries vs. manifoldness: Although vertex-first baselines show fewer boundary edges and components, this comes from indiscriminate over-connection rather than valid surface closure. Linking nearby vertices into overlapping faces and across separate parts artificially hides open boundaries behind 11.5%–33.4% non-manifold edges and 5.7%–25.7% redundant area (Fig. 3), alongside 102–1,031 non-manifold vertices. EdgeMatch instead leaves ambiguous or mismatched half-edges unmerged as clean local seams rather than forcing invalid connections, keeping every component strictly manifold.
  • Non-manifold vertices: "Bowtie" vertices occur when isolated vertices are welded without a shared edge. EdgeMatch never welds single vertices; instead, it merges corners in pairs along matched half-edges under checks against collapsed faces, duplicate faces, and non-manifold edges. Consequently, vertex fans are always joined along shared edges rather than pinched at a single point, keeping every vertex link a single path or cycle. An explicit vertex-link check confirms 0.00 non-manifold vertices across all outputs in both tasks.

2. Face Orientation Recovery after Coordinate Sorting (W1, Q3)

Following previous works including MeshGPT (Siddiqui et al.), MeshAnything / V2 (Chen et al.), MeshRipple (Lin et al.), and MeshFlow (Sun et al.), we sort triangle corners canonically to provide deterministic regression targets, preventing inconsistent vertex ordering from destabilizing triangle coordinate supervision.

Prior methods—such as MeshAnything V2, BPT (Weng et al.), DeepMesh (Zhao et al.), and MeshFlow—subsequently recover face orientation in post-processing via Trimesh's fix_normals(). However, fix_normals() only propagates orientation across adjacent faces and cannot resolve Möbius-like non-orientable loops that can form when stitching disconnected triangles.

Inspired by your suggestions, we extend EdgeMatch with a relative winding check during stitching without retraining. Because each shared manifold edge fixes the relative orientation of its two incident faces, EdgeMatch rejects merges that would close non-orientable loops. We then apply fix_normals() to unify face winding within each component. Adding ~0.5 s per mesh, this yields 100% winding-consistent outputs in both settings, while keeping non-manifold defects at 0 and geometric and topology metrics virtually unchanged (see Response to mTL3, Q2).

AuthorsOpenReview ↗

Response to Reviewer Fn25 (Part 2/2)

3. Toys4K Unfiltered Evaluation (W2, Q1)

For consistent curation, Toys4K underwent the same three-stage filter as our training set (Appendix B, Table 7), retaining compact meshes (100–20,000 faces), limiting OctBVH leaf collisions, and removing defective assets via mesh-quality checks (slender, degenerate, or non-manifold faces):

Filtering stepRemovedRemaining
Raw Toys4K–3,229
Face count (100–20,000)1,0812,148
Leaf collisions (≤5%)4641,684
Mesh quality3111,373

For unfiltered evaluation, we removed both the leaf-collision and mesh-quality filters while keeping the 100–20,000 face bound, as we target compact artist-style meshes—overly dense assets are typically scans or reconstructions, and MeshFlow (Li et al.) and LATO / LATO.2 were not trained at such high face counts either. Across all 2,148 Toys4K meshes:

SettingMethodCD ↓HD ↓NC ↑
VAE reconstructionMeshFlow8.1844.220.926
VAE reconstructionLATO4.9157.720.950
VAE reconstructionOurs4.8829.420.965
Point-cloud generationMeshFlow11.2363.520.881
Point-cloud generationLATO.28.8879.530.880
Point-cloud generationOurs8.8872.400.922

In VAE reconstruction, our method remains best on all three metrics. In point-cloud generation, despite training only on curated meshes, BVHMesh still achieves the best CD and NC and remains competitive in HD. Note that LATO.2 includes Toys4K in its training data (LATO.2, Sec. 4.1), so its results here are not strictly held-out.

4. Evaluation Dataset and Overlap Practice (W2, Q5)

We follow the official TRELLIS-500K split—holding out all of Toys4K from training—without additional cross-repository deduplication between Objaverse-XL and Toys4K. Treating Toys4K as a dataset-level held-out benchmark is standard across recent 3D and native-mesh generators, including TRELLIS, TRELLIS.2, FastMesh, MeshFlow (Li et al.), PolyFlow, and Nexus. Since most compared baselines are likewise trained on Objaverse(-XL) or TRELLIS-500K, any potential cross-repository overlap affects methods equally rather than favoring BVHMesh.

5. Inference Time Comparison with MeshFlow and LATO.2 (W2, Q4)

We timed all three flow-based methods on the same 100 shapes on an RTX 5090 (batch size 1):

MethodFlow params (M)Mean time (s) ↓Median time (s) ↓
MeshFlow895.613.263.21
LATO.2382.954.553.68
BVHMesh (Ours)2,584.4314.8012.67

We admit that BVHMesh is slower than MeshFlow (Li et al.) and LATO.2; Fig. 8 was meant to show constant-time scaling relative to autoregressive baselines rather than claim a speed advantage over parallel flow models. Our latency stems from backbone scale rather than OctBVH or EdgeMatch: we use two 1.3B TRELLIS.2 DiTs, accounting for ~84% of runtime versus only ~14.5% for OctBVH decoding and EdgeMatch stitching. We plan to accelerate the flow backbones in future work.

6. EdgeMatch Precision and Recall on Decoded and Generated Soups (W2, Q6)

We ran the same six-row EdgeMatch ablation on real decoded VAE and point-cloud-generated soups on Toys4K. Each soup triangle matches its mutual nearest GT face if all three corners fall within τ=0.02\tau = 0.02 in [−1,1]3[-1,1]^3, and two soup half-edges form a GT pair if their matched GT faces share a manifold edge. This covers 94.3% of decoded VAE faces and 36.5% of generated faces, since generation re-triangulates the surface:

VariantVAE P (%) ↑VAE R (%) ↑VAE F1 (%) ↑Point P (%) ↑Point R (%) ↑Point F1 (%) ↑
Distance-welding baseline33.3999.9743.9436.8298.6247.20
+ One-to-one matching96.3597.2996.8182.2575.6278.46
+ Topology checks97.4896.9697.2185.3474.9179.28
+ Blossom initialization97.2996.9697.1284.3274.1378.42
+ Matching head97.3996.2096.7886.1075.0679.72
+ Denoising head (full)97.3996.2096.7886.1075.0679.72

One-to-one matching and topology checks contribute the main gains on real soups, lifting F1 from 43.94% to 97.21% on VAE soups and 47.20% to 79.28% on point-cloud soups by rejecting false distance-welding merges. Subsequent components show limited gain on VAE soups because their errors are very small relative to the heavier training noise (σ∼U[0.004,0.020]\sigma \sim \mathcal{U}[0.004, 0.020]) of the matching and denoising heads. On noisier flow-generated point-cloud soups, however, these learned heads further lift precision to 86.10% and F1 to 79.72%.

Thanks authors for addressing the concerns. Most of my concerns are addressed. The numbers and further analysis reported in reply is informative. I am keeping my initial rating. With an inclination to accept, provided these analysis and results will go into the paper .

Comments on the paper

3 comments
AuthorsOpenReview ↗

General Response and Summary of Revisions

We sincerely thank all reviewers (Fn25, b5nP, and mTL3) and the Area Chair for their constructive feedback and encouraging assessments. We appreciate their recognition of our face-first formulation with constrained half-edge matching (Fn25, mTL3), the OctBVH representation (Fn25, b5nP, mTL3), the standalone potential of EdgeMatch (mTL3), our reconstruction and generation performance (Fn25, b5nP), and the clarity of our presentation (Fn25, b5nP, mTL3).

Following the reviewers' suggestions, we have conducted additional experiments and analyses, and uploaded a revised manuscript (with revisions highlighted in blue) as summarized below:

Summary of Manuscript Revisions

  • Introduction & Related Work (Sec. 1, Sec. 2.3): Clarified why sparse convolutions cannot be directly applied to conventional irregular BVHs, refined our third contribution, and contrasted our hierarchical representation with prior triangle-soup methods (b5nP).
  • Vertex Ordering & Face Orientation (Sec. 3.2, Sec. 3.3, Appendix A): Explained the rationale for canonical vertex sorting and added a new winding check in EdgeMatch to ensure consistent face orientations (Fn25, mTL3).
  • Topology Metrics & Analysis (Sec. 3.1, Sec. 3.3, Appendix C.2): Defined and reported non-manifold vertex and winding-consistency metrics, and clarified how EdgeMatch prevents non-manifold vertices (Fn25).
  • Model Architectures (Sec. 3.2, Sec. 3.4, Appendix A, Appendix B): Added architectural details for the OctBVH VAE and flow models, clarifying how they build on OctFormer, O-CNN, and TRELLIS.2 (mTL3).
  • Dataset Filtering & Additional Ablation (Sec. 4.1, Sec. 4.5, Appendix B, Appendix D): Added filtering statistics and unfilted evaluation results for the Toys4K dataset and an EdgeMatch ablation on decoded and generated triangle soups (Fn25).

We remain happy to address any further questions during the discussion period.

AuthorsOpenReview ↗

Anonymous Project Page Now Available

Dear Reviewers and Area Chair,

As promised in our responses, we have released an anonymous project page:

https://bvhmesh.pages.dev

Since static figures alone cannot fully convey mesh quality (b5nP), the page provides:

  • Method video visualizing OctBVH construction, coarse-to-fine decoding, and EdgeMatch stitching.
  • Interactive mesh viewer for freely rotating and zooming generated meshes with wireframe rendering.
  • Side-by-side comparisons with baselines under synchronized views for pointcloud-conditioned generation, image-conditioned generation, and VAE reconstruction.

We would sincerely welcome any feedback or suggestions on the page and video, which we will continue to improve for the camera-ready version.

Best regards,
The Authors

Dear Reviewers,

The authors have submitted their rebuttal to address your concerns. As the discussion deadline approaches, please review their response and share any remaining concerns or questions soon so the authors have enough time to respond.

Thank you, -AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.