Chunks

CPR/CPRAnalyzer.py

@@ -9,6 +9,8 @@ from CPR.role_classifier import RoleClassifier
 from CPR.chest_initializer import ChestInitializer
 from CPR.metrics_calculator import MetricsCalculator
 from CPR.posture_analyzer import PostureAnalyzer
+import os
+import uuid
 
 class CPRAnalyzer:
     """Main CPR analysis pipeline with execution tracing"""
@@ -39,6 +41,11 @@ class CPRAnalyzer:
         self.metrics_calculator = MetricsCalculator(shoulder_width_cm=45)
         self.posture_analyzer = PostureAnalyzer()
         
+        self.collected_warnings = {}
+
+        self.average_compression_depth = 0
+        self.average_compression_rate = 0
+
         # Window configuration
         self.window_name = "CPR Analysis"
         #cv2.namedWindow(self.window_name, cv2.WINDOW_NORMAL)
@@ -155,6 +162,18 @@ class CPRAnalyzer:
         warnings = self.posture_analyzer.validate_posture(keypoints, self.chest_initializer.chest_point)
         frame = self.posture_analyzer.display_warnings(frame, warnings)
 
+        for warning in warnings:
+            if warning not in self.collected_warnings:
+                self.collected_warnings[warning] = []
+            if len(self.collected_warnings[warning]) < 2:
+                # Save the frame to disk or memory
+                filename = f"warning_{uuid.uuid4().hex}.jpg"
+                file_path = os.path.join("screenshots", filename)
+                os.makedirs("screenshots", exist_ok=True)
+                cv2.imwrite(file_path, frame)
+                self.collected_warnings[warning].append(file_path)
+                print(f"[CAPTURE] Saved warning screenshot: {file_path}")
+
         if warnings:
             print(f"[WARNING] Posture issues: {', '.join(warnings)}")
         else:
@@ -206,6 +225,25 @@ class CPRAnalyzer:
         #cv2.imshow(self.window_name, resized)
         print(f"[DISPLAY] Resized to {new_w}x{new_h} (scale: {scale:.2f}) in {(time.time()-display_start)*1000:.1f}ms")
 
+    def get_posture_warning_results(self):
+        """Return a list of posture warning entries with image URLs and descriptions"""
+        result = []
+        for description, paths in self.collected_warnings.items():
+            for path in paths:
+                # You might want to convert local paths to URLs if you're serving them via FastAPI
+                result.append({
+                    "image_url": f"/static/{os.path.basename(path)}",  # Adjust if hosted elsewhere
+                    "description": description
+                })
+        return result
+
+    def get_compression_metrics(self):
+        """Return average compression depth and rate"""
+        return {
+            "average_compression_depth": self.average_compression_depth,
+            "average_compression_rate": self.average_compression_rate
+        }
+
     def _finalize_analysis(self):
         """Final analysis with detailed reporting"""
         print("\n[PHASE] Starting final analysis")
@@ -225,6 +263,9 @@ class CPRAnalyzer:
 
             print(f"[RESULTS] Compression Depth: {depth:.1f} cm")
             print(f"[RESULTS] Compression Rate: {rate:.1f} cpm")
+
+            self.average_compression_depth = depth
+            self.average_compression_rate = rate
             
             print("[VISUAL] Generating motion curve plot...")
             self.metrics_calculator.plot_motion_curve()

app.py

@@ -23,6 +23,7 @@ import base64
 import cv2
 import time
 from CPR.CPRAnalyzer import CPRAnalyzer
+import tempfile
 
 
 
@@ -197,22 +198,76 @@ async def process_video(file: UploadFile = File(...)):
 
     print("File content type:", file.content_type)
     print("File filename:", file.filename)
+
     # Save uploaded file
     video_path = os.path.join(UPLOAD_DIR, file.filename)
     with open(video_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
 
-    start_time = time.time()
     print("[START] CPR Analysis started")
+    start_time = time.time()
 
-    analyzer = CPRAnalyzer(video_path)
-    analyzer.run_analysis()
-
-    end_time = time.time()
-    print(f"[END] Total execution time: {end_time - start_time:.2f}s")
-
-
-    return JSONResponse(content={"message": "Video processed successfully", "result_dir": "runs/detect/testResult"})
+    cap = cv2.VideoCapture(video_path)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    duration_seconds = total_frames / fps
+    chunk_duration = 10  # seconds
+    frames_per_chunk = int(fps * chunk_duration)
+
+    chunks = []
+    chunk_index = 0
+    current_frame = 0
+
+    while current_frame < total_frames:
+        # Read the chunk into memory
+        frames = []
+        for _ in range(frames_per_chunk):
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frames.append(frame)
+            current_frame += 1
+
+        if not frames:
+            break
+
+        # Save chunk to temp video
+        temp_chunk_path = os.path.join(tempfile.gettempdir(), f"chunk_{chunk_index}.mp4")
+        height, width = frames[0].shape[:2]
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(temp_chunk_path, fourcc, fps, (width, height))
+        for f in frames:
+            out.write(f)
+        out.release()
+
+        # Analyze chunk
+        print(f"[CHUNK {chunk_index}] Processing chunk at {temp_chunk_path}")
+        analyzer = CPRAnalyzer(temp_chunk_path)
+        analyzer.run_analysis()
+
+        # Gather results
+        metrics = analyzer.get_compression_metrics()
+        warnings = analyzer.get_posture_warning_results()
+
+        # Estimate score (adjust this logic as needed)
+        penalty = len(warnings) * 0.1
+        rate_score = min(metrics["average_compression_rate"] / 120, 1.0)
+        depth_score = min(metrics["average_compression_depth"] / 5.0, 1.0)
+        average_score = max(0.0, (rate_score + depth_score)/2 - penalty)
+
+        chunks.append({
+            "average_score": round(average_score, 2),
+            "average_rate": round(metrics["average_compression_rate"], 1),
+            "average_depth": round(metrics["average_compression_depth"], 1),
+            "posture_warnings": warnings
+        })
+
+        chunk_index += 1
+
+    cap.release()
+    print(f"[END] Total processing time: {time.time() - start_time:.2f}s")
+
+    return JSONResponse(content={"chunks": chunks})
 
 
 @app.post("/process_image")