betaFeedback

WorksComputer Science

CLOCs-R: Radar-Assisted Camera-LiDAR Fusion for Long-Range Object Detection

Abstract

Long-range 3D object detection remains difficult for autonomous vehicles because LiDAR returns become sparse and camera evidence weakens with distance, while automotive radar keeps returning measurements far beyond both. We present CLOCs-R, an extension of the CLOCs candidate-level fusion framework that adds radar evidence to camera-LiDAR rescoring. Radar returns are accumulated over several sweeps, compensated for ego-motion, and associated with each pre-NMS 3D candidate through a range-dependent gate. Compact features summarizing support, Doppler speed and spread, range residual, and offset are then appended to every camera-LiDAR pair before a lightweight fusion network rescores the candidates. We first verify that our fusion implementation reproduces CLOCs on KITTI. We then evaluate on the daytime clear-weather subset of the aiMotive dataset, reporting distance-binned metrics out to 200 m with frozen SECOND and Cascade R-CNN detectors. Camera-LiDAR CLOCs improves on SECOND up to 50 m but degrades beyond it. A residual scoring variant, introduced post hoc, corrects SECOND's score instead of replacing it and recovers most of this loss. Radar consistently improves BEV AP at 30-50 m (0.857 to 0.870), but beyond 50 m its gain is small (+0.003 center-distance AP), within seed variation, and CLOCs-R with residual scoring is statistically tied with LiDAR-only SECOND. Our analysis attributes the limited long-range benefit to weak separation of true and false detections by radar features, scarce far-range training positives, poor camera evidence at distance, and missing LiDAR proposals that rescoring cannot recover. We report all as-designed and post hoc results side by side.

Related Work

This section reviews the camera-LiDAR and radar fusion methods most relevant to our proposed approach, grouped by the sensors used and the stage at which they are fused. Table 1 summarizes the method, inputs, dataset, key result, and main limitation of each work referenced in this section.

WorkMethodInputDatasetKey ResultLimitation
SECOND [1]Sparse 3D convolution on voxelsLKITTI73.66 mod. car 3D AP at 20 FPSMisses cars with <10 points
PointPainting [2]Image segmentation scores on pointsC+LKITTI, nuSc.mAP 40.1 → 46.4 (nuSc. test)Needs LiDAR points on the object
CLOCs [3]Rescores pre-NMS 2D–3D pairsC+LKITTI+5.90 mod. car 3D AP; best at 40–50 mCannot add missed 3D boxes
Fast-CLOCs [4]Light 2D detector cued by 3D boxesC+LKITTI, nuSc.mAP 58.0 → 63.1; 8–13 HzNeeds high 3D recall
BEVFusion [5]Shared BEV feature fusionC+LnuSc., Waymo70.2 mAP, 72.9 NDS (test)Depth errors misalign features
CRF-Net [6]Radar image channels, multi-levelC+RnuSc., TUMmAP 43.47 → 43.952D only; small gain
RRPN [7]Distance-scaled radar anchorsC+RnuSc.Beats Selective Search; >100× faster2D only; needs a radar return
CenterFusion [8]Frustum radar–center associationC+RnuSc.NDS 40.0 → 44.9 (test)Only marginal mAP gain
RADIANT [9]Radar-to-center offsets, depth fusionC+RnuSc.PGD mAP 36.0 → 38.0 (test)Refines position only
CRN [10]Radar-guided BEV transformC+RnuSc.62.4 NDS; beats LiDAR at 30–100 m1LiDAR depth used in training
CR3DT [11]Radar pillars + BEV features, trackingC+RnuSc.+5.3 mAP, +14.9 AMOTA (val)21.3 mAP below LiDAR
RCM-Fusion [12]BEV + instance-level radar refinementC+RnuSc.58.7 NDS, 50.6 mAP (test)2.3 FPS; 87.6 M parameters
RadarNet [13]Early and attention-based late fusionL+RnuSc., DenseRadarCar AP 82.3 → 84.5 (val)Only +0.8 AP at 70–100 m
FUTR3D [14]Sensor-agnostic query samplerAnynuSc.C+R 39.9 vs. 33.2 mAP (val)No C+L+R results
View-of-Delft [15]4D radar datasetC+L+RVoDRadar mAP 38.0 → 29.1 without DopplerLabels only to 50 m
K-Radar [16]4D radar tensor datasetC+L+RK-RadarHeavy snow AP: radar 44.5 vs. LiDAR 29.7Labels to 120 m; ∼12 TB
aiMotive [17]Long-range dataset with baselinesC+L+RaiMotiveNight AP >75 m: 0.464 → 0.550Simple fusion; worse in rain

Table 1. Comparison of reviewed work (C = Camera, L = LiDAR, R = Radar, nuSc. = nuScenes, VoD = View-of-Delft)

Camera-LiDAR Fusion

Most camera-LiDAR fusion methods build on a LiDAR detector. SECOND [1] replaced the dense 3D convolutions of earlier voxel networks with sparse convolutions, reaching 73.66 moderate difficulty car 3D AP on the KITTI test set [18] at about 20 frames per second. Its authors note, however, that it misses many distant cars that return fewer than 10 LiDAR points [1].

Fusion methods differ mainly in where the two modalities meet. At the point level, PointPainting [2] projects each LiDAR point into an image segmentation map and appends the class scores to the point, so that any LiDAR detector can use them. This raised PointPillars+ from 40.1 to 46.4 mAP on the nuScenes test set [2], [19], but painting can only help objects that already have LiDAR points. At the feature level, BEVFusion [5] lifts camera features into a bird’s-eye-view (BEV) grid shared with LiDAR and makes this transform about 40 times faster, reaching 70.2 mAP and 72.9 NDS on nuScenes test, although inaccurate camera depth leaves local misalignment between the two feature maps.

At the decision level, CLOCs [3] takes the candidates of a pretrained 2D detector and a pretrained 3D detector before non-maximum suppression (NMS). Each overlapping pair is encoded by its image-plane IoU, both confidence scores, and the object’s distance, and a small network learns to rescore the 3D candidates. Fusing SECOND with Cascade R-CNN raised moderate car 3D AP on the KITTI test set by 5.90 points, with the largest gains at 40-50 m [3]. Because late fusion only prunes and rescores, however, CLOCs cannot recover objects that the 3D detector never proposed [3]. Fast-CLOCs [4] replaces the separate 2D detector with a lightweight one that uses projected 3D candidates as proposals, running at 8-13 Hz on a desktop GPU and raising CenterPoint from 58.0 to 63.1 mAP on nuScenes test. This design makes the 2D branch depend even more on the recall of the 3D detector [4].

Camera-Radar Fusion

Radar complements both cameras and LiDAR. Automotive radars detect targets at ranges of 250 m or more, measure radial velocity directly through the Doppler effect, and are less affected by poor lighting and weather [19], [20]. Their returns, however, are sparse, noisy, and lack reliable height information [8], [13].

Early work used radar to guide 2D detection. CRF-Net [6] projects radar returns into the image as additional input channels and lets the network learn at which feature level to fuse them, while RRPN [7] converts each projected radar return into distance-scaled anchor boxes, generating proposals far faster than Selective Search. Both produce only 2D boxes, and CRF-Net gained little from unfiltered radar [6], [7].

Object-level methods attach radar to camera detections. CenterFusion [8] associates radar returns with camera-detected object centers through a frustum and uses them to re-estimate depth and velocity. This improved NDS and sharply reduced velocity error on nuScenes, but mAP improved only marginally, since radar can only refine objects the camera has already found. RADIANT [9] instead predicts the offset from each radar return to the object center and fuses radar depth into a frozen monocular detector, although only object position is refined.

BEV-level methods fuse radar earlier so that it can help locate objects. CRN [10] uses radar occupancy to guide the camera-to-BEV transform and fuses the two maps with deformable cross-attention. For cars at 30-100 m it even outperforms the LiDAR detector CenterPoint, although its training still relies on depth supervision from projected LiDAR points [10]. CR3DT [11] concatenates radar pillars with camera BEV features and passes the improved velocity estimates to a tracker, improving both detection and tracking with little added latency, but it still trails CenterPoint by a wide margin. RCM-Fusion [12] adds an instance-level stage that refines each proposal using nearby radar points, which improves accuracy at the cost of a large and slow model.

Radar-LiDAR Fusion

Radar has also been fused directly with LiDAR. RadarNet [13] combines the two sensors through early voxel-level fusion and late attention-based fusion, improving car AP on nuScenes over the best LiDAR-only model while lowering velocity error. Its authors observe that LiDAR point density decreases with range, whereas radar provides more observations at long range, yet on their 100 m DenseRadar dataset radar added little at 70-100 m [13]. FUTR3D [14] uses a modality-agnostic query sampler so that a single transformer decoder can use any combination of cameras, LiDAR, and radar. Its camera-radar model outperforms CenterFusion on nuScenes, but the paper reports no results using all three sensors.

Datasets with Radar and Long-Range Evaluation

Long-range gains are also difficult to measure. KITTI has no radar [18], and in nuScenes the LiDAR is rated only to 70 m while each radar reaches 250 m [19]. Two recent datasets provide 4D radar, which measures elevation in addition to range, azimuth, and Doppler velocity. View-of-Delft [15] pairs a 3+1D radar with a 64-beam LiDAR and a stereo camera in dense urban traffic. A radar-only detector trained on it still trails its LiDAR counterpart, and removing Doppler velocity from the radar input markedly lowers accuracy, but annotations extend only to 50 m [15]. K-Radar [16] records the full 4D radar tensor together with LiDAR and cameras in fog, rain, and snow, with labels to 120 m, and its radar-only baseline outperforms a LiDAR detector in heavy snow. The aiMotive dataset [17] was designed specifically for long-range perception, with four cameras, a 64-beam LiDAR, two long-range radars, and annotations out to about 200 m across highway, urban, night, and rain scenes. In its baselines, adding radar to LiDAR barely changed overall AP beyond 75 m but raised it substantially at night, while it reduced accuracy in heavy rain, which the authors attribute to their simple fusion method [17].

Research Gap

Radar helps most where cameras and LiDAR are weakest, at long range and at night [10, 17], yet long-range accuracy remains low: even CRN reaches only 7.0 car AP at 60-100 m on nuScenes [10]. Most radar fusion methods pair radar with cameras alone and train the full network end to end [10, 11, 12], while the few that use all three sensors either report no three-sensor results [14] or rely on simple fusion [17]. Public datasets also limit long-range study: the 4D radar datasets View-of-Delft and K-Radar label objects only to 50 and 120 m [15, 16], so among the datasets reviewed here, only aiMotive combines camera, LiDAR, and long-range radar with annotations out to 200 m [17]. Candidate-level fusion such as CLOCs [3, 4] is lightweight, works with any pretrained detectors, and gains the most at long range, but it has been studied only with cameras and LiDAR, and its long-range benefit has been analyzed only out to 50 m [3]. To our knowledge, no prior work adds radar evidence to candidate-level fusion. CLOCs-R plans to address this gap by adding radar-derived features, namely the radar returns supporting each 3D candidate and their Doppler consistency, to the CLOCs pair encoding while keeping all detectors frozen, and by evaluating detection accuracy by distance out to 200 m on the aiMotive dataset.

Methodology

CLOCs-R extends the candidate-level fusion of CLOCs [3] with radar evidence. A pretrained 2D image detector and a pretrained 3D LiDAR detector produce candidates before non-maximum suppression (NMS), radar returns are associated with each 3D candidate, and a small fusion network rescores the 3D candidates using geometric, semantic, and radar cues. Both detectors remain frozen, so only the fusion network is trained. Because it is not known in advance which radar cues are most informative, CLOCs-R defines a set of candidate radar features and evaluates several combinations of them as inputs to the fusion network. This section describes candidate generation, the radar features, the fusion network and its training, and the evaluation protocol.

Overview

For each frame, the inputs are a front camera image, a LiDAR sweep, and the radar returns from the most recent radar sweeps, together with the calibration between the sensors. The 2D detector outputs kk axis-aligned image boxes with scores si2Ds_i^{2D}, and the 3D detector outputs nn oriented boxes with scores sj3Ds_j^{3D}. Following CLOCs [3], every 2D-3D pair is encoded as one cell of a sparse k×nk \times n tensor, a stack of 1×11 \times1 convolutions maps each cell to a logit, and max-pooling over the 2D axis yields one fused score per 3D candidate. CLOCs-R appends radar channels to each cell, drawn from the candidate features in Section II-C. Because these channels describe the 3D candidate rather than the pair, they are also available to candidates that have no overlapping 2D detection, which allows radar to support distant objects that the camera detector misses. The fused scores replace the original 3D scores, and standard NMS produces the final detections. As in CLOCs, box geometry is inherited from the 3D detector and only confidence scores change. Figure 1 shows the pipeline on a clear daytime urban frame from the aiMotive dataset, using the front camera, the LiDAR, and the front long-range radar, with the bird’s-eye views drawn out to 100 m. LiDAR density falls quickly with range: a car at 14 m receives about 2,000 LiDAR points, whereas a car at 63 m receives 39. The radar returns in the same frame extend to 171 m, beyond the region shown. Radar returns are separated into moving objects and static clutter by their ego-compensated Doppler velocity and are matched to each 3D candidate through a gate that widens with range. The resulting radar features, namely the support rr, Doppler speed vv, Doppler spread ee, range residual Δ\Delta, and nearest-return offset oo defined in Section II-C, are appended to every cell of column jj, including the no-camera row. Components that CLOCs-R adds are shown in orange, and the fusion network, whose input is widened, in purple. The aiMotive data are used under the CC BY-NC-SA 4.0 license.

Figure 1. CLOCs-R architecture, shown on a frame from the aiMotive dataset [17]. The frozen camera and LiDAR detectors produce candidates before NMS, radar returns gated around each 3D candidate give its radar features ϕj\phi_j, and these are appended to every cell of column jj of the pair tensor before the fusion network rescores each 3D box. Candidate boxes are generated from ground-truth labels for illustration.

Candidate Generation

3D detector. We use SECOND [1] as the 3D detector, the same detector used in the CLOCs configuration that we reproduce on KITTI. For aiMotive [17], the detector is retrained with its point-cloud range extended to cover the dataset’s annotation range and its anchor sizes set from the aiMotive training labels. All anchor-level predictions are exported before NMS with no score threshold, so that the fusion stage sees every candidate the detector produces.

2D detector. We use Cascade R-CNN [21] as the 2D detector, implemented in MMDetection [22]. Because aiMotive provides only 3D annotations, 2D training labels are generated by projecting each annotated 3D box into the front camera image with the dataset’s calibration and taking the tightest enclosing axis-aligned rectangle. Boxes whose projections fall outside the image are discarded. At inference, the detector’s outputs are likewise taken before NMS and with a very low score threshold, and the top K2D=200K_{2D}=200 candidates per image are kept, matching the CLOCs implementation.

Caching. Both detectors are run once over every frame, and their candidates are stored on disk. The fusion network is then trained and evaluated from these cached candidates, which keeps its training independent of the cost of the detectors.

Radar Evidence Features

Preprocessing. Radar returns are transformed into the LiDAR coordinate frame using the extrinsic calibration. Because a single radar sweep is sparse, returns from the last MM sweeps are accumulated and transformed into the current frame using the ego-vehicle poses. Each return qq provides a bird’s-eye-view position pq\mathbf{p}_q and a measured radial velocity vqrv_q^r. The aiMotive radars report the range, azimuth, elevation, radial speed (in m/s), and reflectivity of every return [17], so a Doppler measurement is available for each return that CLOCs-R uses. This measurement is important: on View-of-DelF, removing Doppler velocity from the input of a radar-only detector lowered mAP from 38.0 to 29.1 [15]. The reported speed is relative to the ego vehicle: in the aiMotive sample sequence, returns from static structures read about −30-30 m/s at highway speed, close to the negative ego speed, while returns on annotated vehicles match their labeled relative velocities. The radial velocity is therefore compensated as

v~q=vqm+uTpq∥pq∥,(1)\tilde{v}_q = v_q^m + \mathbf{u}^{\mathsf{T}}\frac{\mathbf{p}_q}{\lVert\mathbf{p}_q \rVert}, \tag*{(1)}

where u\mathbf{u} is the ego velocity in the BEV plane, obtained by differencing the consecutive GNSS-INS ego poses provided with the dataset, so that static objects have v~q≈0\tilde{v}_q \approx0. We verify the compensation on each sequence by checking that returns from static structures, such as guardrails and signs, have near-zero v~q\tilde{v}_q.

Association. For each 3D candidate jj, we form a gate Gj\mathcal{G}_j by enlarging its BEV footprint by a margin

δj=δ0+κρj,(2)\delta_j = \delta_0 + \kappa\rho_j, \tag*{(2)}

where ρj\rho_j is the candidate’s distance from the ego vehicle. The range-dependent term accounts for radar’s lateral position error, which grows with distance for a fixed angular resolution. The parameters δ0\delta_0 and κ\kappa are selected on a held-out subset of the training scenes. Let Qj\mathcal{Q}_j be the set of radar returns inside Gj\mathcal{G}_j, with Nj=∣Qj∣N_j = \lvert\mathcal{Q}_j \rvert.

Candidate features. We define five candidate features that summarize the radar evidence for candidate jj, each computed only from the positions and compensated radial velocities of the returns in Qj\mathcal{Q}_j:

  • Support, rj=log⁡(1+Nj)r_j = \log(1 + N_j), which measures how many returns fall in or near the box. The logarithm limits the influence of large vehicles that produce many returns.

  • Doppler speed, vj=median⁡q∈Qj∣v~q∣/vmax⁡v_j = \operatorname{median}_{q \in\mathcal{Q}_j} \lvert\tilde{v}_q \rvert/ v_{\max}, which helps distinguish moving objects from static clutter such as guardrails and signs.

  • Doppler spread, ej=median⁡q∈Qj∣v~q−vˉj∣/vmax⁡e_j = \operatorname{median}_{q \in Q_j} \lvert\tilde{v}_q - \bar{v}_j \rvert/ v_{\max}, where vˉj\bar{v}_j is the median of v~q\tilde{v}_q. Returns from a single rigid object share one velocity, so a small spread indicates that the returns are consistent with one object rather than a mix of neighboring objects and clutter.

  • Range residual, Δj=∣median⁡q∈Qj∥pq∥−ρj∣/δj\Delta_j = \lvert\operatorname{median}_{q \in Q_j} \lVert p_q \rVert- \rho_j \rvert/ \delta_j, which compares radar’s direct range measurement with the range of the 3D box and can indicate a candidate placed at the wrong depth.

  • Nearest-return offset, oj=min⁡q∈Qj∥pq−cj∥/δjo_j = \min_{q \in Q_j} \lVert p_q - c_j \rVert/ \delta_j, where cjc_j is the box center in BEV, which measures how closely the radar evidence agrees with the box location.

The medians reduce the effect of outlying returns, and dividing by the constant vmax⁡v_{\max} or the gate margin δj\delta_j keeps every feature on a comparable scale. When Nj=0N_j = 0, we set rj=0r_j = 0 and all other radar features to −1-1, following the CLOCs convention of using −1-1 to mark missing evidence so that it is distinguishable from a measured zero.

Feature combinations. Table 2 lists the radar feature sets we evaluate. They range from single features, which show what each cue contributes on its own, to the support and Doppler pair proposed for CLOCs-R and the full set of five. Each set is trained and evaluated separately with an otherwise identical network and training schedule. The set used for the final CLOCs-R model is selected by its center-distance AP beyond 50 m on held-out training scenes, and all sets are reported on the validation split.

Setrjr_jvjv_jeje_jΔj\Delta_jojo_jChannels
R0 (CLOCs, no radar)4
R1✓5
R2✓5
R3✓✓6
R4✓✓✓7
R5✓✓✓7
R6✓✓✓7
R7 (all)✓✓✓✓✓9

Table 2. Radar feature sets evaluated.

Fusion Network and Training

Each non-empty cell of the input tensor holds

Tij=[IoU⁡ij, si2D, sj3D, dj, ϕjT],(3)T_{ij} = \left[\operatorname{IoU}_{ij},\ s_i^{2D},\ s_j^{3D},\ d_j,\ \phi_j^{\mathsf{T}}\right], \tag*{(3)}

where IoU⁡ij\operatorname{IoU}_{ij} is the overlap between 2D box ii and the image projection of 3D box jj, djd_j is the normalized BEV distance of candidate jj from the LiDAR, and ϕj∈Rm\phi_j \in\mathbb{R}^m holds the mm radar features of the feature set being evaluated. As in CLOCs, cells with zero IoU are discarded, and each 3D candidate without an overlapping 2D box is kept in a reserved row with IoU and sj2Ds_j^{2D} set to −1-1 [3]. The radar channels are filled in every cell of column jj, including this reserved row. The fusion network keeps the CLOCs architecture of four 1×11 \times1 convolutions with ReLU activations (((4+m)→18→36→36→1)((4+m) \to18 \to36 \to36 \to1)), so only the input width changes with the feature set. The network therefore has between 2,161 and 2,233 parameters across the sets in Table 2, compared with 2,143 for CLOCs. The fused score of candidate jj is

s^j=max⁡ifθ(Tij),(4)\hat{s}_j = \max_i f_{\theta}(T_{ij}), \tag*{(4)}

where fθf_{\theta} is the fusion network and the maximum is taken over all non-empty cells in column jj. Algorithm 1 summarizes the per-frame procedure.

Algorithm 1 CLOCs-R inference for one frame
Require: image $I$, LiDAR sweep $P$, last $M$ radar sweeps, ego poses, radar feature set $S$
1: $\{(B_j^{2D},s_j^{2D})\}\leftarrow 2D\ detector(I)$ ▷ pre-NMS, top $K_{2D}$
2: $\{(B_j^{3D},s_j^{3D})\}\leftarrow 3D\ detector(P)$ ▷ pre-NMS
3: $Q\leftarrow accumulate\ radar\ sweeps$; compensate Doppler (1)
4: for each 3D candidate $j$ do
5: $\delta_j\leftarrow\delta_0+\kappa\rho_j$ (2)
6: $Q_j\leftarrow\{q\in Q:p_q\in G_j\}$
7: $\phi_j\leftarrow features\ in\ S\ from\ Q_j$ ▷ $-1$ if $Q_j=\varnothing$
8: end for
9: $T\leftarrow cells\ T_{ij}\ with\ \operatorname{IoU}_{ij}>0$, plus no-camera row (3)
10: $\hat{s}_j\leftarrow\max_i f_\theta(T_{ij})$ for all $j$ (4)
11: return $\operatorname{NMS}\{(B_j^{3D},\hat{s}_j)\}$

Training targets follow the CLOCs implementation: a 3D candidate is positive if its BEV IoU with a ground-truth box is at least 0.7 and negative if it is at most 0.5, and candidates in between are ignored. Because nearly all candidates are background, the network is trained with focal loss [23] with α=0.25\alpha=0.25 and γ=2\gamma=2. We use the Adam optimizer [24] with a one-cycle learning-rate schedule (maximum learning rate 3×10−33\times10^{-3}), weight decay of 0.01, and a batch size of one frame.

Datasets and Evaluation Protocol

KITTI verification. Before modifying the method, we reproduce camera-LiDAR CLOCs on KITTI [18] with the official implementation, confirming that our software environment matches the published results. This step uses the standard split of 3,712 training and 3,769 validation frames.

aiMotive. All CLOCs-R experiments use the aiMotive dataset [17], which provides synchronized camera, 64-beam LiDAR, and long-range radar data, GNSS-INS ego poses, and 3D annotations out to about 200 m. We use the front camera, the LiDAR, and the front long-range radar. We use its official split of 151 training and 25 validation scenes (21,402 and 5,181 annotated frames), hold out a subset of training scenes for hyperparameter selection, and report all results on the validation split. Experiments begin with the car class.

Distance-binned metrics. Because the expected benefit of radar is at long range, every metric is reported separately for objects at 0–30 m, 30–50 m, 50–100 m, and 100–200 m from the ego vehicle. For each bin we report 3D average precision (AP), recall, and center-distance AP. Center-distance AP matches predictions to ground truth by BEV center distance rather than IoU, following nuScenes [19], because small position errors at long range would otherwise dominate an IoU-based score. We also report the latency that the radar features and fusion network add per frame.

Baselines and ablations. We compare against two baselines trained on aiMotive under the same split: the LiDAR-only 3D detector with its original scores, and camera-LiDAR CLOCs (set R0). Together they isolate the contributions of the camera and of radar. Each radar feature set in Table II is then compared with R0 to measure which radar cues carry the gain and whether adding more features helps or introduces noise. To measure how the method behaves when the camera is unavailable or degraded, for example at night, the selected feature set is also evaluated with all 2D candidates removed at test time, so that every 3D candidate uses the reserved no-camera row. The LiDAR-radar and three-sensor baselines released with aiMotive [17] serve as external reference points, although they use different detectors.

Implementation Details

The fusion network and training pipeline build on the official CLOCs implementation [3], updated to run with PyTorch 1.10 and CUDA 11.3 on current GPUs. The fixed candidate dimensions of the original code are generalized so that the number of 3D candidates follows the extended aiMotive anchor grid. The 3D detector is trained with OpenPCDet [25]. Experiments run on NVIDIA A100 GPUs, and the latency added by computing the radar features and running the fusion network is measured for each feature set on a single GPU with batch size one, excluding the cost of the two detectors, which is reported separately.

Experiments

This section reports the experiments that follow the protocol of Section II, and Section III-B states where a run departs from it. Fusion results are means over three training seeds. Every number comes from the result files and logs in our repository. Changes made after the validation split had been scored are marked as post hoc (†).

Dataset

Source and subset. We use the aiMotive dataset [17], restricted to its daytime clear-weather highway and urban scenes; night and rain scenes are left for future work. In each of the two conditions, every tenth official training scene is held out for selection, which leaves 109 training scenes and 13 holdout scenes. All 21 official validation scenes in these conditions are used for reporting. To limit storage, every second annotated frame of the training and holdout scenes is kept, giving 7,753 training, 923 holdout and 4,292 validation frames.

Labels and scored region. The car class combines the CAR, VAN and PICKUP labels. Trucks, buses and trailers are ignored: candidates that overlap them (BEV IoU of at least 0.1) count as neither true nor false positives, in training or in evaluation. An object is scored when its center lies inside the SECOND grid (0≤x≤204.80\leq x\leq204.8 m, ∣y∣≤25.6|y|\leq25.6 m) and inside the front camera’s view. The validation split then contains 17,669 cars, and holdout contains 6,242, of which only 466 are at 100–200 m.

Label shift. The training scenes are auto-annotated with manual checks, while the validation scenes were labeled by hired annotators [17]. The car labels differ accordingly. The median length is 4.00 m in training, where 43% of cars are exactly 4.00 m long (58% in holdout), and 4.37 m in validation, where none are. Detectors learn the training convention, so strict IoU metrics on validation reflect label differences as well as detection errors (Section III-D).

Composition. The 21 validation scenes come from five drives, and 83% of the validation cars beyond 50 m (11,352 of 13,685) come from nine consecutive urban scenes of one drive, about 2.25 minutes long. Five validation scenes and one holdout scene pass through tunnels, where the camera is badly underexposed, and no training scene does. Eleven of the 13 holdout scenes come from drives that also contribute training scenes, so holdout measures generalization to unseen scenes rather than unseen drives.

Preprocessing. 2D training labels are generated as in Section II. Returns from the front long-range radar are accumulated over M=3M = 3 sweeps and compensated with Eq. (1). In 33 of the 12,876 validation sweeps (0.26%), the ego poses have no timestamps, and the ego velocity is then computed with the sequence’s frame period. We checked the compensation on all 143 sequences. In the median sequence, 88%, 90% and 91% of the returns away from labeled objects are near static (below 1 m/s) in training, holdout and validation, and Doppler speeds on labeled cars differ from their labeled velocities by a median of 0.06, 0.08 and 0.18 m/s. No sequence fails both checks.

Experimental Setup

Hardware and software. All runs use one 20 GB NVIDIA A100 virtual GPU (A100X-20C) on the Jetstream2 cloud, with Python 3.8, PyTorch 1.10.2, CUDA 11.3 and spconv 1.2.1. SECOND is trained with OpenPCDet [25], and Cascade R-CNN with MMDetection 2.28.2 [22].

SECOND. The network follows the OpenPCDet SECOND configuration and is trained from random initialization for 40 epochs with batch size 4, using Adam with a one-cycle schedule (maximum learning rate 3×10−33 \times10^{-3}) and weight decay 0.01, which took about 2 h 50 min. The grid covers [0,204.8]×[−25.6,25.6]×[−1.5,2.5][0, 204.8] \times[-25.6, 25.6] \times[-1.5, 2.5] m with 0.1 m voxels, and one car anchor of 4.2 × 2.0 × 1.55 m is placed at two yaw angles. Augmentation uses random left-right flips, rotations of

up to ±5∘\pm5^\circ (larger rotations move distant cars out of the narrow grid), and scaling by 0.95–1.05.

Cascade R-CNN. A ResNet-50 FPN Cascade R-CNN pre-trained on COCO [26] is fine-tuned for 4 epochs with SGD (learning rate 0.005, batch size 4) at an input size of 1280 × 704, which took about 1 h 10 min.

Candidates. Cascade R-CNN keeps its top K2D=200K_{2D} = 200 boxes per image. SECOND produces 32,768 anchor-level boxes per frame, and storing all of them did not fit on our disk, so the top 2,000 by score are kept, rather than every anchor as Section II states. These contain a box with BEV IoU of at least 0.3 for 85% of the validation cars at 100–200 m, and for 59% of the holdout cars.

Fusion network. The network, inputs and loss follow Section II. It is trained for 3 epochs over the 7,753 training frames with a batch size of one frame, a one-cycle schedule (maximum learning rate 3×10−33 \times10^{-3}, 40% warm-up) and weight decay 0.01. The optimizer is AdamW [27], the decoupled-weight-decay form of Adam. Training targets use BEV IoU and the reserved row uses −1-1, as Section II states, whereas the official CLOCs code uses 3D IoU and −10-10. Each configuration is trained with seeds 1, 2 and 3, at about 2 minutes per seed. GPU training is not bit-identical between runs: retraining one seed reproduced its scores to within 0.005. The gate was selected on holdout with R3, from δ0∈{0.25,0.5,1.0}\delta_0 \in\{0.25, 0.5, 1.0\} m and κ∈{0.01,0.02,0.04}\kappa\in\{0.01, 0.02, 0.04\}, giving δ0=0.5\delta_0 = 0.5 m and κ=0.02\kappa= 0.02, and vmax⁡=40v_{\max} = 40 m/s.

Evaluation. Detections are evaluated with no score threshold after BEV NMS at IoU 0.1, which keeps at most 1,000 boxes before and 100 after NMS per frame. Matching is greedy in score order, and AP is all-point interpolated. Each ground-truth box and detection falls in a distance bin by its own BEV range, and only pairs in the same bin can match. Besides 3D AP at IoU 0.5 and 0.7, recall, and center-distance AP (APCD, the mean AP at 0.5, 1, 2 and 4 m [19]), we report BEV AP at IoU 0.3 (APBEV), the matching threshold of the aiMotive baselines [17], because the label shift makes strict

IoU thresholds unreliable on this dataset. Recall uses BEV IoU 0.3. The selection metric, APCD beyond 50 m, pools the 50–100 and 100–200 m bins. The 100-box limit is reached on 99% of validation frames. Raising it to 500, with 2,000 boxes before NMS, changes APBEVAP_{\mathrm{BEV}} and APCDAP_{\mathrm{CD}} by at most 0.003, but raises recall at 100–200 m from 0.650 to 0.695 for SECOND and from 0.659 to 0.695 for CLOCs-R with residual scoring, so recall differences between methods should be read with care.

KITTI Verification

With the authors’ released weights, CLOCs reproduces the published car 3D AP of 92.75 / 81.28 / 77.70 (easy / moderate / hard) on KITTI validation in our environment. SECOND alone gives 90.82 / 79.73 / 76.87, against 90.97 / 79.94 / 77.09 in the CLOCs repository, and a two-epoch training run of the official code reaches 92.01 / 80.82 / 77.42. We then ran our own fusion implementation, the one used on aiMotive, on the authors’ KITTI candidates (3 epochs, 3 seeds). It matches the authors’ CLOCs to within 0.006 on every metric and distance bin (Table IV).

ModelAPBEV@0.3AP_{\mathrm{BEV}}@0.3 AllAPBEV@0.3AP_{\mathrm{BEV}}@0.3 30–50APBEV@0.3AP_{\mathrm{BEV}}@0.3 50–70AP3D@0.7AP_{3D}@0.7 AllAP3D@0.7AP_{3D}@0.7 30–50AP3D@0.7AP_{3D}@0.7 50–70
SECOND0.9290.8670.4820.7040.4960.104
Ours (3 seeds)0.9420.9060.6210.7190.5420.160
Authors’ CLOCs0.9410.9060.6220.7170.5360.156

Table IV. Our Fusion Implementation on KITTI Validation (3,769 Frames). Distance bins in meters; 50–70 ends at 70.4 m.

Detector Baselines

Table V compares SECOND on aiMotive with SECOND on KITTI. Within KITTI’s 70.4 m range, aiMotive is level with KITTI at lenient matching: APBEVAP_{\mathrm{BEV}} is 0.975 against 0.973 at 0–30 m, 0.847 against 0.867 at 30–50 m, and 0.738 against 0.481 at 50–70.4 m. Its lower score over 0–70.4 m (0.867 against 0.929) comes from the distance mix, since 47% of aiMotive cars in that range are at 50–70.4 m, against 9% on KITTI. The full-range score falls to 0.630 because 38% of all validation cars are at 100–200 m, where APBEVAP_{\mathrm{BEV}} is 0.277. At strict matching the gap is large (AP3D@0.7AP_{3D}@0.7 of 0.066 against 0.704), and much of it is the label shift: matched validation boxes are about 0.2 m too wide at up to 100 m, and the median BEV IoU is about 0.7, so APBEVAP_{\mathrm{BEV}} falls from 0.699 at IoU 0.1 to 0.207 at IoU 0.7.

DistanceaiMotive [email protected]aiMotive APCDaiMotive [email protected]KITTI [email protected]KITTI APCDKITTI [email protected]
0–30 m0.9750.9090.3930.9730.9710.854
30–50 m0.8470.6640.0410.8670.8610.496
50–70.4 m0.7380.6280.0440.4810.4670.104
0–70.4 m0.8670.7480.1580.9290.9250.704
50–100 m0.7250.6150.024–––
100–200 m0.2770.2800.001–––
All0.6300.5560.0660.9290.9250.704

Table V. SECOND Alone on aiMotive and KITTI Validation. KITTI’s SECOND grid ends at 70.4 m.

At long range, LiDAR coverage is the main limit. On holdout, 49% of cars at 100–200 m have no LiDAR points and 66% have fewer than five, and counting only cars with at least five points raises APBEVAP_{\mathrm{BEV}} there from 0.313 to 0.817 (158 cars). Both detectors also score much higher on frames they were trained on: on 900 training frames, SECOND reaches APBEVAP_{\mathrm{BEV}} 0.835 and Cascade R-CNN AP2D@0.5AP_{2D}@0.5 0.803, against 0.629 and 0.499 on holdout. Cascade R-CNN reaches AP2D@0.5AP_{2D}@0.5 of 0.431 on validation against 0.827 on KITTI, but 0.827 against 0.812 for boxes at least 40 pixels tall, and 57% of aiMotive cars are under 25 pixels tall, against 12% on KITTI. At 100–200 m, its candidates overlap only 32% of the validation cars at IoU 0.5.

Main Results

Table III compares the fusion models with SECOND alone. Camera-LiDAR CLOCs (R0) improves on SECOND up to 50 m, most clearly in APCD (0.664 to 0.693 at 30–50 m) and in AP3D@0.5AP_{3D}@0.5 at 30–50 m (0.514 to 0.603). Beyond 50 m it loses: APCD there falls from 0.458 to 0.424, and full-range APBEVAP_{\mathrm{BEV}} from 0.630 to 0.599. On KITTI the same code gains most at long range, and on aiMotive the loss also appears within KITTI’s range (APBEVAP_{\mathrm{BEV}} at 50–70.4 m falls from 0.738 to 0.704). With the selected feature set R2, radar raises APBEVAP_{\mathrm{BEV}} at 30–50 m from 0.857 to 0.870 but leaves the selection metric almost unchanged (0.428 against 0.424), and both fusion models stay below SECOND beyond 50 m.

Method[email protected] 0–3030–5050–100100–200>50AllCenter-distance AP (APCD) 0–3030–5050–100100–200>50All
SECOND0.9750.8470.7250.2770.5170.6300.9090.6640.6150.2800.4580.556
CLOCs (R0)0.9740.8570.7010.2670.4930.5990.9260.6930.5890.2520.4240.525
CLOCs-R (R2)0.9740.8700.7060.2710.4970.6070.9180.6980.5930.2550.4280.530
R0 + residual†0.9740.8610.7230.2960.5210.6230.9250.6970.6060.2800.4480.545
R2 + residual†0.9740.8740.7270.2980.5240.6300.9220.7040.6090.2830.4510.551
Method[email protected] 0–3030–5050–100100–200All[email protected] 0–3030–5050–100100–200All[email protected] 0–3030–5050–100100–200All
SECOND0.9500.5140.3230.0520.3360.3930.0410.0240.0010.0660.9870.9200.8580.6500.807
CLOCs (R0)0.9580.6030.3280.0470.3490.4130.0470.0180.0010.0630.9870.9240.8580.6140.794
CLOCs-R (R2)0.9570.5950.3290.0470.3500.3810.0440.0180.0010.0620.9880.9240.8600.6230.798
R0 + residual†0.9580.6020.3350.0500.3540.4160.0470.0200.0010.0660.9880.9250.8710.6550.815
R2 + residual†0.9580.5990.3360.0500.3540.4050.0450.0200.0010.0660.9880.9270.8720.6590.817

Table III. Results on aiMotive validation (daytime clear weather, 4,292 frames). Distance bins in meters; validation has 17,669 cars (2,474, 1,470, 6,908 and 6,777 in the four bins), and >50 pools the last two bins, the selection metric. R0 is CLOCs without radar and R2 is CLOCs-R with the selected feature set. Fusion rows are means of 3 seeds. †Post hoc residual scoring, Eq. (5). Recall is limited by the 100-box cap (Section III-B).

Residual scoring (post hoc). At 100–200 m, CLOCs ranks SECOND’s boxes worse than SECOND’s own score does (AUC 0.873 against 0.909 for separating real cars from false detections). After this analysis, and therefore after the validation split had been scored, we tested six changes on holdout under a rule fixed in advance (Section III-G). Only one was adopted: the fusion network corrects SECOND’s score instead of replacing it,

s^j=logit⁡(sj3D)+max⁡ifθ(Tij),(5)\hat{s}_j = \operatorname{logit}\left(s_j^{3D}\right) + \max_i f_{\theta}(\mathbf{T}_{ij}), \tag*{(5)}

where the last layer of fθf_{\theta} is initialized to zero, so that training starts from SECOND’s ranking. This adds no parameters. Residual scoring recovers most of the loss beyond 50 m, where APCD rises to 0.448 without radar and to 0.451 with R2. APBEVAP_{\mathrm{BEV}} beyond 50 m (0.524) and over the full range (0.630) then match or exceed SECOND. On top of residual scoring, radar adds little: 0.003 in APCD beyond 50 m, and 0.013 in APBEVAP_{\mathrm{BEV}} at 30–50 m (0.861 to 0.874). SECOND keeps a lead in APCD beyond 50 m (0.458 against 0.451) and at 50–100 m, but Section III-H shows that this lead is not significant.

Comparison with the aiMotive Baselines

Table VI places our models next to the baselines released with aiMotive [17]. These use different networks (a VoxelNet LiDAR branch and BEVFusion-style fusion), evaluate four The baselines’ >75 m values come from their longer-trained models, and no three-sensor value is reported there. Our rows (SECOND, R0 = CLOCS, R2 = CLOCS-R, res. = residual scoring) score cars only in daytime clear-weather scenes and are means of 3 seeds; our urban rows cover 14,625 cars, mostly from one drive.

ModelSensorsFull range: HighwayFull range: Urban>75 m: Highway>75 m: Urban
aiMotiveL0.7550.6080.5260.470
aiMotiveL+C0.7720.6560.5090.466
aiMotiveL+R0.7690.6170.5220.525
aiMotiveL+R+C0.7620.644––
SECONDL0.6390.6330.4260.405
R0L+C0.5940.6030.3790.399
R2L+R+C0.5990.6130.3850.403
R0 + res.†L+C0.6350.6230.4350.418
R2 + res.†L+R+C0.6390.6320.4410.420

Table VI. Reference comparison with the aiMotive baselines [17] (all-point BEV [email protected], validation).

Means of 3 seeds. Holdout chose the set, and validation played no part. The [email protected] and [email protected] columns are on validation. Latency is the median per frame of the radar features (one CPU thread) and the fusion forward pass (GPU), excluding the detectors.

object categories class-agnostically with Hungarian matching, and score a region that extends behind the vehicle, while our models score cars only, inside the front camera’s view, with greedy matching. The numbers therefore indicate the expected range rather than a ranking. Our SECOND scores below their LiDAR baseline on highways (0.639 against 0.755), slightly above it in urban scenes (0.633 against 0.608), and below it beyond 75 m in both (0.426 and 0.405 against 0.526 and 0.470). Their radar fusion raises AP beyond 75 m in urban scenes (0.470 to 0.525) but not on highways (0.526 to 0.522), whereas radar raises ours by at most 0.006 beyond 75 m in either condition. Their camera fusion raises full-range AP in both conditions, while camera-LiDAR CLOCS lowers ours until residual scoring is added.

Ablation

Radar feature sets. Table VII reports every set of Table II. Beyond 50 m, all eight sets lie within 0.007 of each other on validation and within 0.006 on holdout, about the spread between seeds of one set (validation standard deviation up to 0.010). R2 (Doppler speed alone) was selected under the rule of Section II-C, with 0.4554 on holdout, but R7 (0.4550) and R3 (0.4547) are effectively tied with it. A retraining of R2 during tuning scored 0.4545, which would have ranked it below both, so the selection is not stable and does not show that Doppler speed is the best single cue. More features do not help: R7, with all five, is no better than R2 on either split. The consistent radar effect is at 30–50 m, where every set raises validation APBEV from 0.857 to between 0.866 and 0.871, and support alone (R1) already reaches 0.866. At strict close-range matching, the sets with Doppler speed lose [email protected] at 0–30 m on validation (0.375–0.386 against 0.413 for R0). This does not repeat on holdout, however, where R5, which has no Doppler speed, loses the most (0.465 against 0.492).

SetAPCD >50 m: HoldoutAPCD >50 m: Val.[email protected]: 30–50 m[email protected]: 0–30 mLatency (ms)
SECOND0.46010.4580.8470.393–
R00.45040.4240.8570.4131.5
R10.45090.4240.8660.4174.8
R2 (selected)0.45540.4280.8700.38119.0
R30.45470.4260.8670.38419.2
R40.45420.4270.8680.37544.8
R50.44950.4210.8660.41121.5
R60.45360.4220.8700.38632.0
R70.45500.4230.8710.38462.1

Table VII. Radar feature sets (Table II): accuracy and added latency

Camera removed. With all 2D candidates removed at test time, APCD beyond 50 m on validation rises for both R0 (0.424 to 0.444) and R2 (0.428 to 0.448). On holdout, it rises for R0 (0.450 to 0.460) but falls for R2 (0.455 to 0.439). The reserved row is almost untrained, because only 78 of about 50,000 confident training candidates lack an overlapping 2D box. The test therefore describes the camera’s effect on these models at long range, not a model trained to work without a camera, and it does not cover night driving, which our subset excludes.

Gate. Across the nine gates, holdout APCD beyond 50 m spans 0.4522 to 0.4551, about the spread between the seeds of one gate (0.452–0.459). Every gate beats R0 (0.450), and none reaches SECOND (0.460), so the results are not sensitive to the gate within this grid.

Fusion changes (post hoc). Table VIII lists the six changes tried after the as-designed results. Each was tested alone against R2 on holdout and adopted only if its mean beat R2’s by more than the standard deviation of R2’s three seeds, a bar of 0.4582 fixed before the runs. The winner was scored once on validation and also trained without radar. Only residual scoring passed. Far-range targets lowered the score, and neither more radar sweeps with motion correction nor a radar cross-section channel raised it.

Change to R2HoldoutAdopted
None (R2 retrained)0.4545–
Far-range targets: positive at BEV IoU ≥0.5\ge0.5, negative ≤0.3\le0.3 beyond 50 m0.4433No
Residual scoring, (5)0.4619Yes
SECOND’s score as a scaled logit input0.4502No
M=5M = 5 sweeps with motion correction0.4552No
M=10M = 10 sweeps with motion correction0.4550No
Median radar cross-section as an extra channel0.4529No

Table VIII. Post hoc fusion changes, selected on holdout (APCD >50 m, mean of 3 seeds)

Runtime. Radar features dominate the added latency (Table VII), with medians of 3.7 to 61.0 ms per frame in unoptimized single-threaded Python, against 1.1 to 1.5 ms for the fusion forward pass. With batch size one on 200 validation frames, the detectors themselves take a median of 20.9 ms (SECOND, from GPU transfer to the top-2,000 candidates, with voxelization done by the data loader) and 50.6 ms (Cascade R-CNN at 1280×7041280 \times704, including preprocessing but not image decoding) per frame, so the 19.0 ms that R2 adds compares with 71.5 ms for the two detectors run one after the other.

Analysis

Uncertainty. Table IX gives 95% intervals from resampling scenes with replacement (1,000 resamples), with the trained models held fixed and their three seeds averaged. CLOCs’ loss to SECOND beyond 50 m and the gain from residual scoring are clear on validation. CLOCs-R with residual scoring and SECOND are statistically tied. Radar’s effect beyond 50 m is small but positive on both splits. It is, however, smaller than the variation between training seeds (standard deviation about 0.004), and the intervals treat scenes as independent although many share a drive, so they are likely too narrow.

ComparisonValidationHoldout
R0 − SECOND−.034 [−.057, −.011]−.010 [−.023, +.008]
R0 + residual − R0+.024 [+ .018, +.033]+.008 [+ .004, +.010]
R2 + residual − R0 + residual (radar)+.003 [+ .000, +.005]+.004 [+ .002, +.006]
R2 + residual − SECOND−.007 [−.026, +.012]+.002 [−.010, +.018]
Radar with residual, [email protected], 30–50 m+.014 [−.002, +.028]+.009 [+.002, +.017]
R2 + residual − SECOND, APCD, 30–50 m+.040 [+ .016, +.063]+.010 [−.005, +.022]

Table IX. Differences with 95% scene-bootstrap intervals (APCD >50 m unless stated).

Why radar adds little at range. At 100–200 m on validation, 62% of the real cars among SECOND’s detections have a radar return in their gate, but so do 39% of the false detections, and the radar features alone separate the two only weakly (AUC 0.615 for support and 0.664 for Doppler speed, against 0.909 for SECOND’s score). A logistic model of SECOND’s score with and without radar, scored on scenes it was not fit on, gains at most 0.008 AUC there. The trained R3 networks also barely use radar at that range: replacing the radar inputs with “no return” changes the fused logit of real cars by about +0.5 at 30–50 m but by −0.02 at 100–200 m. Training offers little signal there, since only 7,232 of 136,332 training positives (5%) are at 100–200 m, and SECOND looks nearly perfect on its own training frames at that range (AUC 0.984, against 0.909 on validation).

Failure modes. Four effects limit the results. First, most of SECOND’s remaining lead comes from the tunnel scenes, where the camera is dark. Beyond 50 m there, APCD is 0.461 for SECOND against 0.431 for CLOCs-R with residual scoring (and 0.346 for R0), while without the tunnel scenes the two score 0.458 and 0.456. Second, camera evidence is weakest where fusion was meant to help: only 8% of real cars at 100–200 m on validation have a well-aligned 2D box (2D–3D IoU of at least 0.5) scoring above 0.5, against 97% at 0–30 m. Third, rescoring cannot recover cars that SECOND never proposed: among the 2,000 kept candidates, 15% of the validation cars at 100–200 m and 41% of those on holdout have none with BEV IoU of at least 0.3. Fourth, strict 3D AP is bounded by the label shift, which rescoring cannot correct because box geometry comes from SECOND.

Disclosure. The detectors were frozen, and the gate and the feature set were selected, using holdout only. Residual scoring was proposed after an analysis of validation results, however, so validation is not an untouched test set for it, and a clean estimate would need new data. For this reason, Table III reports the as-designed and post hoc models side by side.

AI Usage Statement

Claude Opus 5.5 was used to format our original draft made in Google Docs to conform to the IEEE LaTeX template provided on Canvas. It was also used to generate LaTeX code for the comparison table and verify that this document followed the requirements outlined in Canvas for this phase.

References

  1. [1]Y. Yan, Y. Mao, and B. Li, “SECOND: Sparsely embedded convolutional detection,” Sensors, vol. 18, no. 10, p. 3337, 2018.DOI
  2. [2]S. Vora, A. H. Lang, B. Helou, and O. Beijbom, “PointPainting: Sequential fusion for 3D object detection,” in Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit. (CVPR), 2020, pp. 4604–4612.arxiv.org/abs/1911.10150
  3. [3]S. Pang, D. Morris, and H. Radha, “CLOCs: Camera-LiDAR object candidates fusion for 3D object detection,” in Proc. IEEE/RSJ Int. Conf. Intell. Robots Syst. (IROS), 2020, pp. 10 386–10 393.arxiv.org/abs/2009.00784
  4. [4]——, “Fast-CLOCs: Fast camera-LiDAR object candidates fusion for 3D object detection,” in Proc. IEEE/CVF Winter Conf. Appl. Comput. Vis. (WACV), 2022, pp. 187–196.DOI
  5. [5]Z. Liu, H. Tang, A. Amini, X. Yang, H. Mao, D. L. Rus, and S. Han, “BEVFusion: Multi-task multi-sensor fusion with unified bird’s-eye view representation,” in Proc. IEEE Int. Conf. Robot. Automat. (ICRA), 2023, pp. 2774–2781.arxiv.org/abs/2205.13542
  6. [6]F. Nobis, M. Geisslinger, M. Weber, J. Betz, and M. Lienkamp, “A deep learning-based radar and camera sensor fusion architecture for object detection,” in Proc. Sensor Data Fusion: Trends, Solutions, Applications (SDF), 2019, pp. 1–7.arxiv.org/abs/2005.07431
  7. [7]R. Nabati and H. Qi, “RRPN: Radar region proposal network for object detection in autonomous vehicles,” in Proc. IEEE Int. Conf. Image Process. (ICIP), 2019, pp. 3093–3097.
  8. [8]——, “CenterFusion: Center-based radar and camera fusion for 3D object detection,” in Proc. IEEE/CVF Winter Conf. Appl. Comput. Vis. (WACV), 2021, pp. 1527–1536.DOI
  9. [9]Y. Long, A. Kumar, D. Morris, X. Liu, M. Castro, and P. Chakravarty, “RADIANT: Radar-image association network for 3D object detection,” in Proc. AAAI Conf. Artif. Intell., vol. 37, no. 2, 2023, pp. 1808–1816.
  10. [10]Y. Kim, J. Shin, S. Kim, I.-J. Lee, J. W. Choi, and D. Kum, “CRN: Camera radar net for accurate, robust, efficient 3D perception,” in Proc. IEEE/CVF Int. Conf. Comput. Vis. (ICCV), 2023, pp. 17 615–17 626.arxiv.org/abs/2304.00670
  11. [11]N. Baumann, M. Baumgartner, E. Eghigone, J. Kühne, T. Fischer, Y.-H. Yang, M. Pollefeys, and M. Magno, “CR3DT: Camera-Radar fusion for 3D detection and tracking,” in Proc. IEEE/RSJ Int. Conf. Intell. Robots Syst. (IROS), 2024, pp. 4926–4933.arxiv.org/abs/2403.15313
  12. [12]J. Kim, M. Seong, G. Bang, D. Kum, and J. W. Choi, “RCM-Fusion: Radar-camera multi-level fusion for 3D object detection,” in Proc. IEEE Int. Conf. Robot. Automat. (ICRA), 2024, pp. 18 236–18 242.arxiv.org/abs/2307.10249
  13. [13]B. Yang, R. Guo, M. Liang, S. Casas, and R. Urtasun, “RadarNet: Exploiting radar for robust perception of dynamic objects,” in Proc. Eur. Conf. Comput. Vis. (ECCV). Springer, 2020, pp. 496–512.arxiv.org/abs/2007.14366
  14. [14]X. Chen, T. Zhang, Y. Wang, Y. Wang, and H. Zhao, “FUTR3D: A unified sensor fusion framework for 3D detection,” in Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit. Workshops (CVPRW), 2023, pp. 172–181.arxiv.org/abs/2203.10642
  15. [15]A. Palffy, E. Pool, S. Baratam, J. F. P. Kooij, and D. M. Gavrila, “Multi-class road user detection with 3+1D radar in the View-of-Delft dataset,” IEEE Robot. Autom. Lett., vol. 7, no. 2, pp. 4961–4968, 2022.
  16. [16]D.-H. Paek, S.-H. Ko, and K. T. Kim, “K-Radar: 4D radar object detection for autonomous driving in various weather conditions,” in Proc. Neural Inf. Process. Syst. (NeurIPS) Datasets Benchmarks Track, 2022.arxiv.org/abs/2206.08171
  17. [17]T. Matuszka, I. Barton, Á. Butykai, P. Hajas, D. Kiss, D. Kovács, S. Kunsági-Máté, P. Lengyel, G. Németh, L. Pető, D. Ribli, D. Szeghy, S. Vajna, and B. V. Varga, “aiMotive dataset: A multimodal dataset for robust autonomous driving with long-range perception,” in Proc. Int. Conf. Learn. Represent. (ICLR) Workshop Scene Represent. Auton. Driving (SR4AD), 2023.arxiv.org/abs/2211.09445
  18. [18]A. Geiger, P. Lenz, and R. Urtasun, “Are we ready for autonomous driving? The KITTI vision benchmark suite,” in Proc. IEEE Conf. Comput. Vis. Pattern Recognit. (CVPR), 2012, pp. 3354–3361.
  19. [19]H. Caesar, V. Bankiti, A. H. Lang, S. Vora, V. E. Liong, Q. Xu, A. Krishnan, Y. Pan, G. Baldan, and O. Beijbom, “nuScenes: A multimodal dataset for autonomous driving,” in Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit. (CVPR), 2020, pp. 11 621–11 631.arxiv.org/abs/1903.11027
  20. [20]S. Yao, R. Guan, X. Huang, Z. Li, X. Sha, Y. Yue, E. G. Lim, H. Seo, K. L. Man, X. Zhu, and Y. Yue, “Radar-camera fusion for object detection and semantic segmentation in autonomous driving: A comprehensive review,” IEEE Trans. Intell. Veh., vol. 9, no. 1, pp. 2094–2128, 2024.DOI
  21. [21]Z. Cai and N. Vasconcelos, “Cascade R-CNN: Delving into high quality object detection,” in Proc. IEEE/CVF Conf. Comput. Vis. Pattern Recognit. (CVPR), 2018.arxiv.org/abs/1712.00726
  22. [22]K. Chen, J. Wang, J. Pang, Y. Cao, Y. Xiong, X. Li, S. Sun, W. Feng, Z. Liu, J. Xu, Z. Zhang, D. Cheng, C. Zhu, T. Cheng, Q. Zhao, B. Li, X. Lu, R. Zhu, Y. Wu, J. Dai, J. Wang, J. Shi, W. Ouyang, C. C. Loy, and D. Lin, “MMDetection: Open MMLab detection toolbox and benchmark,” arXiv:1906.07155, 2019.arxiv.org/abs/1906.07155
  23. [23]T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár, “Focal loss for dense object detection,” in Proc. IEEE Int. Conf. Comput. Vis. (ICCV), 2017, pp. 2980–2988.
  24. [24]D. P. Kingma and J. Ba, “Adam: A method for stochastic optimization,” in Proc. Int. Conf. Learn. Represent. (ICLR), 2015.arxiv.org/abs/1412.6980
  25. [25]OpenPCDet Development Team, “OpenPCDet: An open-source toolbox for 3D object detection from point clouds,” https://github.com/open-mmlab/OpenPCDet, 2020.
  26. [26]T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick, “Microsoft COCO: Common objects in context,” in Proc. Eur. Conf. Comput. Vis. (ECCV). Springer, 2014, pp. 740–755.arxiv.org/abs/1405.0312
  27. [27]I. Loshchilov and F. Hutter, “Decoupled weight decay regularization,” in Proc. Int. Conf. Learn. Represent. (ICLR), 2019.

Paper details

vlnc:W_x6nchrwb
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC0-1.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Claude Opus 5.5

View statement
Looking for related papers…
Contents