app.py

import cv2 #type: ignore
import streamlit as st #type: ignore
import tempfile
import os
import time

from lane_detection import detect_lane_lines, average_lane_lines, draw_adas_overlay
from object_detection import detect_objects, get_object_summary

st.set_page_config(
    page_title="AI-Based Lane Detection & ADAS System",
    page_icon="🚗",
    layout="wide"
)

st.title("AI-Based Lane Detection & ADAS Warning System")

st.markdown(
    """
    Upload a road-driving video and view the ADAS lane detection output frame-by-frame.
    """
)

st.sidebar.header("📁 Upload Road Video")

uploaded_video = st.sidebar.file_uploader(
    "",
    type=["mp4", "avi", "mov", "mkv"]
)

st.sidebar.markdown("---")

left_col, right_col = st.columns([2.2, 1])
with left_col:
    st.subheader("🎥 ADAS Output Preview")
    video_placeholder = st.empty()
st.subheader("Object Detection")

obj_col1, obj_col2, obj_col3, obj_col4 = st.columns(4)

with obj_col1:
    vehicle_box = st.empty()
with obj_col2:
    pedestrian_box = st.empty()
with obj_col3:
    traffic_light_box = st.empty()
with obj_col4:
    objects_box = st.empty()
with right_col:
    st.subheader("ADAS Parameters")

    frame_count_box = st.empty()
    lane_status_box = st.empty()
    offset_box = st.empty()
    steering_box = st.empty()
    fps_box = st.empty()
    detection_box = st.empty()
    warning_box = st.empty()
   


def get_lane_metrics(frame, left_lane, right_lane):
    height, width, _ = frame.shape

    if left_lane is None or right_lane is None:
        return {
            "lane_detected": False,
            "lane_status": "Lane Not Detected",
            "offset_pixels": "N/A",
            "steering_advice": "No Lane Data",
            "risk_level": "Unknown"
        }

    lx1, ly1, lx2, ly2 = left_lane
    rx1, ry1, rx2, ry2 = right_lane

    lane_center = (lx1 + rx1) // 2
    vehicle_center = width // 2
    offset_pixels = vehicle_center - lane_center

    if abs(offset_pixels) < 40:
        lane_status = "SAFE"
        steering_advice = "Keep Center"
        risk_level = "Low"
    elif offset_pixels > 40:
        lane_status = "WARNING"
        steering_advice = "Move LEFT"
        risk_level = "Medium"
    else:
        lane_status = "WARNING"
        steering_advice = "Move RIGHT"
        risk_level = "Medium"

    return {
        "lane_detected": True,
        "lane_status": lane_status,
        "offset_pixels": offset_pixels,
        "steering_advice": steering_advice,
        "risk_level": risk_level
    }


def process_video(video_path):
    import lane_detection
    lane_detection.prev_left_lane = None
    lane_detection.prev_right_lane = None

    cap = cv2.VideoCapture(video_path)

    if not cap.isOpened():
        st.error("❌ Could not open the video file.")
        return

    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    video_fps = cap.get(cv2.CAP_PROP_FPS)
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    frame_count = 0
    detected_frames = 0
    warning_frames = 0

    progress_bar = st.progress(0)
    start_time = time.time()

    while cap.isOpened():
        ret, frame = cap.read()

        if not ret:
            break

        frame_count += 1

        # frame = cv2.resize(frame, (640, 480))

        lines = detect_lane_lines(frame)
        left_lane, right_lane = average_lane_lines(frame, lines)

        metrics = get_lane_metrics(frame, left_lane, right_lane)
        output_frame = draw_adas_overlay(frame, left_lane, right_lane)

        output_frame, detected_objects = detect_objects(output_frame)
        object_summary = get_object_summary(detected_objects)

        if metrics["lane_detected"]:
            detected_frames += 1

        if metrics["lane_status"] == "WARNING":
            warning_frames += 1

        frame_rgb = cv2.cvtColor(output_frame, cv2.COLOR_BGR2RGB)

        video_placeholder.image(
            frame_rgb,
            channels="RGB",
            use_container_width=True
        )

        elapsed_time = time.time() - start_time
        processing_fps = frame_count / elapsed_time if elapsed_time > 0 else 0
        detection_rate = (detected_frames / frame_count) * 100 if frame_count > 0 else 0

        frame_count_box.metric("Processed Frames", f"{frame_count}/{total_frames}")
        lane_status_box.metric("Lane Status", metrics["lane_status"])
        offset_box.metric("Offset Pixels", metrics["offset_pixels"])
        steering_box.metric("Steering Advice", metrics["steering_advice"])
        fps_box.metric("Processing FPS", round(processing_fps, 2))
        detection_box.metric("Detection Rate", f"{detection_rate:.2f}%")
        warning_box.metric("Warning Frames", warning_frames)
        vehicle_box.metric("Vehicles", object_summary["vehicle_count"])
        pedestrian_box.metric("Pedestrians", object_summary["pedestrian_count"])
        traffic_light_box.metric("Traffic Lights", object_summary["traffic_light_count"])
        objects_box.metric("Objects", object_summary["total_objects"])

        if total_frames > 0:
            progress_bar.progress(min(frame_count / total_frames, 1.0))

    cap.release()

    st.success("✅ Video processing completed successfully.")

    #st.markdown("### 📌 Video Summary")
    #s1, s2, s3 = st.columns(3)
    #s1.metric("Original FPS", round(video_fps, 2))
    #s2.metric("Resolution", f"{width} × {height}")
    #s3.metric("Total Frames", frame_count)



if uploaded_video is not None:
    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4")
    temp_file.write(uploaded_video.read())
    temp_video_path = temp_file.name

    st.sidebar.success("✅ Video uploaded successfully")

    st.sidebar.markdown("### ▶ Processing Control")

    if st.sidebar.button("▶ Start Lane Detection", use_container_width=True):
        process_video(temp_video_path)

else:
    st.info("<-- Upload a road-driving video from the sidebar to start.")