Enhance lane detection functionality with method selection and GPU support

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+    "configurations": [
+        {
+            "name": "Python 디버거: 현재 파일",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        }
+    ]
+}

app.py

@@ -3,22 +3,22 @@ import tempfile
 from lane_detection import process_video as process_video_file
 
 
-def process_video(video_path):
+def process_video(video_path, method, use_enhanced, use_segmented):
     """
     Process the uploaded video and return side-by-side comparison.
     Wrapper function for Gradio interface.
     """
     if video_path is None:
         return None
-    
+
     # Create temporary output file
     temp_output = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
     output_path = temp_output.name
     temp_output.close()
-    
-    # Process the video
-    success = process_video_file(video_path, output_path)
-    
+
+    # Process the video with selected method
+    success = process_video_file(video_path, output_path, method, use_enhanced, use_segmented)
+
     if success:
         return output_path
     else:
@@ -28,34 +28,85 @@ def process_video(video_path):
 # 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. The result will show the original video on the left and the lane-detected video on the right.")
-    
+    gr.Markdown("Upload a video to detect lane lines. Choose between basic and advanced methods.")
+
     with gr.Row():
         with gr.Column():
             video_input = gr.Video(label="Upload Video")
+
+            with gr.Row():
+                method_selector = gr.Radio(
+                    choices=["basic", "advanced"],
+                    value="advanced",
+                    label="Detection Method",
+                    info="Basic: Fast Hough Transform | Advanced: Accurate polynomial fitting"
+                )
+
+            enhanced_checkbox = gr.Checkbox(
+                value=True,
+                label="Enhanced Thresholding",
+                info="Better accuracy but slightly slower (Advanced method only)",
+                visible=True
+            )
+
+            segmented_checkbox = gr.Checkbox(
+                value=False,
+                label="Segmented Lines",
+                info="Multiple segments for better curve representation (Basic method only)",
+                visible=False
+            )
+
             process_btn = gr.Button("Process Video", variant="primary")
-        
+
         with gr.Column():
             video_output = gr.Video(label="Result (Original | Lane Detection)")
-    
+
+    # Update checkbox visibility based on method
+    def update_checkboxes(method):
+        enhanced_visible = (method == "advanced")
+        segmented_visible = (method == "basic")
+        return gr.Checkbox(visible=enhanced_visible), gr.Checkbox(visible=segmented_visible)
+
+    method_selector.change(
+        fn=update_checkboxes,
+        inputs=method_selector,
+        outputs=[enhanced_checkbox, segmented_checkbox]
+    )
+
     process_btn.click(
         fn=process_video,
-        inputs=video_input,
+        inputs=[video_input, method_selector, enhanced_checkbox, segmented_checkbox],
         outputs=video_output
     )
-    
+
     gr.Markdown("""
+    ### Detection Methods:
+
+    **🔹 Basic Method (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
+
+    **🔹 Advanced Method (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
+
     ### How it works:
     1. Upload a video file containing road scenes
-    2. Click "Process Video" button
-    3. The system will:
-       - Convert frames to grayscale
-       - Apply Gaussian blur to reduce noise
-       - Use Canny edge detection to find edges
-       - Apply region of interest (ROI) mask to focus on the road
-       - Use Hough transform to detect lane lines
-       - Draw detected lanes on the original video
-    4. View the side-by-side comparison result
+    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
+    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
     """)
 
 

cli.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
 Command-line interface for lane detection
-Usage: python cli.py <input_video> <output_video>
+Usage: python cli.py <input_video> <output_video> [method] [enhanced] [segmented]
 """
 import sys
 import os
@@ -9,31 +9,53 @@ from lane_detection import process_video
 
 
 def main():
-    if len(sys.argv) != 3:
-        print("Usage: python cli.py <input_video> <output_video>")
-        print("\nExample:")
+    if len(sys.argv) < 3 or len(sys.argv) > 6:
+        print("Usage: python cli.py <input_video> <output_video> [method] [enhanced] [segmented]")
+        print("\nArguments:")
+        print("  input_video: Path to input video file")
+        print("  output_video: Path to output video file")
+        print("  method: 'basic' or 'advanced' (default: advanced)")
+        print("  enhanced: 'true' or 'false' for enhanced thresholding (default: true, advanced only)")
+        print("  segmented: 'true' or 'false' for segmented lines (default: false, basic only)")
+        print("\nExamples:")
         print("  python cli.py road_video.mp4 output_result.mp4")
+        print("  python cli.py road_video.mp4 output_result.mp4 basic")
+        print("  python cli.py road_video.mp4 output_result.mp4 basic false true")
+        print("  python cli.py road_video.mp4 output_result.mp4 advanced true false")
         sys.exit(1)
-    
+
     input_path = sys.argv[1]
     output_path = sys.argv[2]
-    
+    method = sys.argv[3] if len(sys.argv) >= 4 else "advanced"
+    enhanced = sys.argv[4].lower() == "true" if len(sys.argv) >= 5 else True
+    segmented = sys.argv[5].lower() == "true" if len(sys.argv) >= 6 else False
+
+    # Validate method
+    if method not in ["basic", "advanced"]:
+        print(f"Error: Invalid method '{method}'. Use 'basic' or 'advanced'")
+        sys.exit(1)
+
     # Check if input file exists
     if not os.path.exists(input_path):
         print(f"Error: Input file '{input_path}' not found!")
         sys.exit(1)
-    
+
     print(f"Processing video: {input_path}")
     print(f"Output will be saved to: {output_path}")
+    print(f"Method: {method}")
+    if method == "advanced":
+        print(f"Enhanced thresholding: {'enabled' if enhanced else 'disabled'}")
+    if method == "basic":
+        print(f"Segmented lines: {'enabled' if segmented else 'disabled'}")
     print("\nProcessing...")
-    
+
     try:
-        success = process_video(input_path, output_path)
-        
+        success = process_video(input_path, output_path, method, enhanced, segmented)
+
         if success:
             print("\n✓ Video processing completed successfully!")
             print(f"✓ Result saved to: {output_path}")
-            
+
             if os.path.exists(output_path):
                 size = os.path.getsize(output_path)
                 print(f"✓ File size: {size:,} bytes")

lane_detection.py

@@ -1,10 +1,26 @@
 """
 Lane detection module using OpenCV
+Advanced lane detection with multiple methods and GPU acceleration.
 This module contains the core lane detection logic without UI dependencies.
 """
 import cv2
 import numpy as np
 
+# GPU acceleration setup - prioritize NVIDIA GPU
+USE_GPU = False
+GPU_TYPE = "none"
+try:
+    if cv2.cuda.getCudaEnabledDeviceCount() > 0:
+        USE_GPU = True
+        GPU_TYPE = "nvidia"
+        cv2.cuda.setDevice(0)  # Use first GPU
+        print(f"✓ NVIDIA CUDA enabled! Using GPU acceleration on device: {cv2.cuda.printShortCudaDeviceInfo(cv2.cuda.getDevice())}")
+    else:
+        print("ℹ CUDA not available. Using CPU.")
+except Exception as e:
+    print(f"ℹ GPU acceleration not available: {e}. Using CPU.")
+    GPU_TYPE = "none"
+
 
 def region_of_interest(img, vertices):
     """
@@ -16,61 +32,61 @@ def region_of_interest(img, vertices):
     return masked_image
 
 
-def draw_lines(img, lines, color=[0, 255, 0], thickness=3):
+def draw_lines_basic(img, lines, color=[0, 255, 0], thickness=3):
     """
-    Draw lines on the image with filled lane area.
+    Draw lines on the image with filled lane area (Basic method).
     - Lane lines: Red color
     - Lane interior: Green semi-transparent fill
     """
     if lines is None:
         return img
-    
+
     line_img = np.zeros_like(img)
-    
+
     # Separate left and right lane lines
     left_lines = []
     right_lines = []
-    
+
     for line in lines:
         x1, y1, x2, y2 = line[0]
         if x2 == x1:
             continue
         slope = (y2 - y1) / (x2 - x1)
-        
+
         # Filter by slope to separate left and right lanes
         if slope < -0.5:  # Left lane (negative slope)
             left_lines.append(line[0])
         elif slope > 0.5:  # Right lane (positive slope)
             right_lines.append(line[0])
-    
+
     # Average lines for left and right lanes
     def average_lines(lines, img_shape):
         if len(lines) == 0:
             return None
-        
+
         x_coords = []
         y_coords = []
-        
+
         for line in lines:
             x1, y1, x2, y2 = line
             x_coords.extend([x1, x2])
             y_coords.extend([y1, y2])
-        
+
         # Fit a polynomial to the points
         poly = np.polyfit(y_coords, x_coords, 1)
-        
+
         # Calculate line endpoints
         y1 = img_shape[0]
         y2 = int(img_shape[0] * 0.6)
         x1 = int(poly[0] * y1 + poly[1])
         x2 = int(poly[0] * y2 + poly[1])
-        
+
         return [x1, y1, x2, y2]
-    
+
     # Draw averaged lines
     left_line = average_lines(left_lines, img.shape)
     right_line = average_lines(right_lines, img.shape)
-    
+
     # Fill the lane area with green color
     if left_line is not None and right_line is not None:
         # Create polygon points for the lane area
@@ -80,38 +96,166 @@ def draw_lines(img, lines, color=[0, 255, 0], thickness=3):
             (right_line[2], right_line[3]), # Right top
             (right_line[0], right_line[1])  # Right bottom
         ]], dtype=np.int32)
-        
+
         # Fill the lane area with green (semi-transparent)
         cv2.fillPoly(line_img, lane_polygon, (0, 255, 0))
-    
+
     # Draw the lane lines in red with thicker lines
     if left_line is not None:
-        cv2.line(line_img, (left_line[0], left_line[1]), (left_line[2], left_line[3]), 
+        cv2.line(line_img, (left_line[0], left_line[1]), (left_line[2], left_line[3]),
                  (0, 0, 255), thickness * 2)  # Red color (BGR format)
-    
+
     if right_line is not None:
-        cv2.line(line_img, (right_line[0], right_line[1]), (right_line[2], right_line[3]), 
+        cv2.line(line_img, (right_line[0], right_line[1]), (right_line[2], right_line[3]),
                  (0, 0, 255), thickness * 2)  # Red color (BGR format)
-    
+
     # Blend with original image (make the overlay semi-transparent)
     return cv2.addWeighted(img, 0.8, line_img, 0.5, 0)
 
 
-def process_frame(frame):
+def draw_lines_segmented(img, lines, color=[0, 255, 0], thickness=3):
     """
-    Process a single frame for lane detection.
+    Draw multiple short line segments to represent curves.
+    Better curve representation with Hough Transform.
+    - Lane lines: Red segmented lines
+    - Lane interior: Green semi-transparent fill
+    """
+    if lines is None:
+        return img
+
+    line_img = np.zeros_like(img)
+    fill_img = np.zeros_like(img)
+
+    # Separate left and right lane lines
+    left_lines = []
+    right_lines = []
+
+    for line in lines:
+        x1, y1, x2, y2 = line[0]
+        if x2 == x1:
+            continue
+        slope = (y2 - y1) / (x2 - x1)
+
+        # Filter by slope to separate left and right lanes
+        if slope < -0.5:  # Left lane (negative slope)
+            left_lines.append(line[0])
+        elif slope > 0.5:  # Right lane (positive slope)
+            right_lines.append(line[0])
+
+    # Extract left and right lane boundaries
+    left_x = []
+    left_y = []
+    right_x = []
+    right_y = []
+
+    for line in left_lines:
+        x1, y1, x2, y2 = line
+        left_x.extend([x1, x2])
+        left_y.extend([y1, y2])
+
+    for line in right_lines:
+        x1, y1, x2, y2 = line
+        right_x.extend([x1, x2])
+        right_y.extend([y1, y2])
+
+    # Initialize sorted lists
+    left_x_sorted = []
+    left_y_sorted = []
+    right_x_sorted = []
+    right_y_sorted = []
+
+    # Sort by y coordinate to maintain order
+    if len(left_x) > 0:
+        left_coords = sorted(zip(left_y, left_x))
+        left_y_sorted = [c[0] for c in left_coords]
+        left_x_sorted = [c[1] for c in left_coords]
+
+        # Draw all individual line segments for left lane
+        for line in left_lines:
+            x1, y1, x2, y2 = line
+            cv2.line(line_img, (x1, y1), (x2, y2), (0, 0, 255), thickness + 2)
+
+    if len(right_x) > 0:
+        right_coords = sorted(zip(right_y, right_x))
+        right_y_sorted = [c[0] for c in right_coords]
+        right_x_sorted = [c[1] for c in right_coords]
+
+        # Draw all individual line segments for right lane
+        for line in right_lines:
+            x1, y1, x2, y2 = line
+            cv2.line(line_img, (x1, y1), (x2, y2), (0, 0, 255), thickness + 2)
+
+    # Fill the area between left and right lanes
+    if len(left_y_sorted) > 0 and len(right_y_sorted) > 0:
+        # Create a polygon by combining left and right points
+        min_y = max(min(left_y_sorted), min(right_y_sorted))
+        max_y = min(max(left_y_sorted), max(right_y_sorted))
+
+        if max_y > min_y:
+            # Interpolate to get matching y-coordinates
+            y_range = np.arange(int(min_y), int(max_y), 10)
+
+            poly_points = []
+
+            # Left points
+            for y in y_range:
+                if y >= min(left_y_sorted) and y <= max(left_y_sorted):
+                    idx = np.searchsorted(left_y_sorted, y)
+                    if idx > 0 and idx < len(left_x_sorted):
+                        x = left_x_sorted[idx]
+                        poly_points.append([x, y])
+
+            # Right points (reverse order for polygon)
+            for y in reversed(y_range):
+                if y >= min(right_y_sorted) and y <= max(right_y_sorted):
+                    idx = np.searchsorted(right_y_sorted, y)
+                    if idx > 0 and idx < len(right_x_sorted):
+                        x = right_x_sorted[idx]
+                        poly_points.append([x, y])
+
+            if len(poly_points) >= 3:
+                poly_points = np.array(poly_points, dtype=np.int32)
+                cv2.fillPoly(fill_img, [poly_points], (0, 255, 0))
+
+    # Combine filled area and lines
+    result_img = cv2.addWeighted(line_img, 0.6, fill_img, 0.7, 0)
+
+    # Blend with original image
+    return cv2.addWeighted(img, 0.8, result_img, 0.5, 0)
+
+
+def process_frame_basic(frame, use_segmented=False):
+    """
+    Process a single frame for lane detection using basic Hough Transform method.
+    use_segmented: If True, draw multiple line segments for better curve representation.
+                   If False, draw averaged single line (default).
     """
     height, width = frame.shape[:2]
-    
-    # Convert to grayscale
-    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
-    
-    # Apply Gaussian blur
-    blur = cv2.GaussianBlur(gray, (5, 5), 0)
-    
-    # Apply Canny edge detection
-    edges = cv2.Canny(blur, 50, 150)
-    
+
+    if USE_GPU and GPU_TYPE == "nvidia":
+        # Upload frame to GPU
+        gpu_frame = cv2.cuda_GpuMat()
+        gpu_frame.upload(frame)
+
+        # Convert to grayscale on GPU
+        gpu_gray = cv2.cuda.cvtColor(gpu_frame, cv2.COLOR_BGR2GRAY)
+
+        # Apply Gaussian blur on GPU
+        gpu_blur = cv2.cuda.createGaussianFilter(cv2.CV_8UC1, cv2.CV_8UC1, (5, 5), 0)
+        gpu_blurred = gpu_blur.apply(gpu_gray)
+
+        # Apply Canny edge detection on GPU
+        gpu_canny = cv2.cuda.createCannyEdgeDetector(50, 150)
+        gpu_edges = gpu_canny.detect(gpu_blurred)
+
+        # Download edges from GPU
+        edges = gpu_edges.download()
+    else:
+        # CPU processing
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        blur = cv2.GaussianBlur(gray, (5, 5), 0)
+        edges = cv2.Canny(blur, 50, 150)
+
     # Define region of interest (ROI)
     vertices = np.array([[
         (int(width * 0.1), height),
@@ -119,10 +263,10 @@ def process_frame(frame):
         (int(width * 0.55), int(height * 0.6)),
         (int(width * 0.9), height)
     ]], dtype=np.int32)
-    
+
     # Apply ROI mask
     masked_edges = region_of_interest(edges, vertices)
-    
+
     # Apply Hough transform to detect lines
     lines = cv2.HoughLinesP(
         masked_edges,
@@ -132,54 +276,353 @@ def process_frame(frame):
         minLineLength=40,
         maxLineGap=100
     )
-    
+
     # Draw detected lanes on the original frame
-    result = draw_lines(frame.copy(), lines)
-    
+    if use_segmented:
+        result = draw_lines_segmented(frame.copy(), lines)
+    else:
+        result = draw_lines_basic(frame.copy(), lines)
+
     return result
 
 
-def process_video(input_path, output_path):
+def calibrate_perspective(img):
+    """
+    Apply perspective transform to get bird's eye view.
+    Converts trapezoidal ROI to rectangular view for easier lane detection.
+    """
+    height, width = img.shape[:2]
+
+    # Define source points (trapezoid in original image)
+    src = np.float32([
+        [width * 0.45, height * 0.65],  # Bottom left
+        [width * 0.55, height * 0.65],  # Bottom right
+        [width * 0.9, height],          # Top right
+        [width * 0.1, height]           # Top left
+    ])
+
+    # Define destination points (rectangle in bird's eye view)
+    dst = np.float32([
+        [width * 0.25, 0],              # Top left
+        [width * 0.75, 0],              # Top right
+        [width * 0.75, height],         # Bottom right
+        [width * 0.25, height]          # Bottom left
+    ])
+
+    # Calculate perspective transform matrix
+    M = cv2.getPerspectiveTransform(src, dst)
+    # Calculate inverse perspective transform matrix
+    Minv = cv2.getPerspectiveTransform(dst, src)
+
+    # Apply perspective transform
+    warped = cv2.warpPerspective(img, M, (width, height), flags=cv2.INTER_LINEAR)
+
+    return warped, M, Minv
+
+
+def color_and_gradient_threshold(img, use_enhanced=True):
+    """
+    Apply color and gradient thresholding to isolate lane lines.
+    Enhanced version with better accuracy for various conditions.
+    Returns binary image with lane pixels set to 255.
+    """
+    # Convert to HLS color space
+    hls = cv2.cvtColor(img, cv2.COLOR_BGR2HLS)
+
+    # Extract channels
+    h_channel = hls[:, :, 0]
+    l_channel = hls[:, :, 1]
+    s_channel = hls[:, :, 2]
+
+    # Enhanced thresholding for better lane detection
+    if use_enhanced:
+        # Adaptive thresholding for saturation channel
+        s_thresh = (90, 255)  # Lower threshold for yellow lanes
+        s_binary = np.zeros_like(s_channel)
+        s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 255
+
+        # Adaptive thresholding for lightness channel
+        l_thresh = (180, 255)  # Lower threshold for white lanes
+        l_binary = np.zeros_like(l_channel)
+        l_binary[(l_channel >= l_thresh[0]) & (l_channel <= l_thresh[1])] = 255
+
+        # Apply CLAHE (Contrast Limited Adaptive Histogram Equalization) for better contrast
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        l_channel_enhanced = clahe.apply(l_channel.astype(np.uint8))
+
+        # Apply Sobel operator on enhanced channel
+        sobelx = cv2.Sobel(l_channel_enhanced, cv2.CV_64F, 1, 0, ksize=3)
+        abs_sobelx = np.absolute(sobelx)
+        scaled_sobel = np.uint8(255 * abs_sobelx / np.max(abs_sobelx))
+
+        # More sensitive gradient threshold
+        sobel_thresh = (15, 255)  # Lower threshold for better edge detection
+        sobel_binary = np.zeros_like(scaled_sobel)
+        sobel_binary[(scaled_sobel >= sobel_thresh[0]) & (scaled_sobel <= sobel_thresh[1])] = 255
+
+        # Direction threshold to focus on vertical edges
+        sobely = cv2.Sobel(l_channel_enhanced, cv2.CV_64F, 0, 1, ksize=3)
+        abs_sobely = np.absolute(sobely)
+        scaled_sobely = np.uint8(255 * abs_sobely / np.max(abs_sobely))
+
+        # Calculate gradient direction
+        grad_dir = np.arctan2(abs_sobely, abs_sobelx)
+        dir_thresh = (0.7, 1.3)  # Focus on near-vertical edges (lane lines)
+        dir_binary = np.zeros_like(scaled_sobel)
+        dir_binary[(grad_dir >= dir_thresh[0]) & (grad_dir <= dir_thresh[1])] = 255
+
+        # Combine all binary images with direction filter
+        combined_binary = np.zeros_like(s_binary)
+        combined_binary[((s_binary == 255) | (l_binary == 255) | (sobel_binary == 255)) & (dir_binary == 255)] = 255
+
+        # Apply morphological operations to reduce noise
+        kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+        combined_binary = cv2.morphologyEx(combined_binary, cv2.MORPH_CLOSE, kernel)
+        combined_binary = cv2.morphologyEx(combined_binary, cv2.MORPH_OPEN, kernel)
+
+    else:
+        # Basic thresholding
+        s_thresh = (100, 255)
+        s_binary = np.zeros_like(s_channel)
+        s_binary[(s_channel >= s_thresh[0]) & (s_channel <= s_thresh[1])] = 255
+
+        l_thresh = (200, 255)
+        l_binary = np.zeros_like(l_channel)
+        l_binary[(l_channel >= l_thresh[0]) & (l_channel <= l_thresh[1])] = 255
+
+        sobelx = cv2.Sobel(l_channel, cv2.CV_64F, 1, 0, ksize=3)
+        abs_sobelx = np.absolute(sobelx)
+        scaled_sobel = np.uint8(255 * abs_sobelx / np.max(abs_sobelx))
+
+        sobel_thresh = (20, 255)
+        sobel_binary = np.zeros_like(scaled_sobel)
+        sobel_binary[(scaled_sobel >= sobel_thresh[0]) & (scaled_sobel <= sobel_thresh[1])] = 255
+
+        combined_binary = np.zeros_like(s_binary)
+        combined_binary[(s_binary == 255) | (l_binary == 255) | (sobel_binary == 255)] = 255
+
+    return combined_binary
+
+
+def fit_polynomial_lanes(binary_warped):
+    """
+    Fit 2nd degree polynomials to lane lines using sliding window approach.
+    Returns left and right lane polynomial coefficients.
+    """
+    # Take a histogram of the bottom half of the image
+    histogram = np.sum(binary_warped[binary_warped.shape[0]//2:, :], axis=0)
+
+    # Find the peak of the left and right halves of the histogram
+    midpoint = len(histogram) // 2
+    leftx_base = np.argmax(histogram[:midpoint])
+    rightx_base = np.argmax(histogram[midpoint:]) + midpoint
+
+    # Sliding window parameters
+    nwindows = 9
+    window_height = binary_warped.shape[0] // nwindows
+    margin = 100
+    minpix = 50
+
+    # Find nonzero pixels
+    nonzero = binary_warped.nonzero()
+    nonzeroy = np.array(nonzero[0])
+    nonzerox = np.array(nonzero[1])
+
+    # Current positions
+    leftx_current = leftx_base
+    rightx_current = rightx_base
+
+    # Lists to store lane pixel indices
+    left_lane_inds = []
+    right_lane_inds = []
+
+    # Step through windows
+    for window in range(nwindows):
+        # Window boundaries
+        win_y_low = binary_warped.shape[0] - (window + 1) * window_height
+        win_y_high = binary_warped.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
+
+        # Find pixels within windows
+        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)
+
+        # Recenter windows
+        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]))
+
+    # Concatenate indices
+    left_lane_inds = np.concatenate(left_lane_inds)
+    right_lane_inds = np.concatenate(right_lane_inds)
+
+    # Extract pixel positions
+    leftx = nonzerox[left_lane_inds]
+    lefty = nonzeroy[left_lane_inds]
+    rightx = nonzerox[right_lane_inds]
+    righty = nonzeroy[right_lane_inds]
+
+    # Fit polynomial (2nd degree)
+    left_fit = None
+    right_fit = None
+
+    if len(leftx) > 0:
+        left_fit = np.polyfit(lefty, leftx, 2)
+    if len(rightx) > 0:
+        right_fit = np.polyfit(righty, rightx, 2)
+
+    return left_fit, right_fit
+
+
+def draw_poly_lines(img, binary_warped, left_fit, right_fit, Minv):
+    """
+    Draw polynomial lane lines on the original image using inverse perspective transform.
+    """
+    if left_fit is None or right_fit is None:
+        return img
+
+    # Create an image to draw on
+    warp_zero = np.zeros_like(binary_warped).astype(np.uint8)
+    color_warp = np.dstack((warp_zero, warp_zero, warp_zero))
+
+    # Generate y values
+    ploty = np.linspace(0, binary_warped.shape[0] - 1, binary_warped.shape[0])
+
+    # Calculate x values using polynomial
+    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]
+
+    # Ensure values are within image bounds
+    left_fitx = np.clip(left_fitx, 0, binary_warped.shape[1] - 1)
+    right_fitx = np.clip(right_fitx, 0, binary_warped.shape[1] - 1)
+
+    # Create points for the 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))
+
+    # Fill the lane area with green
+    cv2.fillPoly(color_warp, np.int_([pts]), (0, 255, 0))
+
+    # Draw the lane lines in red
+    cv2.polylines(color_warp, np.int32([pts_left]), isClosed=False, color=(0, 0, 255), thickness=15)
+    cv2.polylines(color_warp, np.int32([pts_right]), isClosed=False, color=(0, 0, 255), thickness=15)
+
+    # Apply inverse perspective transform to project back to original image
+    newwarp = cv2.warpPerspective(color_warp, Minv, (img.shape[1], img.shape[0]))
+
+    # Combine with original image
+    result = cv2.addWeighted(img, 0.8, newwarp, 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"
+    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)
+    elif method == "advanced":
+        return process_frame_advanced(frame, use_enhanced)
+    else:
+        raise ValueError(f"Unknown method: {method}. Use 'basic' or 'advanced'")
+
+
+def process_frame_advanced(frame, use_enhanced=True):
+    """
+    Process a single frame for lane detection using advanced pipeline.
+    1. Perspective transform to bird's eye view
+    2. Enhanced color and gradient thresholding
+    3. Polynomial fitting with sliding windows
+    4. Draw lanes with inverse perspective transform
+    """
+    # Step 1: Apply perspective transform to get bird's eye view
+    warped, M, Minv = calibrate_perspective(frame)
+
+    # Step 2: Apply enhanced color and gradient thresholding
+    binary_warped = color_and_gradient_threshold(warped, use_enhanced)
+
+    # Step 3: Fit polynomial lanes using sliding window approach
+    left_fit, right_fit = fit_polynomial_lanes(binary_warped)
+
+    # Step 4: Draw polynomial lines on original image
+    result = draw_poly_lines(frame, binary_warped, left_fit, right_fit, Minv)
+
+    return result
+
+
+def process_video(input_path, output_path, method="advanced", use_enhanced=True, use_segmented=False):
     """
     Process the video and create side-by-side comparison.
+    method: "basic" or "advanced"
+    use_enhanced: Use enhanced thresholding for better accuracy (advanced method only)
+    use_segmented: Use segmented lines for curve representation (basic method only)
     Returns True if successful, False otherwise.
     """
     # Open the video
     cap = cv2.VideoCapture(input_path)
-    
+
     if not cap.isOpened():
         return False
-    
+
     # Get video properties
     fps = int(cap.get(cv2.CAP_PROP_FPS))
     width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
     height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    
+    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')
     out = cv2.VideoWriter(output_path, fourcc, fps, (width * 2, height))
-    
+
     frame_count = 0
+    print(f"Processing {total_frames} frames using {method} method...")
+    if method == "advanced" and use_enhanced:
+        print("Enhanced thresholding enabled for better accuracy")
+    if method == "basic" and use_segmented:
+        print("Segmented line mode enabled for better curve representation")
+
     # Process each frame
     while True:
         ret, frame = cap.read()
         if not ret:
             break
-        
+
         # Process frame for lane detection
-        processed_frame = process_frame(frame)
-        
+        processed_frame = process_frame(frame, method, use_enhanced, use_segmented)
+
         # Create side-by-side comparison
         # Original on left, processed on right
         combined = np.hstack((frame, processed_frame))
-        
+
         # Write the combined frame
         out.write(combined)
         frame_count += 1
-    
+
+        # Progress indicator
+        if 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}%)")
+
     # Release resources
     cap.release()
     out.release()
-    
+
+    print(f"✓ Completed! Processed {frame_count} frames using {method} method.")
+
     return frame_count > 0