Bezier curve parameterization

Overview

Some outputs are curves, such as a lane centreline, and a network has to predict each one as a fixed-size vector. The approach is to predict a small number of control points per curve, then evaluate the Bezier curve through them to get the dense points used for the loss and for downstream heads 2310.06753 §3.1. The invariant is that the network outputs only control points and every dense point is derived from them, so each predicted curve has the shape of a Bezier curve with those control points.

Variants

Only one card covers this concept so far. Other papers that parameterize curves differently will be added as they are compiled.

Learned anchors plus per-query offsets

Each lane query starts from a learned 3D anchor. Two independent MLPs predict, for every query, a set of control-point offsets and a class score. The final control points are the anchors plus the offsets 2310.06753 §3.1. The paper uses M = 4 control points per lane 2310.06753 §4.2 and 300 lane queries 2310.06753 §4.2. In its one ablation over control points, on OpenLane-V2 subset A with ResNet-50 and 24 epochs, OLS is 37.3 for M = 3, 38.2 for M = 4 and 37.1 for M = 5. The paper reports one run per setting and no variance 2310.06753 tab. 3. Card: TopoMLP: A Simple yet Strong Pipeline for Driving Topology Reasoning.

When to use which

Implementation sketch

The core is two steps: the network predicts control points, then a fixed Bernstein evaluation turns them into dense points. The Bernstein form is the standard definition of a Bezier curve; the paper does not restate it 2310.06753 §3.1.

# Predict M control points per lane query  [arxiv:2310.06753 §3.1]
# Input:  query_feats (N_L, C); anchors (N_L, 3), learned
# Output: control (N_L, M, 3), in BEV metres
def lane_control_points(query_feats, anchors, reg_head):
    # reg_head is an MLP that outputs M * 3 offsets per query
    offsets = reg_head(query_feats).reshape(N_L, M, 3)   # (N_L, M, 3)
    # Final control points are the anchor plus the offset  [arxiv:2310.06753 §3.1]
    return anchors[:, None, :] + offsets                 # (N_L, M, 3)

# Evaluate one Bezier curve at parameter samples t in [0, 1]
# Input:  control (M, 3); t (T,), with T = 11 for the loss  [arxiv:2310.06753 §4.2]
# Output: points (T, 3)
def bezier_points(control, t):
    # Bernstein basis, shape (T, M): binomial coefficient times powers of t
    basis = [comb(M - 1, i) * t**i * (1 - t)**(M - 1 - i) for i in range(M)]
    # Each row of the basis weights the control points  (T, M) @ (M, 3)
    return stack(basis, axis=-1) @ control               # (T, 3)

Contradictions

• Regression target: paper vs code. The paper gives the lane regression loss only as "L1 loss for lane regression" 2310.06753 §3.1 and does not say on which points it acts. The repository applies L1 to 11 sampled points of the Bezier curve, not to the control points lane_head.py lane_head.py. The TopoMLP card's Paper vs code section records this. Both sides are stated here; a reimplementation has to pick one.

Papers

• TopoMLP: A Simple yet Strong Pipeline for Driving Topology Reasoning: predicts M = 4 Bezier control points per query for 3D lanes, evaluates them for the loss and the topology heads.