Update app.py

app.py

@@ -17,14 +17,14 @@ st.markdown(
     <style>
     .stApp {
         background-color: #f5f5f5;
-        color: #1a1a1a;  /* Dark text for general content */
+        color: #1a1a1a;
     }
     h1 {
-        color: #1a1a1a;  /* Darker title text */
+        color: #1a1a1a;
     }
     .stTabs > div > button {
         background-color: #e0e0e0;
-        color: #1a1a1a;  /* Darker tab text */
+        color: #1a1a1a;
         font-weight: bold;
     }
     .stTabs > div > button:hover {
@@ -33,7 +33,7 @@ st.markdown(
     }
     .stButton > button {
         background-color: #e0e0e0;
-        color: #1a1a1a;  /* Darker button text */
+        color: #1a1a1a;
         font-weight: bold;
     }
     .stButton > button:hover {
@@ -103,13 +103,13 @@ with tabs[1]:
     col1, col2 = st.columns([1, 1])
     with col1:
         st.markdown("**Webcam Feed**")
-        st.write("Provide a webcam URL to check snapshots for hazards every 30 seconds.")
+        st.write("Provide a webcam URL (image or video stream) to monitor for hazards.")
         webcam_url = st.text_input("Webcam URL", "http://<your_webcam_ip>/current.jpg", label_visibility="collapsed")
         confidence = st.slider("Detection Threshold", 0.25, 1.0, 0.4, key="webcam_conf")
+        refresh_rate = st.slider("Refresh Rate (seconds)", 1, 60, 30, key="webcam_rate")
         start = st.button("Begin Monitoring", key="webcam_start")
         stop = st.button("Stop Monitoring", key="webcam_stop")
 
-        # Handle monitoring state
         if start:
             st.session_state.monitoring = True
             st.session_state.current_webcam_url = webcam_url
@@ -119,37 +119,55 @@ with tabs[1]:
 
     with col2:
         if st.session_state.monitoring and st.session_state.current_webcam_url:
-            image_placeholder = st.empty()
+            frame_placeholder = st.empty()
+            status_placeholder = st.empty()
             timer_placeholder = st.empty()
-            refresh_interval = 30  # Refresh every 30 seconds
-            while True:
-                start_time = time.time()
+            
+            # Try video stream first
+            cap = cv2.VideoCapture(webcam_url)
+            is_video_stream = cap.isOpened()
+            
+            while st.session_state.monitoring:
                 try:
-                    response = requests.get(st.session_state.current_webcam_url, timeout=5)
-                    if response.status_code != 200:
-                        st.error(f"Fetch failed: HTTP {response.status_code}")
-                        break
-                    image_array = np.asarray(bytearray(response.content), dtype=np.uint8)
-                    frame = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
-                    if frame is None:
-                        st.error("Image decoding failed.")
-                        break
+                    start_time = time.time()
+                    if is_video_stream:
+                        ret, frame = cap.read()
+                        if not ret:
+                            status_placeholder.error("Video stream interrupted.")
+                            break
+                    else:
+                        # Fallback to image-based webcam
+                        response = requests.get(webcam_url, timeout=5)
+                        if response.status_code != 200:
+                            status_placeholder.error(f"Fetch failed: HTTP {response.status_code}")
+                            break
+                        image_array = np.asarray(bytearray(response.content), dtype=np.uint8)
+                        frame = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+                        if frame is None:
+                            status_placeholder.error("Image decoding failed.")
+                            break
+
                     results = model.predict(frame, conf=confidence)
                     detected_frame = results[0].plot()[:, :, ::-1]
-                    image_placeholder.image(detected_frame, use_column_width=True)
+                    frame_placeholder.image(detected_frame, use_column_width=True)
+                    status_placeholder.write(f"Objects detected: {len(results[0].boxes)}")
+                    
                     elapsed = time.time() - start_time
-                    remaining = max(0, refresh_interval - elapsed)
+                    remaining = max(0, refresh_rate - elapsed)
                     timer_placeholder.write(f"Next scan: {int(remaining)}s")
-                    while remaining > 0:
-                        time.sleep(1)
-                        elapsed = time.time() - start_time
-                        remaining = max(0, refresh_interval - elapsed)
-                        timer_placeholder.write(f"Next scan: {int(remaining)}s")
-                    st.experimental_rerun()
+                    
+                    if not is_video_stream:
+                        time.sleep(remaining)
+                    else:
+                        time.sleep(0.1)  # Faster update for video streams
+                    
                 except Exception as e:
-                    st.error(f"Error: {e}")
+                    status_placeholder.error(f"Error: {e}")
                     st.session_state.monitoring = False
                     break
+            
+            if is_video_stream:
+                cap.release()
 
 # Tab 3: YouTube
 with tabs[2]:
@@ -159,30 +177,44 @@ with tabs[2]:
         st.write("Enter a live YouTube URL to auto-analyze the stream.")
         youtube_url = st.text_input("YouTube URL", "https://www.youtube.com/watch?v=<id>", label_visibility="collapsed")
         confidence = st.slider("Detection Threshold", 0.25, 1.0, 0.4, key="yt_conf")
+        start_yt = st.button("Start Analysis", key="yt_start")
+        stop_yt = st.button("Stop Analysis", key="yt_stop")
+
+        if 'yt_monitoring' not in st.session_state:
+            st.session_state.yt_monitoring = False
+        
+        if start_yt:
+            st.session_state.yt_monitoring = True
+        if stop_yt:
+            st.session_state.yt_monitoring = False
+
     with col2:
-        if youtube_url and youtube_url != "https://www.youtube.com/watch?v=<id>":
-            st.write("Analyzing live stream...")
+        if st.session_state.yt_monitoring and youtube_url and youtube_url != "https://www.youtube.com/watch?v=<id>":
+            status_placeholder = st.empty()
+            frame_placeholder = st.empty()
             try:
+                status_placeholder.write("Initializing stream...")
                 streams = streamlink.streams(youtube_url)
                 if not streams:
-                    st.error("No streams found. Check the URL.")
+                    status_placeholder.error("No streams found. Check if the URL is a live stream.")
                 else:
-                    stream_url = streams["best"].to_url()
+                    stream_url = streams["best"].url
                     cap = cv2.VideoCapture(stream_url)
                     if not cap.isOpened():
-                        st.error("Unable to open stream.")
+                        status_placeholder.error("Unable to open stream.")
                     else:
-                        frame_placeholder = st.empty()
-                        while cap.isOpened():
+                        status_placeholder.write("Analyzing live stream...")
+                        while st.session_state.yt_monitoring and cap.isOpened():
                             ret, frame = cap.read()
                             if not ret:
-                                st.error("Stream interrupted.")
+                                status_placeholder.error("Stream interrupted.")
                                 break
                             results = model.predict(frame, conf=confidence)
                             detected_frame = results[0].plot()[:, :, ::-1]
                             frame_placeholder.image(detected_frame, use_column_width=True)
-                            st.write(f"Objects detected: {len(results[0].boxes)}")
-                            time.sleep(1)  # Check every second
+                            status_placeholder.write(f"Objects detected: {len(results[0].boxes)}")
+                            time.sleep(0.1)  # Control frame rate
                         cap.release()
             except Exception as e:
-                st.error(f"Error: {e}")
+                status_placeholder.error(f"Error: {e}")
+            st.session_state.yt_monitoring = False