Update app.py

app.py

@@ -79,10 +79,26 @@ os.makedirs(CAPTURED_FRAMES_DIR, exist_ok=True)
 os.makedirs(OUTPUT_DIR, exist_ok=True)
 
 def initialize_media(media_file: Optional[Any] = None) -> str:
-    global media_loaded, is_video, static_image, log_entries
+    global media_loaded, is_video, static_image, log_entries, frame_count
     release_video()
     static_image = None
-    media_path = DEFAULT_VIDEO_PATH if media_file is None else media_file.name
+    frame_count = 0  # Reset frame count on new media load
+
+    # Validate media_file
+    if media_file is None:
+        media_path = DEFAULT_VIDEO_PATH
+    elif not hasattr(media_file, 'name') or not media_file.name:
+        status = "Error: Invalid media file uploaded."
+        log_entries.append(status)
+        logging.error(status)
+        media_loaded = False
+        return status
+    else:
+        media_path = media_file.name
+
+    # Log the media path for debugging
+    log_entries.append(f"Attempting to load media from path: {media_path}")
+    logging.info(f"Attempting to load media from path: {media_path}")
 
     if not os.path.exists(media_path):
         status = f"Error: Media file '{media_path}' not found."
@@ -167,9 +183,14 @@ def generate_line_chart() -> Optional[str]:
     ax.grid(True)
     fig.tight_layout()
     chart_path = "chart_temp.png"
-    fig.savefig(chart_path)
-    plt.close(fig)
-    return chart_path
+    try:
+        fig.savefig(chart_path)
+        plt.close(fig)
+        return chart_path
+    except Exception as e:
+        log_entries.append(f"Error generating chart: {str(e)}")
+        logging.error(f"Error generating chart: {str(e)}")
+        return None
 
 def monitor_feed() -> Tuple[
     Optional[np.ndarray],
@@ -205,7 +226,13 @@ def monitor_feed() -> Tuple[
             if is_video:
                 frame = get_next_video_frame()
                 if frame is None:
-                    raise RuntimeError("Failed to retrieve frame from video.")
+                    # Reset video if it ends
+                    log_entries.append("Video ended, resetting to start.")
+                    logging.info("Video ended, resetting to start.")
+                    reset_video_index()
+                    frame = get_next_video_frame()
+                    if frame is None:
+                        raise RuntimeError("Failed to retrieve frame after reset.")
             else:
                 frame = static_image.copy()
         except RuntimeError as e:
@@ -253,8 +280,13 @@ def monitor_feed() -> Tuple[
                 all_detected_items.extend(generic_dets)
 
             # Apply shadow detection
-            cv2.imwrite(TEMP_IMAGE_PATH, frame)
-            shadow_issue = detect_shadow_coverage(TEMP_IMAGE_PATH)
+            try:
+                cv2.imwrite(TEMP_IMAGE_PATH, frame)
+                shadow_issue = detect_shadow_coverage(TEMP_IMAGE_PATH)
+            except Exception as e:
+                log_entries.append(f"Error saving temp image for shadow detection: {str(e)}")
+                logging.error(f"Error saving temp image: {str(e)}")
+                shadow_issue = False
 
             # Apply thermal processing if frame is grayscale
             if len(frame.shape) == 2:
@@ -288,7 +320,11 @@ def monitor_feed() -> Tuple[
                             cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
 
             # Save temporary image
-            cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
+            try:
+                cv2.imwrite(TEMP_IMAGE_PATH, frame, [int(cv2.IMWRITE_JPEG_QUALITY), 95])
+            except Exception as e:
+                log_entries.append(f"Error saving temp image: {str(e)}")
+                logging.error(f"Error saving temp image: {str(e)}")
 
         except Exception as e:
             log_entries.append(f"Processing Error: {str(e)}")
@@ -307,7 +343,9 @@ def monitor_feed() -> Tuple[
         if detection_types:
             try:
                 captured_frame_path = os.path.join(CAPTURED_FRAMES_DIR, f"detected_{frame_count}.jpg")
-                cv2.imwrite(captured_frame_path, frame)
+                success = cv2.imwrite(captured_frame_path, frame)
+                if not success:
+                    raise RuntimeError(f"Failed to save captured frame: {captured_frame_path}")
                 for item in all_detected_items:
                     dtype = item.get("type", "")
                     if dtype == "plant":
@@ -343,7 +381,9 @@ def monitor_feed() -> Tuple[
         # Save processed frame
         try:
             frame_path = os.path.join(OUTPUT_DIR, f"frame_{frame_count:04d}.jpg")
-            cv2.imwrite(frame_path, frame)
+            success = cv2.imwrite(frame_path, frame)
+            if not success:
+                raise RuntimeError(f"Failed to save output frame: {frame_path}")
         except Exception as e:
             log_entries.append(f"Error saving output frame: {str(e)}")
             logging.error(f"Error saving output frame: {str(e)}")
@@ -361,10 +401,17 @@ def monitor_feed() -> Tuple[
         missing_detected = len([item for item in all_detected_items if item.get("type") == "missing_patch"])
         detected_counts.append(plant_detected + crack_detected + hole_detected + missing_detected)
 
-        # Log frame processing details
-        log_message = (f"{last_timestamp} - Frame {frame_count} - "
-                       f"Plants: {plant_detected} - Cracks: {crack_detected} - "
-                       f"Holes: {hole_detected} - Missing Patches: {missing_detected} - GPS: {gps_coord}")
+        # Log frame processing details in the requested format
+        detection_summary = {
+            "timestamp": last_timestamp,
+            "frame": frame_count,
+            "plants": plant_detected,
+            "cracks": crack_detected,
+            "holes": hole_detected,
+            "missing_patches": missing_detected,
+            "gps": gps_coord
+        }
+        log_message = json.dumps(detection_summary, indent=2)
         log_entries.append(log_message)
         logging.info(log_message)