Introduction

Imagine a robotic arm moving rapidly in a crowded factory floor. It needs to pick up a part from a bin and place it on a conveyor belt without hitting the bin walls, the conveyor, or itself. To plan this motion, the robot relies on a collision checker.

Traditionally, motion planners work by sampling the robot’s trajectory at discrete points in time—like a flipbook. They check: “Is the robot hitting anything at time $t=0$? How about $t=1$?” If both are clear, the planner assumes the path is safe. But what happens at $t=0.5$?

If the robot moves quickly or the obstacle is thin, the robot might “teleport” through the obstacle between those two timestamps. This phenomenon is known as the tunneling error.

Figure 1: (a) Illustration of tunneling errors in discrete collision detection. Sampling only a finite set of waypoints along the robot’s trajectory can miss collisions occurring between waypoints (highlighted by the dashed circle). (b) Swept Volume Collision Detection (SVCD). SVCD evaluates the collision between the swept volume of the object along the given trajectory (pink) and obstacles.

As shown in Figure 1, standard discrete collision detection (a) misses the collision entirely. The solution is Swept Volume Collision Detection (SVCD). Instead of checking points, SVCD checks the entire continuous volume the robot occupies as it moves through space (b).

While SVCD is mathematically safer, it is historically computationally expensive. In this post, we will dive into NeuralSVCD, a new approach presented at CoRL 2025 that uses neural networks to solve this problem. It manages to be both faster and more accurate than traditional geometric methods by learning to look at shapes the way humans do: focusing on local details and specific moments in time.

The Background: The Efficiency vs. Accuracy Trade-off

Why is checking a swept volume so hard? The core issue lies in how we represent 3D shapes and how we calculate the intersection between them.

Currently, robotics engineers essentially have to pick their poison among three main approaches:

Convex Decomposition (Exact but Slow): You can break complex objects into many small convex shapes (like wrapping a gift in many small boxes). You then use an algorithm called GJK to check if these boxes collide. This is accurate, but GJK is a serial algorithm—it involves a lot of “if-this-then-that” logic (branching), which means it runs poorly on modern GPUs that prefer parallel processing.
Sphere Approximation (Fast but Inaccurate): You can fill the object with hundreds of spheres. Checking if two spheres touch is incredibly fast and easy to parallelize on a GPU. However, spheres are clumsy. To represent a sharp edge or a thin plate, you need thousands of tiny spheres, or you end up with a shape that is too “puffy,” leading to false collisions in tight spaces.
Implicit Functions (Accurate but Slow): You can represent objects as mathematical functions. While this supports arbitrary trajectories, calculating the exact moment of deepest penetration requires solving complex optimization problems for thousands of surface points.

Figure 2:(a) SVCD problem definition. (b-d) Comparison of geometric representations used in different SvCD algorithms.

Figure 2 visualizes these differences. The Convex hull approach (b) is rigorous but computationally heavy. The Sphere-based approach (c) is fast but loses geometric fidelity. The authors of NeuralSVCD propose a fourth option (d): a learned approach that identifies the “maximum collision probability” by focusing only on the relevant parts of the object and trajectory.

The Core Intuition: Shape and Temporal Locality

The researchers behind NeuralSVCD realized that to make a neural network effective for this task, they couldn’t just feed it entire 3D meshes and hope for the best. That would require massive amounts of data and wouldn’t generalize well to new objects.

Instead, they leveraged two key insights: Shape Locality and Temporal Locality.

Shape Locality

Does a collision checker need to know that it is looking at a “teapot”? Not really. It only needs to know that a specific curve of the teapot’s handle is getting close to a table edge. Local geometric features—corners, edges, flat surfaces—are universal. A sharp corner on a futuristic robot looks geometrically similar to a sharp corner on a simple box.

By focusing on local patches of an object rather than the global shape, the model can learn to predict collisions for objects it has never seen before, simply because it recognizes the local surface features.

Temporal Locality

Similarly, a collision usually happens in a split second. The trajectory of the robot five seconds ago is irrelevant to whether it will crash right now. The collision status is determined by a very short segment of the trajectory where the objects are closest.

Figure 3:(Left - shape locality) Two different pairs of objects have completely different global shapes, but when we focus on the circled contact regions,they have very similar shapes.(Right - temporal locality) Two different object trajectories share the same collision moment, marked by rectangles.

Figure 3 illustrates this beautifully. On the left, two totally different objects share a nearly identical “contact region.” On the right, two different trajectories share the same critical moment of impact. NeuralSVCD is built to exploit these similarities.

The Method: Inside NeuralSVCD

NeuralSVCD is an encoder-decoder architecture designed to predict collision probability between a moving object’s swept volume and a static obstacle. Let’s break down the architecture step-by-step.

$Figure 4: Overview of SVCD pipeline. During encoding, (top), the canonical meshes \$\\mathrm { ( m e s h _ { m o v } }\$ and \$( \\mathrm { { m e s h } _ { \\mathrm { { s t a t i c } } } ) }\$ transform into distributed latent representations ( \$\\mathcal { Z } _ { \\mathrm { m o v } }\$ and \$\\mathcal { Z } _ { \\mathrm { s t a t i c } }\$ , respectively) using a neural encoder. Each representation \$\\mathcal { Z }\$ consists of \$N\$ representative points \$( p _ { i } ^ { \\mathrm { s t a t i c } }\$ and \$p _ { j } ^ { \\mathrm { m o v } } .\$ ,associated bounding spheres with radii \$( r _ { i } ^ { s t a t i c }\$ and \$r _ { j } ^ { m o v }\$ )，and local latent vectors \$( z _ { i } ^ { \\mathrm { s t a t i c } }\$ and \$z _ { j } ^ { \\mathrm { m o v } }\$ ). During inference (bottom)， given latent representations \${ \\mathcal { Z } } _ { \\mathrm { m o v } }\$ and \$\\mathcal { Z } _ { \\mathrm { s t a t i c } }\$ along with a trajectory \$\\tau ( t ) : \\mathsf { [ 0 , 1 ] } \\to S E ( 3 )\$ (botom left), we initially evaluate all possible pairs \$\\{ ( i , \\bar { \\ j } ) \\ | \\ i , j \\in [ \\bar { 1 } , N ] \\}\$ In the broad phase (middle), we use bounding spheres to quickly identify intersecting pairs \$( i , j )\$ and its time \$t _ { i j } ^ { \\dagger }\$ of maximum sphere overlap. The local trajectory is defined as the linearized motion at \$\\xi ^ { t _ { i j } ^ { \\dag } } \\in \\mathbb { R } ^ { 6 }\$ by computing its first-order linear approximation (see black box). In the narrow-phase (right),for all identified collision candidate pairs and time \$( i , j , t _ { i j } ^ { \\dagger } )\$ ， the neural SVCD decoder \$f _ { S V C D }\$ refines collision predictions based on inputs \$( p _ { i } ^ { \\mathrm { s t a t i c } } , z _ { i } ^ { \\mathrm { s t a t i c } } ) , \\xi ^ { t ^ { \\dagger } } , \\tau ( t ^ { \\dagger } )\$ ,and \$( p _ { j } ^ { \\mathrm { m o v } } , z _ { j } ^ { \\mathrm { m o v } } )\$ . The final collision outcomes for rigid bodies are aggregated using max-pooling across all identified pairs.$

1. The Encoder: Distributed Latent Representation

Instead of compressing an entire object into one vector, NeuralSVCD creates a distributed representation.

It samples $N$ representative points across the surface of the object using Furthest Point Sampling (ensuring uniform coverage).
It defines a “patch” around each point (using a bounding sphere radius $r$).
It runs a neural encoder on the local geometry of that patch to produce a latent vector $z$.

Think of this as covering the object in smart sensors. Each sensor ($p_i$) knows its location, its coverage radius ($r_i$), and has a compressed code ($z_i$) describing the shape of the surface “underneath” it.

2. The Broad Phase: Filtering with Spheres

When checking for a collision between a moving object and a static one, we theoretically need to check every “sensor” on the robot against every “sensor” on the obstacle. That’s $N^2$ checks! Doing this with a heavy neural network would be too slow.

To solve this, the authors use a Broad Phase filter. Since every latent point $p$ has a radius $r$, they simply treat the object as a collection of spheres first. They calculate if and when the swept volumes of these spheres intersect.

They solve the following optimization problem to find the time $t^\dagger$ when two spheres are closest:

Equation

If the distance between spheres at this optimal time is greater than the sum of their radii, we know for sure they don’t collide. We can discard that pair immediately. This leaves us with only a few candidate pairs that are potentially colliding.

Now we have a candidate pair of local patches (one static, one moving) and a specific time $t^\dagger$ where they are closest. But spheres are crude approximations—just because the spheres overlap doesn’t mean the actual surfaces collide.

This is where the neural network (the SVCD Decoder) takes over.

Linearization: The system takes the trajectory $\tau$ and approximates it as a linear motion (a straight line with constant velocity) just for that split second around $t^\dagger$.
Decoder Input: The decoder receives the two latent vectors ($z_{static}, z_{mov}$), their positions, and the linearized movement.
Prediction: The network outputs a probability of collision.

Achieving Invariance

A major challenge here is invariance. If you rotate the entire world by 90 degrees, the collision result shouldn’t change. However, raw coordinates change completely. To help the network generalize, the authors preprocess the inputs so they are relative to the pair of points being checked.

$Figure 8: Ilustration of pre-processing for achieving invariance. Case 1 and 2 have the same relative transform between two objects,but their global transforms are different. If we treat the two objects as a single composite rigid body, we can assign frames \$\\{ \\phi ( x _ { 1 } ) \\}\$ and \$\\{ \\phi ( x _ { 2 } ) \\}\$ whose origin is at the mid-point of the centers of two objects,and whose direction is determined by the line intersecting the centers. We then apply \$\\phi ( x _ { 1 } ) ^ { - \\bar { 1 } }\$ and \$\\phi ( x _ { 2 } ) ^ { - 1 }\$ to these frames so that they are at the origin of the world frame,with their orientation aligned with that of world frame as shown in the bottom. This preprocessing step ensures consistent input irrespective of the objects’ global poses.$

As shown in Figure 8, the system creates a canonical frame of reference based on the two objects. Whether the collision happens on the ceiling or the floor, the neural network “sees” the same relative geometry. This is mathematically handled by the following preprocessing function $\Phi(x)$:

Equation

This ensures that the network focuses purely on the geometry of the collision, not the global position of the robot.

Experiments and Results

The authors integrated NeuralSVCD into cuRobo, a state-of-the-art GPU-accelerated motion planner, and compared it against standard methods.

Accuracy vs. Efficiency

The holy grail in collision detection is to be in the top-left corner of the chart: high accuracy and extremely low computation time.

Figure 5: Accuracy efficiency tradeof graph of our SVCD and other baselines for (Left) in-domain object sets and (Right) out-of-domain object sets.

The results in Figure 5 are striking.

Blue Line (Ours - Continuous): NeuralSVCD shoots up to near 100% accuracy almost immediately (around $10^{-4}$ seconds).
Pink/Purple Lines (Convex Cell): These methods are accurate but significantly slower (further to the right).
Green/Orange Lines (Sphere): These are reasonably fast but struggle to reach high accuracy because spheres cannot capture fine details (they plateau lower).

Crucially, the graph on the right shows Out-of-Distribution (OOD) objects—shapes the network never saw during training. NeuralSVCD maintains its performance, proving that the “Shape Locality” hypothesis works: because it learned local features (corners, edges), it can handle new global shapes easily.

Real-World Robotics Tasks

To prove this isn’t just a simulation trick, the researchers tested the system on complex planning tasks shown in Figure 7.

Dish Insertion (a): This requires extremely high precision. Sphere-based methods often fail here because to fit between the rack slots, the spheres must be very small, requiring thousands of them, which kills performance.
Peg Assembly (b): A dual-arm task that requires tight coordination.
Mining Tunnel (c): A navigation task in a cluttered environment.

The motion planner minimizes a trajectory cost function $C_{traj}$, which includes a term for smoothness and a term for collision cost:

Equation

By using NeuralSVCD to compute the $C_{SVCD}$ term, the planner achieved significantly higher success rates. For example, in the dish insertion task, NeuralSVCD achieved a 99.3% success rate, whereas the sphere-based method (using 50 spheres) only managed 73.6% and often got stuck or resulted in collisions.

Conclusion

NeuralSVCD represents a significant step forward in robotic motion planning. It successfully bridges the gap between the high speed of sphere-based checks and the high accuracy of mesh-based checks.

By decomposing objects into distributed latent patches, the system effectively “learns” the geometry of collision. It doesn’t need to check every polygon against every other polygon. It uses a fast spherical filter to find “close calls” and then uses a highly specialized neural network to make the final judgment call based on local geometry.

For students and researchers in robotics, this paper highlights a valuable lesson: sometimes the best way to solve a global problem (robot trajectory) is to focus on the local details (surface patches and split-second moments). As robots move into more cluttered, unstructured environments—like our homes—efficient, continuous collision detection like this will be essential for safety.

Solving the Tunneling Problem: How NeuralSVCD Makes Robot Motion Planning Safer and Faster

Introduction

The Background: The Efficiency vs. Accuracy Trade-off