Update app.py

app.py

@@ -17,6 +17,9 @@ import torch.nn as nn
 import numpy as np
 import pandas as pd
 import joblib
+import smtplib
+import ssl
+from email.message import EmailMessage
 import threading
 import uuid
 import time
@@ -53,8 +56,10 @@ print("--- BOOT SEQUENCE INITIATED ---", flush=True)
 
 app = Flask(__name__)
 
-# --- NTFY PUSH NOTIFICATION TOPIC ---
-NTFY_TOPIC = "crashvision_sos" 
+ALERT_EMAIL_SENDER = "gowreeshgowri50@gmail.com" 
+ALERT_EMAIL_PASSWORD = "oynu ulet pynk xsza".replace(" ", "") 
+ALERT_EMAIL_RECEIVER = "mcblackdevil12342@gmail.com"
+ENABLE_EMAIL_ALERTS = True
 
 UPLOAD_FOLDER = 'uploads'
 MODEL_FOLDER = 'models'
@@ -123,28 +128,27 @@ def process_accident_async(stream_id, frame, location, confidence, severity):
     if stream_id in active_streams:
         active_streams[stream_id]["plates"] = detected_plates
 
-    # --- HTTP PUSH DISPATCH (Guaranteed Two-Step Method) ---
-    try:
-        ntfy_url = f"https://ntfy.sh/{NTFY_TOPIC}"
-        
-        # Step 1: Send Text Notification First (This always succeeds and rings the phone instantly)
-        text_payload = f"Severity: {severity.upper()}\nConfidence: {confidence}%\nLocation: {location}".encode('utf-8')
-        requests.post(ntfy_url, data=text_payload, headers={
-            "Title": f"🚨 {severity.upper()} ACCIDENT DETECTED",
-            "Priority": "high",
-            "Tags": "rotating_light,car"
-        }, timeout=5)
-        
-        # Step 2: Send Image Attachment
-        _, buffer = cv2.imencode('.jpg', frame)
-        requests.post(ntfy_url, data=buffer.tobytes(), headers={
-            "Title": "Crash Snapshot",
-            "Filename": "incident.jpg"
-        }, timeout=10)
-        
-        print(f"📡 SOS Push dispatched to ntfy.sh/{NTFY_TOPIC}", flush=True)
-    except Exception as e:
-        print(f"📡 SOS Push failed: {e}", flush=True)
+    if ENABLE_EMAIL_ALERTS:
+        try:
+            _, buffer = cv2.imencode('.jpg', frame)
+            msg = EmailMessage()
+            msg['Subject'] = f"🚨 ALERT: {severity.upper()} ACCIDENT DETECTED"
+            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.")
+            
+            msg.add_attachment(buffer.tobytes(), maintype='image', subtype='jpeg', filename='incident.jpg')
+            
+            server = smtplib.SMTP('smtp.gmail.com', 587, timeout=15)
+            server.ehlo()
+            server.starttls()
+            server.login(ALERT_EMAIL_SENDER, ALERT_EMAIL_PASSWORD)
+            server.send_message(msg)
+            server.quit()
+            
+            print(f"📧 Dispatch Email Sent Successfully for Stream {stream_id}", flush=True)
+        except Exception as e:
+            print(f"📧 Email Failed to Send: {str(e)}", flush=True)
 
 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)
@@ -160,20 +164,21 @@ def run_temporal_analysis(stream_id, frames_3d_copy, prob_max, prob_mean, prob_m
         
         try:
             ensemble_probs = model_svm.predict_proba(combined)[0]
-            final_idx = model_svm.predict(combined)[0]
+            final_idx = int(model_svm.predict(combined)[0])
             confidence = float(ensemble_probs[final_idx] * 100)
             severity = classes[final_idx]
-        except:
-            final_idx = min(int(np.argmax(prob_max)), 2)
-            confidence = float(np.max(prob_max)) * 100
+        except Exception as svm_err:
+            final_idx = min(int(np.argmax(prob_max)), 2) if np.sum(prob_max) > 0 else min(int(np.argmax(prob_3d)), 2)
+            confidence = float(np.max(prob_max)) * 100 if np.sum(prob_max) > 0 else float(np.max(prob_3d)) * 100
             severity = classes[final_idx]
 
         state["severity"] = severity.capitalize()
         state["confidence"] = round(confidence, 1)
-        state["cnn"] = round(yolo_max_conf, 1)
         state["rcnn"] = round(float(np.max(prob_3d)) * 100, 1)
 
-        if confidence > 75:
+        # 🚨 FIX: Strict Dual-Consensus checks to prevent IP camera frame-drop false positives!
+        # Requires 85% overall confidence AND at least 45% spatial confirmation of an actual object collision.
+        if confidence > 85 and yolo_max_conf > 45.0:
             state["final_decision"] = True
             state["label"] = f"Incident Logged: {severity.capitalize()}"
             threading.Thread(target=process_accident_async, args=(stream_id, raw_frame, location, confidence, severity)).start()
@@ -205,15 +210,20 @@ def init_upload():
 
 @app.route('/init_stream', methods=['POST'])
 def init_stream():
-    url = request.json.get('url')
+    url = request.json.get('url', '').strip()
     
     if 'youtube.com' in url or 'youtu.be' in url:
         try:
-            ydl_opts = {'format': 'best[ext=mp4]/best/bestvideo', 'quiet': True, 'noplaylist': True}
+            ydl_opts = {'format': 'best', 'quiet': True, 'noplaylist': True}
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                 info = ydl.extract_info(url, download=False)
-                if 'url' in info: url = info['url']
-                elif 'formats' in info and len(info['formats']) > 0: url = info['formats'][-1]['url']
+                if 'url' in info: 
+                    url = info['url']
+                elif 'formats' in info and len(info['formats']) > 0: 
+                    for f in reversed(info['formats']):
+                        if f.get('vcodec') != 'none':
+                            url = f['url']
+                            break
         except Exception as e:
             print(f"yt-dlp extraction failed: {e}", flush=True)
 
@@ -302,7 +312,7 @@ def video_stream_gen(stream_id, source, location):
             target_frame = int(elapsed * fps)
             frames_to_skip = target_frame - current_frame_idx
             if frames_to_skip > 0:
-                for _ in range(min(frames_to_skip, 5)):
+                for _ in range(min(frames_to_skip, 3)):
                     cap.grab()
                     current_frame_idx += 1
 
@@ -353,19 +363,36 @@ def video_stream_gen(stream_id, source, location):
                 yolo_probs.append(probs)
                 if len(yolo_probs) > 10: yolo_probs.pop(0)
 
+                # 🚨 FIX: LIVE update of Spatial UI data so the screen doesn't feel stuck
+                if len(yolo_probs) > 0:
+                    curr_max = np.max(yolo_probs, axis=0)
+                    acc_conf = float(np.max(curr_max[:3])) * 100 if len(curr_max) >= 3 else float(np.max(curr_max)) * 100
+                    state["cnn"] = round(acc_conf, 1)
+                    if state["cnn"] > 0 and state["confidence"] == 0:
+                        state["label"] = "Scanning Spatial Features..."
+
                 f_3d = cv2.resize(frame, (112, 112))
                 frames_3d.append(cv2.cvtColor(f_3d, cv2.COLOR_BGR2RGB))
                 if len(frames_3d) > 16: frames_3d.pop(0)
 
-                if len(frames_3d) == 16 and frame_count % 10 == 0 and not state.get("is_analyzing"):
+                if len(frames_3d) >= 8 and frame_count % 10 == 0 and not state.get("is_analyzing"):
                     state["is_analyzing"] = True
-                    p_max = np.max(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
-                    p_mean = np.mean(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
-                    p_min = np.min(yolo_probs, axis=0) if yolo_probs else np.zeros(4)
+                    
+                    analysis_frames = list(frames_3d)
+                    while len(analysis_frames) < 16:
+                        analysis_frames.append(analysis_frames[-1])
+                        
+                    p_max = np.max(yolo_probs, axis=0) if len(yolo_probs) > 0 else np.zeros(4)
+                    p_mean = np.mean(yolo_probs, axis=0) if len(yolo_probs) > 0 else np.zeros(4)
+                    p_min = np.min(yolo_probs, axis=0) if len(yolo_probs) > 0 else np.zeros(4)
+                    
+                    acc_max_conf = float(np.max(p_max[:3])) * 100 if len(p_max) >= 3 else float(np.max(p_max)) * 100
+                    
                     threading.Thread(target=run_temporal_analysis, args=(
-                        stream_id, list(frames_3d), p_max, p_mean, p_min, float(np.max(p_max))*100, frame.copy(), location
+                        stream_id, analysis_frames, p_max, p_mean, p_min, acc_max_conf, frame.copy(), location
                     )).start()
-            except: pass
+            except Exception as e: 
+                state["is_analyzing"] = False
 
         _, buffer = cv2.imencode('.jpg', display_frame)
         last_buffer = buffer.tobytes()