Real-Time Deterministic Lane Detection on CPU-Only Embedded Systems via Binary Line Segment Filtering

Abstract

The deployment of Advanced Driver-Assistance Systems (ADAS) in economically constrained markets frequently relies on hardware architectures that lack dedicated graphics processing units. Within such environments, the integration of deep neural networks faces significant hurdles, primarily stemming from strict limitations on energy consumption, the absolute necessity for deterministic real-time response, and the rigorous demands of safety certification protocols. Meanwhile, traditional geometry-based lane detection pipelines continue to exhibit limited robustness under adverse illumination conditions, including intense backlighting, low-contrast nighttime scenes, and heavy rainfall. Motivated by these constraints, this work re-examines geometry-based lane perception from a sensor-level viewpoint and introduces a Binary Line Segment Filter (BLSF) that leverages the inherent structural regularity of lane markings in bird’s-eye-view (BEV) imagery within a computationally lightweight framework. The proposed BLSF is integrated into a complete pipeline consisting of inverse perspective mapping, median local thresholding, line-segment detection, and a simplified Hough-style sliding-window fitting scheme combined with RANSAC. Experiments on a self-collected dataset of 297 challenging frames show that the inclusion of BLSF significantly improves robustness over an ablated baseline while sustaining real-time performance on a 2 GHz ARM CPU-only platform. Additional evaluations on the Dazzling Light and Night subsets of the CULane and LLAMAS benchmarks further confirm consistent gains of approximately 6–7% in F₁-score, together with corresponding improvements in IoU. These results demonstrate that interpretable, geometry-driven lane feature extraction remains a practical and complementary alternative to lightweight learning-based approaches for cost- and safety-critical ADAS applications.

1. Introduction

1.1. Background and Motivation

Data released in 2023 underscores a critical global challenge: approximately 1.19 million lives were lost to road incidents in 2021 [1], with unintended lane departure identified as a major contributing factor. Advanced driver assistance systems (ADAS) have therefore been widely recognized as a key technology for accident prevention and road safety enhancement [2]. The effectiveness of such systems critically depends on reliable lane detection, which requires both robust image-based algorithms and efficient processing to support functions such as lane keeping and lane-departure warning.

For mass-market vehicles, vision-only approaches are generally favored over LiDAR- or RADAR-based solutions due to their lower cost and easier integration. Nevertheless, camera-based lane detection remains highly sensitive to sensor noise and environmental disturbances, particularly under conditions involving sharp road curvature, intense backlighting, nighttime low contrast, and heavy rainfall [3]. These limitations highlight the urgent need for sensor-layer robustness improvements that can operate effectively on cost-efficient, dashcam-class embedded hardware.

1.2. Deep Learning Approaches and Limitations

In recent years, deep learning-based approaches have become the mainstream direction in lane detection research. Methods employing row-anchor formulations and Transformer-inspired architectures have achieved high detection accuracy and throughput on GPU-enabled platforms, while attention-enhanced networks further improve multi-scale lane feature representation. Learning-based image enhancement techniques have also been investigated to restore lane markings degraded by adverse visual conditions.

Despite these advances, many state-of-the-art DL pipelines incur substantial computational and power overhead, which limits their applicability on low-cost, CPU-only embedded platforms widely used in mass-market vehicles and mobile robotic systems. In addition, practical robustness across varying illumination and weather conditions remains inconsistent, and the opaque nature of large neural models poses challenges for traceability, failure diagnosis, and safety-case construction in certification-driven processes such as ISO 26262 [4]. In safety-critical applications, deterministic algorithms with bounded execution time and interpretable intermediate representations are often preferable when establishing verifiable and auditable system behavior.

Alongside classical methods, recent research has also focused on computationally efficient deep learning-based lane detection designed for real-time use. Ultra-Fast Structure-aware Lane Detection (UFLD) [5], for example, casts the lane detection task into a row-wise prediction formulation and demonstrates high-throughput inference on GPU-equipped platforms.

However, its convolutional backbone relies on dense floating-point operations that can incur substantial latency on general-purpose CPUs. FOLOLane [6] exploits local geometric cues via bottom-up keypoint association, yet still depends on convolutional networks for feature aggregation. Transformer-based models such as Laneformer [7] improve long-range structural modeling through row–column attention, but attention operations typically scale as $O\left(N^2\right)$ with the number of tokens, leading to rapidly increasing computation and memory traffic that hinder real-time execution on CPU-only embedded platforms.

Recent studies on lane detection under adverse weather conditions indicate that geometry- and rule-driven pipelines remain actively studied due to their predictable behavior and well-defined operational boundaries [8]. Similarly, although lightweight CNNs such as TwinLiteNet [9] perform well on GPU-equipped systems, their convolution-heavy design can lead to prohibitive latency when deployed on pure CPU platforms.

Table 1. Comparison of lane detection approaches in terms of computational paradigm, hardware requirements, and robustness.

Approach	Paradigm/Core Idea	Accelerator Need	Determinism & Explainability	Adverse Lighting/Weather Robustness	Positioning vs. BLSF (This Work)
Classical geometric (e.g., Hough variants)	Edge/line extraction + heuristic fitting	CPU (low requirement)	Deterministic; explainable	Often sensitive to glare/shadows	Serves as an efficiency- and explainability-oriented baseline; however, its performance degrades significantly under extreme illumination conditions, leading to frequent failure cases.
Robust Lane Detection [8]	Hybrid geometry/rules with adaptive tuning	CPU-friendly	Explainable relative to DL; behavior depends on tuning policy	Specifically targets challenging weather; supports “geometry is still active”	The results indicate that enforcing bounded and deterministic processing stages may help maintain robustness and predictability in scenarios where data-driven methods exhibit unstable behavior.
UFLD [5]	Lightweight DL; row-wise formulation (ResNet-18/34)	GPU preferred (CPU latency can be high)	Stochastic/black-box vs. geometric	Good when training coverage matches domain	Even when adopting lightweight deep learning, the absence of hardware accelerators leads to substantial performance limitations on pure CPU platforms.
FOLOLane [6]	DL bottom-up keypoints; exploits locality	GPU preferred	Stochastic/black-box vs. geometric	Strong on benchmarks	Shares a similar emphasis on local geometric consistency with BLSF; however, FOLOLane relies on CNN-based keypoint association, whereas BLSF replaces this with direct histogram voting, making it more suitable for extremely resource-constrained environments.
Laneformer [7]	Transformer row–column attention	GPU/accelerator typically required	Stochastic & high-dimensional	Strong on complex scenes	The high computational complexity of attention mechanisms (e.g., quadratic complexity in token interactions) makes such models difficult to deploy on embedded CPU-only systems in real time.
TwinLiteNet [9]	Lightweight multi-task segmentation	Jetson/GPU-class preferred	Stochastic/black-box vs. geometric	Good when trained for target domain	Despite being labeled as “lightweight,” the CNN architecture still incurs substantial GFLOPs. When ported to pure CPU platforms (e.g., ARM Cortex-A), inference latency increases markedly, highlighting the non-substitutability of BLSF in CPU-only scenarios.
BLSF (this work)	Geometric consensus voting + binary line-segment filtering	CPU (ARM Cortex-A)	Deterministic/white-box; bounded execution time	High under adverse illumination via structural consistency prior

summarizes key differences between representative lightweight/hybrid studies and our CPU-oriented deterministic pipeline.

In contrast to GPU-centric learning-based approaches, the present study is designed for embedded platforms where computational resources, power consumption, and timing behavior are tightly constrained. The proposed Binary Line Segment Filter integrates physically interpretable geometric cues into a line-segment–based filtering process, enabling reliable lane extraction under severe illumination variations while maintaining transparent decision logic and bounded, deterministic execution.

1.3. Classical Geometry-Based Methods

These practical limitations have renewed attention toward geometric and model-based pipelines, which offer advantages in computational efficiency, interpretability, and suitability for resource-constrained hardware. Classical approaches typically employ inverse perspective mapping to normalize the road view prior to lane boundary estimation [10], while adaptive or extended local thresholding schemes are used to mitigate spatially varying illumination [11]. Noise suppression has been addressed through edge-based feature extraction [12], and rule-driven binary-blob filtering has been introduced to remove non-lane structures such as road markings, curbs, and nearby vehicles [13]. To further reduce computational overhead, step-row filtering and row-wise anchor selection have been proposed for handling shadows and extreme lighting conditions [5,14], often combined with region-of-interest constraints to limit the search space [15]. Image-sensor-level strategies for high-curvature lane scenarios have also been explored by Kuo et al. [16]. Nevertheless, methods that rely primarily on brightness-related cues remain vulnerable to strong backlighting and other adverse visual conditions, and sensitivity to sensor noise persists. As a result, achieving both robustness and efficiency continues to be a key challenge for real-time lane detection on embedded image-sensor platforms [17].

1.4. Objective and Contribution

This study explores the practical operating envelope of classical geometry-driven lane detection under stringent computational and power constraints, and introduces a Binary Line Segment Filter (BLSF) as a compact enhancement at the sensor-processing level. Within the proposed pipeline, median local thresholding (MLT) [18] is coupled with BLSF to mitigate sensor-induced noise while preserving the intrinsic structural organization of lane markings.

Lane geometry is subsequently reconstructed using a lightweight, Hough-inspired sliding-window initialization [19], followed by RANSAC-based quadratic fitting [20] to yield stable and smooth lane representations. Rather than assuming the availability of GPU acceleration, the entire processing chain is optimized for low-priced embedded execution. On a 2 GHz ARM in-vehicle processor, the system sustains real-time operation with an average latency of 32.7 ms per frame, without reliance on discrete GPUs, thereby conforming to the cost and power budgets of mass-market ADAS and autonomous delivery platforms.

In contrast to GPU-oriented solutions such as Jetson-class systems, which may consume up to 19 W under high-performance configurations [21], the proposed CPU-only design achieves markedly higher energy efficiency and a reduced bill of materials (BOM). Moreover, quantitative comparison with the representative Sensors study by Kuo et al. [16] demonstrates consistent robustness gains under strong backlighting, low-contrast illumination, heavy rain, and high-curvature road scenarios, while retaining the interpretability and deployment simplicity characteristic of sensor-layer, geometry-based processing.

The main contributions of this work are summarized as follows:

• We propose a Binary Line Segment Filter (BLSF), a lightweight and fully deterministic geometric filtering mechanism that enforces global orientation consistency over line segments, specifically designed for CPU-only embedded platforms.
• We demonstrate that combining median local thresholding with BLSF significantly improves robustness against strong backlighting, low-contrast night scenes, heavy rain, and high-curvature lanes, without relying on learning-based feature extraction.
• We present a complete sensor-layer lane detection pipeline with analyzable worst-case execution time, achieving real-time performance (32.7 ms per frame) on a 2 GHz ARM platform without discrete GPU acceleration.
• We provide extensive quantitative and qualitative comparisons against both classical geometric baselines and representative lightweight deep learning methods on challenging subsets of CULane and LLAMAS, highlighting the trade-offs between robustness, efficiency, and deployability.

In the following section, we detail the proposed geometric pipeline, with particular emphasis on the formulation and rationale of the Binary Line Segment Filter and its integration with classical image processing and curve fitting stages.

2. Proposed Lane Detection Pipeline

As illustrated in Figure 1, the proposed image-based lane detection framework consists of three sequential stages: image preprocessing, lane feature extraction, and lane model fitting. During preprocessing, the input RGB image captured from a frontal camera is transformed into a grayscale bird’s-eye-view representation via inverse perspective mapping, which alleviates perspective distortion and illumination-related artifacts. In the feature extraction stage, lane-related line segments are identified from the grayscale image while suppressing sensor noise and non-lane structures. Finally, the lane model fitting stage reconstructs the underlying lane geometry from the extracted features. The overall objective of the image-sensor-based lane detection is to achieve accurate and real-time lane marking detection under challenging conditions, including high-curvature roads, strong backlighting, low-contrast illumination, and heavy rainfall.

2.1. Image Preprocessing

The nomenclature used throughout this paper is summarized in

Table 2. Nomenclature.

Symbol	Description	Symbol	Description
$(X_w,{ Y}_w,{ Z}_w)$	World coordinate system	$T_1$	Length threshold for valid line segments
$(X_c, Y_c,{ Z}_c)$	Camera coordinate system	$T_L,T_U$	Lower and upper bounds of the adaptive orientation threshold
$h$	Mounting height of the camera above ground	A0, A1, A2	Orientation bins for left-curving, straight, and right-curving lanes
$\mathsf{\alpha }$	Camera pitch angle	$B_k$	Accumulated voting score of orientation bin $A_k$
$\beta$	Camera yaw angle	li	Length of line segment i
$(R_x, R_y)$	Camera offset relative to vehicle center	$\omega$	Estimated lane width in BEV domain
$P_w(X_w, Y_w,-h)$	A point on the ground plane in world coordinates	H	Height of the BEV image
$P_i(u_i,{ v}_i)$	Corresponding point in the image plane	Wd	Width of the sliding window
$P_i(u_i,{ v}_i)$	Grayscale intensity at pixel ${(u}_i,{ v}_i$)	$W_h$	Height of the sliding window
(R,G,B)	Red, green, and blue channels of the BEV image	n	Number of sliding windows
$I(u_i, v_i)$	Processed grayscale image after median local thresholding	$x_L$, $x_R$	Horizontal positions of left and right lane markings
$S_m$	1D median filter window (lane width support region)	(a, b, c)	Quadratic lane model parameters (x = ay2 + by + c)
$T_g$	Intensity threshold for median local thresholding	N	Number of inlier points in RANSAC fitting
${\tau }_i$	Length of the (i)-th line segment	$d_i$	Horizontal distance from point i to the fitted lane curve
${\vartheta }_i$	Orientation angle of the (i)-th line segment	S	Aggregate fitting score in RANSAC
Δy	Longitudinal step between sliding windows in BEV	Wlane	Width of lane marking
Δx	Lateral drift of lane centerline per step	Rmin	Minimum road curvature radius
R	Lateral drift of lane centerline per step	emax	Maximum superelevation rate
M	Lateral capture margin of sliding window	fmax	Maximum side-friction factor

.

The input to the lane detection algorithm is obtained from an onboard image sensor (dash camera) mounted on the vehicle, as illustrated in Figure 2, with the scene described in both world coordinates $(X_w,{ Y}_w, Z_w)$ and camera coordinates $(X_c,{ Y}_c,{ Z}_c)$. To mitigate perspective distortion and facilitate geometric lane analysis, the captured frontal-view image is transformed into a bird’s-eye-view (BEV) representation, in which lane markings appear approximately parallel. Given the camera’s intrinsic parameters, including focal length and optical center, an arbitrary world point $P_w(X_w,Y_w,-h)$ can be mapped to its corresponding image-plane coordinate $P_i(u_i,{ v}_i)$ through standard coordinate transformation.

As shown in Figure 3a,b, the BEV image is subsequently converted into a grayscale representation $I(u_i,{ v}_i)$ to reduce computational complexity [23]. A custom weighted RGB combination is adopted, defined as Equation (1).

$$I=0.5R+0.4G+0.1B$$

(1)

where $R$, $G$, and $B$ denote the red, green, and blue channels of the BEV image, respectively. Unlike conventional luminosity models that heavily prioritize the green channel, this formulation intentionally emphasizes the red and green components while suppressing blue. This channel-weighted formulation amplifies the visibility of white and yellow lane markings, which predominantly manifest higher responses in the red and green channels and comparatively weaker signals in the blue channel, especially under challenging visual conditions such as intense backlighting and low-contrast nighttime illumination [24].

2.2. Lane Feature Extraction

To handle adverse visual conditions such as strong backlighting, nighttime scenes, and heavy rain—where lane markings often appear blurred or degraded—a median local thresholding technique [18] is employed to extract preliminary lane features. The method applies a 1D fast median filter [22] in a row-wise manner to the grayscale BEV image. A pixel is classified as a lane candidate if its intensity exceeds the local median value by a predefined threshold, as expressed by Equation (2).

$$I_m\left(u_i,v_i\right)= \{\begin{array}{c}I\left(u_i,v_i\right) \\ 0\end{array} \begin{array}{c}if I\left(u_i,v_i\right)>median\left(I\left(u_i,S_m\right)\right)+T_g\\ otherwise\end{array}$$

(2)

where $I_m$ denotes the processed grayscale image, $S_m$ represents the 1D neighborhood corresponding to the nominal lane-marking width, and $T_g$ is the threshold parameter.

As illustrated in Figure 4, applying the median local thresholding effectively suppresses irrelevant background structures such as asphalt texture and curbs, while preserving both the intensity contrast and geometric continuity of lane markings. Pixels exceeding the threshold $T_g$ form distinct intensity peaks along each sampled row, providing a reliable representation of lane-marking regions for subsequent processing.

Although the processed grayscale image $I_m$ largely suppresses background noise, it may still contain spurious structures that resemble lane markings in geometry. Such false positives typically originate from pedestrian crossings, road stains, or vertical edges of nearby vehicles. To further refine the extracted features, a line segment detector (LSD) [25] is first applied to obtain an initial set of candidate segments. Based on the detected gradients, the local level-line orientation is computed at each pixel to form a dense level-line field, which is subsequently partitioned into angle-consistent line-support regions, as illustrated in Figure 5a.

Using the detected line segments, the grayscale image in Figure 5b is converted into a binary representation (Figure 5c). The proposed Binary Line Segment Filter (BLSF) then enforces geometric constraints to suppress noise while preserving lane-consistent structures. Specifically, line segments are retained only if they satisfy both a minimum length requirement and an orientation constraint, expressed as Equation (3)

$$Rule:{\tau }_i>T_1 \mathrm{and} T_L\le {\vartheta }_i\le T_U$$

(3)

where ${\tau }_i$ and ${\vartheta }_i$ denote the length and orientation of the $i$-th segment, respectively. The threshold $T_1$ is determined from the segment-length distribution histogram, while $T_L$ and $T_U$ define adaptive angular bounds. As shown in Figure 5d, applying BLSF significantly reduces short, misaligned, and non-lane segments, resulting in a cleaner binary representation that better reflects the underlying lane geometry.

After median local thresholding, candidate lane primitives are obtained using the fast Line Segment Detector (LSD) introduced by von Gioi et al. [25]. Instead of relying on raw intensity values, LSD exploits local gradient coherence to identify elongated structures by grouping neighboring pixels with similar directional responses.

This process implicitly defines a dense orientation map over the BEV image, from which line-segment hypotheses are constructed by aggregating spatially connected regions whose directional dispersion remains below a preset tolerance. To impose global geometric regularity, the proposed BLSF further divides the orientation space into three discrete angle bins, as formulated in Equation (4).

A₀ = [−35°, 0°],     A₁ = [−5°, 5°],     A₂ = [0°, 35°],

(4)

Voting (score accumulation)—Let $S$ denote the collection of line segments extracted from the current frame. For each orientation bin $A_k$, the corresponding score $B_k$ is obtained by summing the segment lengths (or, alternatively, the segment counts) whose orientations lie within that bin:

$$B_k={\sum }_{i\in s}I\left({\theta }_i\in A_k\right)\cdot T_i$$

(5)

In Equation (5), ${\theta }_i$ denotes the orientation of the $i$-th segment, while ${\tau }_i$ represents its voting weight (${\tau }_i=l_i$ for length-weighted voting and ${\tau }_i=1$ for count-based voting). The function $I(\cdot )$ is an indicator function. The dominant geometric orientation is determined by selecting.

This reflects the assumption that lane directions within a region of interest are largely consistent within a single frame.

Based on the orientation bin with the highest score, the corresponding angular band $(T_L,T_U)$ in Equation (6) is adaptively assigned to represent left-curving, near-straight, or right-curving lanes:

$$\left(T_L, T_U\right)=\{\begin{array}{c}(-35°, 0°) if B_0 is max\\ (-5°, 5°) if B_1 is max\\ (0°, 35°) if B_2 is max\end{array}$$

(6)

Line segments whose orientations fall outside the selected angular range are treated as incompatible and discarded. Through this operation, BLSF establishes a global, frame-level geometric consistency across the level-line field prior to applying any segment-specific filtering steps.

To further improve robustness and operational safety, an additional boundary condition is incorporated into the BLSF voting mechanism. When the accumulated scores of all orientation bins ($B_0,B_1,B_2$) remain below a predefined absolute threshold, the frame is regarded as lacking sufficient geometric evidence of lane structure. Rather than enforcing a lane model under such uncertainty, the system reports a no-lane or low-confidence state.

This situation commonly arises in unstructured or poorly marked environments, including gravel roads, construction areas, or road sections without painted lane boundaries, where detected line segments fail to exhibit a consistent global orientation. By explicitly accounting for this condition, the proposed pipeline prevents unreliable lane hypotheses from being generated in the absence of meaningful structure, thereby enhancing safety and reducing the risk of misleading inputs to downstream planning or control modules.

2.3. Geometric Priors of Lane Markings in BEV

The formulation of the Binary Line Segment Filter (BLSF) is based on two key geometric characteristics of lane markings in the bird’s-eye-view (BEV) representation. First, within the control-relevant region of interest (ROI), lane markings predominantly manifest as elongated, quasi-linear structures, giving rise to line segments whose lengths and aspect ratios are markedly larger than those produced by typical background clutter. Second, under a properly calibrated inverse perspective mapping, lane markings in the vicinity of the ego vehicle project to near-vertical structures in the BEV image, with their orientations restricted to a limited angular span around the vertical direction, even in the presence of moderate roadway curvature.

According to the criteria summarized in Equation (6), a line segment is retained only if both its length and orientation fall within threshold ranges derived from BEV histograms. Instead of manually tuning these parameters for each scene, the thresholds $T_1$ and $(T_L,T_U)$ are estimated from a calibration dataset. As demonstrated in Section 3.5, the resulting operating region exhibits strong robustness: perturbing $T_1$ by up to ±2 pixels around its nominal value yields negligible changes in F₁-score, and the dominant orientation bands remain stable under moderate variations in camera height, pitch angle, and field of view. These observations indicate that BLSF is not merely a heuristic rule set, but rather a compact and analyzable representation of BEV lane geometry that can be systematically calibrated and validated.

2.4. Lane Model Fitting

After candidate lane features are obtained, the final processing stage focuses on reconstructing the lane geometry with high accuracy. To initialize the fitting process, we adopt a computationally efficient strategy that combines a Hough-inspired formulation with a sliding-window tracking mechanism. In the bird’s-eye-view (BEV) representation, near-field lane markings project as structures that are largely aligned with the vertical axis. Exploiting this property, we compute a column-wise accumulation of pixel responses in the binary image to localize the horizontal positions of the left and right lane boundaries, denoted by $x_L$ and $x_R$. This accumulation step also provides a coarse estimate of the lane width $w$, as illustrated in Figure 6a.

As illustrated in Figure 6, the proposed lane model fitting proceeds from the extracted lane evidence to a parametric lane representation. Specifically, the algorithm first generates an initial hypothesis from the dominant lane-consistent evidence and then refines it via robust fitting to suppress outliers. This two-step design stabilizes the estimation when the extracted lane pixels are fragmented or partially occluded.

Figure 6a shows the intermediate lane evidence after feature extraction, while Figure 6b depicts the initialization stage that proposes a coarse lane model. Figure 6c presents the refined result after robust fitting, where outlier segments are rejected, and the lane curve parameters are finalized.

Using the detected seed locations, a set of $n$ vertically arranged sliding windows [19] is constructed to progressively track lane markings upward within the region of interest (ROI). As defined in Equation (7), the width $W_d$ and height $W_h$ of each window are adaptively determined based on the estimated lane width $w$ and the image height $H$:

$${(W}_d,W_h)=\left(0.4w,H/n\right)$$

(7)

The first sliding window is initialized at the peak of the column-wise intensity projection near the bottom of the image. For each following window, the horizontal center is adjusted to the mean $\mathrm{x}$-coordinate of the nonzero pixels detected in the previous window (Figure 6b). This iterative adjustment allows the tracker to effectively accommodate lane curvature.

To derive a smooth and compact lane representation, an optimized RANSAC scheme is applied to fit a quadratic model of the form $x=\alpha y^2+\beta y+c$ to the set of pixels collected from all sliding windows. For improved robustness, the candidate pixels are divided into $(n-2)$ vertical subsets, from which samples are randomly selected in each iteration to form hypothesis curves. Each hypothesis is scored by its number of inliers $N$, and the final model is chosen by minimizing the total squared horizontal residual defined in Equation (8).

$$S={\sum }_{i=1}^N{d_i}^2$$

(8)

where $d_i$ denotes the horizontal distance between the $i$-th inlier and the fitted curve. The hypothesis yielding the smallest residual is chosen as the final lane model (Figure 6c). By optimizing horizontal deviations rather than Euclidean distance, the fitting process explicitly aligns with the BEV geometry, where lateral accuracy is more critical for vehicle control than longitudinal error.

2.5. Handling Violations of the Global Geometric Prior

Although the proposed Binary Line Segment Filter (BLSF) enforces a global geometric prior that assumes approximate perpendicularity of lane markings in the BEV domain, this assumption may be violated in scenarios involving sharp road curvature. To address this limitation, the proposed system adopts a sliding-window tracking mechanism that operates at a local scale.

Specifically, instead of enforcing global orientation consistency over the entire frame, the sliding window restricts geometric reasoning to a limited spatial region. Within such a local window, even highly curved lanes can be well approximated by short, quasi-linear segments whose orientations remain approximately vertical with respect to the window’s local coordinate system. This locality allows the system to relax the global prior while preserving sufficient geometric structure for reliable tracking.

As the sliding window advances along the road direction, lane curvature is captured progressively through a sequence of locally consistent estimates, effectively decomposing a global curve into multiple locally linear segments. This design enables the proposed method to maintain robustness under high-curvature conditions without resorting to complex curve models or learning-based adaptation.

The effectiveness of this local handling strategy is validated by the experimental results on the “High Curvature” subset, where the proposed system achieves a correct detection rate of 98.8%. These results demonstrate that, although the global geometric prior has a well-defined applicability range, its combination with local sliding-window tracking provides practical robustness against prior violations encountered in real-world driving scenarios.

Geometric Dynamics of the Sliding Window Under Variable Curvature

A key concern is whether a fixed-size sliding window may lag behind or lose the lane marking when the road curvature changes rapidly (e.g., continuous S-curves). Our tracking scheme operates in the BEV domain and updates the window center based on the centroid of detected lane pixels within each window. This implicitly assumes local linearity over a short longitudinal step, which can be justified by bounding the maximum lateral drift of a lane centerline over one window step.

Equation (9) shows that the step between consecutive windows is Δy (approximately the window height in BEV), and let the lane centerline locally follow a circular arc of radius R. The lateral deviation Δx of the arc from its tangent over the step Δy can be approximated by the circular sagitta:

$$\Delta x=R-\sqrt{R^2-{\left({\Delta }_y\right)}^2}$$

(9)

Define the capture margin M as the half-width of the effective search region after accounting for lane-mark thickness W_lane in Equation (10)

$$M={\displaystyle \frac{w_d-w_{lane}}{2}}$$

(10)

where W_d is the window width. A tracking loss can only occur if the lateral drift per step exceeds the capture margin, i.e., Δx > M.

To connect the bound with roadway design constraints, note that legal road geometries constrain the minimum curvature radius at a given design speed. Under standard highway geometric design (e.g., AASHTO), the minimum curve radius can be expressed as Equation (11):

$${\displaystyle \frac{{\left(\Delta y\right)}^2}{2R_{min}}}\le M$$

(11)

where V is the vehicle speed, e_max is the maximum superelevation rate, and f_max is the maximum side-friction factor.

In a high-speed scenario (typical highway design), R_min is on the order of several hundred meters; substituting Δy ≈ 1 m yields Δx on the order of millimeters, far below a typical margin M (centimeters). Even in sharp low-speed urban turns (tens of meters radius), Δx per meter remains at the centimeter level and stays well within the capture margin of our adaptive window width. Therefore, explicit dynamic resizing of the window is unnecessary in practice: the local linear approximation remains valid over each step, and the fixed-window tracker remains mathematically bounded from drifting out of the search region, provided the window is initialized near the lane marking.

3. Experimental Verification

3.1. Failure Modes and Dataset Description

3.1.1. Stress-Test Corpus Versus Benchmark-Scale Validation

We clarify that the self-collected 297-frame set is not used as a training corpus (our pipeline is non-learning and does not fit model parameters from data). Instead, it is curated as a stress-test corpus that intentionally concentrates extreme failure modes (e.g., strong backlighting/glare, wet-road reflections, low-contrast dusk, and high-frequency shadow patterns) to probe worst-case behavior and identify operational boundaries. This role is fundamentally different from that of a learning-based dataset, where diversity is required primarily for generalization through parameter fitting. For a deterministic geometric pipeline, the stress-test corpus is used to validate robustness under adversarial sensing conditions and to motivate conservative “fail-safe” behaviors when the evidence is insufficient.

3.1.2. “Ordinary but Complex” Illumination: Dappled Sunlight and Dusk

Dappled sunlight (tree shadows) produces high-frequency, locally strong contrast changes that can generate short, fragmented edge responses. In our pipeline, these fragments are suppressed by structural consistency rather than being “learned away”: (i) the line-segment extraction yields many short segments with inconsistent orientations; (ii) the orientation-bin voting mechanism concentrates evidence only when a dominant lane-consistent direction exists; and (iii) segments outside the selected dominant band are rejected by the binary line-segment filter. As a result, shadow-induced segments are treated as outliers that do not accumulate stable votes across the ROI.

Dusk and low-contrast night primarily reduce global illumination while preserving local contrast between lane paint and asphalt within a neighborhood. We therefore adopt median local thresholding (MLT), which determines the binarization threshold from local pixel statistics rather than a global threshold. As long as a local contrast gap remains within each neighborhood, the lane-marking region remains detectable, and the subsequent geometric filtering further removes spurious responses. This provides predictable behavior under gradual illumination changes without requiring retraining or domain adaptation.

Lane detection methods reported in the literature are widely recognized to degrade under adverse visual and geometric conditions, including sharp road curvature, intense backlighting, low-contrast nighttime scenes, and heavy rainfall. High-curvature roads induce pronounced geometric variation in lane shape, while strong backlighting—such as at tunnel exits—or insufficient nighttime illumination substantially diminishes the contrast between lane markings and the pavement. These effects are further compounded by heavy rain, which introduces reflections, water streaks, and stochastic noise, leading to severe visual degradation and unreliable feature extraction.

To specifically evaluate performance under such conditions, we construct a self-collected dataset comprising 297 frames captured by a forward-facing dash camera mounted on a test vehicle operating in urban and suburban environments. Instead of sampling nominal driving scenarios, data collection deliberately targets four well-known failure modes of lane detection systems: strong backlighting (e.g., tunnel exits and low sun angles), low-contrast night scenes (including fog-like or weak illumination), heavy rain, and high-curvature lanes. Frames are extracted from continuous driving sequences when the vehicle enters these conditions, and near-duplicate frames are removed to mitigate temporal correlation. Ground-truth lane annotations are manually produced in the BEV domain by two independent annotators, with inconsistencies resolved through joint review.

The resulting dataset is intended to reflect realistic yet challenging operating regimes for entry-level ADAS platforms equipped with dashcam-class image sensors. Owing to privacy considerations involving identifiable vehicles and pedestrians, the raw video data cannot be released publicly at this time. However, anonymized BEV image crops along with the corresponding annotation tools will be made available upon acceptance to support reproducibility.

Robustness is first assessed on the 297 challenging frames, with results reported alongside 95% confidence intervals to account for the limited sample size. To further evaluate generalization beyond this targeted stress-test set, additional experiments are conducted on subsets of large-scale public benchmarks, including CULane [26] and LLAMAS [27], which together comprise approximately 100,042 images. In particular, the Dazzling Light and Night subsets—containing 12,370 annotated frames—are selected, as they represent the most visually demanding conditions within these benchmarks.

It is important to note that large-scale driving datasets typically follow a long-tail distribution, where the vast majority of samples correspond to nominal conditions such as straight roads, clear weather, and standard illumination. Consequently, a model achieving high average accuracy on such datasets may still fail catastrophically in rare but safety-critical scenarios. For example, dazzling glare or low-contrast night scenes are often severely underrepresented in general training and evaluation sets.

The 297-frame dataset used in this study should therefore not be interpreted as a random sample of everyday driving. Instead, it constitutes a targeted stress corpus curated to maximize the density of known failure modes. This philosophy is analogous to Accelerated Life Testing (ALT) in reliability engineering, where systems are exposed to extreme operating conditions to determine failure boundaries, rather than evaluated under prolonged nominal operation. From this perspective, validating on 297 frames of pure Heavy Rain provides greater statistical insight into that specific Operational Design Domain (ODD) than validating on thousands of generic highway frames in which rain occurs only sporadically.

To quantify statistical uncertainty under the limited sample size, performance is reported with 95% confidence intervals computed using the Wilson score interval rather than the standard Wald approximation. The Wald interval is known to be unreliable for small $n$ or extreme proportions, whereas the Wilson interval provides well-calibrated coverage under such conditions.

For the proposed method, an observed accuracy of 95.0% on $n=297$ frames yields a 95% Wilson confidence interval of approximately [91.9%, 97.0%].

$$p\pm z\sqrt{p(1-p)/n}$$

(12)

Equation (12) is well known to be inaccurate for small sample sizes or when the estimated probability approaches 0 or 1, often producing overly optimistic or even invalid bounds.

Instead, we adopt the Wilson Score Interval, a statistically robust method derived by inverting the score test for a binomial proportion, which exhibits excellent coverage properties even for small sample sizes.

The Wilson interval limits $(w^{-},w^{+})$ are given in Equation (13).

$$w^{\pm }=\frac{\widehat{p}+\frac{z^2}{2n}\pm z\sqrt{\frac{\widehat{p}(1-\widehat{p})}{n}+\frac{z^2}{4n^2}}}{1+\frac{z^2}{n}}$$

(13)

where $\widehat{p}$ denotes the observed success proportion, $n$ is the number of samples, and $z$ corresponds to the standard normal quantile for the desired confidence level (for 95%, $z\approx 1.96$).

Substituting $n=297$, $\widehat{p}=0.95$, and $z^2=3.8416$, the resulting 95% Wilson confidence interval is approximately in Equation (14).

$$[w^{-},w^{+}]\approx [91.9\%,97.0\%]$$

(14)

The lower bound of this interval (91.9%) represents the worst-case performance consistent with the observed data at a 95% confidence level. Even under this conservative bound, the performance remains substantially higher than that of the baseline geometric method reported by Kuo et al. [16], who achieved approximately 36% accuracy in low-contrast night scenes and 19% accuracy under high-curvature conditions. This corresponds to a performance margin of more than 55 percentage points. Consistent performance improvements are observed across both the targeted stress-test dataset and large-scale public benchmarks, suggesting that the observed gains associated with the proposed BLSF are not specific to a single dataset size or composition.

To further characterize statistical uncertainty across different adverse conditions, we report condition-wise performance together with 95% confidence intervals computed using the Wilson score method.

Table 3. Statistical confidence of stress-test results (Wilson Score Interval). The lower bound of the Wilson interval consistently exceeds the baseline performance, providing statistical certainty of improvement despite the small sample size.

Condition	Frames (n)	Successes	$\mathbf{Accuracy} \left(\widehat{\mathit{p}}\right)$	95% Wilson Interval (w±)	Baseline Accuracy [16]
High Curvature	85	84	98.8%	[93.6%, 99.8%]	19%
Heavy Rain	60	57	95.0%	[86.3%, 98.3%]	17%
Strong Backlight	72	67	93.1%	[84.7%, 97.0%]	3%
Low Contrast Night	80	74	92.5%	[84.6%, 96.5%]	36%
Total Stress Test	297	282	95.0%	[91.9%, 97.0%]	<30%

provides a statistically reliable summary of performance dispersion under small-sample stress-test settings and enables a direct comparison with baseline methods.

In addition to point estimates, we report 95% confidence intervals for the binomial correct-rate using the Wilson score method, which is more reliable than the Wald approximation for moderate sample sizes and proportions close to 0 or 1. Over the 297-frame stress-test set, the proposed pipeline achieves an overall correct rate of 95.0% (282/297), with a 95% Wilson confidence interval of [91.9%, 97.0%]. Table 3 summarizes the per-condition intervals together with the corresponding baseline accuracies.

Table 3 indicates that the lower bounds of the Wilson intervals remain substantially higher than the reported baseline accuracies across all four adverse conditions, supporting the statistical robustness of the observed improvements on the stress-test set.

3.2. Quantitative Validation and Statistical Confidence

Statistical Confirmation on Large-Scale Benchmarks

To complement the stress-test corpus and address concerns regarding “ordinary but complex” scenarios, we additionally evaluate BLSF on benchmark-scale datasets that contain orders of magnitude more frames and diverse everyday driving conditions. In particular, CULane and LLAMAS collectively provide large-scale coverage across road materials, traffic density, illumination transitions, and seasonal variations. We focus on challenging subsets relevant to this study (e.g., dazzling light and night conditions) and compare BLSF with representative baselines under the same BEV preprocessing and evaluation protocol.

Across these benchmark subsets, BLSF consistently improves the F1 score by approximately 6–7% over the baseline, indicating that the gain is not an artifact of the small stress-test set. We further report 95% Wilson score confidence intervals to quantify statistical reliability under the evaluated sample sizes. This benchmark confirmation should be interpreted as deployment validation for a deterministic pipeline (rather than “generalization through training”), demonstrating that the first-principles geometric priors and bounded filtering stages remain effective under wide-ranging ordinary road conditions.

Under identical preprocessing and parameter configurations ($S_{\mathrm{m}}=9$, $T_{\mathrm{g}}=15$, $T_1=17$), the proposed BLSF attains an average F₁-score of 0.861 with an IoU of 0.792 on the Dazzling Light subset, and an F₁-score of 0.847 with an IoU of 0.774 on Night scenes. In contrast, the baseline line-segment-based pipeline without BLSF achieves F₁-scores of 0.801 and 0.776 on the respective subsets. This corresponds to absolute gains of +6.0% under Dazzling Light and +7.1% under Night conditions, demonstrating the effectiveness of BLSF in suppressing reflections and low-contrast noise while preserving lane continuity.

All reported metrics are accompanied by 95% Wilson score confidence intervals (±0.013 and ±0.016 for F₁ on the two subsets), providing statistical assurance despite dataset variability. These results indicate that the proposed geometry-based filtering strategy maintains robust and consistent performance across large-scale and diverse conditions in the CULane and LLAMAS benchmarks, supporting its generalization capability beyond the self-collected stress-test scenarios.

3.3. Computational Complexity and Runtime Analysis

From a computational standpoint, the proposed pipeline operates in linear time with respect to the number of BEV pixels within the ROI. Given a BEV resolution of $W\times H$, both inverse perspective mapping and grayscale conversion involve a single pass over the image.

The median local thresholding stage adopts a one-dimensional sliding median filter of size $S_m$, which supports amortized constant-time updates. As a result, its total runtime increases linearly with the image resolution.

Line-segment extraction based on the LSD algorithm operates on image gradients and level-line structures and empirically scales linearly with the pixel count for the compact ROI considered in this study. The Binary Line Segment Filter (BLSF) introduces only lightweight processing, consisting of orientation histogram voting and threshold-based filtering, and therefore adds negligible overhead relative to segment detection. The simplified Hough transform further performs column-wise accumulations in $\mathcal{O}\left(WH\right)$, while both the sliding-window tracking and the subsequent RANSAC-based lane fitting scale linearly with the number of candidate lane pixels. Overall, each stage of the pipeline maintains linear complexity, supporting real-time execution on resource-constrained embedded platforms.

To better characterize the runtime behavior,

Table 4. Stage-wise runtime breakdown of the proposed BLSF pipeline on a 2 GHz ARM CPU platform.

Processing Stage	Avg. Time (ms)	Percentage (%)
IPM + Grayscale	4.1	12.5%
Median Local Threshold (MLT)	6.3	19.3%
LSD	9.8	30.0%
BLSF (Voting + Filtering)	2.1	6.4%
Hough + Sliding Window	4.6	14.1%
RANSAC Fitting	5.8	17.7%
Total	32.7	100%

reports a stage-wise breakdown of the average processing time on the target platform. The results show that line-segment detection and robust fitting dominate the computational cost, whereas the proposed BLSF accounts for less than 7% of the total runtime. This indicates that the robustness improvement introduced by BLSF is achieved with minimal additional computational burden.

Static Memory Footprint and Cache-Resident Execution

Beyond average runtime, embedded CPU-only deployment requires predictable memory behavior and bounded latency. The proposed BLSF is implemented with a static-memory design: all core buffers (binary ROI mask, window accumulators, line-segment lists, and voting histograms) are pre-allocated, and the per-frame processing avoids dynamic memory allocation. This design eliminates allocator jitter and reduces the risk of latency spikes due to heap fragmentation, which is critical for real-time safety monitoring.

Moreover, the most frequently accessed data structures are intentionally kept compact (e.g., a small number of angle bins and fixed-size counters for voting), enabling cache-resident execution on typical ARM Cortex-A class platforms. Since the voting and filtering stages primarily perform sequential scans over short line-segment arrays and small histograms, the memory access pattern is streaming-friendly and exhibits low cache-miss rates compared to convolution-heavy inference pipelines. These architectural choices align with the deterministic behavior emphasized by BLSF: predictable execution time, explainable intermediate states, and stable performance under tight power envelopes.

In summary, the overall computational cost of the proposed pipeline scales linearly with the BEV image size, i.e., $\mathcal{O}\left(WH\right)$, with a relatively small constant overhead. On a CPU-only platform equipped with a 2 GHz ARM processor, the complete pipeline processes a $225\times 300$ BEV region in an average of 32.7 ms per frame across the 297-frame adverse-condition dataset, corresponding to a throughput of approximately 30 frames per second. All timing results are obtained using a single-threaded implementation, which leaves ample computational margin for additional perception or control modules on multi-core ARM system-on-chips.

Because the pipeline is dominated by lightweight integer operations and localized memory accesses, its execution characteristics align well with ARM Cortex-A microarchitectures. As a result, comparable performance behavior can be expected across different Cortex-A variants, with end-to-end latency scaling approximately linearly with processor clock frequency.

Table 5. Comparative efficiency profile (CPU vs. GPU).

Metric	Proposed Geometric Pipeline (BLSF)	SOTA Deep Learning (e.g., UFLD/ResNet18)
Platform	ARM Cortex-A (CPU Only)	NVIDIA Jetson/Discrete GPU
Compute Paradigm	Integer Logic & Histograms	Float-32 Matrix Multiplication (GEMM)
Power Envelope	<2 Watts	10–20 Watts
Memory Usage	<5 MB (LUTs + Line Buffers)	>50 MB (Weights + Feature Maps)
Inference Latency	32.7 ms (Deterministic)	8.4 ms (GPU)/>150 ms (CPU)
Safety Certifiability	High (White-Box/Auditable)	Low (Black-Box/Stochastic)

compares the proposed geometric lane-detection pipeline with representative deep-learning-based approaches from an efficiency and deployability perspective. Unlike GPU-centric deep networks that rely on floating-point matrix multiplication and large feature maps, the proposed method is implemented on a CPU-only ARM platform using integer logic, histograms, and fixed-size buffers, resulting in a compact memory footprint (<5 MB) and a power envelope below 2 W. Although deep models achieve lower per-frame latency on GPUs, their advantage diminishes on CPU-only systems and comes at the cost of significantly higher power consumption and memory usage. More importantly, the proposed pipeline exhibits deterministic execution time and a white-box structure with explicitly bounded control flow, which facilitates timing analysis and functional-safety certification, whereas deep learning approaches remain largely black-box and stochastic. This comparison underscores that the proposed method prioritizes predictability, energy efficiency, and safety certifiability over peak throughput, making it well-suited for SWaP-constrained and safety-critical embedded applications.

3.4. Experimental Setup and Image Preprocessing

The experimental platform employs a forward-facing image sensor (dash camera) mounted on a test vehicle, providing a 140° field of view (FOV) and operating at 30 frames per second. To limit computational cost, a compact region of interest (ROI) is selected from the input image with a resolution of 320 × 240 pixels. The ROI spans 319 pixels in width and 85 pixels in height, with its top-left corner located at (0, 12.5), as illustrated in Figure 3a.

The cropped frontal-view image is first warped into a bird’s-eye-view (BEV) domain of resolution $225\times 300$ pixels using inverse perspective mapping, where lane markings become approximately parallel to each other (Figure 3b). To improve robustness across varying lane appearances—including discontinuous, white, and yellow markings—the BEV image is then transformed into a grayscale representation via the weighted channel formulation in Equation (1).

Line segments are subsequently extracted using the fast Line Segment Detector (LSD) introduced by von Gioi et al. [25]. A uniform parameter setting is adopted for all experiments (e.g., scale = 0.8 and ${\sigma }_{\mathrm{s}\mathrm{c}\mathrm{a}\mathrm{l}\mathrm{e}}=0.6$), and no dataset-dependent tuning is performed, ensuring consistent and unbiased evaluation conditions.

3.5. Lane Feature Extraction and Parameter Optimization

The BEV grayscale image is first processed using a 1-D fast median filter with window size $S_m$ to suppress intensity noise. The value of $S_m$ is selected based on the physical width of lane markings in the BEV domain rather than empirical tuning. Using camera calibration and inverse perspective mapping, the expected lane-mark width is approximately ${\overline{\omega }}_{px}=8.6$ pixels, leading to the choice of the nearest odd integer, $S_m=9$.

To validate the parameter choice, an ablation study was performed by varying the median window size $S_{\mathrm{m}}\in \{\mathrm{5,7},\mathrm{9,11,13}\}$. The resulting detection metrics (IoU and F₁-score) exhibit a clear unimodal pattern, with peak performance attained at $S_{\mathrm{m}}=9$. This value provides the most favorable balance between suppressing background noise and preserving lane-marking structure. A Friedman test further confirms that the performance differences across window sizes are statistically significant ($p<0.01$), with $S_{\mathrm{m}}=9$ consistently ranked as the optimal setting.

The local threshold parameter $T_g$ in Equation (2) is tuned using Particle Swarm Optimization (PSO) and Differential Evolution (DE) on a held-out validation set. Both optimization methods converge to a stable solution near $T_g=15$, and performance remains largely unchanged within a tolerance of ±1, indicating low sensitivity around the optimum. Following median local thresholding, a line segment detector is employed to extract candidate geometric features, after which the proposed Binary Line Segment Filter (BLSF) applies additional geometric constraints to suppress spurious responses. An examination of the segment-length distribution reveals that the majority of noise-induced segments are shorter than 17 pixels; accordingly, a minimum length threshold of $T_1=17$ is selected for use in Equation (3).

3.6. Sensitivity Analysis and Geometric Filtering

Although the nominal value $T_1=17$ was initially selected through empirical observation, its robustness was subsequently examined via global sensitivity analysis (GSA). The parameter $T_1$ was systematically swept over the range of 10 to 25 pixels, and the corresponding F₁-scores were evaluated across the dataset. A Sobol-based variance decomposition was then applied to quantify the influence of $T_1$ on the output metrics. Results show that when $T_1$ remains within ±2 pixels of 17, its total-effect sensitivity index contributes less than 5% of the overall variance in F₁-score, indicating a stable and well-conditioned operating region. In contrast, noticeable performance degradation occurs for $T_1<15$, where noise suppression becomes insufficient, and for $T_1>19$, where excessive smoothing removes valid lane features. The peak mean F₁-score is achieved at $T_1=17$, confirming this value as an effective balance between noise rejection and geometric continuity.

Based on the resulting orientation histogram, each detected line segment is assigned to its corresponding angular region, and the region with the highest accumulated score is used to determine the adaptive orientation thresholds in Equation (6).

Figure 7 illustrates how the adaptive orientation band used in the Binary Line Segment Filter (BLSF) is determined from the line-segment angle histogram in the BEV domain. In a left-curving scenario (Figure 7a), the lane-consistent segments concentrate within a dominant band (approximately −35° to 0°), while isolated peaks outside this band correspond to spurious responses (e.g., curb edges, shadows, or glare-induced artifacts). In a straight-lane scenario (Figure 7b), the dominant band narrows to approximately −5° to 5°. Based on the accumulated voting score over orientation bins, the dominant band is selected to define the acceptance range, and line segments whose orientations fall outside this band are rejected before lane model fitting. This global, histogram-driven gating effectively suppresses abnormal-slope segments under challenging illumination and low-contrast conditions, improving the stability of the subsequent sliding-window tracking and robust curve fitting (see Figure 6b,c).

4. Performance Evaluation

For qualitative comparison, the bird’s-eye-view (BEV) ground-truth (GT) lane masks corresponding to the representative examples in Figure 8 are additionally provided to enable a clearer visual assessment. As shown in Figure 8, the proposed method consistently yields more accurate lane-feature extraction under challenging scenarios, including high-curvature roads, strong backlighting, low-contrast nighttime scenes, and heavy rain.

Previous approaches, such as those by Duong et al. [12] and Xu et al. [14], enhance extraction performance by exploiting intensity differences between lane markings and the road surface. However, their results often retain background structures—such as curbs and road textures—that are geometrically similar to lane markings. Kuo et al. [16] adopt a global intensity-based thresholding strategy to preserve bright lane features, but relying solely on intensity information makes their method particularly vulnerable to noise with comparable brightness levels, especially under strong backlighting. In contrast, the proposed approach jointly incorporates intensity cues and geometric constraints, including segment width, length, and orientation. This combined strategy effectively suppresses non-lane structures while preserving lane continuity, resulting in more reliable lane-feature extraction across diverse adverse conditions.

To quantitatively assess lane detection performance, this study adopts the correct detection rate metric commonly used in prior work [28]. Considering that real-world lane markings occupy a finite physical width, two criteria are applied when determining correctness. First, a detected lane is regarded as correct if more than half of the predicted lane pixels fall within the annotated lane-marking width of the manually labeled ground truth. Second, in scenarios where no lane marking is present, the algorithm is required to produce no lane prediction. These guidelines ensure a fair and practical evaluation of detection accuracy under realistic road conditions. The proposed lane detection algorithm is evaluated under four representative and challenging conditions—high-curvature roads, strong backlighting, low-contrast nighttime scenes, and heavy rain—with quantitative results summarized in

Table 6. Comparison of lane detection correctness rates (%) for the proposed method with and without the Binary Line Segment Filter (BLSF), and the reference approach reported by Kuo et al. [16], under four challenging conditions.

Condition	With BLSF	Without BLSF	[16]
High curvature	99%	97%	19%
Strong backlighting	93%	89%	3%
Low contrast night	92%	92%	36%
Heavy rain	95%	78%	17%

Note: Bold values are used to indicate the highest correctness rate within each condition for readability.

. Without the Binary Line Segment Filter (BLSF), the correct detection rates reach 97%, 89%, 92%, and 78% for the four scenarios, respectively. After incorporating BLSF, performance improves to 99% under high curvature, 93% under strong backlighting, 92% at night, and 95% in heavy rain. The most pronounced gain is observed in rainy conditions, where geometric filtering effectively suppresses reflections and spurious noise. The remaining single-digit failure cases are primarily attributed to fitting inaccuracies at far distances; however, these errors have minimal practical impact, as downstream control decisions predominantly rely on near-field lane estimates.

Table 6 further compares the proposed approach with the method reported in [16], showing a consistently higher correct detection rate across all challenging scenarios. As illustrated in Figure 8, the approach in [16] is particularly sensitive to noise under strong backlighting, whereas the proposed method maintains stable performance by jointly leveraging intensity cues and geometric constraints during lane feature extraction. On the self-collected dataset of 297 challenging frames, the average processing time on an onboard 2 GHz ARM CPU is approximately 32.7 ms per frame, satisfying real-time requirements. The evaluation is further extended to the CULane benchmark [26], focusing on the Dazzling Light and Night subsets comprising 12,370 annotated frames. Under identical parameter settings ($S_m=9$, $T_g=15$, $T_1=17$), the proposed method achieves mean F₁-scores of approximately 0.83 and 0.81, with corresponding IoUs of about 0.76 and 0.73, respectively, outperforming the baseline by more than 6%. Collectively, these results demonstrate that the proposed algorithm is both efficient and robust under adverse lane conditions.

Lane-keeping is not only a requirement for passenger vehicles, but also a foundational capability for autonomous last-mile delivery platforms that operate under stringent power and cost budgets. Motivated by this application context, Section 5 explores the deployment implications of the proposed CPU-only pipeline for autonomous logistics and mobile robotic systems.

To remain consistent with common evaluation protocols in lane-detection research, additional metrics—including precision, recall, F₁-score, Intersection over Union (IoU), and processing speed in frames per second (FPS)—are also reported on selected subsets of the CULane [26] and LLAMAS [27] benchmarks.

4.1. Discussion of the Effect of Removing BLSF

Beyond the reported quantitative gains, it is instructive to examine the underlying causes of performance degradation when the Binary Line Segment Filter (BLSF) is omitted. In the absence of BLSF, lane feature extraction depends primarily on the Line Segment Detector (LSD) combined with simple length-based pruning. Under adverse visual conditions—such as intense backlighting, nighttime scenes with wet road surfaces, or heavy rainfall—this configuration becomes vulnerable to numerous false detections. In particular, LSD tends to extract elongated segments arising from specular reflections, water streaks, curb edges, and other high-gradient structures on the road surface, many of which exhibit lengths comparable to true lane markings. Noise-induced line segments may exhibit lengths comparable to true lane markings, rendering simple length-based suppression ineffective. Consequently, elongated reflective artifacts can survive early filtering stages and propagate into subsequent lane model fitting, where they introduce erroneous hypotheses and destabilize lane estimates.

The key contribution of BLSF is the incorporation of a global geometric voting strategy. Rather than evaluating line segments in isolation, BLSF establishes a frame-level consensus by aggregating orientation-consistent evidence from all detected segments. Segments aligned with the dominant global orientation are preserved, while visually prominent yet geometrically inconsistent artifacts are systematically discarded.

This global geometric enforcement accounts for the observed performance gain of approximately 7% in F₁-score and correct detection rate when BLSF is applied, particularly under challenging illumination and weather conditions. Importantly, the improvement does not stem from additional ad hoc rules, but from a principled lane-level consistency constraint that cannot be realized through purely local or segment-wise filtering approaches.

In addition to the representative geometry-based approach by Kuo et al. [16], we include two classical geometric baselines to provide a more comprehensive comparison. First, a line-segment-based pipeline using the standard Line Segment Detector (LSD) without the proposed BLSF is evaluated, which effectively represents an edge/segment detection + geometric fitting baseline commonly used in traditional lane-detection systems. Second, the simplified Hough transform-based sliding-window tracker is employed as part of the shared fitting stage, allowing us to isolate the contribution of BLSF from the downstream model fitting.

To address recent lightweight approaches, we further compare against two CPU-executable deep learning models, ENet-SAD and UFLD, re-implemented under the same BEV resolution and without GPU acceleration. These models are selected because they are among the most computationally efficient lane-detection networks reported in the literature and represent a realistic upper bound for CPU-only deployment.

As summarized in

Table 7. Quantitative evaluation on the Dazzling Light and Night subsets of the CULane and LLAMAS benchmarks. All approaches are tested using an identical bird’s-eye-view (BEV) resolution and region of interest (ROI). The proposed BLSF-based pipeline is compared with a representative geometry-driven method [16], an ablation variant without BLSF (LSD only), and two lightweight learning-based models, UFLD [5] and ENet-SAD [15]. To ensure a fair assessment for embedded deployment, all methods are executed under the same CPU-only configuration on a 2 GHz ARM platform, without relying on discrete GPU acceleration.

Method	Backbone Type	Dazzling Light (F1/IoU)	Night (F1/IoU)	FPS (CPU)	Power Efficiency
BLSF (Ours)	Geometric (Edge/Segment + Hough)	0.861/0.792	0.847/0.774	30.6	High
Baseline (No BLSF)	Geometric (Edge/Segment)	0.801/0.776	0.776/0.731	29.2	High
Kuo et al. [16]	Geometric (Grid-based)	0.654/0.582	0.698/0.610	28.5	High
UFLD [5]	DL (ResNet-18)	0.872/0.805	0.855/0.781	8.4	Low
ENet-SAD [15]	DL (ENet)	0.841/0.763	0.832/0.755	14.1	Medium

Note: Bold values are used to highlight the highest value within each column for ease of comparison.

, incorporating BLSF consistently yields higher F1-scores and IoU than the ablation baseline based solely on line-segment detection, indicating that the introduced geometric priors are effective in mitigating reflective artifacts and low-contrast noise. When evaluated against lightweight learning-based approaches—specifically Ultra-Fast Lane Detection (UFLD) [5] and ENet-SAD [15]—re-implemented with the same BEV resolution and executed under CPU-only constraints, the proposed method attains comparable accuracy on the Dazzling Light and Night subsets, while delivering substantially higher frame rates and deterministic worst-case execution behavior on the target ARM platform.

Although deep learning models accelerated by GPUs can achieve strong accuracy on server-class systems, such performance does not directly carry over to CPU-only embedded environments. On general-purpose ARM processors, convolution-intensive networks are limited by memory bandwidth and the absence of specialized acceleration units, resulting in increased latency from repeated convolution operations and feature-map memory accesses.

By contrast, the BLSF pipeline is dominated by lightweight and predictable computations, including integer-based accumulation and comparison during global geometric voting, along with a modest amount of floating-point processing in the RANSAC fitting stage. These operations exhibit favorable cache locality and align well with ARM Cortex-A microarchitectures. This architectural compatibility explains why the proposed approach sustains real-time performance with deterministic execution characteristics on a 2 GHz ARM CPU, while maintaining robust accuracy under adverse illumination without reliance on GPU acceleration.

4.2. Quantification of the Failure Boundary of the Geometric Prior

To further clarify the limitations of the proposed Binary Line Segment Filter (BLSF), this section quantifies the failure boundary of the underlying geometric prior. BLSF enforces a global orientation consensus in the bird’s-eye-view (BEV) domain by discretizing line-segment orientations into bins with a tolerance of ±35°. This threshold determines the maximum curvature that can be accommodated before the global geometric assumption becomes invalid.

Based on a simplified geometric relationship between road curvature and local orientation variation, the minimum supported radius of curvature $R_{\mathrm{m}\mathrm{i}\mathrm{n}}$ can be approximated as Equation (15).

$$R_{\mathrm{m}\mathrm{i}\mathrm{n}}\approx {\displaystyle \frac{L}{\theta }}$$

(15)

where $L$ denotes the look-ahead distance, and $\theta$ represents the allowable angular deviation in radians. With $L=40$ meters and $\theta = 35° \approx 0.61$ rad, the resulting minimum curvature radius is approximately $R_{\mathrm{m}\mathrm{i}\mathrm{n}}\approx 65$ meters.

This theoretical bound indicates that the proposed geometric prior comfortably covers the vast majority of highway and urban arterial road designs, where curvature radii typically exceed 150 m. For such scenarios, the dominant lane orientation remains sufficiently consistent within the BEV domain, allowing BLSF to reliably suppress geometrically inconsistent noise while preserving true lane markings.

It is important to note that this bound characterizes the global applicability of the geometric prior. In extreme cases, such as sharp hairpin turns, 90-degree intersections, or highly unstructured road layouts, the global orientation consensus may be violated. However, as discussed in Section 2.4, the sliding-window tracking strategy operates locally, enabling the system to follow curved lanes progressively as long as the local orientation variation within each window remains moderate.

By explicitly quantifying this failure boundary, we emphasize that the robustness of BLSF is not unbounded, but grounded in a well-defined geometric operating range. This clarification avoids overgeneralization while reinforcing the practical relevance of the proposed method for real-world highway and urban driving scenarios.

5. Application in Autonomous Logistics

5.1. Enabling Sustainable Last-Mile Delivery

In addition to passenger vehicles, reliable lane-keeping capability is increasingly critical for autonomous last-mile delivery robots and vehicles. Recent techno-economic analyses and user studies indicate that a wide range of autonomous delivery platforms—including sidewalk robots and compact delivery vans—have the potential to lower logistics costs and reduce environmental impact relative to human-operated delivery, particularly in dense urban settings [29,30]. Owing to their reliance on battery power and strict cost constraints, such platforms typically adopt lightweight sensing configurations and modest onboard computing resources.

Within this deployment context, the proposed geometry-based BLSF pipeline offers a practical perception solution for entry-level autonomous delivery systems. By operating entirely on a CPU and avoiding the power and cost overhead associated with GPU-driven deep-learning pipelines, the method achieves robust lane-following performance even under adverse illumination conditions. As summarized in Table 6, the proposed approach maintains high correctness rates under strong backlighting (93%), low-contrast nighttime scenes (92%), and heavy rain (95%), whereas a representative classical baseline exhibits substantial degradation under the same conditions (e.g., 36% correctness at night) [16]. These results directly align with the continuous-operation requirements emphasized in last-mile delivery studies, where dependable nighttime performance is essential for extending service availability and maximizing fleet utilization [29,30].

5.2. Overcoming Infrastructure and Regulatory Barriers

Studies on autonomous delivery robots (ADRs) emphasize that large-scale deployment is limited not only by algorithmic accuracy but also by factors such as infrastructure readiness, regulatory frameworks, and societal acceptance [30]. In real-world settings, urban environments cannot be assumed to undergo rapid modification to accommodate robotic platforms; consequently, perception systems must remain effective on roads and sidewalks with worn, intermittent, or partially occluded markings.

The proposed BLSF pipeline is explicitly designed to operate under such imperfect conditions. Instead of relying on dense, pixel-level predictions, it integrates sparse line-segment evidence through global geometric voting and subsequent model fitting, allowing fragmented lane markings to be connected while rejecting artifacts introduced by glare or noise. In addition, the decision-making process is governed by physically interpretable parameters—such as segment length, orientation consistency, and voting confidence—which improves transparency. This interpretability facilitates failure diagnosis and supports engineering verification activities required in safety-critical deployments, thereby addressing the regulatory and public-acceptance challenges highlighted in [30].

5.3. Integration with 5PL and Digital-Twin Logistics Ecosystems

Looking ahead, last-mile logistics is gradually shifting toward multi-agent and multi-modal operational paradigms, in which robots, drones, and human-driven vehicles are jointly managed through cloud-based scheduling and optimization platforms. Within such ecosystems, communication bandwidth limitations and end-to-end latency emerge as critical practical constraints.

Since the proposed pipeline operates entirely at the edge, autonomous delivery robots can execute perception locally and communicate only compact, high-level semantic information—such as lane-center deviation, confidence or quality indicators, and detected hazards—rather than transmitting raw image streams to cloud servers. This edge-centric architecture substantially reduces network load and latency, while enhancing responsiveness and robustness. As a result, the proposed approach is well positioned to serve as a lightweight perception component within future fifth-party logistics (5PL) coordination systems and digital-twin-based monitoring and optimization frameworks.

6. Limitations and Future Work

6.1. Environmental Scope and Visual Complexity

Although the proposed BLSF-based pipeline exhibits strong robustness under multiple adverse conditions, the current evaluation is primarily conducted on structured road environments with clearly painted lane markings. Scenarios involving unstructured roads—such as rural paths without markings, complex urban intersections, or road segments containing dense textual symbols (e.g., “STOP” or “HOV”)—are not yet included. In such cases, the geometric assumptions underlying BLSF may no longer hold, which can adversely affect performance.

Furthermore, while higher-resolution CCD/CMOS sensors provide richer visual detail, the increased data volume poses challenges for real-time processing on embedded hardware. Although the proposed binary line segment filtering strategy remains computationally efficient and well-suited to low-cost image sensors, complex textual patterns and visually cluttered road surfaces remain difficult cases and merit further study.

6.2. Benchmark Coverage and Parameter Adaptation

The experimental comparison in this work focuses on representative geometry-based and line-segment-based baselines. However, evaluations against modern lightweight learning-based approaches remain limited. A broader assessment across additional public datasets, benchmark suites, and heterogeneous embedded platforms—including GPU-enabled systems and dedicated AI accelerators—would offer deeper insight into the trade-offs among accuracy, efficiency, and robustness.

In addition, the current implementation relies on a fixed set of parameters obtained from an offline calibration dataset. While sensitivity analysis indicates a stable operating range, enabling online or adaptive parameter adjustment in response to changing road conditions, illumination, and weather remains an important direction for future development.

6.3. Hybrid Architectures and Safety-Oriented Integration

Future ADAS designs are unlikely to rely solely on either purely geometric methods or fully learning-based models. Instead, a hybrid architecture is expected to emerge, in which data-driven perception modules handle complex semantic understanding, while deterministic algorithms—such as BLSF—serve as real-time safety monitors within a dedicated safety island.

Beyond its role in lane-following perception, the proposed BLSF pipeline is well-suited to function as a fallback or supervisory component in autonomous logistics and last-mile delivery systems. Its deterministic execution, interpretable decision criteria, and explicitly characterized failure modes enable predictable behavior that is difficult to guarantee with end-to-end learning approaches alone. The bounded operating conditions identified in Section 4.2 and Section 2.4 allow the system to report degraded confidence when geometric assumptions are violated, enabling higher-level planners to initiate conservative actions, request human oversight, or cross-check learning-based outputs.

6.4. Future Directions and System Integration Outlook

Future work will focus on several directions: (i) extending experimental validation to more diverse datasets and driving scenarios, including unstructured and mixed urban environments; (ii) exploring hybrid pipelines that integrate BLSF-style geometric filtering with lightweight neural networks, for example by using BLSF as a pre-filter or safety-monitoring layer; and (iii) investigating formal verification and worst-case timing analysis under ISO 26262 to further strengthen suitability for safety-critical embedded deployment.

From a system integration perspective, BLSF can be encapsulated as a ROS 2 Lifecycle Node with deterministic state transitions and controlled parameter updates. Within an Autoware-style architecture, it may operate as a deterministic “safety guardian” that validates or constrains lane-related decisions when visual evidence becomes unreliable. Full-stack integration and closed-loop evaluation are left for future work, with the proposed interface definition provided as a reproducible foundation.

7. Conclusions

This study presents a robust and deterministic lane detection pipeline specifically engineered for CPU-only embedded systems. By integrating a novel Binary Line Segment Filter (BLSF) with classical geometric constraints, the system achieves a reliable balance between computational frugality and environmental robustness.

The key conclusions of this work are summarized as follows:

• Algorithmic Efficiency: The pipeline achieves an average processing time of 32.7 ms per frame on a 2 GHz ARM processor. This real-time performance is achieved without GPU acceleration, significantly reducing the power envelope and hardware cost for mass-market ADAS deployment.
• Robustness in Extreme Conditions: Experimental results demonstrate that the BLSF effectively suppresses sensor noise and environmental interference. Compared to previous geometric approaches [16], the proposed method shows superior stability under challenging scenarios, including strong backlighting, heavy rain, and low-contrast night scenes, maintaining an average correct detection rate of 95%.
• Determinism and Explainability: Unlike “black-box” deep learning models, our purely geometric approach offers mathematical transparency and predictable execution time, which are essential for achieving higher Automotive Safety Integrity Levels (ASIL) and formal safety certification.
• Balanced Design: The study confirms that for resource-constrained platforms, the integration of well-motivated geometric priors can recover significant robustness typically associated with heavy convolutional backbones, without the associated hardware overhead.

Future Work: Despite the high performance in marked environments, the current system’s reliance on clear geometric priors poses limitations on unmarked roads and extremely high-curvature urban intersections. Future research will focus on:

• Exploring hybrid architectures that combine lightweight temporal tracking with BLSF to handle intermittent markings.
• Evaluating the pipeline’s performance across a broader range of ARM-based architectures and sensor mounting configurations to further validate its cross-platform generalizability.
• Developing adaptive thresholding mechanisms to better handle the transition between urban canyons and open highways.