Update app.py

app.py

@@ -73,7 +73,7 @@ st.markdown("---")
 # Tabs
 tabs = st.tabs(["Upload", "Webcam"])
 
-# Tab 1: Upload (With preview and progress)
+# Tab 1: Upload (Simplified with diagnostics)
 with tabs[0]:
     col1, col2 = st.columns(2)
     with col1:
@@ -81,79 +81,95 @@ 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 FPS": 1, "2 FPS": 2, "5 FPS": 5}
+        sampling_rate = st.selectbox("Analysis Rate", list(sampling_options.keys()), index=1, key="sampling_rate")
     
     with col2:
         frame_placeholder = st.empty()
         status_placeholder = st.empty()
-        progress_placeholder = st.empty()  # For progress percentage
+        progress_placeholder = st.empty()
         download_placeholder = st.empty()
         
-        if source_file and st.button("Detect Wildfire", key="upload_detect"):
-            file_type = source_file.type.split('/')[0]
-            if file_type == 'image':
-                uploaded_image = PIL.Image.open(source_file)
-                res = model.predict(uploaded_image, conf=confidence)
-                detected_image = res[0].plot()[:, :, ::-1]
-                frame_placeholder.image(detected_image, use_column_width=True)
-                status_placeholder.write(f"Objects detected: {len(res[0].boxes)}")
-            elif file_type == 'video':
-                # Save input video to temporary file
-                input_tfile = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
-                input_tfile.write(source_file.read())
-                input_tfile.close()
+        if source_file:
+            st.write(f"File size: {source_file.size / 1024 / 1024:.2f} MB")  # Diagnostic
+            if st.button("Detect Wildfire", key="upload_detect"):
+                file_type = source_file.type.split('/')[0]
+                if file_type == 'image':
+                    uploaded_image = PIL.Image.open(source_file)
+                    res = model.predict(uploaded_image, conf=confidence)
+                    detected_image = res[0].plot()[:, :, ::-1]
+                    frame_placeholder.image(detected_image, use_column_width=True)
+                    status_placeholder.write(f"Objects detected: {len(res[0].boxes)}")
+                elif file_type == 'video':
+                    try:
+                        # Save input video
+                        input_tfile = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4')
+                        input_tfile.write(source_file.read())
+                        input_tfile.close()
 
-                # Open video to get total frame count
-                vidcap = cv2.VideoCapture(input_tfile.name)
-                if not vidcap.isOpened():
-                    status_placeholder.error("Failed to open video file.")
-                else:
-                    total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
-                    if total_frames <= 0:
-                        total_frames = None  # Fallback if frame count unavailable
-                    
-                    # Prepare output video
-                    output_tfile = tempfile.NamedTemporaryFile(delete=False, suffix='_detected.mp4')
-                    frame_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))
-                    frame_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-                    fps = int(vidcap.get(cv2.CAP_PROP_FPS)) or 30
-                    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-                    out = cv2.VideoWriter(output_tfile.name, fourcc, fps, (frame_width, frame_height))
-                    
-                    success, frame = vidcap.read()
-                    frame_count = 0
-                    while success:
-                        res = model.predict(frame, conf=confidence)
-                        detected_frame = res[0].plot()[:, :, ::-1]
-                        frame_placeholder.image(detected_frame, use_column_width=True)  # Preview
-                        status_placeholder.write(f"Frame {frame_count}: Objects detected: {len(res[0].boxes)}")
-                        
-                        # Write to output video
-                        detected_frame_bgr = detected_frame[:, :, ::-1]
-                        out.write(detected_frame_bgr)
-                        
-                        # Update progress
-                        if total_frames:
-                            progress_percent = (frame_count + 1) / total_frames * 100
-                            progress_placeholder.write(f"Progress: {progress_percent:.1f}%")
+                        # Open video
+                        vidcap = cv2.VideoCapture(input_tfile.name)
+                        if not vidcap.isOpened():
+                            status_placeholder.error("Failed to open video file.")
                         else:
-                            progress_placeholder.write(f"Progress: {frame_count} frames processed (total unknown)")
-                        
-                        success, frame = vidcap.read()
-                        frame_count += 1
-                        time.sleep(0.05)
-                    
-                    vidcap.release()
-                    out.release()
-                    
-                    os.unlink(input_tfile.name)
-                    with open(output_tfile.name, 'rb') as f:
-                        download_placeholder.download_button(
-                            label="Download Analyzed Video",
-                            data=f,
-                            file_name="analyzed_video.mp4",
-                            mime="video/mp4"
-                        )
-                    status_placeholder.write(f"Video processing complete. Processed {frame_count} frames.")
+                            total_frames = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
+                            fps = int(vidcap.get(cv2.CAP_PROP_FPS)) or 30
+                            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))
+                            
+                            # Output video
+                            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))
+                            
+                            success, frame = vidcap.read()
+                            frame_count = 0
+                            processed_count = 0
+                            last_detected_frame = None
+                            
+                            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)}")
+                                    processed_count += 1
+                                elif last_detected_frame is not None:
+                                    frame_placeholder.image(last_detected_frame, use_column_width=True)
+                                
+                                if last_detected_frame is not None:
+                                    out.write(last_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)")
+                                else:
+                                    progress_placeholder.write(f"Progress: {frame_count} frames processed")
+                                
+                                success, frame = vidcap.read()
+                                frame_count += 1
+                                time.sleep(0.05)
+                            
+                            vidcap.release()
+                            out.release()
+                            
+                            os.unlink(input_tfile.name)
+                            with open(output_tfile.name, 'rb') as f:
+                                download_placeholder.download_button(
+                                    label="Download Analyzed Video",
+                                    data=f,
+                                    file_name="analyzed_video.mp4",
+                                    mime="video/mp4"
+                                )
+                            status_placeholder.write(f"Video processing complete. Processed {processed_count} of {frame_count} frames.")
+                    except Exception as e:
+                        status_placeholder.error(f"Error processing video: {str(e)}")
 
 # Tab 2: Webcam (Unchanged)
 with tabs[1]: