LiDAR

LiDAR (light detection and ranging) measures the distance to a surface by sending out laser light and timing its echo. A single laser rangefinder measures one distance along one direction; a LiDAR sensor steers one or many such beams across its field of view and reports each echo as a direction, a range and a return strength. The result, after a conversion to Cartesian coordinates, is a point cloud: sparse compared with a camera image, but with every point at a directly measured, metric distance, independent of scene lighting. Driving datasets such as KITTI record LiDAR alongside cameras, which supply the dense appearance that LiDAR lacks.

This article covers the sensor: how range is measured, how beams are steered, what a scan contains, how the sensor is calibrated against cameras and corrected for its own motion, and where it fails.

How It Works

A LiDAR has two parts (Li & Ibanez-Guzman, 2020): a laser rangefinder, consisting of a laser transmitter, optics and a photodetector with signal-processing electronics that turn an echo into a distance, and a scanning system that points the rangefinder in successive directions, indexed by an azimuth $\phi_i$ and an elevation $\theta_i$.

Pulsed time of flight

Most automotive sensors send short pulses and time their return, which Li and Ibanez-Guzman call direct detection. Light covers the distance twice, so a round-trip time $\Delta t$ gives the range

$$R = \frac{c\,\Delta t}{2n},$$

where $c$ is the speed of light and $n \approx 1$ the refractive index of air. Royo and Ballesta-Garcia (2019) give the consequences of this formula. The range resolution is set by the timing electronics: resolving $0.1$ ns, a typical value limited by jitter and noise, gives $1.5$ cm in range. Averaging several pulses improves it, at the cost of frame rate or spatial resolution. The maximum range is limited in principle by the longest measurable interval, but in practice by the signal-to-noise ratio of weak echoes. A second limit is ambiguity: if a new pulse leaves before the previous echo returns, an echo cannot be assigned to its pulse, so the unambiguous range is $c/(2 f_\text{rep})$ for a pulse repetition rate $f_\text{rep}$, about 150 m at repetition rates near 1 MHz.

How much light comes back is described by a power budget. For a pulse of energy $E_p$ and a target at range $r$, Li and Ibanez-Guzman approximate the received power as

$$P_r = E_p \, \frac{c\,\eta\,A_r}{2 r^2} \, \beta \, T_r,$$

with receiver aperture area $A_r$, overall system efficiency $\eta$, target reflectance $\beta$ and transmission loss $T_r$ through the air. For a Lambertian surface of reflectivity $\Gamma$, $\beta = \Gamma/\pi$; $\beta$ also depends on the incidence angle, and by Lambert’s cosine law a diffuse surface tilted away from the beam returns proportionally less. The $1/r^2$ factor is the central fact of LiDAR design: a target ten times farther returns a hundredth of the power. Raising the transmit power is the obvious remedy, and it is capped by eye safety.

A third principle, amplitude-modulated continuous wave (AMCW), compares the phase of an intensity-modulated signal with its echo. Royo and Ballesta-Garcia describe it as limited to moderate ranges by its short ambiguity distance and mostly suited to indoor use; it is the principle of most time-of-flight cameras.

Frequency-modulated continuous wave

A frequency-modulated continuous-wave (FMCW) LiDAR emits a laser whose optical frequency is swept linearly, by a bandwidth $B$ over a ramp of duration $T$, and mixes the echo with a copy of the outgoing light (coherent detection). The echo is delayed by $2R/c$, so at any instant it differs in frequency from the outgoing light by the sweep slope times the delay, a beat frequency (Royo & Ballesta-Garcia, 2019):

$$f_r = \frac{B}{T}\cdot\frac{2R}{c} \quad\Longrightarrow\quad R = \frac{c\,T}{2B}\,f_r .$$

The beat frequency is found with a Fourier transform of the mixed signal. It follows from this relation that the range resolution depends on the sweep bandwidth: over one ramp the Fourier transform separates frequencies about $1/T$ apart, which corresponds to $\Delta R = c/(2B)$, so a 1 GHz sweep separates echoes about 15 cm apart. Royo and Ballesta-Garcia report resolutions down to 150 µm from FMCW systems, about two orders of magnitude finer than the other principles.

FMCW also measures velocity. A target moving with radial velocity $v_r$ shifts the echo by the Doppler frequency $f_d$. With a triangular sweep, the beat frequency on the rising ramp is $f^+ = f_r + f_d$ and on the falling ramp $f^- = f_r - f_d$, so the two separate:

$$R = \frac{c\,T}{4B}\,\bigl(f^+ + f^-\bigr), \qquad v_r = \frac{\lambda}{2}\,f_d = \frac{\lambda}{4}\,\bigl(f^+ - f^-\bigr),$$

where $\lambda$ is the laser wavelength (Royo & Ballesta-Garcia, 2019, Eqs. 5–7). Li and Ibanez-Guzman give the same relations in Eqs. 3–4 of their arXiv version, written with the full triangle period $2T$. At 1550 nm a radial speed of 1 m/s gives a Doppler shift of about 1.3 MHz. Every point thus carries its own radial velocity, which a pulsed sensor can only estimate by comparing successive scans. The surveys list the costs: the laser must stay coherent over the round trip, the frequency sweep must be accurately linear, and the system must be stable in temperature. They also note that coherent detection helps against interference from sunlight and other LiDARs.

Wavelength and eye safety

LiDARs work in the near infrared. Royo and Ballesta-Garcia (2019) group the sources into 0.8–0.95 µm diode lasers read by silicon detectors, 1.06 µm fibre lasers, and 1.55 µm lasers from the telecommunications industry, which need indium gallium arsenide (InGaAs) detectors. Both surveys describe the trade-off between the two common choices, 905 nm and 1550 nm. Eye-safety limits allow much more power at 1550 nm, which buys range, but the InGaAs detectors it needs are expensive. Li and Ibanez-Guzman (2020) add that InGaAs detectors are less efficient than mature silicon ones and that water absorbs more strongly at 1550 nm, and concluded that 905 nm systems were still the mainstream.

Eye safety is governed by IEC 60825-1, which classifies laser products by the hazard of their accessible radiation, for wavelengths from 180 nm to 1 mm. As of October 2026 the current edition is Edition 3.0 of 2014, which introduced a new Class 1C; the IEC lists a further edition as under development. The U.S. Food and Drug Administration’s table maps its own Classes I to IV to roughly equivalent IEC classes: Class I (IEC 1 and 1M) is considered non-hazardous, although the hazard increases when it is viewed through optical aids such as binoculars, while IIa and II (IEC 2 and 2M), IIIa (3R), IIIb (3B) and IV (4) carry increasing hazard. Royo and Ballesta-Garcia state the power advantage of 1550 nm against the Class 1 limit, and a sensor held to that limit cannot buy maximum range with power alone. The HDL-64E S3, a version of the spinning sensor family that recorded KITTI, is documented in its 2013 manual as a Class 1, 905 nm sensor firing 5 ns pulses (Velodyne LiDAR, 2013).

Beam steering

The scanning system decides where the points fall. The surveys distinguish four main designs.

• Mechanical spinning. A head carrying a vertical column of lasers and detectors, or a rotating mirror or prism, turns about a vertical axis and covers 360° of azimuth. The number of beams sets the vertical sampling, and the firing rate and rotation speed set the horizontal sampling. Royo and Ballesta-Garcia describe these sensors as offering long range and wide coverage, with large collection optics, but as bulky, power-hungry and sensitive to shock and vibration, with frame rates from below 1 Hz to about 100 Hz. They were the sensors of choice for autonomous-driving research. KITTI’s HDL-64E had 64 beams, a 26.8° vertical field of view and 0.09° azimuth resolution at 10 Hz (Geiger et al., 2013).
• MEMS mirrors. A mirror a few millimetres across on a microelectromechanical (MEMS) chip tilts under an electrostatic, electromagnetic or piezoelectric drive. Resonant mirrors swing through large angles at high frequency but sweep sinusoidally, so the scan speed is not uniform. Non-resonant (quasi-static) mirrors can follow a programmed trajectory over smaller angles. A common raster pattern pairs a fast resonant horizontal axis, typically above 10 kHz, with a slow vertical one (Royo & Ballesta-Garcia, 2019). The field of view is limited, so several units are combined for wide coverage.
• Optical phased arrays (OPA). An array of on-chip optical antennas whose relative phases are tuned steers the emitted beam by interference, with no moving parts, as a phased-array radar does. Royo and Ballesta-Garcia list fast steering, above 100 kHz, and compactness as the attractions, and power loss in the chip and limited power handling as the obstacles. The two surveys differ on maturity: Royo and Ballesta-Garcia (2019) report OPAs in some commercial short- and mid-range units, while Li and Ibanez-Guzman (2020) state that no commercial OPA product existed yet.
• Flash. A single diffused pulse floods the whole field of view, and a 2D array of detectors, like a camera sensor, times the echo at every pixel. There are no moving parts, and because all pixels are measured at once the frame has no motion distortion (Li & Ibanez-Guzman, 2020). The cost is range: the pulse energy is spread over the whole scene under the same eye-safety cap. Li and Ibanez-Guzman give ranges usually under 100 m, and Royo and Ballesta-Garcia 20–150 m for automotive units. Flash receivers are often single-photon avalanche diode (SPAD) arrays, which retroreflective road signs and licence plates can saturate, blinding the sensor for some frames.

Mixed designs are common. Royo and Ballesta-Garcia describe a 1D MEMS mirror scanning a projected line that is read by a detector array.

Data It Produces

A scanning LiDAR reports, for each firing of each beam, a small record:

• Direction, as a beam index (often called the ring or channel) and an azimuth, or as elevation and azimuth angles.
• Range along the beam. Converting direction and range to Cartesian coordinates gives $\mathbf{p} = R\,(\cos\theta\cos\phi,\ \cos\theta\sin\phi,\ \sin\theta)^\top$ in the sensor frame. The Waymo Open Dataset paper gives the inverse: range $\sqrt{x^2+y^2+z^2}$, azimuth $\operatorname{atan2}(y, x)$ and inclination $\operatorname{atan2}(z, \sqrt{x^2+y^2})$ (Sun et al., 2020). Range is distance along the ray, not the depth along a camera’s optical axis that a depth map stores.
• Intensity (also called reflectance or return strength). This is a measure of the echo’s power, so it depends on the surface’s reflectivity, the incidence angle and the range. Sun et al. describe it as only partly based on reflectivity. Its calibration is product-specific: the HDL-64E S3, for example, normalizes raw intensity with its per-unit calibration parameters (Velodyne LiDAR, 2013). Intensities from different sensors are therefore not directly comparable.
• Multiple returns. A beam has a finite footprint, so one pulse can hit a branch and the wall behind it, or a fog droplet and a car, and produce several echoes. Sensors can report one or several per pulse. The HDL-64E S3 can report the strongest return, the last return, or both. Its manual recommends the last return in fog and dust, where the near-field return comes from the obscuring atmosphere and the last from the surface behind it (Velodyne LiDAR, 2013). The Waymo Open Dataset provides the first two returns of every pulse (Sun et al., 2020).
• Timestamp. Each firing has its own time. A spinning sensor at 10 Hz takes 100 ms to complete a turn, so the first and last points of one scan are 100 ms apart. KITTI therefore stores three timestamps per scan, at the start and end of the spin and at the moment the scanner faces forward, and its paper notes that the laser scanner has a “rolling shutter” (Geiger et al., 2013).

Some sensors report more. The Waymo Open Dataset adds an elongation per return, the stretching of the pulse beyond its nominal width; the authors report that a highly elongated, low-intensity return strongly indicates a spurious object such as dust, fog or rain (Sun et al., 2020).

Because returns are indexed by beam and firing, a scan from a spinning sensor fits naturally into a 2D range image: one row per beam, one column per azimuth step, each pixel holding a range and its attributes, with holes where no echo came back. Waymo distributes its LiDAR data in exactly this form, one range image per return (Sun et al., 2020). KITTI distributes each scan as a list of points with $x, y, z$ and reflectance, about 120,000 points per scan on average (Geiger et al., 2013).

The angular pattern fixes the point density. Points from neighbouring firings lie an angle $\Delta\phi$ apart, so on a surface facing the sensor at range $R$ they are about $R\,\Delta\phi$ apart, a direct consequence of the geometry. At the HDL-64E’s 0.09° azimuth step that is about 8 cm at 50 m. The documented 1/3° vertical spacing of its upper beams (Velodyne LiDAR, 2013) gives about 29 cm between rows at the same range, so a pedestrian 50 m away receives only a handful of rows.

Characteristics

The properties that describe a LiDAR, with the values documented for the HDL-64E S3 (Velodyne LiDAR, 2013) as an example, are:

Property	Meaning	HDL-64E S3 (2013 manual)
Range accuracy	Spread of repeated range measurements	Under 2 cm (one sigma)
Maximum range	Depends on target reflectivity	50 m on pavement (about 10%), 120 m on cars and foliage (about 80%)
Field of view	Angular coverage	360° azimuth, 26.8° elevation
Angular resolution	Spacing between firings and between beams	0.09° azimuth; 1/3° and 1/2° between beams
Frame rate	Revolutions or frames per second	5–20 Hz, selectable
Point rate	Returns per second	About 1.3 million (single return)
Wavelength, laser class	Eye safety and detector type	905 nm, Class 1

Maximum range has no meaning without a reflectivity: the same sensor that sees a car at 120 m loses dark pavement at 50 m. The two figures are roughly consistent with the $1/r^2$ power budget, since $0.1/50^2$ and $0.8/120^2$ are within a factor of 1.5 of each other; that check is our own, not the manual’s. Royo and Ballesta-Garcia (2019) leave maximum range out of their comparison table for the same reason: it needs the field of view, target reflectivity and eye-safety level to be defined.

Calibration

Intrinsic calibration. Each beam of a multi-beam sensor has its own elevation angle, azimuth offset and range offset, and small errors in them bend flat walls into ripples. Manufacturers measure these per unit. The HDL-64E S3 ships with a per-laser calibration file that must be applied to the raw data to reach the specified accuracy (Velodyne LiDAR, 2013).

Extrinsic calibration with cameras. Fusing LiDAR with a camera needs the rigid transform $(R, \mathbf{t})$ from the LiDAR frame to the camera frame. A LiDAR point $\mathbf{p}$ then projects to the image through the pinhole camera model:

$$\lambda \begin{pmatrix} u \\ v \\ 1 \end{pmatrix} = K\,(R\,\mathbf{p} + \mathbf{t}),$$

where $K$ holds the camera’s intrinsic parameters, found by camera calibration. KITTI applies exactly this chain, with an extra rectifying rotation for its stereo rig (Geiger et al., 2013). Methods for finding $(R, \mathbf{t})$ fall into two groups.

• Target-based. A planar target such as a checkerboard is seen by both sensors. The camera gives the board’s plane from its corners; the LiDAR gives the points that lie on it; the transform must put those points on that plane. Geiger et al. (2012) made this automatic and single-shot. Several checkerboards are placed in the scene, planes are segmented in the range data, transform hypotheses are generated from random associations between board planes and range-data planes, and the hypotheses are refined by minimizing point-to-point distances with iterative closest point.
• Targetless. Natural scenes contain structure both sensors see. Pandey et al. (2012) maximize the mutual information between the LiDAR’s reflectivity and the camera’s grayscale intensity at the pixels where LiDAR points project, which works in place without targets because the two quantities are correlated on most surfaces.

KITTI combined the ideas. The LiDAR-to-camera transform was initialized with the single-shot method of Geiger et al. (2012), then refined against 50 manually selected correspondences and the disparities of top stereo methods, and the sensors were recalibrated after every day of recording (Geiger et al., 2013).

Time synchronization. A spinning sensor sees different directions at different times, so camera and LiDAR must also agree in time. KITTI mounted a reed contact on the rotating scanner that triggers the cameras when it faces forward (Geiger et al., 2013). nuScenes, whose 32-beam LiDAR spins at 20 Hz, triggers each of six cameras when the LiDAR sweeps across the centre of that camera’s field of view (Caesar et al., 2020). Sensors can also stamp their data with GPS time: the HDL-64E S3 accepts a GPS receiver’s sync pulse and time record for this (Velodyne LiDAR, 2013).

Processing the Data

Motion distortion and deskewing. A scan from a moving spinning sensor is not a snapshot: points fired early in the sweep were measured from a different pose than points fired late. At 15 m/s and 10 Hz the vehicle moves 1.5 m during one sweep, so a wall seen at the start and end of the sweep appears in two places. The correction, called deskewing or motion compensation, transforms every point by the sensor motion between its firing time and a common reference time. LOAM models the motion as constant angular and linear velocity during a sweep and linearly interpolates the pose for each point from its timestamp (Zhang & Singh, 2014). nuScenes motion-compensates its scans with its localization (Caesar et al., 2020), and Waymo stores the vehicle pose for every range-image pixel (Sun et al., 2020). Flash sensors, which capture a whole frame at once, avoid the problem (Li & Ibanez-Guzman, 2020).

Filtering. Clutter from fog, rain and dust appears as points close to the sensor (Bijelic et al., 2018). Intensity alone does not separate it: the Waymo authors found low intensity insufficient on its own, but high elongation with low intensity a strong indicator (Sun et al., 2020), and in Bijelic et al.’s fog tests near clutter could even show high intensity. Other filters choose the last return or apply statistical outlier removal of the kind described in the point cloud article.

Geometric processing. Ground points are separated from obstacles, often by fitting a plane or a smooth surface with RANSAC. Successive scans are aligned by iterative closest point and its variants for LiDAR odometry and mapping, the basis of LiDAR SLAM. The range-image layout lets image operations run on scans, and the projection above lets LiDAR points serve as sparse depth for camera images. KITTI’s depth benchmarks are built that way (see depth estimation).

Learning. 3D object detection and semantic segmentation networks consume LiDAR as raw points, voxels, bird’s-eye-view grids or range images, often combined with camera features (see multimodal fusion).

Simulating a Scan

The example below casts the rays of a 16-beam spinning sensor into a synthetic scene: flat ground, a bright box (reflectivity 0.80) 28 m ahead, a dark box of the same size (reflectivity 0.03) 28 m behind, and a wall 40 m ahead. The detection model follows the power budget above: an echo is reported when $\rho\cos(\text{incidence})/R^2$, times a random fluctuation of the return strength, exceeds a threshold. The threshold is chosen so that a 10% surface at normal incidence drops out near 50 m. Detected ranges get Gaussian noise of 2 cm. The sensor rides on a vehicle driving forward at 15 m/s, so every column of the scan is fired from a different position. The code then compares points assembled without motion correction with deskewed points.

import numpy as np

rng = np.random.default_rng(0)

# Spinning sensor: 16 beams from -15 to +15 degrees elevation, 0.2 degree azimuth
# steps, one revolution per 0.1 s (10 Hz), mounted 1.8 m above flat ground.
elev = np.radians(np.linspace(-15, 15, 16))
azim = np.radians(np.arange(0, 360, 0.2))
t_fire = azim / (2 * np.pi) * 0.1                    # time of each column in the sweep
E, A = np.meshgrid(elev, azim, indexing="ij")         # (16, 1800) range-image layout
T = np.broadcast_to(t_fire, E.shape)
d = np.stack([np.cos(E) * np.cos(A), np.cos(E) * np.sin(A), np.sin(E)], -1)

# Scene (world frame, metres): ground, two boxes of equal size and distance, a wall.
# Each axis-aligned box: (min corner, max corner, reflectivity).
boxes = {"bright box": ([28, -2, 0], [32, 2, 1.5], 0.80),   # 28 m ahead
         "dark box":   ([-32, -2, 0], [-28, 2, 1.5], 0.03),  # 28 m behind
         "wall":       ([40, -30, 0], [41, 30, 6.0], 0.50)}
rho_ground = 0.20

def cast(origin, d):
    """Nearest hit of each ray: range, surface label, reflectivity, normal."""
    n_rays = d.shape[:-1]
    r = np.full(n_rays, np.inf); label = np.full(n_rays, "none", dtype=object)
    rho = np.zeros(n_rays); normal = np.zeros(d.shape)
    # ground plane z = 0
    with np.errstate(divide="ignore", invalid="ignore"):
        tg = -origin[..., 2] / d[..., 2]
    hit = (d[..., 2] < 0) & (tg < r)
    r[hit], label[hit], rho[hit], normal[hit] = tg[hit], "ground", rho_ground, [0, 0, 1]
    for name, (lo, hi, refl) in boxes.items():       # slab test for each box
        with np.errstate(divide="ignore", invalid="ignore"):
            t1 = (np.array(lo) - origin) / d; t2 = (np.array(hi) - origin) / d
        tnear = np.minimum(t1, t2).max(-1); tfar = np.maximum(t1, t2).min(-1)
        hit = (tnear <= tfar) & (tnear > 0) & (tnear < r)
        face = np.minimum(t1, t2).argmax(-1)         # axis of the entry face
        nrm = np.zeros(d.shape)
        np.put_along_axis(nrm, face[..., None], -np.sign(np.take_along_axis(d, face[..., None], -1)), -1)
        r[hit], label[hit], rho[hit], normal[hit] = tnear[hit], name, refl, nrm[hit]
    return r, label, rho, normal

# The vehicle drives along +x at 15 m/s; each column fires from where the sensor is then.
v = np.array([15.0, 0, 0])
origin = np.array([0, 0, 1.8]) + T[..., None] * v
r_true, label, rho, normal = cast(origin, d)

# Detection: received signal ~ rho * cos(incidence) / R^2 (Lambertian target), with a
# random fluctuation; a return is reported when it exceeds the detector threshold.
cos_inc = np.abs(np.sum(normal * d, -1))
signal = 25000 * rho * cos_inc / r_true**2 * rng.lognormal(0, 0.3, r_true.shape)
detected = np.isfinite(r_true) & (signal > 1.0) & (r_true < 120)
r_meas = np.where(detected, r_true + rng.normal(0, 0.02, r_true.shape), np.nan)
intensity = np.where(detected, np.minimum(signal, 255).round(), 0)

print(f"shots fired: {r_true.size}, returns: {detected.sum()} "
      f"({detected.mean():.0%}), range image {r_meas.shape}")
print(f"{'surface':11s} {'shots':>6s} {'returned':>9s} {'range std (cm)':>15s} "
      f"{'median intensity':>17s}")
for name in ["ground", "bright box", "dark box", "wall"]:
    m = label == name; k = m & detected
    err = (r_meas[k] - r_true[k]) * 100
    print(f"{name:11s} {m.sum():6d} {k.sum() / m.sum():9.0%} {err.std():15.1f} "
          f"{np.median(intensity[k]):17.0f}")
g = (label == "ground")
ground_r = r_true[g]; ground_ok = detected[g]
print("farthest ground return: %.1f m (ground hit out to %.1f m)"
      % (ground_r[ground_ok].max(), ground_r.max()))

# Point output: Cartesian points in the sensor frame at each firing time.
p_sensor = r_meas[..., None] * d
# A driver that ignores motion stacks every point into the frame at sweep end.
# Deskewing moves each point by the motion between its firing time and sweep end.
t_end = 0.1
p_naive = p_sensor
p_deskew = p_sensor - (t_end - T)[..., None] * v
hit_world = origin + np.where(detected, r_true, 0)[..., None] * d
truth = hit_world - (np.array([0, 0, 1.8]) + t_end * v)   # true points, sweep-end frame
for name in ["bright box", "wall", "dark box"]:
    k = (label == name) & detected
    e0 = np.linalg.norm(p_naive[k] - truth[k], axis=1)
    e1 = np.linalg.norm(p_deskew[k] - truth[k], axis=1)
    print(f"{name:11s} point error, no deskew: median {np.median(e0):.2f} m, max {e0.max():.2f} m"
          f" | deskewed: median {np.median(e1):.3f} m, max {e1.max():.3f} m")

# The returned fraction of each box depends on the random fluctuation: ten seeds.
fr = {n: [] for n in ["bright box", "dark box"]}
for seed in range(10):
    g = np.random.default_rng(seed).lognormal(0, 0.3, r_true.shape)
    ok = np.isfinite(r_true) & (25000 * rho * cos_inc / r_true**2 * g > 1.0)
    for n in fr:
        fr[n].append(ok[label == n].mean())
for n, f in fr.items():
    print(f"{n} returned over seeds 0-9: {min(f):.0%} to {max(f):.0%}")

Output:

shots fired: 28800, returns: 11495 (40%), range image (16, 1800)
surface      shots  returned  range std (cm)  median intensity
ground       13906       72%             2.0                 9
bright box      84      100%             2.1                26
dark box        78       36%             1.5                 1
wall          1431      100%             2.1                 6
farthest ground return: 20.7 m (ground hit out to 103.1 m)
bright box  point error, no deskew: median 0.75 m, max 1.55 m | deskewed: median 0.013 m, max 0.055 m
wall        point error, no deskew: median 0.17 m, max 1.56 m | deskewed: median 0.014 m, max 0.073 m
dark box    point error, no deskew: median 0.75 m, max 0.79 m | deskewed: median 0.015 m, max 0.030 m
bright box returned over seeds 0-9: 100% to 100%
dark box returned over seeds 0-9: 24% to 42%

Fewer than half the shots return. The upper beams point at open sky, which returns nothing, and the ground disappears beyond about 21 m although rays meet it out to 103 m. On flat ground the incidence becomes grazing with distance, so the cosine factor falls roughly as $1/R$ and the signal as $1/R^3$. The two boxes have the same size and range, yet the bright box returns on every shot over all ten seeds and the dark one on only a quarter to two fifths of them: the dark box sits near the detection threshold, and whether a given shot returns depends on the fluctuation. Its returns also have the lowest intensities, so a filter that removes weak returns as clutter would remove the dark object first. The range noise of returned points matches the 2 cm put in; the dark box’s 1.5 cm comes from only 28 points.

The motion errors follow the firing times. The dark box, behind the vehicle, is scanned halfway through the sweep and is displaced by about 0.75 m, half the 1.5 m driven. The bright box straddles the azimuth where the sweep starts and ends: its points fired at the end of the sweep are nearly correct, and those fired at the start are off by up to 1.55 m. A single object is thus torn into two copies at the scan seam. Deskewing with the known motion brings every surface back to centimetre-level error, the residual being the range noise. A real system must estimate the motion first, from odometry, an inertial sensor or the scans themselves as LOAM does.

Strengths

• Direct metric range. Each point is measured, not inferred. Zhang and Singh (2014) note that LiDAR range errors stay relatively constant whatever the distance; stereo depth error, by contrast, grows with the square of distance. Li and Ibanez-Guzman (2020) call LiDAR the most precise of the driving sensors in measuring range.
• Independent of ambient light. The sensor provides its own illumination and works the same at night. Strong pulses also keep sunlight interference low (Royo & Ballesta-Garcia, 2019).
• Wide coverage. A spinning sensor sees all around the vehicle in one scan.
• Velocity per point for FMCW sensors, through the Doppler shift.
• Geometry for free. Ground, free space and object extents come almost directly from the points. KITTI built most of its ground truth from its laser scanner, as the KITTI article describes.

Limitations

• Sparsity. Point spacing grows linearly with range, and the vertical sampling of a spinning sensor is set by its few dozen beams. Royo and Ballesta-Garcia (2019) work through a highway example: detecting a 10 cm obstacle at 150 m needs 0.67 mrad resolution for a single point, and about 67 µrad if five to ten points are wanted for identification. Thin objects such as poles and wires fall between beams.
• Dark and grazing surfaces. Received power scales with reflectivity and incidence angle. Black cars, dark clothing, wet asphalt and surfaces seen edge-on return weak echoes or none, as the 50 m versus 120 m specification above and the simulation show.
• Specular and transparent surfaces. A mirror-like surface reflects the beam away from the receiver instead of scattering it back. It follows from the geometry that the sensor then either gets no echo or measures the folded path to whatever the reflected beam hits, placing a phantom point behind the mirror. Glass can likewise pass the beam to the objects behind it. Retroreflectors do the opposite and return so much light that they can saturate the detector; Royo and Ballesta-Garcia (2019) describe them blinding SPAD-based flash sensors.
• Rain, fog, snow and dust. Droplets absorb and scatter the beam, which shortens the range and adds false points near the sensor (Royo & Ballesta-Garcia, 2019). In fog-chamber tests of four 905 nm sensors, Bijelic et al. (2018) found a cloud of clutter around the sensor and a maximum viewing distance, on a 90% reflective target, well under 25 m once meteorological visibility fell below 40 m. Last returns overlapped the clear-weather point cloud better than strongest returns. Li and Ibanez-Guzman (2020) expected 1550 nm sensors, which may transmit more power, to cope better.
• Interference. A pulsed receiver can mistake another LiDAR’s pulse, or strong sunlight, for its own echo (Li & Ibanez-Guzman, 2020). Royo and Ballesta-Garcia (2019) note that as more vehicles carry LiDAR, each sensor’s signal must be made distinguishable. They see coherent FMCW detection with individual modulation signatures as a promising answer, still to be proven at mass scale.
• Motion distortion in scanning sensors, which must be corrected with an estimate of the platform’s motion.
• Little appearance information. Intensity is a single, range-dependent channel with no colour or texture, so recognition from LiDAR alone is harder than from images; Li and Ibanez-Guzman (2020) call semantic description its shortcoming. This is why it is paired with cameras.
• Cost, size and moving parts, which the solid-state designs aim to reduce (Li & Ibanez-Guzman, 2020).

Typical Applications

• Autonomous driving. LiDAR is part of the sensor suite of most driving datasets. KITTI recorded one 64-beam spinning sensor at 10 Hz (Geiger et al., 2013). nuScenes recorded one 32-beam sensor at 20 Hz with a range of up to 70 m, alongside six cameras and five radars (Caesar et al., 2020). The Waymo Open Dataset recorded five LiDARs, one on the roof and four around the vehicle, with the first two returns of each pulse (Sun et al., 2020). Perception uses LiDAR for 3D detection and tracking, free-space estimation and localization against prior maps.
• Mapping and localization. LiDAR odometry and SLAM, such as LOAM (Zhang & Singh, 2014), build metric maps of streets, buildings and mines.
• Ground truth for vision. Projected LiDAR points supply sparse metric depth for training and evaluating stereo and monocular depth estimation and visual odometry, as in KITTI.
• Robotics. Mobile robots use LiDAR for obstacle avoidance, localization and mapping, for the same reasons as vehicles.
• Surveying. Airborne and terrestrial laser scanners map terrain, vegetation and buildings, typically exchanging data in the ASPRS LAS format described in the point cloud article.

Comparison with Other Sensors

Sensor	Measures	Range and density	Main weaknesses
Camera	Appearance (colour, texture); depth only by inference	Dense pixels; no direct range	Lighting, no metric scale from one view
Stereo camera	Depth by triangulation of matched pixels	Dense; error grows with the square of range	Textureless surfaces, needs light
Time-of-flight (AMCW) camera	Range per pixel from phase	Dense, short range (metres)	Background light outdoors, ambiguity distance
LiDAR	Range and intensity along each beam	Sparse; accurate to tens or hundreds of metres	Dark and specular surfaces, weather, cost
Radar	Range and radial velocity from radio echoes	Very sparse; 200–300 m in driving use	Imprecise position

The nuScenes authors summarize the complementarity this way (Caesar et al., 2020): cameras give edges, colour and lighting but make 3D localization hard; LiDAR localizes accurately in 3D but carries less semantic information and is sparse, with ranges typically limited to 50–150 m; radar reaches 200–300 m and measures velocity through the Doppler effect but is sparser and less precise in position. Because their failure modes differ, driving systems combine all three.