Add Gradio UI with OpenCV lane detection implementation

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

.gitignore

@@ -205,3 +205,13 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# Temporary video files
+*.mp4
+*.avi
+*.mov
+*.mkv
+
+# Gradio temporary files
+gradio_cached_examples/
+flagged/

README.md

@@ -1,2 +1,59 @@
 # OpenCVLaneDetectionDemo
 OpenCV Lane Detection Demo with Gradio
+
+## 개요 (Overview)
+이 프로젝트는 OpenCV를 사용하여 비디오에서 차선을 감지하고, Gradio UI를 통해 결과를 시각화하는 데모 애플리케이션입니다.
+
+This project is a demo application that detects lane lines in videos using OpenCV and visualizes the results through a Gradio UI.
+
+## 기능 (Features)
+- 🎥 Gradio를 통한 비디오 업로드 (Video upload via Gradio)
+- 🛣️ OpenCV를 이용한 실시간 차선 검출 (Real-time lane detection using OpenCV)
+- 📊 원본/처리 비디오 사이드바이사이드 비교 (Side-by-side comparison of original and processed videos)
+
+## 설치 (Installation)
+
+1. 저장소 클론 (Clone the repository):
+```bash
+git clone https://github.com/kr4phy/OpenCVLaneDetectionDemo.git
+cd OpenCVLaneDetectionDemo
+```
+
+2. 필요한 패키지 설치 (Install required packages):
+```bash
+pip install -r requirements.txt
+```
+
+## 사용법 (Usage)
+
+1. 애플리케이션 실행 (Run the application):
+```bash
+python app.py
+```
+
+2. 브라우저에서 자동으로 열리는 Gradio UI에 접속합니다.
+   (The Gradio UI will automatically open in your browser)
+
+3. 비디오 파일을 업로드하고 "Process Video" 버튼을 클릭합니다.
+   (Upload a video file and click the "Process Video" button)
+
+4. 처리된 결과를 확인합니다 (왼쪽: 원본, 오른쪽: 차선 감지 결과).
+   (View the processed result - left: original, right: lane detection result)
+
+## 차선 감지 알고리즘 (Lane Detection Algorithm)
+
+1. **Grayscale 변환** (Convert to grayscale)
+2. **가우시안 블러** 적용 (Apply Gaussian blur)
+3. **Canny 에지 검출** (Canny edge detection)
+4. **관심 영역(ROI) 마스킹** (Apply region of interest mask)
+5. **Hough 변환**으로 직선 검출 (Detect lines using Hough transform)
+6. **차선 평균화 및 그리기** (Average and draw lane lines)
+
+## 요구사항 (Requirements)
+- Python 3.7+
+- gradio==4.44.0
+- opencv-python==4.10.0.84
+- numpy==1.26.4
+
+## 라이선스 (License)
+MIT License

app.py

@@ -0,0 +1,207 @@
+import cv2
+import numpy as np
+import gradio as gr
+import tempfile
+import os
+
+
+def region_of_interest(img, vertices):
+    """
+    Apply a region of interest mask to the image.
+    """
+    mask = np.zeros_like(img)
+    cv2.fillPoly(mask, vertices, 255)
+    masked_image = cv2.bitwise_and(img, mask)
+    return masked_image
+
+
+def draw_lines(img, lines, color=[0, 255, 0], thickness=3):
+    """
+    Draw lines on the image.
+    """
+    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)
+    
+    if left_line is not None:
+        cv2.line(line_img, (left_line[0], left_line[1]), (left_line[2], left_line[3]), color, thickness)
+    
+    if right_line is not None:
+        cv2.line(line_img, (right_line[0], right_line[1]), (right_line[2], right_line[3]), color, thickness)
+    
+    return cv2.addWeighted(img, 1.0, line_img, 1.0, 0)
+
+
+def process_frame(frame):
+    """
+    Process a single frame for lane detection.
+    """
+    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)
+    
+    # Define region of interest (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)
+    
+    # Apply ROI mask
+    masked_edges = region_of_interest(edges, vertices)
+    
+    # Apply Hough transform to detect lines
+    lines = cv2.HoughLinesP(
+        masked_edges,
+        rho=2,
+        theta=np.pi / 180,
+        threshold=50,
+        minLineLength=40,
+        maxLineGap=100
+    )
+    
+    # Draw detected lanes on the original frame
+    result = draw_lines(frame.copy(), lines)
+    
+    return result
+
+
+def process_video(video_path):
+    """
+    Process the uploaded video and return side-by-side comparison.
+    """
+    if video_path is None:
+        return None
+    
+    # Open the video
+    cap = cv2.VideoCapture(video_path)
+    
+    if not cap.isOpened():
+        return None
+    
+    # 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))
+    
+    # Create temporary output file
+    temp_output = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+    output_path = temp_output.name
+    temp_output.close()
+    
+    # Video writer for output (side-by-side, so width is doubled)
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(output_path, fourcc, fps, (width * 2, height))
+    
+    # Process each frame
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        # Process frame for lane detection
+        processed_frame = process_frame(frame)
+        
+        # Create side-by-side comparison
+        # Original on left, processed on right
+        combined = np.hstack((frame, processed_frame))
+        
+        # Write the combined frame
+        out.write(combined)
+    
+    # Release resources
+    cap.release()
+    out.release()
+    
+    return output_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.")
+    
+    with gr.Row():
+        with gr.Column():
+            video_input = gr.Video(label="Upload Video")
+            process_btn = gr.Button("Process Video", variant="primary")
+        
+        with gr.Column():
+            video_output = gr.Video(label="Result (Original | Lane Detection)")
+    
+    process_btn.click(
+        fn=process_video,
+        inputs=video_input,
+        outputs=video_output
+    )
+    
+    gr.Markdown("""
+    ### 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
+    """)
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=4.0.0
+opencv-python>=4.5.0
+numpy>=1.20.0

test_lane_detection.py

@@ -0,0 +1,108 @@
+"""
+Basic tests for lane detection functionality
+"""
+import numpy as np
+import cv2
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from app import region_of_interest, process_frame
+
+
+def test_region_of_interest():
+    """Test region of interest masking"""
+    print("Testing region_of_interest function...")
+    
+    # Create a test image
+    img = np.ones((100, 100), dtype=np.uint8) * 255
+    
+    # Define vertices
+    vertices = np.array([[(20, 100), (40, 50), (60, 50), (80, 100)]], dtype=np.int32)
+    
+    # Apply ROI
+    result = region_of_interest(img, vertices)
+    
+    # Check that result has correct shape
+    assert result.shape == img.shape, f"Expected shape {img.shape}, got {result.shape}"
+    
+    # Check that areas outside ROI are masked (zero)
+    assert result[10, 10] == 0, "Pixels outside ROI should be 0"
+    
+    print("✓ region_of_interest test passed")
+
+
+def test_process_frame():
+    """Test frame processing for lane detection"""
+    print("Testing process_frame function...")
+    
+    # Create a test frame with simulated road
+    height, width = 480, 640
+    frame = np.zeros((height, width, 3), dtype=np.uint8)
+    
+    # Draw white lines to simulate lanes
+    cv2.line(frame, (200, height), (280, int(height*0.6)), (255, 255, 255), 5)
+    cv2.line(frame, (440, height), (360, int(height*0.6)), (255, 255, 255), 5)
+    
+    # Process the frame
+    result = process_frame(frame)
+    
+    # Check that result has correct shape
+    assert result.shape == frame.shape, f"Expected shape {frame.shape}, got {result.shape}"
+    
+    # Check that result is not identical to input (lanes should be drawn)
+    assert not np.array_equal(result, frame), "Result should have lane lines drawn"
+    
+    print("✓ process_frame test passed")
+
+
+def test_imports():
+    """Test that all required modules can be imported"""
+    print("Testing imports...")
+    
+    try:
+        import gradio
+        print("✓ gradio imported successfully")
+    except ImportError as e:
+        print(f"✗ Failed to import gradio: {e}")
+        return False
+    
+    try:
+        import cv2
+        print("✓ opencv-python imported successfully")
+    except ImportError as e:
+        print(f"✗ Failed to import cv2: {e}")
+        return False
+    
+    try:
+        import numpy
+        print("✓ numpy imported successfully")
+    except ImportError as e:
+        print(f"✗ Failed to import numpy: {e}")
+        return False
+    
+    return True
+
+
+if __name__ == "__main__":
+    print("Running lane detection tests...\n")
+    
+    # Test imports
+    if not test_imports():
+        print("\nImport tests failed!")
+        sys.exit(1)
+    
+    print()
+    
+    # Test functions
+    try:
+        test_region_of_interest()
+        test_process_frame()
+        print("\n✅ All tests passed!")
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)