Update app.py

app.py

@@ -15,13 +15,21 @@ logger = logging.getLogger(__name__)
 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"
+    "container_name": "logs",
+    "max_size_mb": 500  # 500MB file size limit
 }
 
-# YOLO Model
+# YOLO Model Configuration
+MODEL_CONFIG = {
+    "model_path": "./best_yolov11 (1).pt",
+    "conf_threshold": 0.5,
+    "frame_skip": 1  # Process every frame (0 = no skipping)
+}
+
+# Initialize YOLO Model
 try:
-    MODEL = YOLO("./best_yolov11 (1).pt")
-    logger.info("Model loaded successfully")
+    MODEL = YOLO(MODEL_CONFIG["model_path"])
+    logger.info(f"Loaded YOLO model: {MODEL_CONFIG['model_path']}")
 except Exception as e:
     logger.error(f"Model loading failed: {e}")
     raise
@@ -44,7 +52,13 @@ def list_videos():
         logger.error(f"Error listing videos: {e}")
         return []
 
-def get_video(blob_name):
+def validate_video_size(blob_client):
+    props = blob_client.get_blob_properties()
+    size_mb = props.size / (1024 * 1024)
+    if size_mb > AZURE_CONFIG["max_size_mb"]:
+        raise ValueError(f"Video exceeds {AZURE_CONFIG['max_size_mb']}MB limit")
+
+def download_video(blob_name):
     try:
         client = get_azure_client()
         blob = client.get_blob_client(
@@ -52,8 +66,13 @@ def get_video(blob_name):
             blob=blob_name
         )
         
+        # Validate video size
+        validate_video_size(blob)
+        
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as f:
-            f.write(blob.download_blob().readall())
+            download_stream = blob.download_blob()
+            for chunk in download_stream.chunks():
+                f.write(chunk)
             return f.name
     except Exception as e:
         logger.error(f"Download failed: {e}")
@@ -61,101 +80,161 @@ def get_video(blob_name):
 
 def process_video(input_path, progress=gr.Progress()):
     try:
-        # Validate input
         if not input_path or not os.path.exists(input_path):
-            return None, "Invalid input video"
-        
-        # Video setup
+            raise ValueError("Invalid input video path")
+
         cap = cv2.VideoCapture(input_path)
+        if not cap.isOpened():
+            raise RuntimeError("Failed to open video file")
+
+        # Get video properties
         frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
         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))
-        
+
         # Output setup
         output_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp4").name
-        writer = cv2.VideoWriter(output_file, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
-        
-        # Process frames
-        progress(0, desc="Starting processing...")
-        for frame_num in progress.tqdm(range(frame_count), desc="Processing"):
+        writer = cv2.VideoWriter(output_file, 
+                               cv2.VideoWriter_fourcc(*'mp4v'), 
+                               fps, 
+                               (width, height))
+
+        # Processing parameters
+        frame_skip = MODEL_CONFIG["frame_skip"]
+        processed_frames = 0
+        total_processed = 0
+
+        progress(0, desc="Initializing video processing...")
+        start_time = time.time()
+
+        while cap.isOpened():
             ret, frame = cap.read()
             if not ret:
                 break
-            
-            # YOLO detection
-            results = MODEL(frame)
+
+            # Frame skipping logic
+            if total_processed % (frame_skip + 1) != 0:
+                total_processed += 1
+                continue
+
+            # YOLO inference
+            results = MODEL(frame, verbose=False)
+            class_counts = {}
+
             for result in results:
                 for box in result.boxes:
-                    if box.conf.item() < 0.5:
+                    # Convert tensor to Python scalar
+                    conf = box.conf.item()
+                    if conf < MODEL_CONFIG["conf_threshold"]:
                         continue
-                    
-                    # Draw bounding box
+
+                    # Get detection coordinates
                     x1, y1, x2, y2 = map(int, box.xyxy[0].tolist())
-                    cv2.rectangle(frame, (x1, y1), (x2, y2), (0,255,0), 2)
+                    class_id = int(box.cls.item())
+                    class_name = MODEL.names[class_id]
+
+                    # Draw bounding box
+                    cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
                     
-                    # Add label
-                    label = f"{MODEL.names[int(box.cls)]} {box.conf:.2f}"
-                    cv2.putText(frame, label, (x1, y1-10), 
-                               cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 2)
-            
+                    # Create label with proper float conversion
+                    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:
+                progress(processed_frames / frame_count, 
+                       desc=f"Processed {processed_frames}/{frame_count} frames")
+
+        # Calculate statistics
+        duration = time.time() - start_time
+        fps = processed_frames / duration if duration > 0 else 0
+
         # Cleanup
         cap.release()
         writer.release()
         os.remove(input_path)
-        
-        return output_file, "Processing completed successfully"
-    
+
+        return output_file, f"Processed {processed_frames} frames in {duration:.1f}s ({fps:.1f} FPS)"
+
     except Exception as e:
         logger.error(f"Processing failed: {e}")
         return None, f"Error: {str(e)}"
 
 # Gradio Interface
-with gr.Blocks(theme=gr.themes.Soft()) as app:
-    gr.Markdown("# Video Processing Interface")
-    
+with gr.Blocks(theme=gr.themes.Soft(), title="PRISM Video Analyzer") as app:
+    gr.Markdown("# 🏗️ PRISM Site Diary - Construction Video Analysis")
+
     with gr.Row():
-        with gr.Column():
+        with gr.Column(scale=1):
             gr.Markdown("## Video Selection")
             video_select = gr.Dropdown(
-                label="Available Videos",
+                label="Available Videos from Azure",
                 choices=list_videos(),
-                interactive=True,
-                filterable=False
+                filterable=False,
+                interactive=True
             )
-            refresh_btn = gr.Button("🔄 Refresh List")
+            refresh_btn = gr.Button("🔄 Refresh List", variant="secondary")
             process_btn = gr.Button("🚀 Process Selected Video", variant="primary")
             
-        with gr.Column():
-            gr.Markdown("## Output")
-            video_output = gr.Video(label="Processed Video", format="mp4")
-            status = gr.Textbox(label="Status", interactive=False)
+        with gr.Column(scale=2):
+            gr.Markdown("## Analysis Results")
+            video_output = gr.Video(
+                label="Processed Video Output",
+                format="mp4",
+                interactive=False
+            )
+            status = gr.Textbox(
+                label="Processing Status",
+                interactive=False,
+                value="Ready to process videos"
+            )
 
-    # Event handlers
-    def refresh_list():
+    def refresh_video_list():
         return gr.Dropdown.update(choices=list_videos())
-    
-    def handle_process(blob_name):
-        start_time = time.time()
+
+    def handle_video_processing(blob_name):
         if not blob_name:
             return None, "No video selected!"
         
-        local_path = get_video(blob_name)
-        if not local_path:
-            return None, "Download failed!"
-        
-        result, message = process_video(local_path)
-        duration = time.time() - start_time
-        return result, f"{message} | Time: {duration:.1f}s"
+        try:
+            local_path = download_video(blob_name)
+            if not local_path:
+                return None, "Video download failed"
+            
+            result, message = process_video(local_path)
+            return result, message
+            
+        except Exception as e:
+            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_list, outputs=video_select)
     process_btn.click(
-        handle_process,
+        fn=handle_video_processing,
         inputs=video_select,
-        outputs=[video_output, status]
+        outputs=[video_output, status],
+        queue=True
     )
 
 if __name__ == "__main__":
-    app.launch(server_name="0.0.0.0", server_port=7860)
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    )