Update app.py

app.py

@@ -73,7 +73,7 @@ st.markdown("---")
 # Tabs
 tabs = st.tabs(["Upload", "Webcam"])
 
-# Tab 1: Upload (Simplified with diagnostics)
+# Tab 1: Upload (Optimized with new sampling options)
 with tabs[0]:
     col1, col2 = st.columns(2)
     with col1:
@@ -81,7 +81,16 @@ with tabs[0]:
         st.write("Upload an image or video to scan for fire or smoke.")
         source_file = st.file_uploader("", type=["jpg", "jpeg", "png", "mp4"], label_visibility="collapsed")
         confidence = st.slider("Detection Threshold", 0.25, 1.0, 0.4, key="upload_conf")
-        sampling_options = {"Every Frame": 0, "1/4 FPS": .25, "2 FPS": 2, "5 FPS": 5}
+        # Expanded sampling options
+        sampling_options = {
+            "Every Frame": 0,
+            "1 FPS": 1,
+            "2 FPS": 2,
+            "5 FPS": 5,
+            "1 frame / 5s": 5,
+            "1 frame / 10s": 10,
+            "1 frame / 15s": 15
+        }
         sampling_rate = st.selectbox("Analysis Rate", list(sampling_options.keys()), index=1, key="sampling_rate")
     
     with col2:
@@ -91,7 +100,7 @@ with tabs[0]:
         download_placeholder = st.empty()
         
         if source_file:
-            st.write(f"File size: {source_file.size / 1024 / 1024:.2f} MB")  # Diagnostic
+            st.write(f"File size: {source_file.size / 1024 / 1024:.2f} MB")
             if st.button("Detect Wildfire", key="upload_detect"):
                 file_type = source_file.type.split('/')[0]
                 if file_type == 'image':
@@ -117,9 +126,19 @@ with tabs[0]:
                             frame_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))
                             frame_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))
                             
-                            # Frame sampling
-                            target_fps = sampling_options[sampling_rate]
-                            frame_skip = 1 if target_fps == 0 else max(1, int(fps / target_fps))
+                            # Calculate frame skip
+                            target_rate = sampling_options[sampling_rate]
+                            if target_rate == 0:  # Every frame
+                                frame_skip = 1
+                            elif target_rate <= 5:  # FPS-based (1, 2, 5)
+                                frame_skip = max(1, int(fps / target_rate))
+                            else:  # Seconds-based (5s, 10s, 15s)
+                                frame_skip = max(1, int(fps * target_rate))
+                            
+                            # Batch processing setup
+                            batch_size = 10  # Process 10 frames at a time
+                            frames_to_process = []
+                            frame_indices = []
                             
                             # Output video
                             output_tfile = tempfile.NamedTemporaryFile(delete=False, suffix='_detected.mp4')
@@ -130,18 +149,27 @@ with tabs[0]:
                             frame_count = 0
                             processed_count = 0
                             last_detected_frame = None
+                            last_ui_update = time.time()
                             
                             while success:
                                 if frame_count % frame_skip == 0:
-                                    res = model.predict(frame, conf=confidence)
-                                    detected_frame = res[0].plot()[:, :, ::-1]
-                                    last_detected_frame = detected_frame
-                                    frame_placeholder.image(detected_frame, use_column_width=True)
-                                    status_placeholder.write(f"Frame {frame_count}: Objects detected: {len(res[0].boxes)}")
+                                    frames_to_process.append(frame)
+                                    frame_indices.append(frame_count)
                                     processed_count += 1
-                                elif last_detected_frame is not None:
-                                    frame_placeholder.image(last_detected_frame, use_column_width=True)
                                 
+                                # Process batch when full or at end
+                                if len(frames_to_process) >= batch_size or (not success and frames_to_process):
+                                    res = model.predict(frames_to_process, conf=confidence)
+                                    for i, (result, idx) in enumerate(zip(res, frame_indices)):
+                                        detected_frame = result.plot()[:, :, ::-1]
+                                        last_detected_frame = detected_frame
+                                        # Update UI sparingly (every 1s)
+                                        if time.time() - last_ui_update >= 1.0:
+                                            frame_placeholder.image(detected_frame, use_column_width=True)
+                                            status_placeholder.write(f"Frame {idx}: Objects detected: {len(result.boxes)}")
+                                            last_ui_update = time.time()
+                                
+                                # Write all frames (processed or last detected)
                                 if last_detected_frame is not None:
                                     out.write(last_detected_frame[:, :, ::-1])
                                 
@@ -154,7 +182,9 @@ with tabs[0]:
                                 
                                 success, frame = vidcap.read()
                                 frame_count += 1
-                                time.sleep(0.05)
+                                if len(frames_to_process) >= batch_size:
+                                    frames_to_process = []
+                                    frame_indices = []
                             
                             vidcap.release()
                             out.release()