acceptodds
Under review as a conference paper at ICLR 2027

Physics-Based Sphere Packing for Lagrangian Mesh Morphing

Abstract

This paper studies tetrahedral meshes as the body representation for differentiable simulation and computational design. Both change the shape of a body throughout an optimization and need meshes that follow large shape changes while keeping their interior nodes in correspondence. Fixed-connectivity meshes degrade under large morphs, while remeshing from scratch discards node correspondence. We present JamTet, a physics-based sphere-packing framework for volumetric meshing and morphing. We contribute (i) a GPU-parallel mesher combining octree-hierarchical packing with constrained Delaunay tetrahedralization, producing lower element-volume spread than TetGen and fTetWild; (ii) Lagrangian mesh morphing that preserves interior-node identities by re-equilibrating the same spheres within changing shapes and rebuilding the boundary and connectivity, remaining inversion-free where fixed-connectivity and TetSphere meshes invert; and (iii) a differentiable GPU simulator in JAX, with mass–spring edges and a volumetric Neo-Hookean term, integrated with mesh morphing in a design pipeline. In soft-robot morphology design experiments, interior-node gradients improve swimming fitness by 0.73–1.07 over a matched surface-only variant, while voxelized versions of the same designs yield 32–63% lower fitness. These results establish sphere packing as a practical volumetric mesh representation for gradient-based shape optimization. Code and media: https://anonymous.4open.science/r/jamtet/.

Primary area:
applications to robotics, autonomy, planning
Keywords:
tetrahedral meshing, sphere packing, mesh morphing, Lagrangian mesh, differentiable simulation, soft robotics, morphology optimization, shape optimization

Reviews

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

This paper introduces JamTet, an approach to represent a volumetric shape under deformation with a tetrahedral mesh, where the correspondence between each internal node is maintained throughout the deformation. This approach is mainly based on sphere packing algorithm. For the given shape (defined with a SDF), the surface mesh is first computed, which defines the surface nodes of the shape. Then, the internal volume of the shape is computed to get the number of spheres to pack into the shape, with their radius. To pack the spheres into the shape seamlessly, this approach proposes to main losses to optimize the sphere positions; water and jam losses. After moving the spheres inside the shape by minimizing the losses, this approach uses TetGen to get CDT of the surface nodes and spherical centers to compute the final tetrahedral mesh of the shape. When the shape goes throught deformation, the sphere packing starts from the previous setup, so the sphere correspondence is natually maintained between the deformation. To accelerate this approach, the authors propose to use Octree-based approach, which seems to bring about 4-5x acceleration compared to the naive approach. To validate this approach, authors test it under static meshing scenario, mesh deformation scenario (ball to bunny), and designing mesh using differentiable simulation. The results look competent to the baseline methods, but they require more investigation at the current stage.

Critical strengths

The main strength of this work lies in the efficient (octree-based) sphere packing formulation and its natural extension to consistency of internal nodes under deformation. As the spheres are maintained throughout the deformation, it is easy to maintain the tetreahedral mesh quality during the deformation -- the optimization already starts from the well-distributed spheres in the shape. Therefore, the experimental results in section 4.2 were interesting. Also, it was interesting that the static meshing results are comparable to that of fTetWild (especially about tet mesh quality). Finally, the experimental results in 4.3 about the effect of optimizing internal nodes, not only surface nodes, gives the better results in optimizing swimming meshes were also interesting.

Critical weaknesses

Even though some of the experimental results were interesting, I'm not fully convinced that the experimental settings are fair and thorough yet.

First, when it comes to static meshing experiment in 4.1, the authors provided Vol CV as one of the main metrics, and mentioned that this is lower the better. However, as far as I know, the lower spread of the element size is not always preferrable -- we usually leverage adaptive meshing to adjust the element size based on our computational requirements. It is often desirable to place larger elements wherever possible, so that we can reduce the number of elements and thus reduce the computational cost. In this regard, I think the large runtime of fTetWild came from enforcing the uniform element size as JamTet, which is usually not the intended use case of this baseline. I think there should be a justification of the reason why we need uniform element size if we really want to compare in this way.

Second, there are two concerns about the experimental results in 4.3. The first one is about the analysis. I think there are two main differences between the full JamTet and the surface-node only JamTet -- the first difference is that full algorithm optimizes the internal nodes as well, and the second difference is that it maintains the correspondence between the internal nodes. I'm not sure which of these two differences contributed to the increased performance in 4.3. The best way to test this would be, removing the correspondence between the internal nodes by running JamTet from scratch at each design interation. If the correspondence between the spheres turn out to be not very helpful for this optimization, I'm afraid that the main strenghth of this work could be weakened. The second concern is in walking scenario. Even though the authors mentioned that the absence of contact gradient could be the reason why remesh-ftw outperforms JamTet, but isn't this absence also same for the remesh-ftw? As far as I know DiffTaichi already showed the differentiable optimization even when there is ground contact. Maybe it would be worthwhile for authors to check if this absence is the real root cause of this issue.

Questions for authors

As I pointed out in the weakness, it is often desirable to generate adaptive mesh for physics simulation. I think it is easy to extend JamTet to allow adaptive mesh, isn't it? Did authors consider it?

1 comment
AuthorsOpenReview ↗

Response to Reviewer 5bKZ: W1 uniform size, W2a correspondence control, W2b walking, Q adaptive sizing

Thank you for the review. We ran the control you proposed and fTetWild at its default settings.

W1. Uniform size and the fTetWild runtime. We ran fTetWild at its default settings on the nine shapes (appendix of the revision). As you say, the default grades the mesh: apart from the cube and the two beams, 62–77% of its nodes lie on the surface and interior tetrahedra have 3–5 times the volume of those touching the surface (cube: 42% and 1.4 times). It therefore returns far fewer nodes: 101–4,683 on the sphere, cube, beam, Spot, Bob and bunny, against 72k–82k when sized to match our meshes.

A simulation at a given resolution needs a given number of nodes, so we compare speed at an equal node budget; the paper's call differs from the default only in the target edge length. On these six shapes the time per node is similar in both settings (0.2–3.0 ms at matched count, 0.6–5.3 ms at default), so the uniform target does not slow fTetWild down per node. Its long runs come from the node count and the input surface: on the armadillo the default run takes 6,693 s against 4,925 s for the uniform one.

Why uniform size here? For analysis on a fixed shape a graded mesh is usually the better choice, and the revision will present Vol CV as a measure for our use case, which calls for uniform elements for three reasons. (1) The simulator is a lumped model with equal node masses and springs on the edges, so uniform nodes give uniform density and stiffness. (2) In design the shape is the unknown: a sizing field would have to be chosen again at every iteration. (3) Interior resolution matters for the gradient: in the design study fitness rose with the number of interior nodes, and the remesher whose interior count fell to about 290 reached the lowest fitness.

W2a. Interior optimization or correspondence? We ran the control as you describe it, with a fresh packing at every design iteration (three seeds):

Swim fitness1k up–down1k lateral8k up–down8k lateral
Ours2.47 ± 0.122.35 ± 0.032.49 ± 0.042.62 ± 0.08
Ours, fresh packing at every iteration2.49 ± 0.082.34 ± 0.032.48 ± 0.052.58 ± 0.04
Ours-surface1.40 ± 0.021.41 ± 0.031.76 ± 0.011.78 ± 0.01

The gain comes from optimizing the interior nodes; correspondence does not change swimming fitness in this study. This agrees with the abstract, and the revision will state the attribution next to Table 3.

What persistence provides is separate from this gain. First, the strength you name: mesh quality is kept through deformation because each packing starts from the previous one (Section 4.2; now nine morphs with no inverted element). Second, nodal state is carried with no interpolation. In a cantilever co-design with a two-material layout on the nodes (appendix of the revision), the result on our rebuilt meshes stays within 2.4% of that on a mesh that is never rebuilt, whereas the result of remeshing depends on the transfer rule and ends with a compliance between 21% lower and 10% higher. Third, persistent nodes allow optimizer state per node, such as momentum or a gradient history; this is future work.

W2b. Walking and the contact gradient. A gradient check on a fixed mesh (stiffness gradient against finite differences) shows a disagreement of 19–97% with ground contact and of 5.5×10−95.5\times10^{-9} without. All methods share this contact formulation, so it limits every method and by itself cannot explain a ranking. Walking is also far noisier than swimming: at 1k the method means lie within 1.73–1.96 with seed standard deviations of 0.09–0.54, and at 8k remesh-fTetWild reaches 2.43 ± 0.46 against 1.84 ± 0.15 for JamTet (three seeds); swimming has standard deviations of 0.01–0.13. We therefore do not rank the methods on walking, and the revision will say so in place of the sentence on the contact gradient. DiffTaichi corrects the gradient for rigid contact with a time-of-impact term; our simulator does not have one yet.

Q. Adaptive sizing. Yes. The pair force has rest length ri+rjr_i + r_j, so a sizing field h(x)h(x) becomes a radius per sphere; bubble packing used graded radii with the same kind of force. One question arises with persistent nodes: a sphere that moves into a region with a different target size changes its radius, so the count is no longer fixed by the volume. We have not evaluated graded packings; this is future work.

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

The paper studies tetrahedral meshes as the body representation for differentiable simulation and computational design. Fixed-connectivity meshes distort and invert under large shape changes, while remeshing from scratch restores element quality but discards node identity. The proposed method builds volumetric meshes from physical sphere packings. Spheres flow inside a re-triangulated surface and jam into a dense packing, and constrained Delaunay tetrahedralization (CDT) turns the sphere centers together with the surface nodes into a conforming mesh. To morph, the same spheres re-settle inside each new surface and CDT rebuilds the connectivity, so interior nodes keep their identity while the topology is updated at every step. The system combines GPU packing with an octree schedule, a two-stage jamming force, a differentiable JAX simulator with mass-spring edges and a Neo-Hookean volume term, and a design loop that propagates simulator gradients to all nodes. The experiments cover static meshing of nine shapes against TetGen and fTetWild, identity-preserving morphing against fixed connectivity, fTetWild remeshing and TetSphere splatting, and a soft-robot design study in which five methods are compared under one protocol. Interior-node gradients raise swimming fitness by 0.73 to 1.07 over a matched surface-only variant, and the designed swimmers reach 1.5 to 2.7 times the fitness of their voxel versions.

Critical strengths
  1. The central mechanism is a real advance over TetSphere splatting rather than a reimplementation. In TetSphere splatting, node identity is kept by a Lagrangian connectivity that is not rebuilt, and inversion is only discouraged with a soft penalty, so its tetrahedra still invert. Table 2 reports 4.70 ± 1.85% inverted elements for M=1 and 0.44 ± 0.45% for M=6. In this work, identity is carried by the persistent spheres while CDT rebuilds the connectivity at every step, so inversion is excluded structurally: ours reports 0.00 ± 0.00% inverted elements and a volume spread that stays flat at 0.143 ± 0.008, while fixed connectivity reaches 4.1% at the end of the same morph. Physically based relaxation for mesh generation dates back to bubble packing (Shimada and Gossard, 1995), so the ingredients are classical and cited as such; the contribution lies in the two-stage jamming schedule, the octree schedule, and carrying one packing across shape changes, which I could not find in earlier packing methods.

  2. The evaluation is carefully controlled. All five design methods share the start shape, the simulator, the gait and the budget; ours and ours-surface share every step except the gradient support, so the fitness margin isolates the contribution of interior-node gradients, and the seed ranges of the two methods are disjoint in all four swimming conditions. The fresh-packing control completes the argument: because the variant that discards identity reaches the same volume spread, the quality comes from re-packing itself, and keeping identity adds no cost.

  3. The system works end to end and transfers across tasks. The meshes support a differentiable JAX simulator with forward rollouts at 10.6k to 60.6k steps per second, and Appendix F uses the same meshes for compliance design with linear finite elements: the optimized profiles deviate from the uniform-strength theoretical profile by an RMS of only 0.067 to 0.069, and on the short beams the TetGen and fTetWild meshes reach the same compliance reduction within 0.2 percentage points, which supports mesh quality beyond the swimming task.

  4. The disclosure is complete and specific. The limitations section names the GPU requirement, the shorter stable time step caused by thin boundary tetrahedra, the lost surface-node identity, the unexercised identity-to-fitness path, and the per-condition protocol differences in the design study.

Critical weaknesses
  1. The quantitative morph evidence covers one shape pair. The inversion and quality claims are demonstrated on a sphere-to-bunny morph of about 10k spheres over nine steps, and the 64k result of Figure 1 is qualitative. Because zero inversion is presented as a structural property of the method rather than an outcome of one experiment, results on more shape pairs, concave and thin features, and larger scales would let me judge how far the claim reaches.

  2. Meshing cost is high relative to the fastest baselines. On the bunny at 64k interior spheres the pipeline takes 36.9 s against 0.5 s for TetGen, and the comparison with fTetWild is mixed: our meshes finish faster on the bunny, 36.9 against 77.2 s, and on the dragon, but slower on shapes where fTetWild succeeds quickly, for example 44.6 against 6.7 s on the I-beam. Thin boundary tetrahedra also shorten the stable time step of explicit integration relative to both baselines. This cost bounds where the method fits best, for example design loops that re-pack at every iteration.

Questions for authors
  1. Does zero inversion hold for other morph pairs, for example shapes with thin features or a change of topology, and at larger sphere counts? Separately, what surface conditions triggered the four CDT failures among the 90 design runs, and can a fallback re-packing avoid them without losing a design step?

  2. What is the cost breakdown of the morph step, in particular the CPU CDT, at 1k, 8k and 64k spheres, and how does the re-packing cost per design iteration compare with the simulation cost that the appendix reports?

1 comment
AuthorsOpenReview ↗

Response to Reviewer YmMt: W1/Q1 morph pairs, CDT failures, W2/Q2 cost

Thank you for the careful reading. Both questions are answered with new runs, and your I-beam example led us to correct a row of our static table.

W1 / Q1, first part. Zero inversion on other pairs and scales. The inverted shares are those of the worst step.

Morph, 8 steps, 10k unless notedOurs: invertedOurs: Vol CVFixed connectivity: inverted
Sphere → bunny00.12–0.150.5%
Cube → bunny00.14–0.153.0%
Sphere → armadillo (thin limbs)00.12–0.171.9%
Sphere → dragon (horns, claws)00.13–0.2313.1%
Cube → dragon00.14–0.2314.3%
Bunny → dragon00.15–0.2312.5%
Spot → Bob (genus 0 → 1)00.16–0.2424.2%
Sphere → bunny, 64k00.13–0.150.6%
Sphere → dragon, 64k00.13–0.357.4%

JamTet inverts no tetrahedron in any of the nine morphs. Its Vol CV stays at 0.12–0.15 on the bunny and peaks at 0.17–0.24 on the thin targets at 10k, below fTetWild remeshing (0.29–0.60). TetSphere (M=6), which starts from a sphere and follows its own path to the same target, inverts 1.5% on the bunny, 3.7% on the armadillo and 2.2% on the dragon.

The six 10k pairs and the 64k bunny use a new surface path, a level-set flow that keeps one body and holds the volume; Spot → Bob and the 64k dragon use the earlier path. On the new path fixed connectivity inverts less on the bunny, but its mesh does not fill the target: its tetrahedra sum to 92–94% of the target volume on the bunny and 46–54% on the dragon.

Q1, second part. The four CDT failures. All four occur late in a run on flattened bodies, and one is a remeshing baseline with no spheres, so the trigger is the surface handed to CDT: one run reports two intersecting input facets, two end in a CDT crash without a message, and one exceeds our 900 s limit for a CDT call.

The 78 new design runs save the failing shape, and we rebuilt each surface from its saved level set. CDT failed on five shapes in four runs. All five are a single body with a pinch: in four the wall thins to under 0.3 sphere spacings, in the fifth two parts of the surface touch, and three have a hole that has just opened through the plate. Four of the five surfaces have near-degenerate triangles at the pinch (edges down to 0.02 spacings). CDT then crashes (two cases) or returns the nodes in a changed order, which we reject (three cases).

All 6,031 meshes built in the new runs have zero inverted elements. A failed CDT need not cost a design step: the loop evaluates several candidate updates per iteration and rejects any that cannot be meshed. Three of the four runs completed all 50 iterations this way; one stopped at iteration 39, when the failure hit the accepted update. For that case the released code has a fallback (relax the same spheres once more and retry, else keep the previous mesh for the iteration). It is switched off in all reported runs.

W2 / Q2. Cost. First the I-beam row: fTetWild had been run at 11.6k nodes there. At our node count (104k) it takes 298 s on our test machine, against 44.6 s for JamTet on the paper's machine; the revision will correct the row.

One morph step (sphere → bunny), seconds on one RTX 5090:

SpheresSphere relaxation (GPU)Distance grid (CPU)CDT stage (CPU)of which CDT callTotal
1k3.98.10.090.00518
8k5.615.72.10.0330
64k14.739.560.20.30121

(The total includes 6 s of surface re-triangulation and overhead.) The CDT stage is dominated by a point-in-mesh test in NumPy (99% of the stage in a profiled 64k step); the CDT call itself takes 0.3 s. The cost that grows with size is the CPU code around the packing.

One design iteration (ours, swimming):

1k8k
Total37 s76 s
Simulation with gradients50%69%
Rebuild: surface, warm re-pack, CDT6.3 s (17%)9.9 s (13%)
Rebuild of the remeshing baselines0.8–0.9 s1.2–5.3 s

Thin boundary tetrahedra shorten the stable time step, as the limitations say; the revision will add a geometric estimate (3% of fTetWild's step for JamTet, 14% for TetGen). We agree that the method fits best in loops that rebuild the mesh many times.

Numbers cited in your review that change. (1) Fixed connectivity on sphere → bunny: 4.1% → 0.5% on the new path; JamTet stays at zero. (2) Following Reviewer NRkc, the remeshing baselines were also run with interior-node gradients and gain 0.40–0.90 in fitness; the comparison of ours with ours-surface is unchanged.

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

JamTet packs soft spheres inside a surface on the GPU, then connect them into tetrahedra with Tetgen. It then enables morphing between different shapes with the same spheres settled inside each new surface so that the interior nodes keep their indices. A differentiable JAX soft-body simulator then drives a swimmer-shape design loop.

Critical strengths
  • The pipeline is simple and practical: re-triangulate the surface, pack the spheres and then constrained Delaunay. It is easy to reproduce and gives very uniform elements.
  • They developed an end-to-end system that connect the mesher, a GPU differentiable simulator and a design loop, which runs at useful speeds.
  • It is sensible to keep a fixed set of particles and re-settle them inside each new shape. This seems a good middle ground between fixed connectivity, which distorts and inverts, and remeshing from scratch, which loses the correspondence.
Critical weaknesses
  • The design gain may come from the gradient, not from JamTet. Gradients reach the FFD lattice on the current mesh at every iteration, so the remeshing baselines could also use interior-node gradients, but they were given surface gradients only. Please compare with remesh-TetGen and remesh-fTetWild using all-node gradients.
  • The closest prior methods aren’t compared. For example, DistMesh is cited but not compared, which already re-triangulates a persistent point set. The same goes for CVT/ODT variational meshing.
  • The morph test is narrow. There’s one shape pair, no topology changes or thin features, and each snapshot is rescaled to the target volume. That suggests the method can’t handle large volume changes with a fixed sphere count.
Questions for authors
  • Identity is claimed but never measured. Each morph step re-packs and re-tetrahedralizes, so “node i = sphere i” is only meaningful if sphere i stays in roughly the same material location. A fresh packing at each step gives identical quality (Vol CV 0.144 vs 0.143), so identity is the only advantage, and all we see of it is coloured pictures. Fix: add a correspondence metric, such as neighbour retention or distortion against the harmonic map, plus a “remesh + nearest-neighbour matching” baseline.
  • In this work, every metric is a mean, but worst-case element quality is not evaluated. It is likely that the worst elements are worse than the baselines'. Fix: report the mesh-wide minimum dihedral, the sliver count, and the stable time step.
  • There’s a possible mass confound. Surface nodes scale with surface area and every node has equal mass. So flattening into a plate adds mass and drag area. Does that bias fitness?
2 comments
AuthorsOpenReview ↗

Response to Reviewer NRkc (1/2): W1 all-node baselines, W2 DistMesh, W3 morph pairs

Thank you for the review. We ran all six comparisons you asked for.

W1. Remeshing baselines with all-node gradients. We ran both remeshers with gradients on all nodes, with three seeds and the protocol of Table 3:

Swim fitness1k up–down1k lateral8k up–down8k lateral
Ours2.47 ± 0.122.35 ± 0.032.49 ± 0.042.62 ± 0.08
Remesh-TetGen, all nodes1.88 ± 0.131.83 ± 0.072.60 ± 0.042.47 ± 0.04
Remesh-fTetWild, all nodes1.65 ± 0.041.68 ± 0.042.50 ± 0.062.60 ± 0.04
Surface gradients (three meshers)1.25–1.401.23–1.411.69–1.761.68–1.78

The paper attributes the design gain to interior-node gradients (abstract; Section 4.3), and your experiment confirms it on two more meshers: interior gradients raise fitness on every mesher, by 0.40–1.07. Table 3 will list both gradient settings for each mesher. At 8k every mesher has thousands of interior nodes, and all three reach 2.47–2.62. At 1k interior nodes are scarce and fitness rises with their number (0.43 per doubling over 42 runs, R² = 0.75). JamTet holds 988 interior nodes at every iteration and is highest at the mesh sizes used in the paper; TetGen and fTetWild fall to about 635 and 290 interior nodes as the body flattens, and need their size parameter re-tuned for the task to hold a comparable count (appendix of the revision).

In the design loop JamTet contributes a fixed number of interior spheres, set once for any shape, each of which keeps its index. Fitness is differentiated at every node of the CDT mesh, and persistent spheres can carry optimizer state (momentum, a history of the gradient) with no transfer step, whereas a remesher would need a transfer rule.

W2. DistMesh and CVT/ODT. Bubble packing (Shimada and Gossard, 1995) and DistMesh (Persson and Strang, 2004) form the force-based node-placement family that JamTet builds on; Section 2 cites both. Our baselines are TetGen and fTetWild because simulation pipelines use them today. We have now run DistMesh and CGAL's ODT and CVT as well (appendix of the revision). Vol CV on the bunny at 77k nodes:

DistMeshOursODT, CVTTetGenfTetWild
0.11–0.120.130.19–0.200.300.54

Uniform element volume is a property of the force-equilibrium family. JamTet adds three things.

  1. Surface. In JamTet the given surface triangulation is the mesh boundary. DistMesh projects nodes onto a distance function; on our dragon morph it misses up to 2.1% of the volume and its boundary is not a manifold.
  2. Cost and termination. JamTet runs a fixed schedule on the GPU and calls CDT once per step. DistMesh re-triangulates inside its loop (450–1,840 times per step here), and its stopping test never fired in our runs; its authors name slow execution and possible non-termination as its main disadvantages.
  3. Morph and use. JamTet carries one packing through 3-D morphs and is used in a differentiable design loop. The DistMesh paper has no moving geometry; the moving-mesh examples of Persson's thesis are two-dimensional, and the density control used there adds and deletes nodes. We also ran DistMesh with a fixed node set through two of our morphs; its neighbour retention and surface error are given under Q1.

W3. Morph test. We now report nine morphs: sphere → bunny, cube → bunny, sphere → armadillo (thin limbs, fingers), sphere, cube and bunny → dragon (horns, claws), Spot → Bob (genus 0 → 1), and bunny and dragon at 64k. JamTet inverts no tetrahedron in any of them, and its Vol CV stays at 0.12–0.24 at 10k (fTetWild remeshing: 0.29–0.60). On the same targets fixed connectivity inverts 0.5–24% of its elements and TetSphere 1.5–3.7%.

On rescaling: the new surface path is a level-set flow that keeps one body and holds the volume, so the rescaling of the submission reduces to a correction below 0.04%. (Spot → Bob and the 64k dragon still use the earlier path.) At a fixed sphere count the sphere radius follows the volume, r∝(V/N)1/3r \propto (V/N)^{1/3}, so a uniform change of volume by a factor cc is the same packing problem scaled by c1/3c^{1/3}. Keeping the element size fixed under a large change of volume requires inserting or removing spheres, which preserves the identity of the others; this is future work.

AuthorsOpenReview ↗

Response to Reviewer NRkc (2/2): Q1 identity, Q2 worst-case quality, Q3 mass

Q1. Measuring identity. We added neighbour retention (the share of a node's interior mesh neighbours that are still its neighbours later) and the baseline you propose: a fresh mesh at every step with nearest-node matching chained along the path. Each cell gives the retention per step / from the first to the last step.

Morph, 8 steps unless notedOurs, by indexFresh packing + matchingfTetWild + matching
Bunny targets (10k and 64k)0.84–0.88 / 0.40–0.480.69 / 0.150.51–0.54 / 0.02–0.05
Sphere → armadillo0.78 / 0.310.66 / 0.100.52 / 0.02
Spot → Bob0.69 / 0.160.61 / 0.070.54 / 0.04
Dragon targets (three sources)0.46–0.48 / 0.030.63–0.64 / 0.07–0.080.48–0.55 / 0.00–0.05
Dragon targets, 16 steps0.76–0.77 / 0.09–0.100.68 / 0.030.57 / 0.01 (bunny → dragon only)

On the bunny, the armadillo and Spot → Bob, following the spheres by their index keeps two to three times more neighbours over the whole morph than matching. On the dragon each of the eight steps moves the surface by 5.2 sphere spacings, twice as far as on the bunny; with 16 steps the index keeps three times more neighbours than matching. The dragon rows use a stop rule that we added to the fluid stage (it stops when the largest gap no longer shrinks); the bunny and armadillo meshes are identical with and without it.

Retention has to be read together with surface accuracy. Fixed connectivity and TetSphere keep every neighbour by construction and DistMesh keeps 0.70–0.89 per step, but their meshes do not end on the target. The table gives the distance from the supplied target surface to the final mesh, as mean / maximum over 40,000 surface samples in sphere spacings (TetSphere: mean of three runs):

Sphere → target, 10kBunnyArmadilloDragon
Ours0 / 00 / 00 / 0
DistMesh, fixed nodes0.02 / 0.4not run0.05 / 2.7
TetSphere (M=6)0.10 / 1.30.21 / 1.90.69 / 5.8
Fixed connectivity1.3 / 174.3 / 198.6 / 31

JamTet is at zero because the supplied surface triangulation is its mesh boundary; a fresh packing is also at zero but carries no nodes from step to step. Among the methods that carry nodes, only JamTet conforms to the surface, with no inverted element. Identity lets a per-node quantity travel with no transfer step: a two-material field carried by index keeps its volume fraction within 0.2 percentage points, whereas nearest-node transfer drifts by up to 3.4.

Q2. Worst-case element quality. We now report the mesh-wide minimum dihedral, the share of slivers and a time-step measure (appendix of the revision). Compared with TetSphere and fixed connectivity, which also carry nodes through the deformation, JamTet has the better worst case. Each cell gives TetSphere (M=6) / ours on the sphere → target morph at 10k:

TargetInverted, worst stepMesh-wide min dihedral, median over stepsTetrahedra below 5°, worst step
Bunny1.5% / 00.02° / 0.71°1.8% / 0.12%
Armadillo3.7% / 00.004° / 0.73°4.6% / 0.09%
Dragon2.2% / 00.005° / 0.66°2.6% / 0.19%

Fixed connectivity has 0.5–13% of its tetrahedra inverted and 0.7–5.5% below 5°. A geometric proxy for the stable explicit time step, the smallest altitude divided by the mean edge length, is 65–320 times larger for JamTet than for TetSphere.

JamTet is a packing simulation followed by CDT and does not optimize element shape, so thin tetrahedra remain where CDT joins the packing to the surface: about 0.1% of our tetrahedra are below 5°. The paper names this limitation, and the revision will add the numbers next to those of TetGen and fTetWild, which optimize element shape and keep no nodes: a mesh-wide minimum dihedral of 0.2–0.7° against 1.9–7.5° and 11–22° on the nine static shapes, and a time-step proxy that is 3% of fTetWild's (TetGen: 14% of fTetWild's).

Q3. Mass. We re-evaluated the final designs under two other mass models: total mass rescaled to that of the start capsule, and node mass taken from tetrahedron volume (appendix of the revision). Fitness changes by at most 2.1% and 6%, respectively. The order of the methods is unchanged at 1k, and at 8k the all-node group (2.44–2.71) stays above the surface-gradient group (1.67–1.80) under all three models. Flattening adds drag area (surface +42–52%), which is how thrust arises in this drag model; the gap between all-node and surface gradients does not depend on the mass model.

Comments on the paper

1 comment
AuthorsOpenReview ↗

General response to all reviewers

We thank the reviewers and the area chair for their careful reviews. We ran the experiments the reviews asked for; the three replies give the numbers. This note summarizes the contribution as the reviews describe it, the new results, and the revision.

Contribution. (1) Idea. One set of spheres is re-settled inside each new shape, so interior nodes keep their identity while CDT rebuilds the connectivity. The reviews see this as a sensible middle ground between fixed connectivity and remeshing [NRkc], as an advance over TetSphere splatting in which inversion is excluded structurally [YmMt], and as a natural extension of packing to deformation [5bKZ]. (2) Method. Physically based packing is classical and cited as such; the contribution lies in the two-stage jamming schedule, the octree schedule and carrying one packing across shape changes [YmMt, 5bKZ]. (3) System. The mesher, the differentiable GPU simulator and the design loop run end to end [NRkc, YmMt], and interior-node gradients raise swimming fitness [YmMt, 5bKZ].

New results. (1) Interior-node gradients explain the design gain. With gradients over all nodes, remesh-TetGen and remesh-fTetWild gain 0.40–0.90 in swimming fitness and JamTet gains 0.73–1.07, so the gain reported in the abstract holds on three meshers [NRkc W1]. A control with a fresh packing at every design iteration reaches the same fitness, which confirms that the gain comes from the gradient support [5bKZ W2a]. (2) JamTet keeps persistent interior nodes while it rebuilds a boundary-conforming mesh through large shape changes. No element inverts in nine morphs: six shape pairs at 10k, a change of topology, and two runs at 64k. On the same targets fixed connectivity inverts 0.5–24% of its elements and TetSphere 1.5–3.7%, and neither of their meshes ends on the target surface [YmMt W1/Q1, NRkc W3, Q1]. Because interior nodes keep their index, nodal state is carried across rebuilds with no interpolation: a material field keeps its volume fraction within 0.2 percentage points [NRkc Q1, 5bKZ W2a]. In the design loop the number of interior spheres is set once and stays fixed, whereas the interior node count of a remesher changes with the shape. (3) Further comparisons. We also compare with DistMesh, ODT and CVT, report worst-case element quality, run fTetWild at its default settings, break down the cost of a morph step and of a design iteration, and analyze the geometry behind failed mesh builds.

Revision. The revised PDF, to be uploaded before the discussion closes, will put Figure 4 and Table 2 on a morph path that keeps one body and holds the volume (one added sentence in Section 3.3, details in the appendix), add a table of all morph pairs, add the all-node baselines to Table 3, and add appendix material for the comparisons above. Changes are marked in blue. It also contains two corrections: the "Min Dih" cells of Tables 1 and 2 are recomputed with a corrected formula (the correction changes no ranking), and the fTetWild I-beam row is rerun at the matched node count.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.