Create app.py

app.py

@@ -0,0 +1,133 @@
+import gradio as gr
+import cv2
+import torch
+import torch.nn as nn
+import numpy as np
+from torchvision import transforms
+import os
+
+# --- 1. MODEL ARCHITECTURE ---
+class LDobjModel(nn.Module):
+    def __init__(self):
+        super(LDobjModel, self).__init__()
+        self.enc1 = self.conv_block(3, 16); self.pool1 = nn.MaxPool2d(2)
+        self.enc2 = self.conv_block(16, 32); self.pool2 = nn.MaxPool2d(2)
+        self.bottleneck = self.conv_block(32, 64)
+        self.up1 = nn.ConvTranspose2d(64, 32, 2, 2)
+        self.dec1 = self.conv_block(64, 32)
+        self.up2 = nn.ConvTranspose2d(32, 16, 2, 2)
+        self.dec2 = self.conv_block(32, 16)
+        self.final = nn.Sequential(nn.Conv2d(16, 1, 1), nn.Sigmoid())
+
+    def conv_block(self, in_c, out_c):
+        return nn.Sequential(nn.Conv2d(in_c, out_c, 3, 1, 1), nn.ReLU(),
+                             nn.Conv2d(out_c, out_c, 3, 1, 1), nn.ReLU())
+
+    def forward(self, x):
+        e1 = self.enc1(x); e2 = self.enc2(self.pool1(e1))
+        b = self.bottleneck(self.pool2(e2))
+        d1 = torch.cat((e2, self.up1(b)), dim=1); d1 = self.dec1(d1)
+        d2 = torch.cat((e1, self.up2(d1)), dim=1); d2 = self.dec2(d2)
+        return self.final(d2)
+
+# --- 2. LOAD AI ON STARTUP ---
+device = torch.device('cpu') # Hugging Face Free Tier uses CPU
+model = LDobjModel().to(device)
+# Load weights (Make sure the filename matches exactly what you uploaded)
+model.load_state_dict(torch.load('LDobj_weights.pth', map_location=device))
+model.eval()
+
+transform = transforms.Compose([
+    transforms.ToPILImage(),
+    transforms.Resize((288, 800)),
+    transforms.ToTensor()
+])
+
+# --- 3. VIDEO PROCESSING LOGIC ---
+def analyze_video(input_video_path):
+    if input_video_path is None:
+        return None
+
+    cap = cv2.VideoCapture(input_video_path)
+    
+    # Get video specs
+    width  = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps    = cap.get(cv2.CAP_PROP_FPS)
+    
+    # Setup output writer
+    raw_output = "raw_output.mp4"
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(raw_output, fourcc, fps, (width, height))
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret: break
+
+        # Pre-process frame
+        input_img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        img_tensor = transform(input_img).unsqueeze(0).to(device)
+
+        # AI Prediction
+        with torch.no_grad():
+            pred = model(img_tensor).squeeze().numpy()
+
+        # Binary Mask
+        mask = (pred > 0.5).astype(np.uint8)
+        mask_full = cv2.resize(mask, (width, height))
+
+        # Departure Logic
+        moments = cv2.moments(mask_full[int(height*0.8):, :])
+        alert_triggered = False
+        
+        if moments["m00"] > 0:
+            lane_center_x = int(moments["m10"] / moments["m00"])
+            car_center_x = width // 2
+            
+            # If car drifts > 10% of screen width
+            if abs(lane_center_x - car_center_x) > (width * 0.1):
+                alert_triggered = True
+
+        # ONLY MODIFY FRAME IF ALERT IS HAPPENING
+        if alert_triggered:
+            status_color = (0, 0, 255) # Red BGR
+            overlay = frame.copy()
+            overlay[mask_full > 0] = status_color
+            
+            # Add UI Text
+            cv2.putText(frame, "WARNING: LANE DEPARTURE!", (width//10, 100), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 1.5, status_color, 4)
+            
+            # Blend frame with red lanes
+            final_frame = cv2.addWeighted(frame, 0.7, overlay, 0.3, 0)
+            out.write(final_frame)
+        else:
+            # Normal driving: return the clean, untouched dashcam footage
+            out.write(frame)
+
+    cap.release()
+    out.write(frame)
+    out.release()
+    
+    # Convert to standard H264 for web browsers (Gradio requires this)
+    web_output = "final_output.mp4"
+    os.system(f"ffmpeg -y -i {raw_output} -vcodec libx264 {web_output}")
+    
+    return web_output
+
+# --- 4. GRADIO WEB INTERFACE ---
+with gr.Blocks(theme=gr.themes.Monochrome()) as app:
+    gr.Markdown("# 🚗 LDobj: AI Lane Departure Alert System")
+    gr.Markdown("Upload a dashcam video. The AI will analyze the footage and **only overlay an alert** during actual lane departures.")
+    
+    with gr.Row():
+        with gr.Column():
+            video_input = gr.Video(label="Upload Dashcam Video (.mp4)")
+            submit_btn = gr.Button("Analyze Video", variant="primary")
+        
+        with gr.Column():
+            video_output = gr.Video(label="AI Analyzed Output")
+            
+    submit_btn.click(fn=analyze_video, inputs=video_input, outputs=video_output)
+
+app.launch()