CrashShapes: Geometry in Crash Analysis

• CrashShapes are a family of geometry-first representations that encode collision-related states, covering both pre-impact scene configuration and post-impact damage.
• They are applied across computer vision, robotics, and automated driving to reconstruct scenarios from dashcam videos, simulate damage, and approximate collision probabilities.
• The framework enables real-time synthesis, measurement, and adversarial deformations to stress-test safety systems and improve crash reconstruction methodologies.

Searching arXiv for papers related to “CrashShapes” and the cited IDs. Tool unavailable in this environment, so I will rely on the supplied arXiv metadata and cite the provided arXiv IDs directly. Taken together, these papers suggest that CrashShapes is a polysemous, geometry-first research concept rather than a single standardized algorithm. Across computer vision, graphics, crash reconstruction, automated driving, and robotics, the term denotes a structured representation of collision-related geometry: the spatiotemporal configuration of a pre-crash scene, a persistent vehicle damage shape, a continuous crush surface, a shape approximation for collision probability, or a physically plausible mesh deformation that induces task failure. A closely related line of work extends this shape-centric view from 2D image masks to 3D Gaussian Splatting, so that damage is localized on a reconstructed vehicle surface rather than only in the image plane (Bashetty et al., 2020, Kenwright, 2023, Scurlock, 2014, Tolksdorf et al., 2024, Goel et al., 15 Sep 2025, Chileban et al., 28 Sep 2025).

1. Terminology and representational scope

The literature uses CrashShapes to encode different kinds of geometry, but the common object is not a scalar crash label; it is a shape-bearing state that can be reconstructed, simulated, segmented, optimized, or integrated into safety metrics. This suggests that CrashShapes is best understood as a family of representations in which geometry is the primary carrier of crash information (Bashetty et al., 2020, Kenwright, 2023, Scurlock, 2014, Tolksdorf et al., 2024, Goel et al., 15 Sep 2025, Chileban et al., 28 Sep 2025).

Usage context	Geometric representation	Operational role
Dashcam reconstruction	ego trajectory, agent vehicle trajectories, lane and road structure, timing/relative placement	replay crashes and generate safe alternative tests
Interactive deformation	coarse deformable control mesh and detailed graphical mesh	plausible, persistent vehicle damage shapes at interactive rates
Severity estimation	$C_{\max}(w)$ and $C_{\max}(w,h)$	peak force, absorbed energy, collision intensity
Collision probability	multiple overlapping circles	fast POC estimation under Gaussian uncertainty
Robotic red-teaming	structurally valid, user-constrained mesh deformations	trigger catastrophic failures and support blue-teaming
3D damage localization	up-lifting 2D masks into 3D Gaussian Splatting	query damage on the reconstructed vehicle surface

A crucial distinction runs through the literature. In some works, CrashShapes refers to the state of the world before impact, as in scenario reconstruction from video. In others, it refers to the state of the object after impact, as in deformation synthesis, crush measurement, or 3D damage segmentation. In the robotic-manipulation setting, the term is extended again: the “crash” is not a physical vehicle collision but a catastrophic policy failure caused by object geometry (Bashetty et al., 2020, Goel et al., 15 Sep 2025).

2. Pre-crash scene geometry from dashcam video

In the automated-driving literature, CrashShapes appears as an end-to-end framework for turning real dashcam crash videos into physics-based virtual crash tests. Here a crash shape is the reconstructed scenario geometry and motion pattern of a collision, represented by the ego trajectory, the agent vehicle trajectories, the lane and road structure, and the timing/relative placement of all actors up to crash time (Bashetty et al., 2020).

The reconstruction pipeline is explicitly modular. Other vehicles are obtained with Mask R-CNN for object detection and instance segmentation, Re3-Tracker for frame-to-frame tracking, and Hungarian matching with IOU for detector–tracker association. Approximate 3D positions are inferred either by 3D-DeepBox or by a monocular depth / pseudo-LiDAR route,

$$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$

with the principal point at the image center and equal horizontal and vertical focal lengths. Ego motion is estimated with a monocular optical-flow-based method using Expected Residual Likelihood (ERL) and a lifted-kernel optimization framework, then corrected laterally with lane geometry from LaneNet, DBSCAN, B-spline fitting, and the Hungarian algorithm with directed Hausdorff distance (Bashetty et al., 2020).

The representation is not only geometric but simulator-ready. Raw trajectories are smoothed by Savitzky–Golay filtering followed by two-stage spline smoothing and then instantiated in Webots through Sim-ATAV. A practical synchronization device is the “step-back” initialization: $$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$ which allows vehicles that are already moving in the video to be spawned from rest and reach their target velocities and relative positions at a common time (Bashetty et al., 2020).

A notable feature is the crash-shape taxonomy for agent motion. Ongoing vehicles are partitioned into D0T1, D0T2, and D0T3; oncoming vehicles into D1T1, D1T2, D1T3, and D1T4. These labels determine how trajectories are extrapolated or delayed in simulation. The framework was then used both for unsafe replay and for counterfactual safety search: 128 simulations were generated from 32 ego initial positions sampled in a 4×8 m box, with 8 simulations collision-free. On KITTI tracking sequences 3, 8, and 10, the reported tracking results were MOTA 58.08%, 67.36%, 77.75%, MOTP 80.35%, 79.55%, 85.04%, and F1 79.75%, 81.73%, 88.56% (Bashetty et al., 2020).

The defining methodological claim is modest and precise. The objective is qualitative correctness, not exact forensic reconstruction. That limitation is central rather than incidental: the value of CrashShapes in this setting lies in transforming internet crash footage into scenario geometry that can stress-test AEB and related ADAS/AV stacks under realistic pre-crash interactions (Bashetty et al., 2020).

3. Vehicle deformation, crush profiles, and 3D damage representation

A second major usage of CrashShapes concerns the geometry of vehicle damage itself. In interactive graphics, the goal is a real-time physically inspired crash-shape synthesis pipeline based on a low-dimensional coupled vehicle body, a reduced-complexity non-linear finite element approximation, and an explicit position-based solver. The vehicle is represented by a coarse deformable control mesh built from the convex hull and a detailed graphical mesh driven by embedding / weighting. The core mapping is

$$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$

with $\alpha \approx 3\text{--}4$ typically. The coarse control elements are treated as an interconnected set of rigid elements solved with iterative penalty-based constraints, while deformation propagation and solver stability are handled with position-based dynamics (PBD) and an explicit position-based integration scheme (Kenwright, 2023).

The pipeline proceeds from collision with rigid objects such as walls, barriers, posts, and vegetation, to deformation of the coarse body, constraint-based propagation, rest-shape recomputation when plastic deformation occurs, and finally mapping back to the visible mesh. Constraints are assumed to break when deformation exceeds a certain threshold, and each control point is only allowed to deviate by a specified amount. The method was implemented on an Intel i7 CPU at 3.2 GHz and NVIDIA GeForce GTX 480 GPU, and examples included a vehicle with 900,000 vertices and 60 control points. The reported outputs were visually plausible dents and bends, deformation spreading like ripples on water, interactive-rate simulation, and large deformations on high-resolution meshes (Kenwright, 2023).

Crash reconstruction uses a more explicitly analytical shape model. The generalization of CRASH3 replaces a few crush depths by a continuous crush profile $C_{\max}(w)$ and then by a 3D crush surface $C_{\max}(w,h)$. The damaged structure is modeled as an ensemble of linear springs, beginning with

$F = kC,$

and generalized under homogeneous stiffness assumptions to

$\frac{dF_{\max}}{dw\,dh} = A + B C_P,$

where $C_{\max}(w,h)$0 is permanent crush and $C_{\max}(w,h)$1. The total absorbed energy at maximum engagement is then obtained from the crush surface, with the discrete 3D formulation

$C_{\max}(w,h)$2

In this usage, CrashShapes is a continuous spatial description of collision damage from which peak force, absorbed energy, and, by implication, delta-v and equivalent barrier speed can be estimated (Scurlock, 2014).

A contemporary extension of this shape-first logic appears in 3D damage localization. CrashSplat performs 3D damage segmentation by up-lifting 2D masks into 3D Gaussian Splatting (3D-GS). The pipeline uses a pretrained YOLO11 segmentation network on CarDD and VehiDE, reconstructs the scene with COLMAP/SfM, and then projects Gaussians into a single annotated view, retaining candidates through Z-buffering and a normal-distribution-based filter over depth and opacity. The reported self-recorded damage metrics were IoU 65.69% on the input view and 52.44% averaged across three views for a scratch, 88.15% and 87.16% for a flat tire, and 82.41% and 67.07% for a broken lamp, with runtimes from 0.04 s to 0.31 s. On SPIn-NeRF scenes, the proposed single-view method reported mean IoU/Acc of 79.9/96.9 (Chileban et al., 28 Sep 2025).

These strands define three complementary regimes of crash-shape representation: synthesis of plausible damage geometry for interactive environments, measurement of crush geometry for severity estimation, and segmentation of damaged regions in a reconstructed 3D vehicle model (Kenwright, 2023, Scurlock, 2014, Chileban et al., 28 Sep 2025).

4. Shape approximations for collision probability and avoidance

In automated driving, CrashShapes also denotes shape approximations used to evaluate safety under uncertainty. One formulation estimates the probability of collision (POC) by replacing exact vehicle footprints with multiple overlapping circles and assuming Gaussian position uncertainty. The object state is $C_{\max}(w,h)$3, and the target quantity is

$C_{\max}(w,h)$4

The ego rectangle of length $C_{\max}(w,h)$5 and width $C_{\max}(w,h)$6 is over-approximated by $C_{\max}(w,h)$7 circles of equal radius $C_{\max}(w,h)$8,

$C_{\max}(w,h)$9

with the circles arranged along the longitudinal axis. For the circle-to-circle case, the anisotropic Gaussian collision integral is reduced from two dimensions to a single integral involving the error function (Tolksdorf et al., 2024).

The principal claim is computational. Average runtime per evaluation was reported as 56.340 ms for Monte Carlo sampling, versus 0.275 ms for the local-coordinate double integral, 0.171 ms for the local-coordinate reduced single integral, 0.372 ms for the global-coordinate double integral, 0.208 ms for the global-coordinate reduced single integral, and 0.395 ms for the polar-coordinate form. The method also supplies an approximation-error corridor: $$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$0 where the upper bound comes from a covering-circle approximation and the lower bound from inscribed circles. In this sense CrashShapes is not the crash event itself but the geometric surrogate that makes online POC computation tractable (Tolksdorf et al., 2024).

A related, broader line of work pursues less conservative collision avoidance by abandoning spherical models in favor of ellipsoids and combinations of one-sheeted and two-sheeted hyperboloids. The resulting 3D collision cone is constructed from planar cross-sections of the shapes. In the 2D slice, collision occurs when

$$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$1

and the 3D cone is obtained by repeating the construction over $$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$2 planes containing the center-to-center vector. For a Monte Carlo study of 10,000 engagement geometries, the relative cross-sectional area error was reported to have an upper bound of about

$$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$3

This work does not use CrashShapes as a formal named framework, but it embodies the same methodological premise: the fidelity of collision reasoning depends materially on the fidelity of the shape model (Dhal et al., 2022).

5. CrashShapes as red-teamed geometry in robotic manipulation

The most explicit formalization of CrashShapes as a named object appears in geometric red-teaming for robotic manipulation. There, CrashShapes are object-specific, physically plausible mesh deformations that reliably cause a pre-trained manipulation policy to fail. The policy is $$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$4, the nominal object is a mesh $$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$5, and the deformation operator is $$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$6. Red-teaming is posed as the black-box minimization

$$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$7

where $$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$8 is the set of physically plausible deformations and $$z = D(u,v), \qquad x = \frac{(u-c_u)\times z}{f_u}, \qquad y = \frac{(v-c_v)\times z}{f_v},$$9 is a task-specific performance metric measured in simulator rollouts (Goel et al., 15 Sep 2025).

The deformation parameterization uses a Jacobian field-based model. Given the source mesh $$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$0, each face has a local affine Jacobian $$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$1, and the mesh reconstruction stage solves

$$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$2

followed by soft handle enforcement through

$$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$3

Search is then performed by a gradient-free black-box optimizer with selective perturbation, population size 10 candidates per iteration, 10 optimization iterations, Gaussian noise std 0.001 in normalized mesh units, and perturbation of half the parameters per iteration. Reported red-teaming cost was about 0.5 to 4 wall-clock hours per object-policy pair on an RTX 4090 (Goel et al., 15 Sep 2025).

Structural validity is enforced through a watertight, manifold mesh assumption, anchor constraints, handle constraints, and optionally a deformation budget given by the Smoothness Score,

$$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$4

This guarantees $$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$5. The paper emphasizes that even SS-constrained deformations can collapse performance, implying that very small, plausible geometry changes can expose brittle geometric assumptions in grasping, insertion, and articulated manipulation (Goel et al., 15 Sep 2025).

The quantitative degradations are large. For grasping with Contact-GraspNet, the reported Final Drop was 76.3% for VLM-guided handles, 63.4% for manual handles, and 58.3% for VLM-guided + SS. For articulated manipulation, the reported Final Drop was 61.9% for VLM-guided, 98.9% for manual, and 44.7% for manual + SS. For insertion, the state-based policy yielded 67.4%, 73.95%, and 60.9%, while the point-cloud policy yielded 77.7%, 71.7%, and 43.4%. The best ablation in grasping was VLM-Guided + Optimization with 76.3%, compared with 63.3% for Heuristic + Gaussian (Goel et al., 15 Sep 2025).

The same geometries support blue-teaming. PPO fine-tuning on individual CrashShapes increased state-based insertion success from 25.0% to 87.8% on CS-1 and from 45.0% to 93.8% on CS-2; the point-cloud insertion policy improved from 31.3% to 81.3% across five CrashShapes, while nominal performance remained high. Hardware validation showed the same pattern: on an xArm 6, nominal insertion success was 90.0%, falling to 22.5% on CS-1 and 55.0% on CS-2; on a Franka Emika Panda, a mustard bottle dropped from 80.0% to 30.0%, and a screwdriver from 90.0% to 35.0%. In this domain, CrashShapes are simultaneously diagnostic and corrective geometries (Goel et al., 15 Sep 2025).

6. Broader shape-centric collision and fracture science

A broader literature, while not using CrashShapes as a formal named framework, treats shape as the principal observable of impact, fracture, and collapse. This suggests a deeper methodological continuity: geometry frequently serves as the compressed signature of a complex dynamical process (Fender et al., 2010, Clark et al., 2013, Sugiura et al., 2018, Sugiura et al., 2019, Man et al., 2022).

In brittle fracture, two approaching cracks generate an “en passant” pattern that releases a lenticular fragment with aspect ratio

$$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$6

with $$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$7 and $$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$8. The crack edge follows

$$t^{s}_{max} = \max (t^{s}_{1}, t^{s}_{2},..., t^{s}_{n}), \qquad D^{s}_{i} = d^{s}_{i} + (t^{s}_{max} - t^{s}_{i})*v^{t}_{i},$$9

with $$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$0 and $$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$1, hence an essentially square-root trajectory. The geometric model assumes that the maximum tensile stress lies along the line connecting the two crack tips and that each crack propagates orthogonal to that direction, yielding

$$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$2

The result is a universal lens with square-root edges across gelatin, nitrile, cork, polystyrene foam, and aluminum foil (Fender et al., 2010).

In granular impact, a collisional model explains the velocity-squared drag term by repeated inelastic collisions with force-chain clusters: $$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$3 For triangular noses, the side contribution scales with

$$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$4

and the measured data collapse gave

$$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$5

The same collisional asymmetry also predicts rotation, so that deceleration and rotational instability are treated as two manifestations of the same grain-scale process (Clark et al., 2013).

Asteroid-collision studies reach an analogous conclusion at planetary scale. Equal-mass, low-velocity impacts with $$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$6 and $$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$7 produce bilobed, spherical, flat, elongated, and hemispherical shapes, and the work argues that flat shapes of asteroids larger than about 80 km are especially likely to originate from primordial similar-mass impacts (Sugiura et al., 2018). By contrast, high-resolution catastrophic-disruption simulations with about $$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$8 SPH particles per run found that collisional remnants are mainly spherical or bilobed, with no remnants with $$\phi_{ij} = \frac{1}{|| c_i - v_j ||^\alpha}, \qquad v'_j = v_j - \left[ \sum_i(c_{i0}\phi_{ij}) - \sum_i(c_i\phi_{ij}) \right],$$9. The conclusion is that catastrophic disruptions explain most family shapes but not significantly flat asteroids, which may be interlopers or products of low-velocity collisions among family members (Sugiura et al., 2019).

Granular-collapse research likewise identifies shape as a control parameter. DEM simulations with square, equilateral triangular, and rectangular column cross-sections show that edge / short-edge directions run farther than vertex / long-edge directions, and that the remaining anisotropy can be collapsed by a finite-size scaling law,

$\alpha \approx 3\text{--}4$0

with fitted parameters $\alpha \approx 3\text{--}4$1 and $\alpha \approx 3\text{--}4$2. The shape effect is thus interpreted as a finite-size effect in disguise (Man et al., 2022).

Across these otherwise disparate domains, the shared pattern is clear. Shape is not merely a visualization of a collision outcome; it is often the state variable, the inference target, the control surrogate, or the failure-inducing perturbation. That continuity explains why the label CrashShapes can plausibly encompass scenario geometry, damage surfaces, safety approximations, and adversarial deformations within a single encyclopedic category.