Add CLI tool, quickstart script, and comprehensive documentation

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

README.md

@@ -10,6 +10,8 @@ This project is a demo application that detects lane lines in videos using OpenC
 - 🎥 Gradio를 통한 비디오 업로드 (Video upload via Gradio)
 - 🛣️ OpenCV를 이용한 실시간 차선 검출 (Real-time lane detection using OpenCV)
 - 📊 원본/처리 비디오 사이드바이사이드 비교 (Side-by-side comparison of original and processed videos)
+- 💻 CLI 도구 제공 (Command-line interface available)
+- 🧪 포괄적인 테스트 스위트 (Comprehensive test suite)
 
 ## 설치 (Installation)
 
@@ -26,6 +28,8 @@ pip install -r requirements.txt
 
 ## 사용법 (Usage)
 
+### 방법 1: Gradio UI 사용 (Using Gradio UI)
+
 1. 애플리케이션 실행 (Run the application):
 ```bash
 python app.py
@@ -40,20 +44,85 @@ python app.py
 4. 처리된 결과를 확인합니다 (왼쪽: 원본, 오른쪽: 차선 감지 결과).
    (View the processed result - left: original, right: lane detection result)
 
+### 방법 2: CLI 사용 (Using Command Line)
+
+```bash
+python cli.py input_video.mp4 output_video.mp4
+```
+
+예시 (Example):
+```bash
+# 테스트 비디오 생성 (Create test video)
+python create_test_video.py
+
+# 차선 감지 처리 (Process with lane detection)
+python cli.py /tmp/test_road_video.mp4 result.mp4
+```
+
 ## 차선 감지 알고리즘 (Lane Detection Algorithm)
 
+본 프로젝트는 다음과 같은 컴퓨터 비전 기법을 사용합니다:
+(This project uses the following computer vision techniques:)
+
 1. **Grayscale 변환** (Convert to grayscale)
-2. **가우시안 블러** 적용 (Apply Gaussian blur)
+   - 컬러 이미지를 흑백으로 변환하여 처리 속도 향상
+
+2. **가우시안 블러** (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)
+   - 이미지에서 가장자리(edge) 검출
+
+4. **관심 영역(ROI) 마스킹** (Region of Interest masking)
+   - 도로 영역에만 집중하여 불필요한 영역 제외
+
+5. **Hough 변환** (Hough transform)
+   - 직선 형태의 차선 검출
+
+6. **차선 평균화 및 그리기** (Lane averaging and drawing)
+   - 검출된 여러 선분을 평균화하여 안정적인 차선 표시
+
+## 프로젝트 구조 (Project Structure)
+
+```
+OpenCVLaneDetectionDemo/
+├── app.py                    # Gradio UI 애플리케이션
+├── lane_detection.py         # 핵심 차선 검출 로직
+├── cli.py                    # 명령줄 인터페이스
+├── create_test_video.py      # 테스트 비디오 생성 도구
+├── create_sample_images.py   # 샘플 이미지 생성 도구
+├── test_lane_detection.py    # 테스트 스위트
+├── requirements.txt          # Python 의존성
+└── README.md                 # 문서
+```
+
+## 테스트 (Testing)
+
+전체 테스트 스위트 실행:
+(Run the complete test suite:)
+
+```bash
+python test_lane_detection.py
+```
 
 ## 요구사항 (Requirements)
 - Python 3.7+
-- gradio==4.44.0
-- opencv-python==4.10.0.84
-- numpy==1.26.4
+- gradio>=4.0.0
+- opencv-python>=4.5.0
+- numpy>=1.20.0
+
+## 기술 스택 (Tech Stack)
+- **OpenCV**: 컴퓨터 비전 처리
+- **NumPy**: 수치 연산
+- **Gradio**: 웹 UI 프레임워크
 
 ## 라이선스 (License)
 MIT License
+
+## 기여 (Contributing)
+이슈와 풀 리퀘스트를 환영합니다!
+(Issues and pull requests are welcome!)
+
+## 문의 (Contact)
+프로젝트에 대한 질문이나 제안사항이 있으시면 이슈를 생성해주세요.
+(For questions or suggestions about the project, please create an issue.)

cli.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+Command-line interface for lane detection
+Usage: python cli.py <input_video> <output_video>
+"""
+import sys
+import os
+from lane_detection import process_video
+
+
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: python cli.py <input_video> <output_video>")
+        print("\nExample:")
+        print("  python cli.py road_video.mp4 output_result.mp4")
+        sys.exit(1)
+    
+    input_path = sys.argv[1]
+    output_path = sys.argv[2]
+    
+    # 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("\nProcessing...")
+    
+    success = process_video(input_path, output_path)
+    
+    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")
+    else:
+        print("\n✗ Video processing failed!")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

create_sample_images.py

@@ -0,0 +1,61 @@
+"""
+Create sample images to demonstrate lane detection
+"""
+import cv2
+import numpy as np
+import os
+
+
+def create_sample_frames():
+    """Create and save sample frames showing lane detection"""
+    
+    # First, create a test video and process it
+    from create_test_video import create_test_video
+    from lane_detection import process_video
+    
+    input_video = "/tmp/demo_input.mp4"
+    output_video = "/tmp/demo_output.mp4"
+    
+    # Create a test video with clear lanes
+    print("Creating demo video...")
+    create_test_video(input_video, duration_sec=2, fps=15)
+    
+    print("Processing video with lane detection...")
+    success = process_video(input_video, output_video)
+    
+    if not success:
+        print("Failed to process video")
+        return
+    
+    # Extract a sample frame from the output
+    cap = cv2.VideoCapture(output_video)
+    
+    # Get a frame from the middle of the video
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    middle_frame = total_frames // 2
+    
+    cap.set(cv2.CAP_PROP_POS_FRAMES, middle_frame)
+    ret, frame = cap.read()
+    
+    if ret:
+        # Save the frame
+        output_path = "/tmp/lane_detection_demo.png"
+        cv2.imwrite(output_path, frame)
+        print(f"✓ Sample frame saved to: {output_path}")
+        print(f"  Frame shows original (left) and lane detection (right)")
+        
+        # Also create a smaller version for documentation
+        height, width = frame.shape[:2]
+        scale = 0.5
+        small_frame = cv2.resize(frame, (int(width * scale), int(height * scale)))
+        small_output_path = "/tmp/lane_detection_demo_small.png"
+        cv2.imwrite(small_output_path, small_frame)
+        print(f"✓ Smaller version saved to: {small_output_path}")
+    else:
+        print("Failed to extract frame")
+    
+    cap.release()
+
+
+if __name__ == "__main__":
+    create_sample_frames()

quickstart.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Quick start script to test the lane detection system
+Creates a test video, processes it, and verifies the output
+"""
+import os
+import sys
+
+
+def main():
+    print("=" * 60)
+    print("OpenCV Lane Detection Demo - Quick Start")
+    print("=" * 60)
+    print()
+    
+    # Check imports
+    print("1. Checking dependencies...")
+    try:
+        import cv2
+        print(f"   ✓ OpenCV {cv2.__version__}")
+    except ImportError:
+        print("   ✗ OpenCV not found. Run: pip install opencv-python")
+        sys.exit(1)
+    
+    try:
+        import numpy as np
+        print(f"   ✓ NumPy {np.__version__}")
+    except ImportError:
+        print("   ✗ NumPy not found. Run: pip install numpy")
+        sys.exit(1)
+    
+    print()
+    
+    # Create test video
+    print("2. Creating test video...")
+    from create_test_video import create_test_video
+    
+    input_video = "/tmp/quickstart_input.mp4"
+    output_video = "/tmp/quickstart_output.mp4"
+    
+    create_test_video(input_video, duration_sec=2, fps=15)
+    print()
+    
+    # Process video
+    print("3. Processing video with lane detection...")
+    from lane_detection import process_video
+    
+    success = process_video(input_video, output_video)
+    
+    if not success:
+        print("   ✗ Processing failed!")
+        sys.exit(1)
+    
+    print(f"   ✓ Processing complete!")
+    print()
+    
+    # Verify output
+    print("4. Verifying output...")
+    if os.path.exists(output_video):
+        size = os.path.getsize(output_video)
+        print(f"   ✓ Output file created: {output_video}")
+        print(f"   ✓ File size: {size:,} bytes")
+    else:
+        print("   ✗ Output file not found!")
+        sys.exit(1)
+    
+    print()
+    print("=" * 60)
+    print("✅ SUCCESS! Lane detection system is working correctly.")
+    print("=" * 60)
+    print()
+    print("Next steps:")
+    print("  • Run Gradio UI: python app.py")
+    print("  • Use CLI tool: python cli.py <input> <output>")
+    print("  • Run tests: python test_lane_detection.py")
+    print()
+
+
+if __name__ == "__main__":
+    main()