Update app.py

app.py

@@ -16,14 +16,14 @@ AZURE_CONFIG = {
     "account_name": "assentian",
     "sas_token": "sv=2024-11-04&ss=bfqt&srt=sco&sp=rwdlacupiytfx&se=2025-04-30T04:25:22Z&st=2025-04-16T20:25:22Z&spr=https&sig=HYrJBoOYc4PRe%2BoqBMl%2FmoL5Kz4ZYugbTLuEh63sbeo%3D",
     "container_name": "logs",
-    "max_size_mb": 500  # 500MB file size limit
+    "max_size_mb": 500
 }
 
 # YOLO Model Configuration
 MODEL_CONFIG = {
     "model_path": "./best_yolov11 (1).pt",
     "conf_threshold": 0.5,
-    "frame_skip": 1  # Process every frame (0 = no skipping)
+    "frame_skip": 0  # Process every frame for testing
 }
 
 # Initialize YOLO Model
@@ -66,7 +66,6 @@ def download_video(blob_name):
             blob=blob_name
         )
         
-        # Validate video size
         validate_video_size(blob)
         
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as f:
@@ -87,8 +86,9 @@ def process_video(input_path, progress=gr.Progress()):
         if not cap.isOpened():
             raise RuntimeError("Failed to open video file")
 
-        # Get video properties
-        frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        # Get video properties with 200 frame limit
+        original_frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        frame_count = min(original_frame_count, 200)  # TESTING LIMIT
         fps = cap.get(cv2.CAP_PROP_FPS)
         width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
         height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
@@ -100,36 +100,27 @@ def process_video(input_path, progress=gr.Progress()):
                                fps, 
                                (width, height))
 
-        # Processing parameters
-        frame_skip = MODEL_CONFIG["frame_skip"]
         processed_frames = 0
         total_processed = 0
 
-        progress(0, desc="Initializing video processing...")
+        progress(0, desc="Processing first 200 frames...")
         start_time = time.time()
 
-        while cap.isOpened():
+        while cap.isOpened() and total_processed < 200:  # FRAME LIMIT
             ret, frame = cap.read()
             if not ret:
                 break
 
-            # Frame skipping logic
-            if total_processed % (frame_skip + 1) != 0:
-                total_processed += 1
-                continue
-
-            # YOLO inference
+            # Process every frame (frame_skip = 0)
             results = MODEL(frame, verbose=False)
             class_counts = {}
 
             for result in results:
                 for box in result.boxes:
-                    # Convert tensor to Python scalar
                     conf = box.conf.item()
                     if conf < MODEL_CONFIG["conf_threshold"]:
                         continue
 
-                    # Get detection coordinates
                     x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
                     class_id = int(box.cls.item())
                     class_name = MODEL.names[class_id]
@@ -137,23 +128,20 @@ def process_video(input_path, progress=gr.Progress()):
                     # Draw bounding box
                     cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                     
-                    # Create label with proper float conversion
+                    # Create label
                     label = f"{class_name} {conf:.2f}"
                     cv2.putText(frame, label, (x1, y1 - 10),
                               cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
-                    
-                    # Update counts
-                    class_counts[class_name] = class_counts.get(class_name, 0) + 1
 
             # Write frame to output
             writer.write(frame)
             processed_frames += 1
             total_processed += 1
             
-            # Update progress
-            if processed_frames % 10 == 0:
+            # Update progress every frame
+            if processed_frames % 5 == 0:
                 progress(processed_frames / frame_count, 
-                       desc=f"Processed {processed_frames}/{frame_count} frames")
+                       desc=f"Processed {processed_frames}/200 frames")
 
         # Calculate statistics
         duration = time.time() - start_time
@@ -172,31 +160,30 @@ def process_video(input_path, progress=gr.Progress()):
 
 # Gradio Interface
 with gr.Blocks(theme=gr.themes.Soft(), title="PRISM Video Analyzer") as app:
-    gr.Markdown("# 🏗️ PRISM Site Diary - Construction Video Analysis")
+    gr.Markdown("# 🏗️ PRISM Site Diary - Video Analysis (TEST MODE: 200 Frames)")
 
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("## Video Selection")
             video_select = gr.Dropdown(
-                label="Available Videos from Azure",
+                label="Available Videos",
                 choices=list_videos(),
-                filterable=False,
-                interactive=True
+                filterable=False
             )
             refresh_btn = gr.Button("🔄 Refresh List", variant="secondary")
-            process_btn = gr.Button("🚀 Process Selected Video", variant="primary")
+            process_btn = gr.Button("🚀 Process First 200 Frames", variant="primary")
             
         with gr.Column(scale=2):
-            gr.Markdown("## Analysis Results")
+            gr.Markdown("## Results")
             video_output = gr.Video(
-                label="Processed Video Output",
+                label="Processed Video",
                 format="mp4",
                 interactive=False
             )
             status = gr.Textbox(
-                label="Processing Status",
-                interactive=False,
-                value="Ready to process videos"
+                label="Status",
+                value="Ready to process first 200 frames",
+                interactive=False
             )
 
     def refresh_video_list():
@@ -209,7 +196,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="PRISM Video Analyzer") as app:
         try:
             local_path = download_video(blob_name)
             if not local_path:
-                return None, "Video download failed"
+                return None, "Download failed"
             
             result, message = process_video(local_path)
             return result, message
@@ -218,15 +205,9 @@ with gr.Blocks(theme=gr.themes.Soft(), title="PRISM Video Analyzer") as app:
             logger.error(f"Processing error: {e}")
             return None, f"Error: {str(e)}"
 
-    # Event handlers
-    refresh_btn.click(
-        fn=refresh_video_list,
-        outputs=video_select,
-        queue=False
-    )
-    
+    refresh_btn.click(refresh_video_list, outputs=video_select)
     process_btn.click(
-        fn=handle_video_processing,
+        handle_video_processing,
         inputs=video_select,
         outputs=[video_output, status],
         queue=True