Occupancy Grid vs Signed Distance Field Maps in Robot Navigation

Occupancy grids and signed distance fields encode two different answers to two different questions about the same environment. An occupancy grid asks whether a cell is blocked; a signed distance field asks how far a point is from the nearest obstacle, and in which direction. That distinction, binary cell state against continuous distance and gradient, shapes nearly every downstream decision a robotics team makes about mapping, planning, and what a given platform can physically do.

What occupancy grids and signed distance fields encode

An occupancy grid divides the environment into a discrete set of cells, and each cell carries a probabilistic estimate of whether it is occupied, free, or unknown. The output per cell is close to binary: blocked or not blocked. Nothing about the relationship between neighboring cells tells a planner how close it is to a surface, only whether the cell it currently occupies is itself a surface. This is the representation dense mapping and path planning were built around for decades, and it remains a reasonable default for many tasks.

A signed distance field works differently. It assigns every point in space a single number, the signed Euclidean distance to the nearest surface, positive outside obstacles and negative inside them. Researchers behind iSDF, presented at Robotics: Science and Systems 2022, describe SDFs as scalar fields that tie each point in space to the signed distance to the closest surface point, with the surface itself captured as the zero level set, the set of points where that distance equals zero²³¹. Querying a signed distance field also returns a gradient, a direction vector pointing away from the nearest obstacle. An occupancy grid has no equivalent output to give. That is not a missing feature so much as a consequence of what each representation was built to store, and it is the premise the rest of this comparison rests on.

Why trajectory optimization needs a gradient signal

A gradient-based solver minimizes a cost function that balances smoothness against collision avoidance, so that cost function needs to be differentiable with respect to the robot's position at every step. The gradient is how the optimizer knows which way to push the trajectory to get away from an obstacle, not just that an obstacle is nearby. iSDF states that signed distance fields are the dominant map representation used in trajectory optimization because the optimizer needs a direction to move in, not just a flag.

An occupancy grid gives a planner no such direction. Any solver built around gradient descent has to manufacture one, and the two common fixes both carry costs. Inflating obstacles heuristically trades real clearance information for a lossy, asymmetric safety margin, discarding information the sensor actually captured. Running a separate distance transform over the grid produces a usable cost field, but at that point the pipeline is doing most of the work of computing an SDF anyway, just later and less directly. Occupancy maps remain common in SLAM systems, where the job is building a consistent map of the world, but they are a poor fit for planning, where the optimizer needs to evaluate cost at many points along a candidate trajectory and needs those evaluations to be cheap. If you precompute a distance field once, querying it repeatedly beats computing cost on the fly from a raw surface reconstruction every time. For any pipeline that leans on gradient-based trajectory optimization, which covers most modern motion planning for manipulators, multirotor aircraft, and ground robots, the occupancy grid is the wrong tool at the planning stage, however useful it remains elsewhere in the stack.

How the classic voxel SDF pipeline introduces error

The theoretical case for SDFs is clean. Building one from real sensor data is not, and the standard voxel-based pipeline runs through two sequential stages that each introduce their own approximation error.

The first stage fuses depth images into an intermediate surface representation, typically a truncated signed distance field (TSDF) or an occupancy grid, before any full distance field exists. The second stage derives the complete SDF from that surface through wavefront propagation, a breadth-first search that spreads distance values outward only from voxels that were just updated, which keeps the computation tractable but is still an approximation of a continuous quantity. Voxblox, introduced by ETH Zürich's Autonomous Systems Lab at IEEE/RSJ IROS 2017, along with later systems FIESTA and Voxfield, built this two-stage architecture into the reference implementations the field still benchmarks against.

Each stage leaks accuracy. Most existing approaches rely on projective distances taken straight from range data as the signal for training or updating the SDF, and that projection approximation degrades mapping quality in ways that compound downstream. In free space, the nearest occupied voxel a query finds may itself be unobserved, so distances in unexplored regions get systematically underestimated. Because the grid is discrete, producing a continuous Euclidean signed distance field (ESDF) value at an arbitrary point requires interpolation between voxels, which introduces a second, separate source of error, most pronounced near surfaces, exactly where accuracy matters most. And wavefront propagation's cost scales with how far distance values have to travel, so practical voxel-grid resolution is limited to around 5 cm, a real constraint in tight indoor spaces or on small robots. An occupancy grid is discretized too, but it never promises more than a cell-level answer, whereas the voxel SDF promises a continuous distance value and delivers only an approximation of one, and closing that gap is what motivates the neural and GPU-based approaches covered later in this piece.

Where occupancy grids remain the practical choice

None of this makes the occupancy grid obsolete. It stays the easiest representation to build, update, and read, and that is why it persists as the sensor-fusion front end even inside systems that ultimately plan against an SDF layered on top.

Updating an occupancy grid is cheap in a way a full distance field is not: each new sensor reading only touches the cells along its ray, with no global propagation step required to keep the rest of the map consistent. Newer extensions have pushed the representation further. SCOPE adds uncertainty modeling for safer navigation in dynamic settings, and dynamic grid mapping built on recurrent neural networks supports real-time updates so the map can adapt as the scene changes. For simple reactive planners and grid-search algorithms like A* or Dijkstra, a binary cell state is exactly the information those algorithms need. No gradient enters the computation, so the occupancy grid is a sufficient representation on its own terms, not a stopgap.

Where the occupancy grid runs into trouble is dynamism. Sensor-derived occupancy maps get degraded by occlusion, localization error, moving obstacles, incomplete sensor coverage, and ordinary perception noise, and any one of these can turn a route that looked clear at mapping time into an unsafe one by the time the robot gets there. That fragility pushes planners toward conservative route selection, treating the map as provisional rather than ground truth, and that caution quietly erodes the efficiency the map was supposed to buy. The update speed of an occupancy grid is real and valuable. It does not make up for the reliability problems in what the occupancy signal is actually reporting, particularly in cluttered or fast-changing spaces.

Sub-voxel SDF accuracy and physical robot capability

In unstructured terrain, the gap between an occupancy grid and a signed distance field moves from a question of planning efficiency to a question of which physical robot configurations even get considered. That is a sharper claim than it sounds, and it holds up under a concrete example.

Occupancy grids and traversability maps collapse the relationship between a robot and the ground beneath it into a binary judgment: traversable or not. That works reasonably well on semi-structured terrain, but the approximation has to be chosen conservatively to avoid accidents, and conservative thresholds remove actions the robot's actual geometry could have handled safely. The failure is sharpest for articulated robots. A heuristic like an occupancy grid has no way to account for current joint positions, so it can block a configuration the robot's true shape would allow, simply because the grid has no concept of the robot's shape changing. Oehler, Daun, Schnaubelt, and von Stryk, working at TU Darmstadt and publishing at IEEE SSRR 2023, show this directly with tracked robots that carry active flippers: the sub-voxel accuracy of a signed distance field's surface representation supports pose prediction that accounts for joint configuration, something occupancy grid heuristics structurally cannot replicate.

The same 3D representation that makes joint-aware pose prediction possible also supports multi-level terrain and stacked or overhanging structures, and a 2D occupancy grid simply has nothing to say about these. The general rule that falls out of this case generalizes well beyond tracked robots: anywhere a robot's geometry interacts with its environment at a finer resolution than the occupancy cell size, a continuous distance signal is the only representation that captures the actual physics of the contact.

How neural SDFs resolve the accuracy-memory trade-off

Neural SDFs attack the two-stage pipeline's weaknesses directly by replacing the voxel grid with a trained network that answers distance queries continuously, which removes the voxel resolution ceiling and cuts memory use sharply, though it introduces a different failure mode in its place.

Traditional voxel-based SDFs face a trade-off that cannot be engineered away within that architecture: finer voxels mean better accuracy, but memory use grows with the cube of resolution, so doubling precision in each dimension costs roughly eight times the memory. A neural network sidesteps that scaling because the representation is the set of network weights, not a dense array of stored values. Its neural method needs only 1 MB of network weights and around 20 keyframes to reconstruct a room, while Voxblox needs 5 MB and KinectFusion+ needs 30 MB for comparable coverage. Beyond the memory savings, the learned representation adapts its level of detail to where the network has actually seen data, it fills in partially observed regions with a plausible estimate rather than leaving voxels empty, and it smooths out sensor noise as part of the fitting process rather than baking that noise directly into stored values.

The real weakness is catastrophic forgetting: because the network trains online, new observations can quietly degrade geometry the system had already reconstructed correctly. Replay-based training is the standard mitigation, replaying past observations alongside new ones so the network does not drift, but existing methods mostly lean on passive replay buffers and uniform sampling, a partial fix. The trade-off between accuracy and memory is being resolved, not eliminated. C-3TO, a 2025 preprint submitted to ICUAS 2026, extends the neural SDF approach into aerial robotics, running local continuous 3D trajectory optimization directly on a neural Euclidean signed distance field built online from 3D LiDAR measurements, which is evidence the approach is moving past indoor depth-camera settings and into outdoor, higher-speed deployment.

GPU acceleration and real-time voxel SDF on embedded hardware

A second line of attack on the same problem comes from engineering rather than learning, and it has closed much of the compute gap that once pushed resource-constrained robots toward occupancy grids by default, so dense real-time SDF maintenance is now practical on embedded hardware.

nvblox, built by NVIDIA and presented at ICRA 2024, is a library for reconstruction and mapping aimed squarely at robotics. It builds a voxel-based map from depth images, 3D LiDAR scans, or both, and it outputs a real-time mesh of the world alongside a cost map ready for path planning. It has already been used for navigating autonomous mobile robots and for motion generation on robotic arms. The architecture runs TSDF integration and ESDF generation entirely in CUDA, and the costmap layer ships as a custom nav2_costmap_2d plugin, so folding it into an existing Nav2 deployment is a configuration change.

NVIDIA's Isaac Perceptor documentation states that nvblox, as the core perception component of Isaac Perceptor, can identify obstacles up to five meters away and update them in under 300 milliseconds to produce a 2D costmap. As of September 2026, nvblox picked up compatibility and integration updates for the Isaac ROS 5.0.0 release, continuing active development. It targets discrete NVIDIA GPUs and Jetson devices, precisely the embedded hardware class that used to have no choice but to fall back on occupancy grids when compute ran short. The old engineering argument for picking an occupancy grid on a Jetson-class robot, that real-time SDF computation costs too much, no longer holds broadly for teams willing to adopt CUDA-based tooling.

The strongest dissent: a 2026 framework that skips map-building entirely

A 2026 framework called EXACT-MPPI raises an objection to the occupancy-grid-versus-SDF comparison. For ground robots with complex footprints, it argues, the chain from sensor data to intermediate map to planner adds latency and approximation error at every step, but sampling-based control can just skip that.

EXACT-MPPI generates motion commands straight from point clouds captured by onboard LiDAR, with no intermediate environment representation built at all: no occupancy grid, no signed distance field, no local costmap sitting between perception and control. Instead, Model Predictive Path Integral control delivers collision-aware, smooth local navigation, and because it samples rather than differentiates, it needs no gradient information or differentiable cost function to work. That removes the structural reason SDFs have been preferred over occupancy grids in the first place: if the controller never needs a gradient, the representation built to supply one stops being necessary for that controller. The case for either an occupancy grid or a signed distance field assumes the robot benefits from an intermediate map. EXACT-MPPI is the sharpest challenge to that assumption on record, and it means this comparison, grounded as it is in gradients and cell states, applies fully only to the broad class of planners built around having a map.