Update app.py

app.py

@@ -86,7 +86,6 @@ except:
 # --- Helper Functions ---
 
 def get_geo_info(ip_or_url=None):
-    """Fetches location and weather based on IP or URL."""
     try:
         target = ""
         if ip_or_url:
@@ -125,11 +124,8 @@ def process_accident_async(stream_id, frame, location, confidence, severity):
             msg['From'] = ALERT_EMAIL_SENDER
             msg['To'] = ALERT_EMAIL_RECEIVER
             msg.set_content(f"Incident Report\nLocation: {location}\nSeverity: {severity}\nConfidence: {confidence}%\nTime: {datetime.datetime.now()}\n\nSystem has locked this stream for investigation.")
-            
-            # Attach Snapshot
             msg.add_attachment(buffer.tobytes(), maintype='image', subtype='jpeg', filename='incident.jpg')
             
-            # 🚨 Attach Original Video if it's an uploaded file and under 20MB 🚨
             source = app.config.get(f'SRC_{stream_id}')
             is_file = source and not str(source).startswith('http') and os.path.exists(source)
             if is_file:
@@ -137,16 +133,13 @@ def process_accident_async(stream_id, frame, location, confidence, severity):
                     if os.path.getsize(source) < 20 * 1024 * 1024:
                         with open(source, 'rb') as f:
                             msg.add_attachment(f.read(), maintype='video', subtype='mp4', filename='incident_video.mp4')
-                except Exception as ve:
-                    print(f"Failed to attach video: {ve}")
+                except Exception as ve: pass
 
             context = ssl.create_default_context()
             with smtplib.SMTP_SSL('smtp.gmail.com', 465, context=context) as smtp:
                 smtp.login(ALERT_EMAIL_SENDER, ALERT_EMAIL_PASSWORD)
                 smtp.send_message(msg)
-            print(f"📧 Dispatch Email Sent for Stream {stream_id}", flush=True)
-        except Exception as e:
-            print(f"📧 Email Failed: {e}", flush=True)
+        except Exception as e: pass
 
 def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_min, yolo_max_conf, raw_frame, location):
     state = active_streams.get(stream_id)
@@ -164,7 +157,6 @@ def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_m
         confidence = float(ensemble_probs[final_idx] * 100)
         severity = classes[final_idx]
 
-        # Lock the decision if confidence is high
         if confidence > 85:
             state["final_decision"] = True
             state["label"] = f"Incident Logged: {severity.capitalize()}"
@@ -180,8 +172,7 @@ def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_m
             state["cnn"] = round(yolo_max_conf, 1)
             state["rcnn"] = round(float(np.max(prob_3d)) * 100, 1)
 
-    except Exception as e:
-        print(f"AI Error: {e}")
+    except Exception as e: pass
     finally:
         if state: state["is_analyzing"] = False
 
@@ -193,11 +184,13 @@ def init_upload():
     filename = secure_filename(file.filename)
     path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
     file.save(path)
-    # Strict Nil for Local Files
     loc, wx, file_time = "Nil", "--", "--"
     stream_id = f"up_{uuid.uuid4().hex}"
     app.config[f'SRC_{stream_id}'] = path
-    active_streams[stream_id] = {"label": "Initializing...", "final_decision": False, "confidence": 0, "severity": "--", "plates": [], "show_tracking": True}
+    active_streams[stream_id] = {
+        "label": "Initializing...", "final_decision": False, "confidence": 0, "severity": "--", 
+        "plates": [], "show_tracking": True, "paused": False, "seek_to": None, "progress": 0
+    }
     return jsonify({"stream_id": stream_id, "location": loc, "weather": wx, "time": file_time})
 
 @app.route('/init_stream', methods=['POST'])
@@ -207,43 +200,90 @@ def init_stream():
     v_time = datetime.datetime.now().strftime("%H:%M:%S")
     stream_id = f"live_{uuid.uuid4().hex}"
     app.config[f'SRC_{stream_id}'] = url
-    active_streams[stream_id] = {"label": "Connecting...", "final_decision": False, "confidence": 0, "severity": "--", "plates": [], "show_tracking": True}
+    active_streams[stream_id] = {
+        "label": "Connecting...", "final_decision": False, "confidence": 0, "severity": "--", 
+        "plates": [], "show_tracking": True, "paused": False, "seek_to": None, "progress": 0
+    }
     return jsonify({"stream_id": stream_id, "location": loc, "weather": wx, "time": v_time})
 
-@app.route('/toggle_tracking/<stream_id>', methods=['POST'])
-def toggle_tracking(stream_id):
-    """Dynamic flip between AI Tracking and Raw Feed without restarting the stream"""
-    if stream_id in active_streams:
-        active_streams[stream_id]["show_tracking"] = request.json.get("track", True)
-        return jsonify({"status": "ok"})
-    return jsonify({"error": "not found"}), 404
+@app.route('/video_control/<stream_id>', methods=['POST'])
+def video_control(stream_id):
+    """Dynamic Video Controls for the AI Player"""
+    state = active_streams.get(stream_id)
+    if not state: return jsonify({"error": "not found"}), 404
+    
+    action = request.json.get('action')
+    if action == 'toggle_tracking': state["show_tracking"] = request.json.get("track", True)
+    elif action == 'pause': state["paused"] = True
+    elif action == 'play': state["paused"] = False
+    elif action == 'seek': state["seek_to"] = request.json.get("value", 0.0)
+    
+    return jsonify({"status": "ok"})
 
 def video_stream_gen(stream_id, source, location):
     cap = cv2.VideoCapture(source)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    if not fps or fps == 0: fps = 30.0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    is_live = str(source).startswith('http')
+    
     frames_3d = []
     yolo_probs = []
     frame_count = 0
+    last_buffer = None
 
     while True:
-        ret, frame = cap.read()
-        if not ret: break
-
         state = active_streams.get(stream_id)
         if not state: break
 
-        # 1. Visualization Toggle
+        # Video Control: Seek
+        if state.get('seek_to') is not None:
+            target = int(state['seek_to'] * total_frames)
+            cap.set(cv2.CAP_PROP_POS_FRAMES, target)
+            state['seek_to'] = None
+            frames_3d.clear()
+            yolo_probs.clear()
+
+        # Video Control: Pause
+        if state.get('paused'):
+            time.sleep(0.1)
+            if last_buffer: yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + last_buffer + b'\r\n')
+            continue
+
+        loop_start = time.time()
+        ret, frame = cap.read()
+        
+        if not ret: 
+            if total_frames > 0: state["progress"] = 100 # End of video
+            break
+
+        # Calculate progress
+        if total_frames > 0:
+            state['progress'] = (cap.get(cv2.CAP_PROP_POS_FRAMES) / total_frames) * 100
+
+        # AI Tracking Layer
         if state.get("show_tracking", True):
             track_res = model_tracker(frame, classes=[2, 3, 5, 7], verbose=False, conf=0.3)[0]
             display_frame = track_res.plot()
         else:
             display_frame = frame
 
-        # 2. Severity Scanning (Only runs if a final decision hasn't been made yet)
+        # Brain / Severity Scanning
         if not state.get("final_decision"):
             res = model_yolo(frame, verbose=False)[0]
+            
+            probs = np.zeros(4)
             if res.probs is not None:
-                yolo_probs.append(res.probs.data.cpu().numpy())
-                if len(yolo_probs) > 10: yolo_probs.pop(0)
+                data = res.probs.data.cpu().numpy()
+                length = min(len(data), 4)
+                probs[:length] = data[:length]
+            elif res.boxes is not None and len(res.boxes) > 0:
+                for box in res.boxes:
+                    cls_id = int(box.cls[0].item())
+                    if cls_id < 4: probs[cls_id] = max(probs[cls_id], float(box.conf[0].item()))
+            
+            yolo_probs.append(probs)
+            if len(yolo_probs) > 10: yolo_probs.pop(0)
 
             f_3d = cv2.resize(frame, (112, 112))
             frames_3d.append(cv2.cvtColor(f_3d, cv2.COLOR_BGR2RGB))
@@ -260,8 +300,16 @@ def video_stream_gen(stream_id, source, location):
                 )).start()
 
         _, buffer = cv2.imencode('.jpg', display_frame)
-        yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + buffer.tobytes() + b'\r\n')
+        last_buffer = buffer.tobytes()
+        yield (b'--frame\r\nContent-Type: image/jpeg\r\n\r\n' + last_buffer + b'\r\n')
         frame_count += 1
+        
+        # 🚨 FIX: Force actual frame playback speed for local videos so AI has time to process 🚨
+        if not is_live:
+            elapsed = time.time() - loop_start
+            sleep_time = (1.0 / fps) - elapsed
+            if sleep_time > 0:
+                time.sleep(sleep_time)
     
     cap.release()
 
@@ -284,14 +332,12 @@ def predict_traffic_risk():
         
         prob = float(model_traffic.predict_proba(df)[0][1] * 100)
         
+        # Strict mapping as requested
         if prob >= 70: status = "Major"
         elif prob >= 35: status = "Moderate"
         else: status = "Minor"
 
-        # No longer returning the exact percentage number to frontend
-        return jsonify({
-            "status": status
-        })
+        return jsonify({"status": status})
     except Exception as e: return jsonify({"error": str(e)}), 500
 
 @app.route('/')