Update app.py

app.py

@@ -6,7 +6,7 @@ import numpy as np
 from torchvision import transforms
 import os
 
-# --- 1. MODEL ARCHITECTURE ---
+# --- 1. MODEL ARCHITECTURE (Hidden from UI) ---
 class LDobjModel(nn.Module):
     def __init__(self):
         super(LDobjModel, self).__init__()
@@ -30,11 +30,11 @@ class LDobjModel(nn.Module):
         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
+# --- 2. INITIALIZATION ---
+device = torch.device('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))
+if os.path.exists('LDobj_weights.pth'):
+    model.load_state_dict(torch.load('LDobj_weights.pth', map_location=device))
 model.eval()
 
 transform = transforms.Compose([
@@ -43,91 +43,82 @@ transform = transforms.Compose([
     transforms.ToTensor()
 ])
 
-# --- 3. VIDEO PROCESSING LOGIC ---
+# --- 3. CORE LOGIC (With Anti-Glitch Processing) ---
 def analyze_video(input_video_path):
-    if input_video_path is None:
+    if not input_video_path:
         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"
+    raw_output = "temp_raw.mp4"
     fourcc = cv2.VideoWriter_fourcc(*'mp4v')
     out = cv2.VideoWriter(raw_output, fourcc, fps, (width, height))
 
+    morph_kernel = np.ones((5, 5), np.uint8)
+
     while cap.isOpened():
         ret, frame = cap.read()
         if not ret: break
 
-        # Pre-process frame
+        # AI Prediction
         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 Cleaning
         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
+        mask_full = cv2.resize(mask, (width, height), interpolation=cv2.INTER_NEAREST)
+        mask_full = cv2.morphologyEx(mask_full, cv2.MORPH_OPEN, morph_kernel)
 
-        # ONLY MODIFY FRAME IF ALERT IS HAPPENING
-        if alert_triggered:
-            status_color = (0, 0, 255) # Red BGR
+        # Departure Alert Logic
+        moments = cv2.moments(mask_full[int(height*0.75):, :])
+        if moments["m00"] > 0 and abs(int(moments["m10"] / moments["m00"]) - width // 2) > (width * 0.1):
             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)
+            overlay[mask_full > 0] = (0, 0, 255)
+            frame = cv2.addWeighted(frame, 0.7, overlay, 0.3, 0)
+            cv2.putText(frame, "LANE DEPARTURE", (width//10, 80), cv2.FONT_HERSHEY_DUPLEX, 1.5, (0, 0, 255), 3)
+
+        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}")
+    # WEB OPTIMIZATION: Convert to H.264 with FastStart for smooth web playback
+    web_output = "ldobj_final.mp4"
+    os.system(f"ffmpeg -y -i {raw_output} -c:v libx264 -pix_fmt yuv420p -movflags +faststart {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.")
+# --- 4. PERFECTED FRONTEND DESIGN ---
+# Custom CSS to lock heights and prevent the "screen flicker" during loading
+custom_css = """
+#video-container { min-height: 400px; }
+.gradio-container { background-color: #f7f9fc; }
+footer { visibility: hidden; }
+"""
+
+with gr.Blocks(css=custom_css, theme=gr.themes.Default(primary_hue="red")) as app:
+    gr.HTML("<h1 style='text-align: center; color: #d32f2f;'>🚗 LDobj Safety Interface</h1>")
+    gr.HTML("<p style='text-align: center;'>AI-Powered Lane Departure Detection & Alert System</p>")
     
-    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")
+    with gr.Group(): # Groups components to prevent them from jumping around
+        with gr.Row():
+            with gr.Column(scale=1):
+                video_in = gr.Video(label="Source Dashcam Feed", mirror_webcam=False)
+                run_btn = gr.Button("START AI ANALYSIS", variant="primary")
             
-    submit_btn.click(fn=analyze_video, inputs=video_input, outputs=video_output)
+            with gr.Column(scale=1):
+                # We set interactive=False to make it a dedicated player
+                video_out = gr.Video(label="LDobj Alert Output", interactive=False, autoplay=True)
+
+    gr.Markdown("---")
+    gr.Markdown("### How it works\n1. **Invisible Monitor:** Under normal conditions, the video remains clean.\n2. **Active Alert:** If the car drifts, the system highlights the lanes in red and triggers an on-screen warning.")
+
+    run_btn.click(fn=analyze_video, inputs=video_in, outputs=video_out)
 
-app.launch()
+if __name__ == "__main__":
+    app.launch()