Update app.py

app.py

@@ -73,7 +73,7 @@ st.markdown("---")
 # Tabs
 tabs = st.tabs(["Upload", "Webcam"])
 
-# Tab 1: Upload (Optimized with new sampling options)
+# Tab 1: Upload (Output only analyzed frames)
 with tabs[0]:
     col1, col2 = st.columns(2)
     with col1:
@@ -81,7 +81,6 @@ 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")
-        # Expanded sampling options
         sampling_options = {
             "Every Frame": 0,
             "1 FPS": 1,
@@ -128,27 +127,28 @@ with tabs[0]:
                             
                             # Calculate frame skip
                             target_rate = sampling_options[sampling_rate]
-                            if target_rate == 0:  # Every frame
+                            if target_rate == 0:
                                 frame_skip = 1
-                            elif target_rate <= 5:  # FPS-based (1, 2, 5)
+                            elif target_rate <= 5:
                                 frame_skip = max(1, int(fps / target_rate))
-                            else:  # Seconds-based (5s, 10s, 15s)
+                            else:
                                 frame_skip = max(1, int(fps * target_rate))
                             
                             # Batch processing setup
-                            batch_size = 10  # Process 10 frames at a time
+                            batch_size = 10
                             frames_to_process = []
                             frame_indices = []
                             
-                            # Output video
+                            # Output video (only analyzed frames)
                             output_tfile = tempfile.NamedTemporaryFile(delete=False, suffix='_detected.mp4')
                             fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-                            out = cv2.VideoWriter(output_tfile.name, fourcc, fps, (frame_width, frame_height))
+                            # Use 1 FPS for output to make it viewable, adjust as needed
+                            output_fps = 1
+                            out = cv2.VideoWriter(output_tfile.name, fourcc, output_fps, (frame_width, frame_height))
                             
                             success, frame = vidcap.read()
                             frame_count = 0
                             processed_count = 0
-                            last_detected_frame = None
                             last_ui_update = time.time()
                             
                             while success:
@@ -162,21 +162,18 @@ with tabs[0]:
                                     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)
+                                        # Update UI sparingly
                                         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])
+                                        # Write only analyzed frames
+                                        out.write(detected_frame[:, :, ::-1])
                                 
                                 # Progress
                                 if total_frames > 0:
                                     progress_percent = (frame_count + 1) / total_frames * 100
-                                    progress_placeholder.write(f"Progress: {progress_percent:.1f}% (Processed {processed_count} frames)")
+                                    progress_placeholder.write(f"Progress: {progress_percent:.1f}% (Analyzed {processed_count} frames)")
                                 else:
                                     progress_placeholder.write(f"Progress: {frame_count} frames processed")
                                 
@@ -197,7 +194,7 @@ with tabs[0]:
                                     file_name="analyzed_video.mp4",
                                     mime="video/mp4"
                                 )
-                            status_placeholder.write(f"Video processing complete. Processed {processed_count} of {frame_count} frames.")
+                            status_placeholder.write(f"Video processing complete. Analyzed {processed_count} frames.")
                     except Exception as e:
                         status_placeholder.error(f"Error processing video: {str(e)}")