Final

.gitignore

@@ -1,4 +1,6 @@
 __pycache__/*
 venv/*
 uploads/*
-runs/*
+runs/*
+screenshots/*
+*.pyc

CPR/CPRAnalyzer.py

@@ -232,7 +232,7 @@ class CPRAnalyzer:
             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
+                    "image_url": f"{os.path.basename(path)}",  # Adjust if hosted elsewhere
                     "description": description
                 })
         return result

CPR/pose_estimation.py

@@ -8,7 +8,7 @@ class PoseEstimator:
     """Human pose estimation using YOLO"""
     
     def __init__(self, model_path="yolo11n-pose.pt", min_confidence=0.2):
-        self.model = YOLO(model_path)
+        self.model = YOLO(model_path).to('cuda')
         self.min_confidence = min_confidence
 
     def detect_poses(self, frame):

app.py

@@ -249,6 +249,12 @@ async def process_video(file: UploadFile = File(...)):
         metrics = analyzer.get_compression_metrics()
         warnings = analyzer.get_posture_warning_results()
 
+                # Upload each warning to cloudinary
+        for w in warnings:
+            local_path = w['image_url']
+            upload_result = cloudinary.uploader.upload(local_path, folder="posture_warnings")
+            w['image_url'] = upload_result['secure_url']
+
         # Estimate score (adjust this logic as needed)
         penalty = len(warnings) * 0.1
         rate_score = min(metrics["average_compression_rate"] / 120, 1.0)

backupbackend.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31c7f003c89e9daecb3cf71a0806f668967632fd7a9eaa0c588ca666e7c87d83
+size 39047568

main.py

@@ -21,6 +21,10 @@ from fastapi import HTTPException
 from fastapi import WebSocket, WebSocketDisconnect
 import base64
 import cv2
+import time
+from CPR.CPRAnalyzer import CPRAnalyzer
+import tempfile
+
 
 
 
@@ -194,28 +198,83 @@ 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)
 
-    model = YOLO("yolo11n-pose_float16.tflite")  # fixed variable name
-
-    print("Model loaded successfully")
-
-    # Run YOLO detection 
-    try:
-        results = model(
-            source=video_path,
-            show=True,     # Set True if running locally and want to view
-            save=True,
-            project="runs/detect",
-            name="testResult"
-        )
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"YOLO processing error: {str(e)}")
-
-    return JSONResponse(content={"message": "Video processed successfully", "result_dir": "runs/detect/testResult"})
+    print("[START] CPR Analysis started")
+    start_time = time.time()
+
+    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()
+
+                # Upload each warning to cloudinary
+        for w in warnings:
+            filename = w['image_url']  # just the filename
+            local_path = os.path.join("screenshots", filename)
+            upload_result = cloudinary.uploader.upload(local_path, folder="posture_warnings")
+            w['image_url'] = upload_result['secure_url']
+
+        # 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")

yolo11n-pose.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:869e83fcdffdc7371fa4e34cd8e51c838cc729571d1635e5141e3075e9319dc0
+size 6255593