S4R: Scaling for Rigid-Body Interpenetration Resolution

Dou, Zhiyang; Zhao, Ang; Peng, Chen; Guo, Minghao; Wu, Haixu; Lin, Cheng; Liu, Yuan; Yao, Junfeng; Guo, Xiaohu; Wang, Wenping; Matusik, Wojciech

S4R progressively resolves dense SIGGRAPH-shaped scenes and repairs a tabletop scene for robot manipulation. — **Scaling for resolution.** Left: S4R separates one thousand overlapping rigid bodies arranged inside the letters of SIGGRAPH and restores them to full size. Right: S4R turns a tilted, overlapping YCB tabletop scene into a stable layout for robot manipulation.

Abstract

Removing static rigid-body overlaps by shrinking and restoring objects.

Rigid-body interpenetration frequently occurs in procedurally assembled and generated scenes and must be removed before downstream simulation. We present S4R, a scale-continuation method for static interpenetration repair. S4R first uniformly shrinks each body about a fixed reference center to a small initial scale—a state that is evaluator-checked and separated in every reported scene—and then restores full scale through a sequence of minimum-norm convex contact quadratic programs (QPs) that maintain the linearized separation margin during continuation. A conservative scale-event bound and frozen-witness gap predictions cut the number of exact mesh queries; the continuation then ends with a full-scale evaluator check and bounded tail refinement. We evaluate S4R on Kubric [Greff et al. 2022], HY3D-Bench [Team Hunyuan3D et al. 2026], and Thingi10K [Zhou and Jacobson 2016] using a shared mesh-level evaluator and a unified per-scene setup+solve timing protocol. Extensive experiments demonstrate the effectiveness and efficiency of S4R. Across all three benchmarks, S4R reaches zero reported penetration with displacement that stays small and nearly independent of scene size, at the lowest wall time among the compared methods. A GPU implementation extends these results to large-scale scenes. Project Page: https://frank-zy-dou.github.io/projects/S4R/index.html

Method

Separate objects at a small scale, then restore their size in controlled steps.

S4R first shrinks every body until the scene has no overlap. It then restores the bodies to full size in small steps. At each step, an optimization moves only the bodies that are touching and keeps the movement as small as possible. Exact mesh checks verify the result and remove any remaining overlap at full size.

Method overview showing initial overlap, shrinking, progressive scaling with repeated contact solves, and the final resolved layout. — **S4R overview.** Bodies are shrunk, separated, and gradually restored to their original size with small position corrections.

Start without overlap

Shrinking the bodies first creates a separated scene, even when the original overlaps are severe.

Restore size step by step

Each step increases the body size and moves touching objects only as much as needed to keep them apart.

Check the final scene

Fast distance estimates reduce repeated collision checks, while an exact mesh check verifies the full-size result.

Experiments

Every method uses the same final collision check and is timed from scene setup to completion.

Evaluation geometry. The experiments cover household objects, generated 3D assets, and artist-created models for 3D printing.

Kubric. The main benchmark uses closed household-object meshes with varied shapes and controlled scene density.
HY3D-Bench. Text- and image-generated 3D assets test a wider range of object shapes.
Thingi10K. Artist-created printable models test whether the method works beyond the curated scene collection.

Representative meshes from Kubric, HY3D-Bench, and Thingi10K.

Main comparison

Method	N = 40			N = 100
Method	Pen. (pairs)	RMSD (scene units)	Time (s)	Pen. (pairs)	RMSD (scene units)	Time (s)
CPU methods: one 14-core socket
AVBD-OBB (tuned)	0	1.33	2.2	0	2.34	8.1
AVBD-OBB (official)	0 (2/3)	4.46	1.3	0	1.15	3.3
Drake-Ipopt (hull)	0	0.022	597	0 (1/3)	0.025 (1/3)	6,518 (1/3)
QP/LCP	0	0.038	0.5	0	0.039	1.7
PD-PGS	0	0.028	1.1	0	0.027	3.4
Soft-Penalty	0	0.030	7.7	0	0.031	32.5
S4R (CPU, ours)	0	0.036	0.2	0	0.035	0.5
GPU methods: one RTX 2080 Ti
ISIR	0	0.22	13	0	0.24	15
S4R-Warp (ours)	0	0.036	5.9	0	0.035	5.9

Table 1. Kubric main comparison. Averages over three runs. Pen. counts overlapping body pairs in the final mesh check; RMSD measures how far the body centers move from their initial positions. Times include both setup and solving and are compared only between methods run on the same hardware. Bold marks the best value and underline marks the second-best value.

Scaling study

Bodies N	CPU: one 14-core socket						GPU: one RTX 2080 Ti
	S4R (ours)		QP/LCP		PD-PGS		S4R-Warp (ours)		ISIR
		RMSD	Time (s)	RMSD	Time (s)	RMSD	Time (s)	RMSD	Time (s)	RMSD	Time (s)
40	0.036	0.2	0.038	0.5	0.028	1.1	0.036	5.9	0.22	13
100	0.035	0.5	0.039	1.7	0.027	3.4	0.035	5.9	0.24	15
200	0.035	1.1	0.039	3.6	0.026	8.6	0.034	6.2	0.22	25
500	0.034	3.2	0.040	11.7	0.024	36.5	0.033	7.4	0.19	97
1,000	0.035	9.6	0.040	31.2	0.025	70.7	0.034	10.6	0.153	361
2,000	0.037	26.9	0.042	89.2	0.025	164	0.036	22.3	0.112	818
5,000	0.037	138	0.042	286	0.025	520	0.036	97.5	T/O

Table 2. Scaling on Kubric. Averages over three runs; lower values are better. Results are compared within the CPU and GPU groups. Overlap counts are omitted because every displayed result ends with zero overlapping pairs. ISIR does not finish within the time limit at 5,000 bodies.

Log-log plots of wall time versus number of rigid bodies for CPU and GPU methods. — **Scaling study.** Across the tested scene sizes, the measured runtimes of S4R and S4R-Warp stay below the quadratic guide shown in the plots. The figure reports measurements only and does not predict runtime beyond this range.

Cross-dataset comparison

Dataset	Method	N = 500			N = 1,000			N = 2,000
Dataset	Method	Pen.	RMSD	Time (s)	Pen.	RMSD	Time (s)	Pen.	RMSD	Time (s)
HY3D-Bench	S4R (ours)	0	0.021	5.8	0	0.020	12.1	0	0.021	30.3
HY3D-Bench	QP/LCP	0	0.022	13.6	0	0.022	33.9	0	0.022	72.3
HY3D-Bench	PD-PGS	0	0.013	28.5	0	0.013	76.7	0	0.013	189
HY3D-Bench	AVBD-OBB	8.7	1.123	70	46.7	0.935	210	104.7	0.935	730
HY3D-Bench	ISIR	0	0.212	54	0	0.192	143	0	0.162	466
Thingi10K	S4R (ours)	0	0.025	5.2	0	0.026	10.6	0	0.026	31.1
Thingi10K	QP/LCP	0	0.026	14.6	0	0.027	34.5	0	0.028	81.4
Thingi10K	PD-PGS	0	0.016	43.8	0	0.017	115	0	0.017	272
Thingi10K	AVBD-OBB	14.0	1.332	72	42.3	1.265	221	134.0	1.234	872
Thingi10K	ISIR	0	0.162	65	0	0.160	222	0	0.131	777

Table 3. Cross-dataset comparison. Averages over three runs on HY3D-Bench and Thingi10K using the same test settings. Bold marks the best value and underline marks the second-best value within each dataset.

Qualitative Results

Each scene is shown from its initial overlap through intermediate sizes to the checked full-size result.

Spherical-spawn stress test comparing initial scenes, S4R, and QP/LCP across increasing body counts. — **Spherical-spawn stress test.** S4R produces more compact results than QP/LCP at N = 100, 500, 1,000, and 2,000. Both methods remove all overlaps.

Four benchmark scenes shown at initial, early, middle, late, and final stages of S4R. — **Progress across datasets.** Scenes from Kubric, HY3D-Bench, and Thingi10K begin with tens to hundreds of overlapping pairs and end with none.

Position and rotation optimization

The main experiments move objects without rotating them. An optional version also allows small rotations. Rotation can reduce how far the objects need to move, but it requires more collision checks and takes longer. Tables 4–6 compare these two settings.

Bodies N	Method	Pen. (pairs)	RMSD	Time (s)
40	3-DOF (translation only)	0	0.036	0.17
40	6-DOF (translation + rotation)	0	0.034	2.3

Table 4. Translation only versus translation and rotation on Kubric. Average over three runs at N = 40. Allowing rotation gives similar body movement but takes approximately 13 times longer.

Spawn	3-DOF: RMSD / Time (s)	6-DOF: RMSD / Time (s)	6-DOF : 3-DOF
Tight	0.0869 / 2.02	0.0798 / 9.60	RMSD 0.92×, time 4.8×
Loose	0.0290 / 1.59	0.0262 / 3.71	RMSD 0.90×, time 2.3×

Table 5. Rotation in compact scenes. Averages over eight runs at N = 40; every test ends without overlap. Allowing rotation reduces body movement in every run but increases runtime.

Method	Pen. (pairs)	Maximum penetration	RMSD	Time (s)
3-DOF (translation only)	0	0.000	0.033	0.015
6-DOF (translation + rotation)	0	0.000	0.034	0.023

Table 6. Chain-link stress test. Averages over three runs with four linked rings. Both settings remove all overlap and produce nearly identical movement; allowing rotation takes approximately 1.5 times longer.

Applications

Repair generated assets, prepare scenes for simulation, and edit separated layouts.

For tabletop scenes, S4R keeps every object on the same flat surface while allowing it to slide and rotate around the vertical axis. The final full-size arrangement is checked using the same meshes shown in the rendered results.

Generated-asset repair. S4R gradually restores the objects to full size while keeping them upright.

Eight generated tabletop scenes progressing from tilted interpenetrating states to upright collision-free layouts. — **Upright tabletop repair.** Eight scenes progress from tilted, overlapping objects through 30%, 60%, and 90% restoration to upright, full-size results.

Generated-asset benchmark

Method	Bodies N	Initial Pen. (pairs)	RMSD (scene units)	Time (s)
S4R (ours)	100	87	0.039	1.8
S4R (ours)	500	491	0.043	13.9
S4R (ours)	1,000	1,031	0.047	37.6
QP/LCP	100	87	0.041	5.3
QP/LCP	500	491	0.051	125
QP/LCP	1,000	1,031	0.051	457
PD-PGS	100	87	0.036	7.7
PD-PGS	500	491	0.040	137
PD-PGS	1,000	1,031	0.042	519

Table 7. Generated-asset layout repair. Averages over three runs on scenes built from the five generated meshes that all methods could process. Every method uses the same scenes, moves objects without rotating them, and removes all overlap. Bold marks the best value and underline marks the second-best value.

Physics-engine initialization

Large overlaps can make simulated objects shoot apart or prevent a physics engine from starting. S4R provides overlap-free starting positions for MuJoCo, PyBullet, and Isaac Gym. In the paper experiments, the original YCB scenes eject objects, while the scenes repaired by S4R remain stable.

Engine	Raw scene (m/s)	After S4R (m/s)
MuJoCo 3.10	7.8	0.000
PyBullet 3.2.7	12.5	0.001
Isaac Gym (PhysX)	230.6	0.000

Rigid-body engines on an interpenetrating scene. Peak body speed over a one-second rollout from an interpenetrating YCB layout and from the same layout after S4R. Values are three-seed means for 50 bodies with gravity disabled, so the measured motion comes from contact response alone.

Application Extension: Editable Scale-Space

The separated small-scale state can also serve as an editing stage: a user rearranges the objects while they are apart, then lets S4R restore them to full scale.

Four-stage editable scale-space workflow showing initial overlap, S4R shrinking, user editing, and full-scale restoration. — **S4R as an editable scale-space.** Two complex 2D shapes initially overlap; after shrinking, the user can move the red object to the right and keep the green object on the left, then restore the scale to obtain a separated layout.

Scope and Limitations

S4R repairs a fixed scene; it does not simulate moving contacts over time. It may fail when objects cannot be restored from the shrunken arrangement without overlap, for example when their centers nearly coincide, one object is trapped inside another, or the scene is too tightly enclosed. The tabletop version assumes one flat support surface and does not handle stacking, lifting, or tipping.

Citation

@article{dou2026s4r,
  title   = {{S4R}: Scaling for Rigid-Body Interpenetration Resolution},
  author  = {Dou, Zhiyang and Zhao, Ang and Peng, Chen and Guo, Minghao
             and Wu, Haixu and Lin, Cheng and Liu, Yuan and Yao, Junfeng
             and Guo, Xiaohu and Wang, Wenping and Matusik, Wojciech},
  journal = {ACM Transactions on Graphics},
  year    = {2026}
}