boost cam speed

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

app.py

@@ -1,16 +1,4 @@
-# python .\src\app.py
-
-# ------------------------------
-# Recycle Material Classifier App
-# ------------------------------
-# This script:
-# 1. Loads a trained ResNet-18 model
-# 2. Lets user upload an image or use a live IP camera
-# 3. Classifies the item (paper/plastic/metal)
-# 4. Shows Grad-CAM heatmaps for explainability
-# 5. Displays classification history
-# ------------------------------
-
+# src/app.py
 import json, torch
 from pathlib import Path
 from PIL import Image
@@ -22,73 +10,77 @@ import threading
 import time
 from explain import generate_gradcam
 
-# ---- GLOBAL FLAG (used to stop live feed thread) ---
-stop_flag = False  
+stop_flag = False  # global flag to stop the thread
 
-# ---- MODEL FILE PATHS ----
+# ---- paths ----
 WEIGHTS = Path("models/resnet18_best.pt")
 LABELS  = Path("models/labels.json")
 
-# ---- SELECT DEVICE (GPU if available) ----
+# ---- device ----
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-# ---- LOAD LABELS ----
+# ---- labels ----
 with open(LABELS) as f:
     idx2name = {int(k): v for k, v in json.load(f).items()}
 class_names = [idx2name[i] for i in sorted(idx2name.keys())]
 
-# ---- LOAD MODEL ----
+# ---- model ----
 model = build_model(num_classes=len(class_names), freeze_backbone=False, device=device)
 state = torch.load(WEIGHTS, map_location=device)
 model.load_state_dict(state)
 model.eval()
 
-# ---- IMAGE TRANSFORMATIONS ----
-# Resize -> Tensor -> Normalize (same as training)
+# ---- transforms (same as eval) ----
 tfm = transforms.Compose([
     transforms.Resize((224, 224)),
     transforms.ToTensor(),
     transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225]),
 ])
 
-# ---- PREDICTION FUNCTION ----
-def predict(img: Image.Image):
-    
-    # Generate Grad-CAM heatmaps (explainable visualization)
-    overlay, heatmap, pred_label, conf = generate_gradcam(img, model, device, class_names)
-    
-    # Compute probability scores for all classes
+# ---- prediction and heatmaps ----
+def predict(img: Image.Image, use_gradcam=True):
+    """
+    Predicts the class of the image.
+    If use_gradcam=False, skips Grad-CAM for speed.
+    """
     with torch.no_grad():
         x = tfm(img.convert("RGB")).unsqueeze(0).to(device)
-        probs = torch.softmax(model(x), dim=1).squeeze(0).cpu().tolist()
+        outputs = model(x)
+        probs = torch.softmax(outputs, dim=1).squeeze(0).cpu().tolist()
         scores = {cls: float(probs[i]) for i, cls in enumerate(class_names)}
-        top = max(scores, key=scores.get)
-    
-    return [img, overlay, heatmap], pred_label, conf, scores
+        top_idx = int(torch.argmax(outputs, dim=1).item())
+        pred_label = class_names[top_idx]
+        conf = scores[pred_label]
 
-# ---- HISTORY SETTINGS ----
-MAX_HISTORY = 12 # show up to 12 previous uploads
+    if use_gradcam:
+        overlay, heatmap, _, _ = generate_gradcam(img, model, device, class_names)
+        gallery = [img, overlay, heatmap]
+    else:
+        # No Grad-CAM, just return original image once
+        gallery = [img]
 
+    return gallery, pred_label, conf, scores
 
-def classify_and_update(img, history_state):
+# ---- history ----
+MAX_HISTORY = 12
 
+def classify_and_update(img, history_state):
     if img is None:
         return [], "N/A", "N/A", {}, history_state
     
-    # Run classification
+    # run classification
     gallery_imgs, pred_label, conf, all_scores = predict(img)
     
-    # Update history (keep last 12 images)
+    # update history
     history_state.append(img)
     history_state = history_state[-MAX_HISTORY:]
     
-    # Pad empty slots
+    # pad with None for empty slots
     padded = history_state + [None]*(MAX_HISTORY - len(history_state))
     
     return gallery_imgs, pred_label, f"{round(conf*100)}%", all_scores, *padded, history_state
 
-
-# ---- HISTORY CLICK EVENT ----
+# ---- history select ----
 def on_history_select(evt: gr.SelectData, history_state):
     return history_state[evt.index]
 
@@ -98,24 +90,21 @@ def on_history_click(idx, history_state):
         return history_state[idx]
     return None
 
-# ---- IP CAMERA SETUP ----
-# Replace the IP with your phone’s IP Webcam URL
+# ---- IP Webcam setup ----
 # ip_url = "http://10.132.39.1:8080/video"  # replace with your phone's IP
-# ip_url = "http://192.168.1.6:8080/video"
-ip_url = "http://10.132.39.1:8080/video"
+#ip_url = "http://192.168.1.6:8080/video"
+ip_url = "http://192.168.1.4:8080/video"
 
-# Variables for motion detection
+# ip_url = "http://10.132.39.1:8080/video"
 # cap = None
 # prev_gray = None
-# motion_active = False
-# recent_preds = []
 
 def start_live_feed():
     global stop_flag
     stop_flag = False
     def run():
         while not stop_flag:
-            outputs = live_ipcam_generator()  # Returns (json_dict, label_dict)
+            outputs = live_ipcam_generator()  # returns (json_dict, label_dict)
             json_out_live.update(outputs[0])
             label_out_live.update(outputs[1])
             time.sleep(0.1)
@@ -132,39 +121,45 @@ recent_preds = []
 
 #ip_url = "http://10.132.39.1:8080/video"
 #ip_url = "http://192.168.1.6:8080/video"
-
 def live_ipcam_generator():
-
     """
     Generator that yields only frames with motion detected.
-    Skips all frames without meaningful motion.
+    Optimized for smoother live video: skips idle frames and
+    avoids Grad-CAM unless motion just stopped.
     """
-
     global cap, prev_gray
 
-    motion_threshold = 100  # How sensitive to motion
-    cooldown_sec = 0.5  # Avoid multiple detections per second
+    # --- Tunable performance parameters ---
+    motion_threshold = 50      # ↓ smaller → more sensitive motion detection
+    cooldown_sec = 0.2         # ↓ shorter → more frequent detections
+    frame_resize = (480, 360)  # ↓ smaller → faster model + less network lag
+    sleep_time = 0.005         # ↓ smaller → higher FPS, ↑ → lower CPU load
+    gradcam_on_idle = True     # True = run Grad-CAM once after motion stops
+
     last_trigger_time = 0
+    last_motion_time = 0
+    motion_active = False
+
+    # Initialize camera once
+    if cap is None or not cap.isOpened():
+        try:
+            cap = cv2.VideoCapture(ip_url)
+            cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)   # don't build up old frames
+            cap.set(cv2.CAP_PROP_FPS, 30)         # request 30 FPS
+            time.sleep(1)
+            ret, prev = cap.read()
+            if not ret or prev is None:
+                prev_gray = None
+                raise ValueError("No frame received")
+            prev_gray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)
+        except Exception:
+            dummy_img = Image.new("RGB", (224, 224), (0, 0, 0))
+            yield {"label": "Camera offline", "conf": 0}, {}, [dummy_img], {"motion_level": 0}
+            time.sleep(1)
+            return
 
+    # --- Frame loop ---
     while True:
-        # Initialize camera if not already
-        if cap is None or not cap.isOpened():
-            try:
-                cap = cv2.VideoCapture(ip_url)
-                time.sleep(1)
-                ret, prev = cap.read()
-                if not ret or prev is None:
-                    prev_gray = None
-                    raise ValueError("No frame received")
-                prev_gray = cv2.cvtColor(prev, cv2.COLOR_BGR2GRAY)
-            except Exception:
-                # If camera fails, send a blank image + "offline" message
-                dummy_img = Image.new("RGB", (224, 224), (0, 0, 0))
-                yield {"label": "Camera offline", "conf": 0}, {}, [dummy_img], {"motion_level": 0}
-                time.sleep(1)
-                continue
-
-        # Read frame
         ret, frame = cap.read()
         if not ret or frame is None:
             cap.release()
@@ -172,56 +167,60 @@ def live_ipcam_generator():
             dummy_img = Image.new("RGB", (224, 224), (0, 0, 0))
             yield {"label": "Camera disconnected", "conf": 0}, {}, [dummy_img], {"motion_level": 0}
             time.sleep(1)
-            continue
+            return
 
-        # Convert to grayscale for motion detection
         gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
         if prev_gray is not None:
             diff = cv2.absdiff(prev_gray, gray)
             motion_level = cv2.countNonZero(cv2.threshold(diff, 25, 255, cv2.THRESH_BINARY)[1])
         else:
             motion_level = 0
-
         prev_gray = gray
 
-        # Only process frames with motion above threshold
+        current_time = time.time()
+        img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)).resize((224, 224))
+
+
+        # --- Motion detected ---
         if motion_level > motion_threshold:
-            current_time = time.time()
+            motion_active = True
+            last_motion_time = current_time
+
+            # Enforce cooldown so we don't overprocess
             if current_time - last_trigger_time >= cooldown_sec:
-                img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-                img = img.resize((840, 480))
+                use_gradcam = False  # disable GradCAM during motion
                 pred_images, pred_label, conf, scores = predict(img)
-
                 pred_json = {"label": pred_label, "conf": round(conf * 100, 2)}
                 motion_info = {"motion_level": motion_level}
 
                 last_trigger_time = current_time
-
                 yield pred_json, scores, pred_images, motion_info
-            else:
-                # Skip frame due to cooldown
-                continue
-        else:
-            # Skip frames without motion
-            continue
 
-        # tiny sleep to avoid hogging CPU
-        time.sleep(0.01)
+        # --- Motion stopped, optionally run GradCAM once ---
+        elif motion_active and gradcam_on_idle:
+            if current_time - last_motion_time > 0.3:  # short delay after motion ends
+                motion_active = False
+                use_gradcam = True
+                pred_images, pred_label, conf, scores = predict(img)
+                pred_json = {"label": f"{pred_label} (GradCAM)", "conf": round(conf * 100, 2)}
+                motion_info = {"motion_level": motion_level}
+                yield pred_json, scores, pred_images, motion_info
 
+        # tiny sleep to limit CPU usage
+        time.sleep(sleep_time)
 
-# ---- SIMPLE CSS (hide Gradio footer) ----
+# ---- minimal CSS ----
 css = """
 footer, #footer, .footer, [data-testid="branding"] {display:none !important;}
 a[href*="gradio.app"] {display:none !important;}
 """
 
-# ---- GRADIO APP LAYOUT ----
+# ---- New Gradio Blocks UI ----
 with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
     gr.Markdown("<h1>♻️ Recycle Material Classifier</h1>")
     gr.Markdown("Upload a photo of a recyclable item to classify it as **paper**, **plastic**, or **metal**.")
 
     with gr.Tabs():
-
         # --- Upload Image ---
         # with gr.TabItem("Upload Image"):
         #     img_input = gr.Image(type="pil", label="  Upload an image")
@@ -231,12 +230,9 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
         #     label_out = gr.Label(num_top_classes=3, label="Top-3 probabilities")
             
         #     predict_btn.click(predict, inputs=img_input, outputs=[gallery_out, label_out])
-
-         # ========== TAB 1: UPLOAD IMAGE ==========
         with gr.TabItem("Upload Image"):
 
             with gr.Row(variant="panel"):
-                
                 # --- Input Column ---
                 with gr.Column(scale=1):
                     image_input = gr.Image(
@@ -244,7 +240,6 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                         label="Upload Image",
                         height=350
                     )
-
                     # Load initial history
                     history_state = gr.State([])
                     with gr.Row():
@@ -283,19 +278,18 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
                 outputs=[heatmap_gallery, predicted_label, confidence_score, all_scores_label, *history_slots, history_state]
             )
             
-        # ========== TAB 2: LIVE CAMERA ==========
+         # --- Live IP Webcam ---
         with gr.TabItem("Live IP Webcam"):
             json_out_live = gr.JSON(label="Prediction (top class + confidence %)")
             label_out_live = gr.Label(num_top_classes=3, label="Top-3 probabilities")
             live_feed = gr.Gallery(label="Live Feed",
-                                   height=500,     # Adjust to fit your page
+                                   height=500,     # adjust to fit your page
                                    columns=1       # 1 image per row
                                    )
             motion_out = gr.JSON(label="Motion Info")
-            start_btn = gr.Button("Start Live Feed!!")
+            start_btn = gr.Button("Start Live Feed")
             stop_btn  = gr.Button("Stop Live Feed")
 
-            # Start live feed (motion-triggered)
             start_btn.click(
                 live_ipcam_generator,
                 inputs=[],
@@ -304,6 +298,5 @@ with gr.Blocks(theme=gr.themes.Soft(), css=css) as demo:
 
     # Stop button can just close the browser tab or set a global stop flag
 
-# ---- RUN THE APP ----
 if __name__ == "__main__":
-    demo.launch(inbrowser=True, share=True)
+    demo.launch(inbrowser=True)