Real-Time 2D LiDAR Object Detection Using Three-Frame RGB Scan Encoding
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Electrical Engineering. The day in electrical engineering: signals, systems and the hardware that carries them.
Rosa: I'm Rosa.
Dev: And I'm Dev, here with Taro.
Rosa: We're looking at the paper: "Real-Time 2D LiDAR Object Detection Using Three-Frame RGB Scan Encoding".
Dev: Here's the gist of the paper. Indoor service robots need perception that is robust, more privacy-friendly than RGB video, and feasible on embedded hardware<ref:2602.02167#pg2> This work presents a camera-free 2D LiDAR object detection pipeline that encodes short-term temporal context by stacking three consecutive scans as RGB channels, yielding a compact YOLOv8n input without occupancy-grid construction while preserving angular structure and motion cues<ref:2602.02167#pg2> The method achieves 98.4% mAP@0.5 (0.778 mAP@0.5:0.95) with 94.9% precision and 94.7% recall on four object classes in simulation<ref:2602.02167#pg2> On a Raspberry Pi 5, it runs in real time with a mean post-warm-up end-to-end latency of 47.8 ms per frame, including scan encoding and postprocessing<ref:2602.02167#pg2> System Overview We propose an efficient object detection pipeline based entirely on 2D LiDAR, designed for real-time execution on embedded CPUs<ref:2602.02167#pg4> Compared with prior LiDAR–YOLO pipelines that first construct occupancy grids, our approach encodes scans directly into a compact RGB-style tensor that can be processed by standard CNN detectors<ref:2602.02167#pg4> The core idea is to stack three consecutive 2D scans as the three channels of a small raster image<ref:2602.02167#pg4> This preserves the ordered angular structure of the scan while injecting short-term temporal cues (motion and viewpoint change) without requiring odometry alignment<ref:2602.02167#pg4> The resulting input is compact (64 × 384 × 3) and avoids the preprocessing cost and large input sizes typical of occupancy-grid pipelines<ref:2602.02167#pg4> Temporal Data Encoding A 2D LiDAR scan is a sequence of angle–range measurements where θi is the bearing and ρi is the measured distance<ref:2602.02167#pg4> Rasterization involves converting each scan into a sparse binary raster It ∈
0, 255: 64×360, where columns represent angle bins and rows represent discretized range bins<ref:2602.02167#pg4> The angular bin index is computed as ab = mod(round(θ
◦: ), 360), (1)i.e., angles are rounded to the nearest degree and wrapped modulo 360<ref:2602.02167#pg4> For the range axis, we discretize into 64 bins with a fixed full-scale value Rmax = 4.0 m<ref:2602.02167#pg4> The range-bin index is computed as rb = clip(ρ · 63 / Rmax, 0, 63, (2)where ρ is in meters<ref:2602.02167#pg4> To encode short-term temporal context, we maintain a first-in, first-out (FIFO) buffer of three consecutive rasters at times t − 2, t − 1, and t<ref:2602.02167#pg4> These are stacked into an RGB tensor I RGB t ∈
0, 255: 64×384×3: I RGB t (r, a,:) = It−2(r, a), It−1(r, a), It(r, a)<ref:2602.02167#pg4> This encoding injects motion cues and short-term viewpoint variation without scan matching or pose alignment<ref:2602.02167#pg4> Where the gains come from The main contributions include a compact multi-frame 2D LiDAR encoding that stacks three consecutive scans as RGB channels, injecting short-term temporal cues without pose alignment<ref:2602.02167#pg2> The model training uses YOLOv8n, chosen for embedded feasibility (approximately 3M parameters), with a fixed input resolution of 64 × 384<ref:2602.02167#pg5> Training was performed on a server with an NVIDIA H100 GPU (80 GB VRAM) for 120 epochs<ref:2602.02167#pg5> Comparison with Prior Work Table III summarizes reported results from Najem et al.
3: alongside our method<ref:2602.02167#pg6> Because Najem et al.
Dev: evaluate on real data with manual labels while our results are simulation-based with automatic labels, accuracy metrics are not directly comparable<ref:2602.02167#pg6> However, the occupancy-grid pipeline in
3: reports substantially higher end-to-end latency on Raspberry Pi 5 than our compact scan encoding This should be interpreted cautiously because the datasets, labeling regimes, software stacks, and timing protocols differ<ref:2602.02167#pg6> Inference Time Analysis We measure end-to-end CPU latency with batch size 1 and FP32 inference, including scan encoding, the YOLOv8n forward pass, and non-maximum suppression (NMS)<ref:2602.02167#pg6> On Raspberry Pi 5, the pipeline achieves a mean end-to-end latency of 47.8 ms per frame<ref:2602.02167#pg6> This meets the real-time target while leaving computational headroom for other onboard modules<ref:2602.02167#pg6> Limitations and Threats to Validity This study is evaluated in simulation; real 2D LiDAR sensors introduce noise, missing returns, and calibration effects that may reduce performance under domain shift<ref:2602.02167#pg6> Labels are derived from simulator metadata, which removes annotation ambiguity and may inflate reported metrics relative to manually labeled real-world datasets<ref:2602.02167#pg6> Temporal stacking is performed without pose alignment and may degrade under fast robot rotation or highly dynamic scenes<ref:2602.02167#pg6> Finally, while 2D LiDAR avoids RGB appearance capture, geometric signals may still enable behavioral inference in some deployments<ref:2602.02167#pg6> This paper presented a privacy-friendly, real-time 2D LiDAR object detection pipeline for indoor service robots<ref:2602.02167#pg6> The proposed approach achieves 98.4% mAP@0.5 (0.778 mAP@0.5:0.95) with 94.9% precision and 94.7% recall on four indoor object classes<ref:2602.02167#pg2> Future work will evaluate sim-to-real transfer on physical robots with real 2D LiDAR sensors, including robustness to noise, missing returns, and calibration effects<ref:2602.02167#pg6> We also plan to extend the object set (including dynamic agents), study failure modes under fast rotations where unaligned temporal stacking may degrade, and explore deployment optimizations such as quantization and hardware-accelerated runtimes to further reduce latency and power consumption<ref:2602.02167#pg6> REFERENCES
1: C.-Y.
Rosa: Wang, H.-Y.
Paper summary: Rosa: Thinking about the title "Real-Time 2D LiDAR Object Detection Using Three-Frame RGB Scan Encoding" and who wrote it, this work by Soheil Behnam Roudsari, Alexandre S <ref:2602.02167#pg1,Real-Time 2D LiDAR Object Detection Using Three-Frame RGB Scan Encoding>. Brandao, and Felipe N. Martins really focuses on making perception practical for indoor service robots <ref:2602.02167#pg1>.
Dev: It’s about taking the raw 2D LiDAR measurements and turning them into a format that looks like an RGB image with a little bit of time baked in by stacking three consecutive scans <ref:2602.02167#pg4>.
Taro: The implication for us is that we can design detection systems that are leaner, fitting on smaller chips, without needing those heavy preprocessing steps they are trying to get rid of <ref:2602.02167#pg4>.
Rosa: It’s about achieving a strong result with ninety-eight point four percent mean average precision at a five percent threshold on four object classes in simulation, which is quite impressive for this kind of setup <ref:2602.02167#pg1>.
Dev: But we must remember the caveats they laid out, because they said that since the method is evaluated in simulation, it might not perform as well when you introduce real-world noise or calibration errors from a physical sensor <ref:2602.02167#pg6>.
Taro: And also that the unaligned three-frame stacking might break down if the robot has fast rotations or encounters very dynamic things in its path <ref:2602.02167#pg3>.
Rosa: So, this paper shows a way to encode short-term temporal context from LiDAR scans to get a compact input for deep learning detectors, aiming for real-time performance on devices like the Raspberry Pi five <ref:2602.02167#pg6>.
Dev: It’s not a complete solution for deployment yet because of those real sensor issues and the limitations on rapid motion, but it's a solid step toward making perception more privacy-friendly and hardware-feasible for indoor robotics <ref:2602.02167#pg1>.
Conclusion: Rosa: So, we’ve been looking at this paper titled "Real-Time 2D LiDAR Object Detection Using Three-Frame RGB Scan Encoding <ref:2602.02167#pg1,Real-Time 2D LiDAR Object Detection Using Three-Frame RGB Scan Encoding>." Basically, they took a standard 2D LiDAR and turned its measurements into something that looks like an RGB image using three consecutive scans stacked together <ref:2602.02167#pg1>.
Dev: Right, so they're trying to make object detection work on embedded hardware by encoding the temporal context—that short-term motion or viewpoint change—into those three channels without needing any complex alignment from odometry.
Taro: It’s interesting because it avoids the whole heavy process of building those occupancy grids that most people use with LiDAR, which is usually super slow and memory hungry.
Rosa: Exactly, and they claim this compact input format, which is small—sixty-four by three hundred eighty-four by three—can run on things like a Raspberry Pi five in real time.
Dev: Forty-seven point eight milliseconds per frame including everything from encoding the scan to the final detection step. That’s tight for real robot control, but it meets the target for processing speed.
Taro: I'm still thinking about how that temporal stacking works when things move really fast or if the robot suddenly rotates quickly; that unaligned stacking could definitely cause some fuzzy detections in those dynamic situations.
Rosa: Well, the authors say it gets ninety-eight point four percent mean average precision at a five percent threshold across four object classes in their simulation tests. That’s a solid number for something running on limited hardware.
Dev: But we have to remember, that’s simulation data, so we gotta be careful about how well it transfers when you move this onto the physical world where real sensor noise and calibration errors kick in.
Taro: Yeah, and the labels they use are from simulator metadata, which means the accuracy numbers might be inflated compared to what we see on actual robots with manually labeled data.
Rosa: It shows that even without using cameras for appearance information, you can use temporal data from LiDAR to get a compact representation that’s viable for indoor service robots.
Dev: So it’s a promising way to build privacy-friendly perception systems, but the next big test is definitely seeing how this holds up when we move out of the simulator and into messy real-world environments.
Soheil Behnam Roudsari, Alexandre S. Brandao, Felipe N. Martins
Institute of Engineering Hanze University of Applied Sciences · Nucleo de Especializacção em Robótica, Departamento de Engenharia ElƔtrica, Universidade Federal de VicƓsa
eess.SP, cs.CV, cs.LG, cs.RO
Submitted: 2026-02-02
Updated: 2026-02-02
Comments: 6 pages, 6 figures, submitted to IEEE SAS 2026
DOI: 10.1109/SAS70013.2026.11744174
Code: https://github.com/soheilbh/2d-lidar-identification
License: http://creativecommons.org/licenses/by-nc-sa/4.0/
Importance score: 85/100
The gist: Indoor service robots need perception that is robust, more privacy-friendly than RGB video, and feasible on embedded hardware<ref:2602.02167#pg2> This work presents a camera-free 2D LiDAR object…
Key concepts
- 2D LiDAR Scan Rasterization
- A raw 2D LiDAR scan consists of angle and distance measurements. Rasterization converts this sparse data into a fixed-size binary image, typically 64x360 pixels. This process maps the angular measurements to columns and the distance measurements to rows, creating a grid representation suitable for image processing.
- Temporal Data Encoding
- To capture motion cues without needing robot pose alignment, three consecutive scans are stacked as three separate RGB channels. This creates a compact input tensor where each pixel location across the 64x384 grid holds the scan data from time t-2, t-1, and t. This stacking allows the model to infer movement over a short time window.
- YOLOv8n for Embedded Feasibility
- The detection model used is YOLOv8n, chosen because it is lightweight with approximately 3 million parameters. This small size makes the model feasible for deployment on resource-constrained embedded CPUs, such as the Raspberry Pi 5. It processes the compact encoded input efficiently to achieve real-time performance.
- Compact Input Tensor (64x384x3)
- The final input format is a compact tensor created by stacking three consecutive rasterized scans. This structure preserves the angular layout of the LiDAR data while adding temporal depth via the three channels. This avoids complex occupancy-grid construction, resulting in a small, efficient input size for standard CNN detectors.
Terminology
Summary
Indoor service robots need perception that is robust, more privacy-friendly than RGB video, and feasible on embedded hardware<ref:2602. p. 0 brandao@ufv. br
Abstract—Indoor service robots need perception that is robust, more privacy-friendly than RGB video, and feasible on
embedded hardware. br
Abstract—Indoor service robots need perception that is robust, more privacy-friendly than RGB video, and feasible on
embedded hardware. We present a camera-free 2D LiDAR object
detection pipeline that encodes short-term temporal context by
stacking three consecutive scans as RGB channels, yielding a
compact YOLOv8n input without occupancy-grid construction
while preserving angular structure and motion cues. We present a camera-free 2D LiDAR object
detection pipeline that encodes short-term temporal context by
stacking three consecutive scans as RGB channels, yielding a
compact YOLOv8n input without occupancy-grid construction
while preserving angular structure and motion cues. Evaluated
in Webots across 160 randomized indoor scenarios with strict
scenario-level holdout, the method achieves 98. 95) with 94. 9% precision and 94. 95) with 94. 9% precision and 94. 9% precision and 94. 7% recall
on four object classes. 7% recall
on four object classes. On a Raspberry Pi 5, it runs in real time
with a mean post-warm-up end-to-end latency of 47. On a Raspberry Pi 5, it runs in real time
with a mean post-warm-up end-to-end latency of 47. 8 ms per
frame, including scan encoding and postprocessing.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
System Overview
We propose an efficient object detection pipeline based entirely on 2D LiDAR, designed for real-time execution on embedded CPUs<ref:2602.02167#pg4> Compared with prior LiDAR–YOLO pipelines that first construct occupancy grids, our approach encodes scans directly into a compact RGB-style tensor that can be processed by standard CNN detectors<ref:2602. p. 1 System Overview
We propose an efficient object detection pipeline based
entirely on 2D LiDAR, designed for real-time execution
on embedded CPUs. Compared with prior LiDAR–YOLO
pipelines that first construct occupancy grids [3], our approach
encodes scans directly into a compact RGB-style tensor that
can be processed by standard CNN detectors. Compared with prior LiDAR–YOLO
pipelines that first construct occupancy grids [3], our approach
encodes scans directly into a compact RGB-style tensor that
can be processed by standard CNN detectors. The core idea is to stack three consecutive 2D scans as
the three channels of a small raster image. The core idea is to stack three consecutive 2D scans as
the three channels of a small raster image. This preserves the
ordered angular structure of the scan while injecting shortterm temporal cues (motion and viewpoint change) without
requiring odometry alignment. This preserves the
ordered angular structure of the scan while injecting shortterm temporal cues (motion and viewpoint change) without
requiring odometry alignment. The resulting input is compact
(64 × 384 × 3) and avoids the preprocessing cost and large
input sizes typical of occupancy-grid pipelines (often resized
to 640 × 640).Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Temporal Data Encoding
A 2D LiDAR scan is a sequence of angle–range measurements where θi is the bearing and ρi is the measured distance<ref:2602.02167#pg4> Rasterization involves converting each scan into a sparse binary raster It ∈ [0, 255] 64×360, where columns represent angle bins and rows represent discretized range bins<ref:2602. p. 1 Rasterization. Each scan is converted into a sparse binary
raster It ∈ {0, 255}
64×360, where columns represent angle
bins and rows represent discretized range bins. We use 360
angular bins (1 degree per bin). The angular bin index is
computed as
ab = mod(round(θ [
◦
]), 360), (1)
i. The angular bin index is
computed as
ab = mod(round(θ [
◦
]), 360), (1)
i. , angles are rounded to the nearest degree and wrapped
modulo 360. , angles are rounded to the nearest degree and wrapped
modulo 360. For the range axis, we discretize into 64 bins with a fixed
full-scale value Rmax = 4. These approaches are efficient and interpretable, but they require careful tuning and do not scale well
to diverse environments and richer object categories. Learning-based methods have shown that 2D LiDAR can
support semantic perception when the ordered angular strucarXiv:2602. 5 m; measurements that are infinite or out-of-range are
replaced with the sentinel Rmax (this sentinel is used only to
handle invalid returns consistently, not to claim measurements
beyond the nominal range). The range-bin index is computed
as:
rb =
clip
ρ ·
63
Rmax
, 0, 63 , (2)
where ρ is in meters. Three-frame temporal stacking. To encode short-term
temporal context, we maintain a first-in, first-out (FIFO) buffer
of three consecutive rasters at times t − 2, t − 1, and t. To encode short-term
temporal context, we maintain a first-in, first-out (FIFO) buffer
of three consecutive rasters at times t − 2, t − 1, and t. These
are stacked into an RGB tensor I
RGB
t ∈ {0, 255}
64×384×3
:
I
RGB
t
(r, a, :) =
It−2(r, a), It−1(r, a), It(r, a)
. These
are stacked into an RGB tensor I
RGB
t ∈ {0, 255}
64×384×3
:
I
RGB
t
(r, a, :) =
It−2(r, a), It−1(r, a), It(r, a)
. (3)
This encoding injects motion cues and short-term viewpoint
variation without scan matching or pose alignment, keeping
preprocessing lightweight.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Where the gains come from
The main contributions include a compact multi-frame 2D LiDAR encoding that stacks three consecutive scans as RGB channels, injecting short-term temporal cues without pose alignment<ref:2602.02167#pg2> The model training uses YOLOv8n, chosen for embedded feasibility (approximately 3M parameters), with a fixed input resolution of 64 × 384<ref:2602. p. 3 variant of YOLOv8, chosen for embedded feasibility (approximately 3M parameters). The input resolution is fixed at
64 × 384, and rectangular training (rect=True) is enabled to
preserve the native LiDAR aspect ratio. Training was performed on a server with an NVIDIA H100
GPU (80 GB VRAM). The model was trained for 120 epochs
with batch size 1,024 (enabled by GPU memory and dataset
caching).Where the paper says it
Where the paper says it
Comparison with Prior Work
Table III summarizes reported results from Najem et al. [3] alongside our method<ref:2602. p. 4 Comparison with Prior Work
Table III summarizes reported results from Najem et al. [3]
alongside our method. [3]
alongside our method. Because Najem et al. Because Najem et al. evaluate on real
data with manual labels while our results are simulation-based
with automatic labels, accuracy metrics are not directly comparable. As shown in Table III, the occupancy-grid pipeline in [3] reports substantially higher end-to-end latency on Raspberry Pi 5
than our compact scan encoding. This should be interpreted
cautiously because the datasets, labeling regimes, software
stacks, and timing protocols differ; nevertheless, the direction
of the difference is consistent with the added preprocessing
cost of occupancy-grid construction and the larger network
input size.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
Inference Time Analysis
We measure end-to-end CPU latency with batch size 1 and FP32 inference, including scan encoding, the YOLOv8n forward pass, and non-maximum suppression (NMS)<ref:2602.02167#pg6> On Raspberry Pi 5, the pipeline achieves a mean end-to-end latency of 47. p. 4 Table II summarizes the measured runtimes. On Raspberry
Pi 5, the pipeline achieves a mean end-to-end latency of
47. On a Raspberry Pi 5, it runs in real time
with a mean post-warm-up end-to-end latency of 47. 8 ms per
frame, including scan encoding and postprocessing. On Raspberry
Pi 5, the pipeline achieves a mean end-to-end latency of
47. 8 ms per frame, meeting the real-time target while leaving
computational headroom for other onboard modules (e.Where the paper says it
Where the paper says it
Where the paper says it
Limitations and Threats to Validity
This study is evaluated in simulation; real 2D LiDAR sensors introduce noise, missing returns, and calibration effects that may reduce performance under domain shift<ref:2602.02167#pg6> Labels are derived from simulator metadata, which removes annotation ambiguity and may inflate reported metrics relative to manually labeled real-world datasets<ref:2602. p. 4 Limitations and Threats to Validity
This study is evaluated in simulation; real 2D LiDAR
sensors introduce noise, missing returns, and calibration effects
that may reduce performance under domain shift. Labels are
derived from simulator metadata, which removes annotation
ambiguity and may inflate reported metrics relative to manually labeled real-world datasets. The task considers four mostly
static indoor object classes and does not evaluate dynamic
agents (e. Temporal stacking is performed without
pose alignment and may degrade under fast robot rotation or
highly dynamic scenes. Temporal stacking is performed without
pose alignment and may degrade under fast robot rotation or
highly dynamic scenes. Finally, while 2D LiDAR avoids RGB
appearance capture, geometric signals may still enable behavioral inference in some deployments; we therefore describe the
approach as privacy-friendly rather than privacy-preserving.Where the paper says it
Where the paper says it
Where the paper says it
Conclusion and Future Work
This paper presented a privacy-friendly, real-time 2D LiDAR object detection pipeline for indoor service robots<ref:2602.02167#pg6> The proposed approach achieves 98. p. 4 The
method encodes short-term temporal context by rasterizing
three consecutive scans and stacking them as RGB channels, producing a compact 64 × 384 × 3 input compatible
with YOLOv8n while avoiding occupancy-grid construction,
which can add preprocessing overhead. In Webots with strict
scenario-level holdout, the proposed approach achieves 98. 9% precision and
94. 7% recall on four indoor object classes. 8 ms/frame (including encoding and
postprocessing), indicating that lightweight temporal encoding
can support accurate LiDAR-only detection on embedded
hardware. Future work will evaluate sim-to-real transfer on physical
robots with real 2D LiDAR sensors, including robustness to
noise, missing returns, and calibration effects. Future work will evaluate sim-to-real transfer on physical
robots with real 2D LiDAR sensors, including robustness to
noise, missing returns, and calibration effects. We also plan
to extend the object set (including dynamic agents), study
failure modes under fast rotations where unaligned temporal
stacking may degrade, and explore deployment optimizations
such as quantization and hardware-accelerated runtimes to
further reduce latency and power consumption.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
REFERENCES
[1] C.-Y. Wang, H.-Y. M. Liao, and I. p. 5 REFERENCES
[1] C. Liao, and I. Liao, and I. Yeh, “YOLOv9: Learning what you
want to learn using programmable gradient information,” in Proceedings
of the European Conference on Computer Vision (ECCV), 2024.Where the paper says it
Where the paper says it
[3] A. Najem, L. Kuiper, T. P. Jansen, A. S. Brandao, and F. p. 0 Real-Time 2D LiDAR Object Detection Using
Three-Frame RGB Scan Encoding
Soheil Behnam Roudsari1
, Alexandre S. Brandao˜
2
, and Felipe N. Brandao, and F. ˜
Martins, “Object classification using 2D-LiDAR and YOLO for robot
navigation,” in Optimization, Learning Algorithms and Applications: 6th
International Conference, OL2A 2025, Sestri Levante, Italy, April 28–30,
2025, Revised Selected Papers, ser.Where the paper says it
Where the paper says it
[4] A. Sec¸kin, “Pedestrian and mobile robot detection with 2D LiDAR,” European Journal of Science and Technology, vol. p. 5 1007/
978-3-032-00140-5 17
[4] A. Sec¸kin, “Pedestrian and mobile robot detection with 2D LiDAR,”
European Journal of Science and Technology, vol. These approaches are efficient and interpretable, but they require careful tuning and do not scale well
to diverse environments and richer object categories. Learning-based methods have shown that 2D LiDAR can
support semantic perception when the ordered angular strucarXiv:2602. These approaches are efficient and interpretable, but they require careful tuning and do not scale well
to diverse environments and richer object categories. Learning-based methods have shown that 2D LiDAR can
support semantic perception when the ordered angular strucarXiv:2602.Where the paper says it
Where the paper says it
Where the paper says it
[5] L. A. Fagundes, A. p. 5 583–588, 2021. Fagundes, A. Fagundes, A. Caldeira, M. Caldeira, M. Quemelli, F. Martins, and
A. Brandao, “Analytical formalism for data representation and object ˜
detection with 2D LiDAR: Application in mobile robotics,” Sensors,
vol.Where the paper says it
Where the paper says it
Where the paper says it
Where the paper says it
[6] L. Beyer, A. Hermans, T. p. 5 2284, 2024. Hermans, T. Arras, and B. Leibe, “Deep person
detection in 2d range data,” IEEE Robotics and Automation Letters, vol.Where the paper says it
Where the paper says it
[7] D Jia, A Hermans, and B Leibe, “DR-SPAAM: A spatial-attention and auto-regressive model for person detection in 2d range data,” arXiv preprint arXiv:2004.14079, 2020<ref:2602. p. 5 Leibe, “DR-SPAAM: A spatial-attention
and auto-regressive model for person detection in 2d range data,” arXiv
preprint arXiv:2004. 14079, 2020, arXiv:2004.Where the paper says it
[8] B Kaleci, K Turgut, and H Dutagaci, “2DLaserNet: A deep learning architecture on 2D laser scans for semantic classification of mobile robot locations,” Engineering Science and Technology, an International Journal, vol. 28<ref:2602. p. 0 These approaches are efficient and interpretable, but they require careful tuning and do not scale well
to diverse environments and richer object categories. Learning-based methods have shown that 2D LiDAR can
support semantic perception when the ordered angular strucarXiv:2602.Where the paper says it
[9] M M Zarrar, Q Weng, B Yerjan, A Soyyigit, and H Yun, “TinyLidarNet: 2D LiDAR-based end-to-end deep learning model for F1TENTH autonomous racing,” 2024<ref:2602.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Temporal context encoding allows for accurate object detection using a compact input that avoids occupancy-grid construction, which
can limit real-time performance.
This enablesLiDAR-only detection for embedded indoor robotics without capturing RGB appearance.
-
The proposed system can achieve high accuracy in simulation, reaching
98.4% mAP@0.5 (0.778 mAP@0.5:0.95) with 94.9% precision and 94.7% recall on four object classes.
This demonstrates the ability to perform reliable multi-class detection in complex indoor scenarios using only geometric data from a 2D LiDAR sensor. -
The pipeline can operate in real time on low-cost embedded hardware, achieving a
mean post-warm-up end-to-end latency of 47.8 ms per frame
on a Raspberry Pi 5, which is better than prior occupancy grid pipelines reported on the same platform. This supportstypical indoor navigation and control loops
at a rate of approximately 20 Hz perception updates. -
The system can be deployed directly onto hardware, consuming the
64x384x3 RGB LiDAR tensor directly
for inference in a single forward pass, requiring only the lightweight encoding step described above. This makes it feasible for deployment on embedded CPUs like the Raspberry Pi 5 and MacBook Air M2.
Abstract
Indoor service robots need perception that is robust, more privacy-friendly than RGB video, and feasible on embedded hardware. We present a camera-free 2D LiDAR object detection pipeline that encodes short-term temporal context by stacking three consecutive scans as RGB channels, yielding a compact YOLOv8n input without occupancy-grid construction while preserving angular structure and motion cues. Evaluated in Webots across 160 randomized indoor scenarios with strict scenario-level holdout, the method achieves 98.4% mAP@0.5 (0.778 mAP@0.5:0.95) with 94.9% precision and 94.7% recall on four object classes. On a Raspberry Pi 5, it runs in real time with a mean post-warm-up end-to-end latency of 47.8ms per frame, including scan encoding and postprocessing. Relative to a closely related occupancy-grid LiDAR-YOLO pipeline reported on the same platform, the proposed representation is associated with substantially lower reported end-to-end latency. Although results are simulation-based, they suggest that lightweight temporal encoding can enable accurate and real-time LiDAR-only detection for embedded indoor robotics without capturing RGB appearance.
Sources
Related papers
- Open-H-RF: A Large-Scale Ultrasound Raw Channel Dataset Initiative
- Scalable Attention for 5G NR Channel Estimation
- Low-Altitude Wireless Networks: A Comprehensive Survey
- Sensing-Assisted OFDM with Index Modulation: A Waveform for Optical Wireless Integrated Communication and Localisation
- Iteration-Free Candidate Pruning and an Index-Domain VLSI Architecture for Sort-Free MIMO Box Decoding up to 1024-QAM
- A Foundation Model for Large-Scale Wireless Network Planning, Operation and Optimization