Add progress bar support and new lane detection methods

Co-authored-by: kr4phy <168257476+kr4phy@users.noreply.github.com>

app.py

@@ -3,10 +3,10 @@ import tempfile
 from lane_detection import process_video as process_video_file
 
 
-def process_video(video_path, method, use_enhanced, use_segmented):
+def process_video(video_path, method, use_enhanced, use_segmented, progress=gr.Progress()):
     """
     Process the uploaded video and return side-by-side comparison.
-    Wrapper function for Gradio interface.
+    Wrapper function for Gradio interface with progress tracking.
     """
     if video_path is None:
         return None
@@ -16,8 +16,12 @@ def process_video(video_path, method, use_enhanced, use_segmented):
     output_path = temp_output.name
     temp_output.close()
 
-    # Process the video with selected method
-    success = process_video_file(video_path, output_path, method, use_enhanced, use_segmented)
+    # Progress callback function
+    def update_progress(value, desc):
+        progress(value, desc=desc)
+
+    # Process the video with selected method and progress callback
+    success = process_video_file(video_path, output_path, method, use_enhanced, use_segmented, progress_callback=update_progress)
 
     if success:
         return output_path
@@ -28,7 +32,7 @@ def process_video(video_path, method, use_enhanced, use_segmented):
 # Create Gradio interface
 with gr.Blocks(title="Lane Detection Demo") as demo:
     gr.Markdown("# 🚗 OpenCV Lane Detection Demo")
-    gr.Markdown("Upload a video to detect lane lines. Choose between basic and advanced methods.")
+    gr.Markdown("Upload a video to detect lane lines. Choose between multiple advanced methods.")
 
     with gr.Row():
         with gr.Column():
@@ -36,10 +40,17 @@ with gr.Blocks(title="Lane Detection Demo") as demo:
 
             with gr.Row():
                 method_selector = gr.Radio(
-                    choices=["basic", "advanced"],
+                    choices=[
+                        "basic_standard",
+                        "basic_segmented", 
+                        "advanced",
+                        "yolop",
+                        "ufld",
+                        "scnn"
+                    ],
                     value="advanced",
                     label="Detection Method",
-                    info="Basic: Fast Hough Transform | Advanced: Accurate polynomial fitting"
+                    info="Select lane detection algorithm"
                 )
 
             enhanced_checkbox = gr.Checkbox(
@@ -64,7 +75,7 @@ with gr.Blocks(title="Lane Detection Demo") as demo:
     # Update checkbox visibility based on method
     def update_checkboxes(method):
         enhanced_visible = (method == "advanced")
-        segmented_visible = (method == "basic")
+        segmented_visible = (method in ["basic_standard", "basic_segmented"])
         return gr.Checkbox(visible=enhanced_visible), gr.Checkbox(visible=segmented_visible)
 
     method_selector.change(
@@ -82,31 +93,63 @@ with gr.Blocks(title="Lane Detection Demo") as demo:
     gr.Markdown("""
     ### Detection Methods:
 
-    **🔹 Basic Method (Hough Transform):**
+    **🔹 Basic Standard (Hough Transform):**
     - Fast and lightweight
     - Good for straight lanes
-    - **New: Segmented Mode** - Draws multiple line segments for better curve representation
-    - Lower accuracy on sharp curves and dashed lines
+    - Uses single averaged line per lane
+    - Fastest processing speed
+
+    **🔹 Basic Segmented (Hough Transform):**
+    - Fast processing
+    - Multiple line segments for better curve representation
+    - Good for moderately curved lanes
+    - Better than basic for curves
 
-    **🔹 Advanced Method (Perspective Transform + Polynomial):**
+    **🔹 Advanced (Perspective Transform + Polynomial):**
     - Perspective transform to bird's eye view
     - Polynomial fitting with sliding windows
     - Excellent for curved and dashed lanes
-    - **Enhanced mode** uses CLAHE and gradient direction filtering for best accuracy
+    - Enhanced mode uses CLAHE and gradient filtering
+    - Best accuracy but slower
+
+    **🔹 YOLOP (Multi-task Learning):**
+    - Inspired by YOLOP (You Only Look Once for Panoptic Driving)
+    - Multi-color lane detection (white and yellow)
+    - Contour-based segmentation
+    - Good for various lane colors
+    - Fast with good accuracy
+
+    **🔹 UFLD (Ultra Fast Lane Detection):**
+    - Inspired by Ultra Fast Structure-aware Deep Lane Detection
+    - Row-wise classification approach
+    - Adaptive thresholding with CLAHE
+    - Excellent balance of speed and accuracy
+    - Real-time capable
+
+    **🔹 SCNN (Spatial CNN):**
+    - Inspired by Spatial CNN for traffic lane detection
+    - Spatial message passing in four directions
+    - Multi-scale edge detection
+    - Best for complex scenarios
+    - High accuracy for challenging conditions
 
     ### How it works:
     1. Upload a video file containing road scenes
-    2. Select detection method and options:
-       - For **Basic**: Enable "Segmented Lines" for curves
-       - For **Advanced**: Enable "Enhanced Thresholding" for better accuracy
-    3. Click "Process Video" button
+    2. Select detection method:
+       - For fastest: Use **Basic Standard**
+       - For curves: Use **Basic Segmented**, **UFLD**, or **Advanced**
+       - For best accuracy: Use **SCNN** or **Advanced + Enhanced**
+       - For multi-color lanes: Use **YOLOP**
+    3. Click "Process Video" button and monitor the progress bar
     4. The system will process each frame and create a side-by-side comparison
     5. Download the result video showing original and detected lanes
 
     ### Tips:
-    - Use **Basic + Segmented** for fastest processing with decent curve handling
-    - Use **Advanced + Enhanced** for best accuracy but slower processing
-    - Adjust based on your video quality and road conditions
+    - **Basic Standard/Segmented**: Fastest, good for straight or gentle curves
+    - **YOLOP**: Best for detecting both white and yellow lanes
+    - **UFLD**: Excellent balance of speed and accuracy
+    - **Advanced + Enhanced**: Best for dashed and curved lanes
+    - **SCNN**: Best overall accuracy for complex road conditions
     """)
 
 

lane_detection.py

@@ -527,19 +527,376 @@ def draw_poly_lines(img, binary_warped, left_fit, right_fit, Minv):
     return result
 
 
+def process_frame_yolop(frame):
+    """
+    YOLOP-inspired lane detection method.
+    Simulates multi-task learning approach with semantic segmentation.
+    Uses enhanced color-based segmentation with adaptive thresholding.
+    """
+    height, width = frame.shape[:2]
+    
+    # Convert to HLS for better color segmentation
+    hls = cv2.cvtColor(frame, cv2.COLOR_BGR2HLS)
+    h_channel = hls[:, :, 0]
+    l_channel = hls[:, :, 1]
+    s_channel = hls[:, :, 2]
+    
+    # Multi-threshold approach for different lane colors
+    # White lanes - high lightness
+    white_mask = cv2.inRange(l_channel, 200, 255)
+    
+    # Yellow lanes - specific hue range
+    yellow_mask = cv2.inRange(h_channel, 15, 35) & cv2.inRange(s_channel, 80, 255)
+    
+    # Combine masks
+    color_mask = cv2.bitwise_or(white_mask, yellow_mask)
+    
+    # Apply morphological operations
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (5, 5))
+    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_CLOSE, kernel)
+    color_mask = cv2.morphologyEx(color_mask, cv2.MORPH_OPEN, kernel)
+    
+    # Apply ROI
+    vertices = np.array([[
+        (int(width * 0.1), height),
+        (int(width * 0.45), int(height * 0.6)),
+        (int(width * 0.55), int(height * 0.6)),
+        (int(width * 0.9), height)
+    ]], dtype=np.int32)
+    
+    color_mask = region_of_interest(color_mask, vertices)
+    
+    # Find contours for lane segments
+    contours, _ = cv2.findContours(color_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    
+    # Create output image
+    result = frame.copy()
+    overlay = np.zeros_like(frame)
+    
+    # Separate left and right lane contours
+    left_contours = []
+    right_contours = []
+    
+    midpoint = width // 2
+    for contour in contours:
+        if cv2.contourArea(contour) > 100:
+            M = cv2.moments(contour)
+            if M["m00"] != 0:
+                cx = int(M["m10"] / M["m00"])
+                if cx < midpoint:
+                    left_contours.append(contour)
+                else:
+                    right_contours.append(contour)
+    
+    # Draw lane regions
+    if len(left_contours) > 0 or len(right_contours) > 0:
+        # Fill lane area
+        if len(left_contours) > 0 and len(right_contours) > 0:
+            # Get bounding points
+            left_points = np.vstack(left_contours).squeeze()
+            right_points = np.vstack(right_contours).squeeze()
+            
+            if len(left_points.shape) == 2 and len(right_points.shape) == 2:
+                # Sort by y coordinate
+                left_points = left_points[left_points[:, 1].argsort()]
+                right_points = right_points[right_points[:, 1].argsort()]
+                
+                # Create polygon
+                poly_points = np.vstack([left_points, right_points[::-1]])
+                cv2.fillPoly(overlay, [poly_points], (0, 255, 0))
+        
+        # Draw lane lines
+        for contour in left_contours:
+            cv2.drawContours(overlay, [contour], -1, (0, 0, 255), 5)
+        for contour in right_contours:
+            cv2.drawContours(overlay, [contour], -1, (0, 0, 255), 5)
+    
+    # Blend with original
+    result = cv2.addWeighted(result, 0.8, overlay, 0.5, 0)
+    
+    return result
+
+
+def process_frame_ufld(frame):
+    """
+    UFLD-inspired (Ultra Fast Lane Detection) method.
+    Uses row-wise classification approach with efficient feature extraction.
+    Focuses on speed and accuracy for real-time applications.
+    """
+    height, width = frame.shape[:2]
+    
+    # Convert to grayscale
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    
+    # Apply CLAHE for enhanced contrast
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
+    enhanced = clahe.apply(gray)
+    
+    # Apply bilateral filter to preserve edges while reducing noise
+    filtered = cv2.bilateralFilter(enhanced, 9, 75, 75)
+    
+    # Adaptive thresholding
+    binary = cv2.adaptiveThreshold(
+        filtered, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+        cv2.THRESH_BINARY, 11, 2
+    )
+    
+    # Apply ROI
+    vertices = np.array([[
+        (int(width * 0.1), height),
+        (int(width * 0.45), int(height * 0.6)),
+        (int(width * 0.55), int(height * 0.6)),
+        (int(width * 0.9), height)
+    ]], dtype=np.int32)
+    
+    binary = region_of_interest(binary, vertices)
+    
+    # Row-wise lane point detection
+    row_samples = 18  # Number of rows to sample
+    row_step = height // row_samples
+    
+    left_lane_points = []
+    right_lane_points = []
+    
+    midpoint = width // 2
+    
+    for i in range(row_samples):
+        y = height - i * row_step - row_step // 2
+        if y < int(height * 0.6):
+            continue
+            
+        row = binary[y, :]
+        
+        # Find peaks in left and right halves
+        left_half = row[:midpoint]
+        right_half = row[midpoint:]
+        
+        # Find lane positions
+        left_peaks = np.where(left_half > 200)[0]
+        right_peaks = np.where(right_half > 200)[0]
+        
+        if len(left_peaks) > 0:
+            # Use the rightmost peak in left half
+            x = left_peaks[-1]
+            left_lane_points.append([x, y])
+        
+        if len(right_peaks) > 0:
+            # Use the leftmost peak in right half
+            x = midpoint + right_peaks[0]
+            right_lane_points.append([x, y])
+    
+    # Create result image
+    result = frame.copy()
+    overlay = np.zeros_like(frame)
+    
+    # Fit curves to lane points
+    if len(left_lane_points) >= 3:
+        left_lane_points = np.array(left_lane_points)
+        left_fit = np.polyfit(left_lane_points[:, 1], left_lane_points[:, 0], 2)
+        
+        # Generate smooth curve
+        ploty = np.linspace(int(height * 0.6), height, 100)
+        left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2]
+        left_fitx = np.clip(left_fitx, 0, width - 1)
+        
+        left_curve = np.array([np.transpose(np.vstack([left_fitx, ploty]))], dtype=np.int32)
+        cv2.polylines(overlay, left_curve, False, (0, 0, 255), 8)
+    
+    if len(right_lane_points) >= 3:
+        right_lane_points = np.array(right_lane_points)
+        right_fit = np.polyfit(right_lane_points[:, 1], right_lane_points[:, 0], 2)
+        
+        # Generate smooth curve
+        ploty = np.linspace(int(height * 0.6), height, 100)
+        right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2]
+        right_fitx = np.clip(right_fitx, 0, width - 1)
+        
+        right_curve = np.array([np.transpose(np.vstack([right_fitx, ploty]))], dtype=np.int32)
+        cv2.polylines(overlay, right_curve, False, (0, 0, 255), 8)
+    
+    # Fill lane area
+    if len(left_lane_points) >= 3 and len(right_lane_points) >= 3:
+        ploty = np.linspace(int(height * 0.6), height, 100)
+        left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2]
+        right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2]
+        
+        left_fitx = np.clip(left_fitx, 0, width - 1)
+        right_fitx = np.clip(right_fitx, 0, width - 1)
+        
+        pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])
+        pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])
+        pts = np.hstack((pts_left, pts_right))
+        
+        cv2.fillPoly(overlay, np.int32([pts]), (0, 255, 0))
+    
+    # Blend
+    result = cv2.addWeighted(result, 0.8, overlay, 0.5, 0)
+    
+    return result
+
+
+def process_frame_scnn(frame):
+    """
+    SCNN-inspired (Spatial CNN) method.
+    Uses spatial message passing for lane detection.
+    Implements slice-by-slice convolutions in four directions.
+    """
+    height, width = frame.shape[:2]
+    
+    # Preprocessing
+    hls = cv2.cvtColor(frame, cv2.COLOR_BGR2HLS)
+    l_channel = hls[:, :, 1]
+    s_channel = hls[:, :, 2]
+    
+    # Enhanced preprocessing with CLAHE
+    clahe = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8, 8))
+    l_enhanced = clahe.apply(l_channel)
+    
+    # Multi-scale edge detection
+    sobel_x = cv2.Sobel(l_enhanced, cv2.CV_64F, 1, 0, ksize=5)
+    sobel_y = cv2.Sobel(l_enhanced, cv2.CV_64F, 0, 1, ksize=5)
+    
+    # Gradient magnitude and direction
+    magnitude = np.sqrt(sobel_x**2 + sobel_y**2)
+    magnitude = np.uint8(255 * magnitude / np.max(magnitude))
+    
+    direction = np.arctan2(sobel_y, sobel_x)
+    
+    # Focus on near-vertical edges (lane lines)
+    vertical_mask = np.zeros_like(magnitude)
+    vertical_mask[(np.abs(direction) > 0.6) & (np.abs(direction) < 1.5)] = 255
+    
+    # Combine with color thresholding
+    s_binary = cv2.inRange(s_channel, 90, 255)
+    l_binary = cv2.inRange(l_enhanced, 180, 255)
+    
+    combined = cv2.bitwise_or(s_binary, l_binary)
+    combined = cv2.bitwise_and(combined, magnitude)
+    combined = cv2.bitwise_and(combined, vertical_mask)
+    
+    # Simulate spatial message passing with directional filtering
+    # Horizontal message passing (left-to-right and right-to-left)
+    kernel_h = np.ones((1, 15), np.uint8)
+    horizontal_pass = cv2.morphologyEx(combined, cv2.MORPH_CLOSE, kernel_h)
+    
+    # Vertical message passing (top-to-bottom and bottom-to-top)
+    kernel_v = np.ones((15, 1), np.uint8)
+    spatial_features = cv2.morphologyEx(horizontal_pass, cv2.MORPH_CLOSE, kernel_v)
+    
+    # Apply ROI
+    vertices = np.array([[
+        (int(width * 0.1), height),
+        (int(width * 0.45), int(height * 0.6)),
+        (int(width * 0.55), int(height * 0.6)),
+        (int(width * 0.9), height)
+    ]], dtype=np.int32)
+    
+    spatial_features = region_of_interest(spatial_features, vertices)
+    
+    # Lane fitting with sliding window
+    histogram = np.sum(spatial_features[spatial_features.shape[0]//2:, :], axis=0)
+    midpoint = len(histogram) // 2
+    
+    leftx_base = np.argmax(histogram[:midpoint])
+    rightx_base = np.argmax(histogram[midpoint:]) + midpoint
+    
+    # Sliding window parameters
+    nwindows = 12
+    window_height = spatial_features.shape[0] // nwindows
+    margin = 80
+    minpix = 40
+    
+    nonzero = spatial_features.nonzero()
+    nonzeroy = np.array(nonzero[0])
+    nonzerox = np.array(nonzero[1])
+    
+    leftx_current = leftx_base
+    rightx_current = rightx_base
+    
+    left_lane_inds = []
+    right_lane_inds = []
+    
+    for window in range(nwindows):
+        win_y_low = spatial_features.shape[0] - (window + 1) * window_height
+        win_y_high = spatial_features.shape[0] - window * window_height
+        
+        win_xleft_low = leftx_current - margin
+        win_xleft_high = leftx_current + margin
+        win_xright_low = rightx_current - margin
+        win_xright_high = rightx_current + margin
+        
+        good_left_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
+                         (nonzerox >= win_xleft_low) & (nonzerox < win_xleft_high)).nonzero()[0]
+        good_right_inds = ((nonzeroy >= win_y_low) & (nonzeroy < win_y_high) &
+                          (nonzerox >= win_xright_low) & (nonzerox < win_xright_high)).nonzero()[0]
+        
+        left_lane_inds.append(good_left_inds)
+        right_lane_inds.append(good_right_inds)
+        
+        if len(good_left_inds) > minpix:
+            leftx_current = int(np.mean(nonzerox[good_left_inds]))
+        if len(good_right_inds) > minpix:
+            rightx_current = int(np.mean(nonzerox[good_right_inds]))
+    
+    left_lane_inds = np.concatenate(left_lane_inds)
+    right_lane_inds = np.concatenate(right_lane_inds)
+    
+    leftx = nonzerox[left_lane_inds]
+    lefty = nonzeroy[left_lane_inds]
+    rightx = nonzerox[right_lane_inds]
+    righty = nonzeroy[right_lane_inds]
+    
+    result = frame.copy()
+    overlay = np.zeros_like(frame)
+    
+    if len(leftx) > 0 and len(rightx) > 0:
+        left_fit = np.polyfit(lefty, leftx, 2)
+        right_fit = np.polyfit(righty, rightx, 2)
+        
+        ploty = np.linspace(0, spatial_features.shape[0] - 1, spatial_features.shape[0])
+        left_fitx = left_fit[0] * ploty**2 + left_fit[1] * ploty + left_fit[2]
+        right_fitx = right_fit[0] * ploty**2 + right_fit[1] * ploty + right_fit[2]
+        
+        left_fitx = np.clip(left_fitx, 0, width - 1)
+        right_fitx = np.clip(right_fitx, 0, width - 1)
+        
+        # Draw lane area
+        pts_left = np.array([np.transpose(np.vstack([left_fitx, ploty]))])
+        pts_right = np.array([np.flipud(np.transpose(np.vstack([right_fitx, ploty])))])
+        pts = np.hstack((pts_left, pts_right))
+        
+        cv2.fillPoly(overlay, np.int32([pts]), (0, 255, 0))
+        
+        # Draw lane lines
+        cv2.polylines(overlay, np.int32([pts_left]), False, (0, 0, 255), 12)
+        cv2.polylines(overlay, np.int32([pts_right]), False, (0, 0, 255), 12)
+    
+    result = cv2.addWeighted(result, 0.8, overlay, 0.5, 0)
+    
+    return result
+
+
 def process_frame(frame, method="advanced", use_enhanced=True, use_segmented=False):
     """
     Process a single frame for lane detection.
-    method: "basic" or "advanced"
+    method: "basic", "basic_segmented", "advanced", "yolop", "ufld", "scnn"
     use_enhanced: Use enhanced thresholding for better accuracy (advanced method only)
     use_segmented: Use segmented lines for curve representation (basic method only)
     """
-    if method == "basic":
-        return process_frame_basic(frame, use_segmented)
+    if method == "basic" or method == "basic_standard":
+        return process_frame_basic(frame, use_segmented=False)
+    elif method == "basic_segmented":
+        return process_frame_basic(frame, use_segmented=True)
     elif method == "advanced":
         return process_frame_advanced(frame, use_enhanced)
+    elif method == "yolop":
+        return process_frame_yolop(frame)
+    elif method == "ufld":
+        return process_frame_ufld(frame)
+    elif method == "scnn":
+        return process_frame_scnn(frame)
     else:
-        raise ValueError(f"Unknown method: {method}. Use 'basic' or 'advanced'")
+        raise ValueError(f"Unknown method: {method}. Use 'basic', 'basic_segmented', 'advanced', 'yolop', 'ufld', or 'scnn'")
 
 
 def process_frame_advanced(frame, use_enhanced=True):
@@ -565,12 +922,13 @@ def process_frame_advanced(frame, use_enhanced=True):
     return result
 
 
-def process_video(input_path, output_path, method="advanced", use_enhanced=True, use_segmented=False):
+def process_video(input_path, output_path, method="advanced", use_enhanced=True, use_segmented=False, progress_callback=None):
     """
     Process the video and create side-by-side comparison.
-    method: "basic" or "advanced"
+    method: "basic", "basic_segmented", "advanced", "yolop", "ufld", "scnn"
     use_enhanced: Use enhanced thresholding for better accuracy (advanced method only)
     use_segmented: Use segmented lines for curve representation (basic method only)
+    progress_callback: Optional callback function to report progress (value between 0 and 1)
     Returns True if successful, False otherwise.
     """
     # Open the video
@@ -586,8 +944,8 @@ def process_video(input_path, output_path, method="advanced", use_enhanced=True,
     total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
 
     # Video writer for output (side-by-side, so width is doubled)
-    # Use H264 codec for better web browser compatibility
-    fourcc = cv2.VideoWriter_fourcc(*'avc1')
+    # Use mp4v codec for better compatibility
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
     out = cv2.VideoWriter(output_path, fourcc, fps, (width * 2, height))
 
     frame_count = 0
@@ -615,7 +973,10 @@ def process_video(input_path, output_path, method="advanced", use_enhanced=True,
         frame_count += 1
 
         # Progress indicator
-        if frame_count % 30 == 0:
+        if progress_callback and frame_count % 10 == 0:
+            progress = frame_count / total_frames if total_frames > 0 else 0
+            progress_callback(progress, f"Processing frame {frame_count}/{total_frames}")
+        elif frame_count % 30 == 0:
             progress = (frame_count / total_frames) * 100 if total_frames > 0 else 0
             print(f"Progress: {frame_count}/{total_frames} frames ({progress:.1f}%)")
 
@@ -623,6 +984,9 @@ def process_video(input_path, output_path, method="advanced", use_enhanced=True,
     cap.release()
     out.release()
 
+    if progress_callback:
+        progress_callback(1.0, "Completed!")
+
     print(f"✓ Completed! Processed {frame_count} frames using {method} method.")
 
     return frame_count > 0