Real Time Added

CPR/CPRAnalyzer.py

@@ -9,159 +9,308 @@ from CPR.role_classifier import RoleClassifier
 from CPR.chest_initializer import ChestInitializer
 from CPR.metrics_calculator import MetricsCalculator
 from CPR.posture_analyzer import PostureAnalyzer
+from CPR.wrists_midpoint_analyzer import WristsMidpointAnalyzer
+from CPR.shoulders_analyzer import ShouldersAnalyzer
 import os
-import uuid
+import uuid  # For unique filenames
+
 
 class CPRAnalyzer:
     """Main CPR analysis pipeline with execution tracing"""
     
     def __init__(self, video_path):
         print(f"\n[INIT] Initializing CPR Analyzer for: {video_path}")
+        
+        self.video_path = video_path
+        #& Open video file
         self.cap = cv2.VideoCapture(video_path)
         if not self.cap.isOpened():
             print("[ERROR] Failed to open video file")
             return
+        print("[INIT] Video file opened successfully")
 
+        #& Get video properties
         self.frame_count = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
-        print(f"[INFO] Video properties: {self.frame_count} frames, "
-              f"{self.cap.get(cv2.CAP_PROP_FPS):.1f} FPS")
-
-        # Get screen dimensions
-        #root = tk.Tk()
-        self.screen_width = 500
-        self.screen_height = 500
-        #root.destroy()
-        
-        print(f"[DISPLAY] Detected screen resolution: {self.screen_width}x{self.screen_height}")
+        self.fps = self.cap.get(cv2.CAP_PROP_FPS)
+        print(f"[INIT] Video has {self.frame_count} frames at {self.fps:.2f} FPS")
+
+        #& Get screen dimensions
+        root = tk.Tk()
+        self.screen_width = root.winfo_screenwidth()
+        self.screen_height = root.winfo_screenheight()
+        root.destroy()
+        print(f"[INIT] Detected screen resolution: {self.screen_width}x{self.screen_height}")
         
-        # Initialize components
-        self.pose_estimator = PoseEstimator()
+        #& Initialize system components
+        self.pose_estimator = PoseEstimator(min_confidence=0.5)
         self.role_classifier = RoleClassifier()
         self.chest_initializer = ChestInitializer()
-        self.metrics_calculator = MetricsCalculator(shoulder_width_cm=45)
-        self.posture_analyzer = PostureAnalyzer()
+        self.metrics_calculator = MetricsCalculator(self.frame_count, shoulder_width_cm=45*0.65)
         
+        # if avg_right > self.right_arm_angle_threshold: error
+        # if avg_left < self.left_arm_angle_threshold: error
+
+        self.posture_analyzer = PostureAnalyzer(right_arm_angle_threshold=220, left_arm_angle_threshold=160, wrist_distance_threshold=170, history_length_to_average=10)
+        self.wrists_midpoint_analyzer = WristsMidpointAnalyzer()
+        self.shoulders_analyzer = ShouldersAnalyzer()
+        print("[INIT] System components initialized")
+
         self.collected_warnings = {}
 
-        self.average_compression_depth = 0
-        self.average_compression_rate = 0
 
-        # Window configuration
+        #& Configure display window
         self.window_name = "CPR Analysis"
-        #cv2.namedWindow(self.window_name, cv2.WINDOW_NORMAL)
-        print("[INIT] System components initialized successfully")
+        cv2.namedWindow(self.window_name, cv2.WINDOW_NORMAL)
+        print(f"[INIT] Window '{self.window_name}' created")
+
+        #& Keep track of previous results for continuity
+        self.prev_rescuer_processed_results = None
+        self.prev_patient_processed_results = None
+        self.prev_chest_params = None
+        self.prev_midpoint = None
+        self.prev_pose_results = None
+        print("[INIT] Previous results initialized")
+
+        #& Workaround for minor glitches
+        self.consecutive_frames_with_posture_errors = 0
+        self.max_consecutive_frames_with_posture_errors = 10
+
+        #& Initialize variables for reporting warnings
+        self.posture_errors_for_current_error_region = set()
+
+        #& Frequent depth and rate calculations
+        self.reporting_interval_in_seconds = 5
+        self.reporting_interval_in_frames = int(self.fps * self.reporting_interval_in_seconds)
+        print(f"[INIT] Reporting interval set to {self.reporting_interval_in_seconds} seconds ({self.reporting_interval_in_frames} frames)")
 
     def run_analysis(self):
-        """Main processing loop with execution tracing"""
+        try:
+            print("\n[RUN ANALYSIS] Starting analysis")
 
-        print("\n[PHASE] Starting initialization phase")
-        start_time = time.time()
-        
-        if not self._initialize_system():
-            return
-        
-        # Get the first frame to determine orientation
-        ret, frame = self.cap.read()
-        if ret:
-            self._handle_chest_point_rotation(frame)
-            self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # Reset to beginning
-        
-        print(f"[INIT] Completed in {time.time()-start_time:.2f}s\n")
-        print("[PHASE] Starting main processing loop")
-        
-        frame_counter = 0
-        while self.cap.isOpened():
-            ret, frame = self.cap.read()
-            if not ret:
-                print("\n[INFO] End of video stream reached")
-                break
-
-            frame = self._handle_frame_rotation(frame)
-            print(f"\n[FRAME {int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))}/{self.frame_count}] Processing")
-            
-            frame = self._process_frame(frame)
-            
-            self._display_frame(frame)
+            main_loop_start_time = time.time()
+
+            #& Initialize Variables
+            # Handling chunks
+            first_time_to_have_a_proccessed_frame = True
+            waiting_to_start_new_chunk = False
+            # Hndling mini chunks
+            mini_chunk_start_frame_index = None
 
-            if cv2.waitKey(1) == ord('q'):
-                print("\n[USER] Analysis interrupted by user")
-                break
+            print("[RUN ANALYSIS] Starting main execution loop")
+            #& Main execution loop
+            while self.cap.isOpened():
+                #& Get frame number
+                # Retrieve the current position of the video frame being processed in the video capture object (self.cap).
+                frame_counter = self.cap.get(cv2.CAP_PROP_POS_FRAMES)
+                print(f"\n[FRAME {int(frame_counter)}/{self.frame_count}]")
+                
+                #& Read frame
+                ret, frame = self.cap.read()
+                if not ret:
+                    print("[ERROR] Failed to read frame or end of video reached")
+                    break
+                print(f"[RUN ANALYSIS] Read frame")
                 
-        self._finalize_analysis()
+                #& Rotate frame
+                frame = self._handle_frame_rotation(frame)
+                print(f"[RUN ANALYSIS] Rotated frame")
 
-    def _initialize_system(self):
-        """Initialize system components with status tracking"""
-        print("[INIT] Starting chest point initialization")
-        init_start = time.time()
-        
-        if not self.chest_initializer.initialize(self.cap, self.pose_estimator, self.role_classifier):
-            print("[ERROR] Chest initialization failed - check video content")
-            return False
-        
-        self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-        print(f"[INIT] Chest point initialized at {self.chest_initializer.chest_point}")
-        print(f"[INIT] Sampled {len(self.chest_initializer.shoulder_samples)} valid shoulder positions")
-        print(f"[INIT] Initialization completed in {time.time()-init_start:.2f}s")
-        return True
-
-    def _handle_chest_point_rotation(self, frame):
-        """Handle chest point rotation once during initialization"""
-        if frame.shape[1] > frame.shape[0]:  # Landscape orientation
-            print(f"[ROTATE] Detected landscape video")
-            
-            if self.chest_initializer.chest_point:
-                print(f"[ROTATE] Adjusting chest point coordinates")
-                cx, cy = self.chest_initializer.chest_point
-                # For 90° clockwise rotation:
-                # New x = original height - original y
-                # New y = original x
-                new_cx = frame.shape[0] - cy
-                new_cy = cx
-                self.chest_initializer.chest_point = (int(new_cx), int(new_cy))
-                print(f"[ROTATE] New chest point: {self.chest_initializer.chest_point}")
+                #& Process frame
+                # Processing a frame means updating the values for the current and previous detections both in the CPR Analyzer and the system components it includes.
+                # The returned flags are:
+                # - is_complete_chunk: True if a "Posture Error" occurs in the frame, False otherwise.
+                # - accept_frame: True if the frame is accepted for further processing, False otherwise.
+                # Not that a frame containing an error could be accepted if the number of consecutive frames with errors is less than the threshold.
+                is_complete_chunk, accept_frame = self._process_frame(frame)
+                print(f"[RUN ANALYSIS] Processed frame")
+                
+                #& Compose frame
+                # This function is responsible for drawing the data detected during the processing of the frame on it.
+                # The frame would not be displayed yet, just composed.
+                processed_frame = self._compose_frame(frame, accept_frame)
+                print(f"[RUN ANALYSIS] Composed frame")
+                
+                #& Set the chunk start frame index for the first chunk
+                # Along the video when a failure  in any step of the processing occurs, the variables are populated with the previous results to keep the analysis going.
+                # The problem occurs when the first few frames have a failure in the processing, and the variables are not populated yet.
+                # This is why the first chunk starts from the first frame that has been processed successfully.
+                if (processed_frame is not None) and first_time_to_have_a_proccessed_frame:
+                    first_time_to_have_a_proccessed_frame = False
+                    chunk_start_frame_index = frame_counter
+                    mini_chunk_start_frame_index = frame_counter
+                    print(f"[RUN ANALYSIS] First processed frame detected")
+
+                #& Set the chunk start frame index for the all chunks after the first one & append the errors detected in the error region before this chunk if any
+                # When a "Posture Error" occurs, a chunk is considered complete, and the program becomes ready to start a new chunk.
+                # is_complete_chunk is returned as true for every frame that has a "Posture Error" in it, and false for every other frame.
+                # This is why we need to wait for a frame with a false is_complete_chunk to start a new chunk.
+                if (waiting_to_start_new_chunk) and (not is_complete_chunk):
+                    waiting_to_start_new_chunk = False
+                    chunk_start_frame_index = frame_counter
+                    mini_chunk_start_frame_index = frame_counter
+                    print(f"[RUN ANALYSIS] A new chunk is starting")
+
+                    if len(self.posture_errors_for_current_error_region) > 0:
+                        self.posture_analyzer.posture_errors_for_all_error_region.append(self.posture_errors_for_current_error_region.copy())
+                        self.posture_errors_for_current_error_region.clear()
+                        print(f"[RUN ANALYSIS] Reset posture errors for current error region")
+
+                #& Process the current chunk or mini chunk if the conditions are met
+                process_chunk = (is_complete_chunk or frame_counter == self.frame_count - 1) and (not waiting_to_start_new_chunk)
+                process_mini_chunk = (frame_counter % self.reporting_interval_in_frames == 0) and (frame_counter != 0) and (mini_chunk_start_frame_index is not None) and (not is_complete_chunk)                     
+
+                if process_chunk: 
+                    print(f"[RUN ANALYSIS] Chunk completion detected")
+
+                    # The difference here results from the fact a first middle chunk is terminated by a "Posture Error" which is a frame not included in the chunk.
+                    # While the last chunk is terminated by the end of the video, which is a frame included in the chunk.
+                    if is_complete_chunk:
+                        chunk_end_frame_index = frame_counter - 1                
+                    elif frame_counter == self.frame_count - 1:
+                        chunk_end_frame_index = frame_counter
+                    print(f"[RUN ANALYSIS] Determined the last frame of the chunk")
+
+                    depth, rate = self._calculate_rate_and_depth_for_chunk(chunk_start_frame_index, chunk_end_frame_index)
+                    print(f"[RUN ANALYSIS] Calculated metrics for the chunk")
+
+                elif process_mini_chunk:
+                    print(f"[RUN ANALYSIS] Mini chunk completion detected")
+
+                    mini_chunk_end_frame_index = frame_counter
+                    print(f"[RUN ANALYSIS] Determined the last frame of the mini chunk")
+
+                    depth, rate = self._calculate_rate_and_depth_for_chunk(mini_chunk_start_frame_index, mini_chunk_end_frame_index)
+                    print(f"[RUN ANALYSIS] Calculated metrics for the mini chunk")                       
+                        
+                if process_chunk or process_mini_chunk:
+                    waiting_to_start_new_chunk = True
+
+                    self.shoulders_analyzer.reset_shoulder_distances()
+                    self.wrists_midpoint_analyzer.reset_midpoint_history()
+                    print(f"[RUN ANALYSIS] Reset shoulder distances and midpoint history")
+
+                #& Display frame
+                if processed_frame is not None:
+                    self._display_frame(processed_frame)
+                else:
+                    self._display_frame(frame)
+                print(f"[RUN ANALYSIS] Displayed frame")
+                                
+                #& Check if the user wants to quit
+                if cv2.waitKey(1) == ord('q'):
+                    print("\n[RUN ANALYSIS] Analysis interrupted by user")
+                    break
+
+            main_loop_end_time = time.time()
+            elapsed_time = main_loop_end_time - main_loop_start_time
+            print(f"[TIMING] Main loop elapsed time: {elapsed_time:.2f}s")
+
+        except Exception as e:
+            print(f"[ERROR] An error occurred during main execution loop: {str(e)}")
+
+        finally:
+            report_and_plot_start_time = time.time()
+
+            #& Cleanup, calculate averages, and plot full motion curve
+            self.cap.release()
+            cv2.destroyAllWindows()
+            print("[RUN ANALYSIS] Released video capture and destroyed all windows")         
+
+            self._calculate_rate_and_depth_for_all_chunks()
+            print("[RUN ANALYSIS] Calculated weighted averages of the metrics across all chunks")
+
+            graphResults = self._plot_full_motion_curve_for_all_chunks()
+            print("[RUN ANALYSIS] Plotted full motion curve")
+
+            report_and_plot_end_time = time.time()
+            report_and_plot_elapsed_time = report_and_plot_end_time - report_and_plot_start_time
+            print(f"[TIMING] Report and plot elapsed time: {report_and_plot_elapsed_time:.2f}s")
+
+            return self.metrics_calculator.annotate_video_with_chunks(self.video_path, self.posture_analyzer.posture_errors_for_all_error_region), graphResults, self.get_posture_warning_results(), self.metrics_calculator.get_json_chunk_data()
 
     def _handle_frame_rotation(self, frame):
-        """Handle frame rotation without adjusting chest point"""
+        #! Till now, the code has only been testes on portrait videos.
         if frame.shape[1] > frame.shape[0]:  # Width > Height
             frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
         return frame
 
     def _process_frame(self, frame):
-        """Process frame with execution tracing"""
-        processing_start = time.time()
+        #* Chunk Completion Check
+        is_complete_chunk = False
+        accept_frame = True
         
-        # Pose estimation
+        #& Pose Estimation
         pose_results = self.pose_estimator.detect_poses(frame)
+
+        #~ Handle Failed Detection or Update Previous Results
         if not pose_results:
-            print("[PROCESS] No poses detected in frame")
-            return frame
-            
-        print(f"[POSE] Detected {len(pose_results.boxes)} people")
-        frame = self.pose_estimator.draw_keypoints(frame, pose_results)
-        frame = self._analyze_rescuer(frame, pose_results)
+            pose_results = self.prev_pose_results
+            print("[POSE ESTIMATION] No pose detected, using previous results (could be None)")
+        else:
+            self.prev_pose_results = pose_results
         
-        # Draw chest point
-        frame = self.chest_initializer.draw_chest_marker(frame)
-        print(f"[PROCESS] Frame processed in {(time.time()-processing_start)*1000:.1f}ms")
-        return frame
-
-    def _analyze_rescuer(self, frame, pose_results):
-        """Analyze rescuer with detailed logging"""
-        rescuer_id = self.role_classifier.find_rescuer(pose_results, frame.shape[:2])
-        if rescuer_id is None:
-            print("[RESCUER] No rescuer identified in frame")
-            return frame
-            
-        print(f"[RESCUER] Identified at index {rescuer_id}")
-        keypoints = self.pose_estimator.get_keypoints(pose_results, rescuer_id)
+        if not pose_results:
+            print("[POSE ESTIMATION] Insufficient data for processing")
+            return is_complete_chunk, accept_frame
         
-        # Draw rescuer bounding box
-        frame = self._draw_rescuer_box(frame, pose_results, rescuer_id)
+        #& Rescuer and Patient Classification
+        rescuer_processed_results, patient_processed_results = self.role_classifier.classify_roles(pose_results, self.prev_rescuer_processed_results, self.prev_patient_processed_results)
+
+        #~ Handle Failed Classifications OR Update Previous Results
+        if not rescuer_processed_results:
+            rescuer_processed_results = self.prev_rescuer_processed_results
+            print("[ROLE CLASSIFICATION] No rescuer detected, using previous results (could be None)")
+        else:
+            self.prev_rescuer_processed_results = rescuer_processed_results
+
+        if not patient_processed_results:
+            patient_processed_results = self.prev_patient_processed_results
+            print("[ROLE CLASSIFICATION] No patient detected, using previous results (could be None)")
+        else:
+            self.prev_patient_processed_results = patient_processed_results
         
-        # Posture analysis
-        warnings = self.posture_analyzer.validate_posture(keypoints, self.chest_initializer.chest_point)
-        frame = self.posture_analyzer.display_warnings(frame, warnings)
+        if not rescuer_processed_results or not patient_processed_results:
+            print("[ROLE CLASSIFICATION] Insufficient data for processing")
+            return is_complete_chunk, accept_frame
+             
+        #^ Set Params in Role Classifier (to draw later)
+        self.role_classifier.rescuer_processed_results = rescuer_processed_results
+        self.role_classifier.patient_processed_results = patient_processed_results
+        print(f"[ROLE CLASSIFICATION] Updated role classifier with new results")
+    
+        #& Chest Estimation
+        chest_params = self.chest_initializer.estimate_chest_region(patient_processed_results["keypoints"], patient_processed_results["bounding_box"], frame_width=frame.shape[1], frame_height=frame.shape[0])
+       
+        #~ Handle Failed Estimation or Update Previous Results
+        if not chest_params:
+            chest_params = self.prev_chest_params
+            print("[CHEST ESTIMATION] No chest region detected, using previous results (could be None)")
+        else:
+            self.prev_chest_params = chest_params
+
+        if not chest_params:
+            print("[CHEST ESTIMATION] Insufficient data for processing")
+            return is_complete_chunk, accept_frame
+
+        #^ Set Params in Chest Initializer (to draw later)
+        self.chest_initializer.chest_params = chest_params
+        self.chest_initializer.chest_params_history.append(self.chest_initializer.chest_params)
+
+        #& Chest Expectation
+        # The estimation up to the last frame
+        expected_chest_params = self.chest_initializer.estimate_chest_region_weighted_avg(frame_width=frame.shape[1], frame_height=frame.shape[0])
+
+        #~ First "window_size" detections can't avg
+        if not expected_chest_params:
+            self.chest_initializer.expected_chest_params = self.chest_initializer.chest_params
+        else:
+            self.chest_initializer.expected_chest_params = expected_chest_params
 
+        #& Posture Analysis
+        # The midpoind of the last frame
+        warnings = self.posture_analyzer.validate_posture(rescuer_processed_results["keypoints"], self.prev_midpoint, self.chest_initializer.expected_chest_params)
+        
+        ##############################################################
         for warning in warnings:
             if warning not in self.collected_warnings:
                 self.collected_warnings[warning] = []
@@ -173,33 +322,86 @@ class CPRAnalyzer:
                 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)}")
+            print(f"[POSTURE ANALYSIS] Posture issues: {', '.join(warnings)}")
+            self.consecutive_frames_with_posture_errors += 1
         else:
-            # Track midpoints
-            frame = self.role_classifier.track_rescuer_midpoints(keypoints, frame)
-            #print(f"[TRACKING] Midpoint added at {self.role_classifier.midpoints[-1]}")
-            self.role_classifier.update_shoulder_distance()
-            
-        return frame
+            print("[POSTURE ANALYSIS] No posture issues detected")
+            self.consecutive_frames_with_posture_errors = 0
+        
+        accept_frame = self.consecutive_frames_with_posture_errors < self.max_consecutive_frames_with_posture_errors
 
-    def _draw_rescuer_box(self, frame, results, rescuer_id):
-        """Draw rescuer box with dimension logging"""
-        boxes = results.boxes.xyxy.cpu().numpy()
-        if rescuer_id < len(boxes):
-            x1, y1, x2, y2 = boxes[rescuer_id].astype(int)
-            w, h = x2-x1, y2-y1
-            print(f"[BOX] Rescuer bounding box: {w}x{h} pixels")
-            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 3)
-            cv2.putText(frame, "RESCUER", (x1, y1-10),
-                        cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
-        return frame
+        if accept_frame:
+            warnings = []  # Reset warnings if the frame is accepted
+
+        #^ Set Params in Posture Analyzer (to draw later)
+        self.posture_analyzer.warnings = warnings  
+        print(f"[POSTURE ANALYSIS] Updated posture analyzer with new results")
 
-    def _display_frame(self, frame):
-        """Adaptive window sizing with aspect ratio preservation"""
-        display_start = time.time()
+        #& Wrist Midpoint Detection
+        midpoint = self.wrists_midpoint_analyzer.detect_wrists_midpoint(rescuer_processed_results["keypoints"])
+
+        #~ Handle Failed Detection or Update Previous Results
+        if not midpoint:
+            midpoint = self.prev_midpoint
+            print("[WRIST MIDPOINT DETECTION] No midpoint detected, using previous results (could be None)")
+        else:
+            self.prev_midpoint = midpoint
         
+        if not midpoint:
+            print("[WRIST MIDPOINT DETECTION] Insufficient data for processing")
+            return is_complete_chunk, accept_frame
+
+        if accept_frame:
+            #^ Set Params in Role Classifier (to draw later)
+            self.wrists_midpoint_analyzer.midpoint = midpoint
+            self.wrists_midpoint_analyzer.midpoint_history.append(midpoint)
+            print(f"[WRIST MIDPOINT DETECTION] Updated wrist midpoint analyzer with new results")
+
+            #& Shoulder Distance Calculation
+            shoulder_distance = self.shoulders_analyzer.calculate_shoulder_distance(rescuer_processed_results["keypoints"])
+            if shoulder_distance is not None:
+                self.shoulders_analyzer.shoulder_distance = shoulder_distance
+                self.shoulders_analyzer.shoulder_distance_history.append(shoulder_distance)
+            print(f"[SHOULDER DISTANCE] Updated shoulder distance analyzer with new results")
+        else:
+            #* Chunk Completion Check
+            is_complete_chunk = True
+            num_warnings_before = len(self.posture_errors_for_current_error_region)
+
+            for warning in warnings:
+                self.posture_errors_for_current_error_region.add(warning)
+                
+                num_warnings_after = len(self.posture_errors_for_current_error_region)
+                
+                if num_warnings_after > num_warnings_before:
+                    print(f"[POSTURE ANALYSIS] Added warning to current error region: {warning}") 
+    
+        return is_complete_chunk, accept_frame
+    
+    def _compose_frame(self, frame, accept_frame):
+        # Chest Region
+        if frame is not None:
+            frame = self.chest_initializer.draw_expected_chest_region(frame)
+            print(f"[VISUALIZATION] Drawn chest region")
+
+        # Warning Messages
+        if frame is not None:
+            frame = self.posture_analyzer.display_warnings(frame)
+            print(f"[VISUALIZATION] Drawn warnings")
+        
+        if frame is not None:
+            if accept_frame:
+                # Midpoint
+                frame = self.wrists_midpoint_analyzer.draw_midpoint(frame)   
+                print(f"[VISUALIZATION] Drawn midpoint")  
+        
+        return frame
+
+    def _display_frame(self, frame):        
         # Get original frame dimensions
         h, w = frame.shape[:2]
         if w == 0 or h == 0:
@@ -220,64 +422,61 @@ class CPRAnalyzer:
         # Center window
         pos_x = (self.screen_width - new_w) // 2
         pos_y = (self.screen_height - new_h) // 2
-        #cv2.moveWindow(self.window_name, pos_x, pos_y)
+        cv2.moveWindow(self.window_name, pos_x, pos_y)
         
-        #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")
+        cv2.imshow(self.window_name, resized)
+        print(f"[DISPLAY FRAME] Resized to {new_w}x{new_h} (scale: {scale:.2f})")
 
-    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"{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")
-        start_time = time.time()
-        
+    def _calculate_rate_and_depth_for_chunk(self, chunk_start_frame_index, chunk_end_frame_index):
         try:
-            print("[METRICS] Smoothing midpoint data...")
-            self.metrics_calculator.smooth_midpoints(self.role_classifier.midpoints)
+            self.metrics_calculator.smooth_midpoints(self.wrists_midpoint_analyzer.midpoint_history)
+            print("[METRICS] Smoothed midpoints")
             
-            print("[METRICS] Detecting compression peaks...")
             self.metrics_calculator.detect_peaks()
+            print("[METRICS] Detected peaks")
             
-            print("[METRICS] Calculating depth and rate...")
             depth, rate = self.metrics_calculator.calculate_metrics(
-                self.role_classifier.shoulder_distances,
-                self.cap.get(cv2.CAP_PROP_FPS))
-
-            print(f"[RESULTS] Compression Depth: {depth:.1f} cm")
-            print(f"[RESULTS] Compression Rate: {rate:.1f} cpm")
+                self.shoulders_analyzer.shoulder_distance_history,
+                self.cap.get(cv2.CAP_PROP_FPS),
+                chunk_start_frame_index, 
+                chunk_end_frame_index)
+            print("[METRICS] Calculated metrics")
 
-            self.average_compression_depth = depth
-            self.average_compression_rate = rate
+            if depth is None or rate is None:
+                print("[ERROR] Depth or rate calculation failed, likely due to insufficient data points (<2 peaks)")
             
-            print("[VISUAL] Generating motion curve plot...")
-            self.metrics_calculator.plot_motion_curve()
+            return depth, rate
             
         except Exception as e:
             print(f"[ERROR] Metric calculation failed: {str(e)}")
-            
-        finally:
-            self.cap.release()
-            #cv2.destroyAllWindows()
-            print(f"\n[ANALYSIS] Completed in {time.time()-start_time:.1f}s")
-            print("[CLEANUP] Resources released")
-
-
 
+    def _calculate_rate_and_depth_for_all_chunks(self):
+        try:
+            self.metrics_calculator.calculate_weighted_averages()
+            print(f"[METRICS] Weighted averages calculated")
+        except Exception as e:
+            print(f"[ERROR] Failed to calculate weighted averages: {str(e)}")
+            
+    def _plot_full_motion_curve_for_all_chunks(self):
+        try:
+            print("[PLOT] Full motion curve plotted")
+            return self.metrics_calculator.plot_motion_curve_for_all_chunks(self.posture_analyzer.posture_errors_for_all_error_region)
+        except Exception as e:
+            print(f"[ERROR] Failed to plot full motion curve: {str(e)}")
+    
+    
+    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
+                    if (len(self.posture_analyzer.posture_errors_for_all_error_region) > 0):
+                        # If the error region is not empty, append the image URL and description
+                        result.append({
+                            "image_url": f"{os.path.basename(path)}",  # Adjust if hosted elsewhere
+                            "description": description
+                        })
+                    
+            return result

CPR/chest_initializer.py

@@ -1,153 +1,143 @@
-# chest_initializer.py
 import cv2
 import numpy as np
 from CPR.keypoints import CocoKeypoints
 
 class ChestInitializer:
-    """Handles chest point detection with separated debug visualization"""
+    """Handles chest point detection with validations in estimation."""
     
-    def __init__(self, num_init_frames=15, min_confidence=0.2, aspect_ratio_thresh=1.2):
-        self.num_init_frames = num_init_frames
-        self.min_confidence = min_confidence
-        self.aspect_ratio_thresh = aspect_ratio_thresh
-        self.chest_point = None
-        self.shoulder_samples = []
-        self.hip_samples = []
-        self.debug_window = "Chest Detection Debug"
-
-    def initialize(self, cap, pose_estimator, role_classifier):
-        """Main initialization routine"""
-        success = self._sample_initial_frames(cap, pose_estimator)
-        self._calculate_chest_point(cap)
-        #cv2.destroyWindow(self.debug_window)
-        return success
-
-    def _sample_initial_frames(self, cap, pose_estimator):
-        """Collect valid shoulder positions"""
-        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
-        valid_samples = 0
-
-        for i in range(self.num_init_frames):
-            ret, frame = cap.read()
-            if not ret:
-                break
-
-            results = pose_estimator.detect_poses(frame) #!could remove this to prevent double detection
-            if not results:
-                continue
-
-            debug_frame = results.plot()
-            shoulders = self._detect_valid_shoulders(results, frame.shape)
-
-            if shoulders:
-                left_shoulder, right_shoulder, left_hip, right_hip = shoulders
-                self.shoulder_samples.append((left_shoulder, right_shoulder))
-                self.hip_samples.append((left_hip, right_hip))
-                valid_samples += 1
-                debug_frame = self._draw_debug_info(
-                    debug_frame, 
-                    left_shoulder, 
-                    right_shoulder, 
-                    frame.shape,
-                    i+1
-                )
-
-            #cv2.imshow(self.debug_window, debug_frame)
-            if cv2.waitKey(400) == ord('q'):
-                break
-
-        return valid_samples > 0
-
-    def _draw_debug_info(self, frame, left_shoulder, right_shoulder, frame_shape, frame_num):
-        """Helper function for drawing debug information"""
-        # Convert normalized coordinates to pixel values
-        lx, ly = (left_shoulder * np.array([frame_shape[1], frame_shape[0]])).astype(int)
-        rx, ry = (right_shoulder * np.array([frame_shape[1], frame_shape[0]])).astype(int)
+    def __init__(self):
+        self.chest_params = None
+        self.chest_params_history = []
+        self.expected_chest_params = None
+
+    def estimate_chest_region(self, keypoints, bounding_box, frame_width, frame_height):
+        """Estimate and validate chest region. Returns (cx, cy, cw, ch) or None."""
+        try:
+            # Unpack bounding box and calculate shoulder dimensions
+            bbox_x1, bbox_y1, bbox_x2, bbox_y2 = bounding_box
+            bbox_delta_y = abs(bbox_y2 - bbox_y1)
+
+            # Keypoints for shoulders
+            left_shoulder = keypoints[CocoKeypoints.LEFT_SHOULDER.value]
+            right_shoulder = keypoints[CocoKeypoints.RIGHT_SHOULDER.value]
+
+            # Midpoints calculation
+            shoulder_center = np.array([(left_shoulder[0] + right_shoulder[0]) / 2,
+                                        (left_shoulder[1] + right_shoulder[1]) / 2])
+            
+            # Calculate chest center by applying directional adjustment separately for x and y
+            chest_center_from_shoulder_x = shoulder_center[0] - 0.3 * bbox_delta_y
+            chest_center_from_shoulder_y = shoulder_center[1] - 0.1 * bbox_delta_y
+            chest_center_from_shoulder = np.array([chest_center_from_shoulder_x, chest_center_from_shoulder_y])
+
+            # Chest dimensions (85% of shoulder width, 40% height)
+            chest_dx = bbox_delta_y * 0.8
+            chest_dy = bbox_delta_y * 1.75
+
+            # Calculate region coordinates
+            x1 = chest_center_from_shoulder[0] - chest_dx / 2
+            y1 = chest_center_from_shoulder[1] - chest_dy / 2
+            x2 = chest_center_from_shoulder[0] + chest_dx / 2
+            y2 = chest_center_from_shoulder[1] + chest_dy / 2
+
+            # Clamp to frame boundaries
+            x1 = max(0, min(x1, frame_width - 1))
+            y1 = max(0, min(y1, frame_height - 1))
+            x2 = max(0, min(x2, frame_width - 1))
+            y2 = max(0, min(y2, frame_height - 1))
+
+            # Check validity
+            if x2 <= x1 or y2 <= y1:
+                return None
+
+            # Adjusted parameters
+            cx = (x1 + x2) / 2
+            cy = (y1 + y2) / 2
+            cw = x2 - x1
+            ch = y2 - y1
+
+            return (cx, cy, cw, ch)
+
+        except (IndexError, TypeError, ValueError) as e:
+            print(f"Chest estimation error: {e}")
+            return None
+
+    def estimate_chest_region_weighted_avg(self, frame_width, frame_height, window_size=60, min_samples=3):
+        """
+        Calculate stabilized chest parameters using weighted averaging with boundary checks.
         
-        # Draw shoulder points
-        cv2.circle(frame, (lx, ly), 5, (0, 0, 255), -1)
-        cv2.circle(frame, (rx, ry), 5, (0, 0, 255), -1)
+        Args:
+            self.chest_params_history: List of recent chest parameters [(cx, cy, cw, ch), ...]
+            frame_width: Width of the video frame
+            frame_height: Height of the video frame
+            window_size: Number of recent frames to consider (default: 5)
+            min_samples: Minimum valid samples required (default: 3)
+            
+        Returns:
+            Tuple of (cx, cy, cw, ch) as integers within frame boundaries,
+            or None if insufficient data or invalid rectangle
+        """
+        if not self.chest_params_history:
+            return None
         
-        # Add informational text
-        cv2.putText(frame, f"CHEST pts - Frame {frame_num}", (lx, ly - 10),
-                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)
+        # Filter out None values and get recent frames
+        valid_history = [h for h in self.chest_params_history[-window_size:] if h is not None]
         
-        return frame
+        if len(valid_history) < min_samples:
+            return None
+        
+        # Convert to numpy array (preserve floating-point precision)
+        history_array = np.array(valid_history, dtype=np.float32)
+        
+        # Exponential weights (stronger emphasis on recent frames)
+        weights = np.exp(np.linspace(1, 3, len(history_array)))
+        weights /= weights.sum()
+        
+        try:
+            # Calculate weighted average in float space
+            cx, cy, cw, ch = np.average(history_array, axis=0, weights=weights)
+            
+            # Convert to rectangle coordinates (still floating point)
+            x1 = max(0.0, cx - cw/2)
+            y1 = max(0.0, cy - ch/2)
+            x2 = min(float(frame_width - 1), cx + cw/2)
+            y2 = min(float(frame_height - 1), cy + ch/2)
+            
+            # Only round to integers after all calculations
+            x1, y1, x2, y2 = map(round, [x1, y1, x2, y2])
+            
+            # Validate rectangle
+            if x2 <= x1 or y2 <= y1:
+                return None
+                
+            return (
+                (x1 + x2) // 2,  # cx
+                (y1 + y2) // 2,  # cy
+                x2 - x1,         # cw
+                y2 - y1          # ch
+            )
+            
+        except Exception as e:
+            print(f"Chest region estimation error: {e}")
+            return None
+    
+    def draw_expected_chest_region(self, frame):
+        """Draws the chest region without validation."""
+        if self.expected_chest_params is None:
+            return frame
 
-    def _detect_valid_shoulders(self, results, frame_shape):
-        """Validate detected shoulders using aspect ratio and confidence"""
-        boxes = results.boxes.xywh.cpu().numpy()
-        keypoints = results.keypoints.xyn.cpu().numpy()
-        confs = results.keypoints.conf.cpu().numpy()
-
-        for i, (box, kp) in enumerate(zip(boxes, keypoints)):
-            x, y, w, h = box
-            # Aspect ratio validation
-            if h < w * self.aspect_ratio_thresh:
-                continue
-
-            # Confidence check
-            if (confs[i][CocoKeypoints.LEFT_SHOULDER.value] < self.min_confidence or 
-                confs[i][CocoKeypoints.RIGHT_SHOULDER.value] < self.min_confidence):
-                continue
-
-            return (kp[CocoKeypoints.LEFT_SHOULDER.value], 
-                    kp[CocoKeypoints.RIGHT_SHOULDER.value],
-                    kp[CocoKeypoints.LEFT_HIP.value],
-                    kp[CocoKeypoints.RIGHT_HIP.value])
-
-        return None
-
-    def _calculate_chest_point(self, cap):
-        """Calculate final chest point from valid samples"""
-        if not self.shoulder_samples:
-            return
-
-        avg_left = np.median([s[0] for s in self.shoulder_samples], axis=0)
-        avg_right = np.median([s[1] for s in self.shoulder_samples], axis=0)
-        avg_left_hip = np.median([h[0] for h in self.hip_samples], axis=0)
-        avg_right_hip = np.median([h[1] for h in self.hip_samples], axis=0)
-
-        frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        cx, cy, cw, ch = self.expected_chest_params
+        x1 = int(cx - cw / 2)
+        y1 = int(cy - ch / 2)
+        x2 = int(cx + cw / 2)
+        y2 = int(cy + ch / 2)
+
+        # Draw rectangle and center
+        cv2.rectangle(frame, (x1, y1), (x2, y2), (128, 128, 0), 5)
+
+        cv2.circle(frame, (int(cx), int(cy)), 8, (128, 128, 0), -1)
+
+        cv2.putText(frame, "EXPECTED CHEST", (x1, max(10, y1 - 5)), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.8, (128, 128, 0), 2)
         
-        avg_left_px = avg_left * np.array([frame_width, frame_height])
-        avg_right_px = avg_right * np.array([frame_width, frame_height])
-        avg_left_hip_px = avg_left_hip * np.array([frame_width, frame_height])
-        avg_right_hip_px = avg_right_hip * np.array([frame_width, frame_height])
-
-        #midpoint = (avg_left_px + avg_right_px) / 2
-        #shoulder_dist = np.linalg.norm(avg_left_px - avg_right_px)
-        #downward_offset = 0.4 * shoulder_dist
-        #self.chest_point = (int(midpoint[0]), int(midpoint[1] + downward_offset))
-
-        if avg_left_px[1] < avg_right_px[1]:
-            shoulder = np.array(avg_left_px)
-            hip = np.array(avg_left_hip_px)
-        else:
-            shoulder = np.array(avg_right_px)
-            hip = np.array(avg_right_hip_px)
-
-        alpha = 0.412  # Relative chest position between shoulder and hip
-        offset = 10  # move 10 pixels upward into the body
-        self.chest_point = (
-            int(shoulder[0] + alpha * (hip[0] - shoulder[0])),
-            int(shoulder[1] + alpha * (hip[1] - shoulder[1])) - offset
-        )
-
-        # Visualize the chest point in the debug window for 2 seconds
-        cap.set(cv2.CAP_PROP_POS_FRAMES, 0)  # Reset to the first frame
-        ret, frame = cap.read()
-        if ret:
-            frame_with_marker = self.draw_chest_marker(frame)
-            #cv2.imshow(self.debug_window, frame_with_marker)
-            cv2.waitKey(2000)  # Wait for 2 seconds
-
-    def draw_chest_marker(self, frame):
-        """Draw chest point with visualization"""
-        print(f"Chest point: {self.chest_point}")
-        if self.chest_point:
-            cv2.circle(frame, self.chest_point, 8, (0, 55, 120), -1)
-            cv2.putText(frame, "Chest", (self.chest_point[0] + 5, self.chest_point[1] - 10),
-                       cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 255), 2)
-        return frame
+        return frame

CPR/metrics_calculator.py

@@ -2,11 +2,18 @@
 import numpy as np
 from scipy.signal import savgol_filter, find_peaks
 import matplotlib.pyplot as plt
+import sys
+import cv2
+import cloudinary as cld
+import cloudinary.uploader
+import tempfile
+import json
+import os
 
 class MetricsCalculator:
     """Rate and depth calculation from motion data with improved peak detection"""
     
-    def __init__(self, shoulder_width_cm=45):
+    def __init__(self, frame_count, shoulder_width_cm):
         self.shoulder_width_cm = shoulder_width_cm
         self.peaks = np.array([])
         self.peaks_max = np.array([])
@@ -16,6 +23,28 @@ class MetricsCalculator:
         self.midpoints_list = np.array([])
         self.shoulder_distances = []
 
+        # Parameters for the final report
+        self.chunks_depth = []
+        self.chunks_rate = []
+        self.chunks_start_and_end_indices = []
+
+        self.chunks_midpoints = []
+        self.chunks_smoothed = []
+        self.chunks_peaks = []
+
+        self.frame_count = frame_count
+
+        # Validation thresholds
+        self.depth = None
+        self.rate = None
+
+        self.min_depth_threshold = 3.0  # cm
+        self.max_depth_threshold = 6.0  # cm
+
+        self.min_rate_threshold = 100.0  # cpm
+        self.max_rate_threshold = 120.0  # cpm
+        
+
     def smooth_midpoints(self, midpoints):
         """Apply Savitzky-Golay filter to smooth motion data"""
         self.midpoints_list = np.array(midpoints)
@@ -38,24 +67,71 @@ class MetricsCalculator:
             return False
 
     def detect_peaks(self):
-        """Improved peak detection with separate max/min peaks"""
+        """Improved peak detection with adjusted prominence for min peaks"""
         if self.y_smoothed.size == 0:
             print("No smoothed values found for peak detection")
             return False
             
         try:
-            self.peaks_max, _ = find_peaks(self.y_smoothed, distance=10)
-            self.peaks_min, _ = find_peaks(-self.y_smoothed, distance=10)
+            distance = min(10, len(self.y_smoothed))  # Dynamic distance based on data length
+
+            # Detect max peaks with default prominence
+            self.peaks_max, _ = find_peaks(self.y_smoothed, distance=distance)
+            
+            # Detect min peaks with reduced or no prominence requirement
+            self.peaks_min, _ = find_peaks(
+                -self.y_smoothed, 
+                distance=distance, 
+                prominence=(0.3, None)  # Adjust based on your data's characteristics
+            )
+            
             self.peaks = np.sort(np.concatenate((self.peaks_max, self.peaks_min)))
+
             return len(self.peaks) > 0
         except Exception as e:
             print(f"Peak detection error: {e}")
             return False
 
-    def calculate_metrics(self, shoulder_distances, fps):
-        """Calculate compression metrics with improved calculations"""
-        self.shoulder_distances = shoulder_distances
+    def _validate_chunk(self, chunk_start_frame_index, chunk_end_frame_index):
+        """Validate that the data length matches the expected frame range.
+        Terminates the program with error code 1 if validation fails.
+        
+        Args:
+            chunk_start_frame_index: Start frame index of the chunk
+            chunk_end_frame_index: End frame index of the chunk
+            
+        Exits:
+            If validation fails, prints error message and exits with code 1
+        """
+        try:
+            # Calculate expected number of frames
+            num_frames = chunk_end_frame_index - chunk_start_frame_index + 1
+            
+            # Validate midpoints data
+            if len(self.midpoints_list[:, 1]) != num_frames:
+                print(f"\nERROR: Data length mismatch in midpoints_list")
+                print(f"Expected: {num_frames} frames ({chunk_start_frame_index}-{chunk_end_frame_index})")
+                print(f"Actual: {len(self.midpoints_list[:, 1])} frames")
+                sys.exit(1)
+                
+            # Validate smoothed data
+            if len(self.y_smoothed) != num_frames:
+                print(f"\nERROR: Data length mismatch in y_smoothed")
+                print(f"Expected: {num_frames} frames ({chunk_start_frame_index}-{chunk_end_frame_index})")
+                print(f"Actual: {len(self.y_smoothed)} frames")
+                sys.exit(1)
+                
+        except Exception as e:
+            print(f"\nCRITICAL VALIDATION ERROR: {str(e)}")
+            sys.exit(1)
+
+    def calculate_metrics(self, shoulder_distances, fps, chunk_start_frame_index, chunk_end_frame_index):
+        """Calculate compression metrics with improved calculations"""        
         
+        self._validate_chunk(chunk_start_frame_index, chunk_end_frame_index)
+                
+        self.shoulder_distances = shoulder_distances
+
         try:
             # Calculate pixel to cm ratio
             if len(self.shoulder_distances) > 0:
@@ -75,35 +151,59 @@ class MetricsCalculator:
             if len(self.peaks_max) > 1:
                 rate = 1 / (np.mean(np.diff(self.peaks_max)) / fps) * 60  # Convert to CPM
 
+            if depth is None or rate is None:
+                depth = 0
+                rate = 0
+                self.peaks = np.array([])  # Reset peaks if no valid data
+
+            # Store the results of this chunk for the final report if they are not None
+            self.depth = depth
+            self.rate = rate
+
+            self.chunks_depth.append(depth)
+            self.chunks_rate.append(rate)
+            self.chunks_start_and_end_indices.append((chunk_start_frame_index, chunk_end_frame_index))
+
+            self.chunks_midpoints.append(self.midpoints_list.copy())
+            self.chunks_smoothed.append(self.y_smoothed.copy())
+            self.chunks_peaks.append(self.peaks.copy())      
+
+
             return depth, rate
             
         except Exception as e:
             print(f"Metric calculation error: {e}")
             return None, None
 
-    def plot_motion_curve(self):
+    def plot_motion_curve(self, chunk_start_frame_index, chunk_end_frame_index):
         """Enhanced visualization with original and smoothed data"""
         if self.midpoints_list.size == 0:
             print("No midpoint data to plot")
             return
+        
+        self._validate_chunk(chunk_start_frame_index, chunk_end_frame_index)
+
+        # Create frame index array for x-axis
+        frame_indices = np.arange(chunk_start_frame_index, chunk_end_frame_index + 1)
+
 
         plt.figure(figsize=(12, 6))
         
-        # Plot original and smoothed data
-        plt.plot(self.midpoints_list[:, 1], 
+        # Plot original and smoothed data with correct frame indices
+        plt.plot(frame_indices, self.midpoints_list[:, 1], 
                 label="Original Motion", 
                 color="red", 
                 linestyle="dashed", 
                 alpha=0.6)
-                
-        plt.plot(self.y_smoothed, 
+    
+        plt.plot(frame_indices, self.y_smoothed, 
                 label="Smoothed Motion", 
                 color="blue", 
                 linewidth=2)
 
         # Plot peaks if detected
         if self.peaks.size > 0:
-            plt.plot(self.peaks, 
+            plt.plot(frame_indices[self.peaks], 
                     self.y_smoothed[self.peaks], 
                     "x", 
                     color="green", 
@@ -117,4 +217,335 @@ class MetricsCalculator:
         plt.title("Compression Motion Analysis")
         plt.grid(True)
         plt.legend()
-        plt.show()
+        plt.show()
+    
+    def calculate_weighted_averages(self):
+        """Calculate weighted averages based on chunk durations
+        """
+        if not self.chunks_depth or not self.chunks_rate or not self.chunks_start_and_end_indices:
+            print("[WARNING] No chunk data available for averaging")
+            return None
+            
+        if not (len(self.chunks_depth) == len(self.chunks_rate) == len(self.chunks_start_and_end_indices)):
+            print("[ERROR] Mismatched chunk data lists")
+            return None
+
+        total_weight = 0
+        weighted_depth_sum = 0
+        weighted_rate_sum = 0
+
+        for depth, rate, (start, end) in zip(self.chunks_depth, 
+                                        self.chunks_rate,
+                                        self.chunks_start_and_end_indices):
+            
+            # Calculate chunk duration (+1 because inclusive)
+            chunk_duration = end - start + 1
+            
+            weighted_depth_sum += depth * chunk_duration
+            weighted_rate_sum += rate * chunk_duration
+            total_weight += chunk_duration
+
+        if total_weight == 0:
+            print("[ERROR] Total chunk durations is zero")
+            return None
+
+        weighted_depth = weighted_depth_sum / total_weight
+        weighted_rate = weighted_rate_sum / total_weight
+
+        print(f"[RESULTS] Weighted average depth: {weighted_depth:.1f} cm")
+        print(f"[RESULTS] Weighted average rate: {weighted_rate:.1f} cpm")
+        
+        return weighted_depth, weighted_rate
+
+    def plot_motion_curve_for_all_chunks(self, posture_errors_for_all_error_region):
+        """Plot combined analysis with metrics annotations and posture error labels"""
+        if not self.chunks_start_and_end_indices:
+            print("No chunk data available for plotting")
+            return
+
+        # Print chunk information before plotting
+        print("\n=== Chunk Ranges ===")
+        for i, (start_end, depth, rate) in enumerate(zip(self.chunks_start_and_end_indices, 
+                                                    self.chunks_depth, 
+                                                    self.chunks_rate)):
+            print(f"Chunk {i+1}: Frames {start_end[0]}-{start_end[1]} | "
+                f"Depth: {depth:.1f}cm | Rate: {rate:.1f}cpm")
+
+        plt.figure(figsize=(16, 8))
+        ax = plt.gca()
+        
+        # Sort chunks chronologically
+        sorted_chunks = sorted(zip(self.chunks_start_and_end_indices, 
+                        self.chunks_depth, 
+                        self.chunks_rate),
+                        key=lambda x: x[0][0])
+        
+        # 1. Plot all valid chunks with metrics
+        prev_chunk_end = None  # Track previous chunk's end position
+
+        for idx, ((start, end), depth, rate) in enumerate(sorted_chunks):
+            chunk_frames = np.arange(start, end + 1)
+            midpoints = self.chunks_midpoints[idx]
+            smoothed = self.chunks_smoothed[idx]
+            peaks = self.chunks_peaks[idx]
+            
+            # Add separator line between chunks
+            if prev_chunk_end is not None:
+                separator_x = prev_chunk_end + 0.5  # Midpoint between chunks
+                ax.axvline(x=separator_x, color='orange', linestyle=':', linewidth=1.5)
+            
+            # Plot data
+            ax.plot(chunk_frames, midpoints[:, 1], 
+                color="red", linestyle="dashed", alpha=0.6,
+                label="Original Motion" if idx == 0 else "")
+            ax.plot(chunk_frames, smoothed,
+                color="blue", linewidth=2,
+                label="Smoothed Motion" if idx == 0 else "")
+            
+            # Plot peaks
+            if peaks.size > 0:
+                ax.plot(chunk_frames[peaks], smoothed[peaks],
+                    "x", color="green", markersize=8,
+                    label="Peaks" if idx == 0 else "")
+
+            # Annotate chunk metrics
+            mid_frame = (start + end) // 2
+            ax.annotate(f"Depth: {depth:.1f}cm\nRate: {rate:.1f}cpm",
+                    xy=(mid_frame, np.max(smoothed)),
+                    xytext=(0, 10), textcoords='offset points',
+                    ha='center', va='bottom', fontsize=9,
+                    bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5))
+
+            # Update previous chunk end tracker
+            prev_chunk_end = end
+        # 2. Identify and label posture error regions
+        error_regions = []
+        
+        # Before first chunk
+        if sorted_chunks[0][0][0] > 0:
+            error_regions.append((0, sorted_chunks[0][0][0]-1))
+        
+        # Between chunks
+        for i in range(1, len(sorted_chunks)):
+            prev_end = sorted_chunks[i-1][0][1]
+            curr_start = sorted_chunks[i][0][0]
+            if curr_start - prev_end > 1:
+                error_regions.append((prev_end + 1, curr_start - 1))
+        
+        # After last chunk
+        last_end = sorted_chunks[-1][0][1]
+        if last_end < self.frame_count - 1:
+            error_regions.append((last_end + 1, self.frame_count - 1))
+
+        # Print error regions information
+        print("\n=== Error Regions ===")
+        for i, (start, end) in enumerate(error_regions):
+            # Get errors for this region if available
+            try:
+                errors = posture_errors_for_all_error_region[i]
+                error_str = ", ".join(errors) if errors else "No errors detected"
+            except IndexError:
+                error_str = "No error data"
+                
+            print(f"Error Region {i+1}: Frames {start}-{end} | Errors: {error_str}")
+
+        # Shade and label error regions
+        for error_region_index, region in enumerate (error_regions):
+            ax.axvspan(region[0], region[1], 
+                    color='gray', alpha=0.2,
+                    label='Posture Errors' if region == error_regions[0] else "")
+            
+            # Add vertical dotted lines at boundaries
+            ax.axvline(x=region[0], color='black', linestyle=':', alpha=0.5)
+            ax.axvline(x=region[1], color='black', linestyle=':', alpha=0.5)
+            
+            # Add frame number labels - properly aligned
+            y_pos = ax.get_ylim()[0] + 0.02 * (ax.get_ylim()[1] - ax.get_ylim()[0])
+            
+            # Start frame label - right aligned before the line
+            ax.text(region[0] - 1, y_pos, 
+                f"Frame {region[0]}",
+                rotation=90, va='bottom', ha='right',
+                fontsize=8, alpha=0.7)
+            
+            # End frame label - left aligned after the line
+            ax.text(region[1] + 1, y_pos,
+                f"Frame {region[1]}",
+                rotation=90, va='bottom', ha='left',
+                fontsize=8, alpha=0.7)
+            
+            # Add error labels if available
+            if posture_errors_for_all_error_region:
+                try:
+                    # Get errors for this specific error region
+                    region_errors = posture_errors_for_all_error_region[error_region_index]
+                    
+                    # Format errors text
+                    error_text = "Errors:\n" + "\n".join(region_errors) if region_errors else ""
+                    
+                    # Position text in middle of the error region
+                    mid_frame = (region[0] + region[1]) // 2
+                    ax.text(mid_frame, np.mean(ax.get_ylim()), 
+                        error_text,
+                        ha='center', va='center', 
+                        fontsize=9, color='red', alpha=0.8,
+                        bbox=dict(boxstyle='round,pad=0.3', 
+                                fc='white', ec='red', alpha=0.7))               
+                except IndexError:
+                    print(f"No error data for region {error_region_index}")
+
+        # 3. Add weighted averages
+        if hasattr(self, 'weighted_depth') and hasattr(self, 'weighted_rate'):
+            ax.annotate(f"Weighted Averages:\nDepth: {self.weighted_depth:.1f}cm\nRate: {self.weighted_rate:.1f}cpm",
+                    xy=(0.98, 0.98), xycoords='axes fraction',
+                    ha='right', va='top', fontsize=10,
+                    bbox=dict(boxstyle='round,pad=0.5', fc='white', ec='black'))
+
+        # 4. Configure legend and layout
+        handles, labels = ax.get_legend_handles_labels()
+        unique = [(h, l) for i, (h, l) in enumerate(zip(handles, labels)) if l not in labels[:i]]
+        ax.legend(*zip(*unique), loc='upper right')
+
+        plt.xlabel("Frame Number")
+        plt.ylabel("Vertical Position (px)")
+        plt.title("Complete CPR Analysis with Metrics")
+        plt.grid(True)
+        plt.tight_layout()
+
+        os.makedirs("plots", exist_ok=True)
+        plot_path = "plots/cpr_analysis.png"
+        plt.savefig("plots/cpr_analysis.png", dpi=300)
+        response = cloudinary.uploader.upload(plot_path, resource_type="image")
+        plt.close()
+        plt.show()
+        return response['secure_url']
+
+    def validate_calculate_metrics(self):
+        """Validate the calculated metrics against thresholds"""
+        if self.depth is None or self.rate is None:
+            print("[ERROR] Depth and rate must be calculated before validation")
+            return False
+
+        depth_valid = self.min_depth_threshold <= self.depth <= self.max_depth_threshold
+        rate_valid = self.min_rate_threshold <= self.rate <= self.max_rate_threshold
+
+        if not depth_valid:
+            print(f"[WARNING] Depth {self.depth:.1f}cm is out of range ({self.min_depth_threshold}-{self.max_depth_threshold})")
+        if not rate_valid:
+            print(f"[WARNING] Rate {self.rate:.1f}cpm is out of range ({self.min_rate_threshold}-{self.max_rate_threshold})")
+
+        return depth_valid and rate_valid
+    
+    def get_json_chunk_data(self):
+        """Get chunk data in JSON format for external use"""
+        if not self.chunks_start_and_end_indices:
+            print("No chunk data available")
+            return None
+
+        chunk_data = [
+            {
+                "start": round(start / 30, 2),
+                "end": round(end / 30, 2),
+                "depth": depth,
+                "rate": rate
+            }
+            for (start, end), depth, rate in zip(
+                self.chunks_start_and_end_indices,
+                self.chunks_depth,
+                self.chunks_rate
+            )
+            if (end - start) >= 60
+        ]
+
+        return chunk_data
+    
+    
+    def annotate_video_with_chunks(self, input_video_path, posture_errors_for_all_error_region):
+        cap = cv2.VideoCapture(input_video_path)
+        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))
+
+        # Validate video opened
+        if not cap.isOpened() or fps == 0 or width == 0 or height == 0:
+            raise ValueError("Failed to open input video or invalid video properties.")
+
+        # Create named temp file for cloudinary upload (must not be open during writing on Windows)
+        temp_video = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
+        temp_video_path = temp_video.name
+        temp_video.close()
+
+        # ALSO save a local version for inspection
+        #os.makedirs("temp_output", exist_ok=True)
+        #local_output_path = os.path.join("temp_output", "annotated_output.mp4")
+
+        out = cv2.VideoWriter(temp_video_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
+        #local_out = cv2.VideoWriter(local_output_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
+
+        frame_idx = 0
+        current_chunk = 0
+
+        # Generate error regions
+        error_regions = []
+        # Before first chunk
+        if self.chunks_start_and_end_indices[0][0] > 0:
+            error_regions.append((0, self.chunks_start_and_end_indices[0][0] - 1))
+
+        # Between chunks
+        for i in range(1, len(self.chunks_start_and_end_indices)):
+            prev_end = self.chunks_start_and_end_indices[i - 1][1]
+            curr_start = self.chunks_start_and_end_indices[i][0]
+            if curr_start - prev_end > 1:
+                error_regions.append((prev_end + 1, curr_start - 1))
+
+        # After last chunk
+        last_end = self.chunks_start_and_end_indices[-1][1]
+        if last_end < self.frame_count - 1:
+            error_regions.append((last_end + 1, self.frame_count - 1))
+
+        # Iterate over the video frames and annotate
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            # Handle chunk annotation
+            if current_chunk < len(self.chunks_start_and_end_indices):
+                start_idx, end_idx = self.chunks_start_and_end_indices[current_chunk]
+                if start_idx <= frame_idx <= end_idx:
+                    rate = self.chunks_rate[current_chunk]
+                    depth = self.chunks_depth[current_chunk]
+
+                    text1 = f"Rate: {rate:.1f}cpm"
+                    text2 = f"Depth: {depth:.1f}cm"
+                    cv2.putText(frame, text1, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+                    cv2.putText(frame, text2, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+
+                if frame_idx > end_idx:
+                    current_chunk += 1
+
+            # Annotate error regions
+            for i, (start, end) in enumerate(error_regions):
+                if start <= frame_idx <= end:
+                    region_errors = posture_errors_for_all_error_region[i]
+                    
+                    # Format errors text
+                    error_text = "Errors: ".join(region_errors) if region_errors else ""
+                    cv2.putText(frame, error_text, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
+
+            out.write(frame)
+            #local_out.write(frame)
+            frame_idx += 1
+
+        cap.release()
+        out.release()
+        #local_out.release()
+
+        # Upload to Cloudinary
+        response = cloudinary.uploader.upload(temp_video_path, resource_type="video")
+
+        # Clean up temp file
+        os.remove(temp_video_path)
+
+        #print(f"✅ Local saved video at: {local_output_path}")
+        return response['secure_url']

CPR/pose_estimation.py

@@ -3,18 +3,19 @@ import cv2
 import numpy as np
 from ultralytics import YOLO
 from CPR.keypoints import CocoKeypoints
+import torch
 
 class PoseEstimator:
     """Human pose estimation using YOLO"""
     
     def __init__(self, model_path="yolo11n-pose.pt", min_confidence=0.2):
-        self.model = YOLO(model_path).to('cuda')
+        self.model = YOLO(model_path).to("cuda:0" if torch.cuda.is_available() else "cpu")
         self.min_confidence = min_confidence
 
     def detect_poses(self, frame):
         """Detect human poses in a frame"""
         try:
-            results = self.model(frame, verbose=False)
+            results = self.model(frame, verbose=False, conf=self.min_confidence, show=False)
             if not results or len(results[0].keypoints.xy) == 0:
                 return None
             return results[0]

CPR/posture_analyzer.py

@@ -6,20 +6,31 @@ from CPR.keypoints import CocoKeypoints
 
 class PostureAnalyzer:
     """Posture analysis and visualization with comprehensive validation"""
+
+    #! The warnings depend on the average readings from the last 10 frames
+    #! This "10" should be adjusted according to the sampling rate of the video
     
-    def __init__(self, right_arm_angle_threshold=210, left_arm_angle_threshold=150, wrist_distance_threshold=170):
+    def __init__(self, right_arm_angle_threshold, left_arm_angle_threshold, wrist_distance_threshold, history_length_to_average):
+        self.history_length_to_average = history_length_to_average
+        
         self.right_arm_angles = []
         self.left_arm_angles = []
         self.wrist_distances = []
+        
         self.right_arm_angle_threshold = right_arm_angle_threshold
         self.left_arm_angle_threshold = left_arm_angle_threshold
         self.wrist_distance_threshold = wrist_distance_threshold
+        
         self.warning_positions = {
-            'arm_angles': (50, 50),
-            'one_handed': (50, 100)
+            'right_arm_angle': (50, 50),
+            'left_arm_angle': (50, 100),
+            'one_handed': (50, 150),
+            'hands_not_on_chest': (50, 200)
         }
 
-    def calculate_angle(self, a, b, c):
+        self.posture_errors_for_all_error_region = []
+
+    def _calculate_angle(self, a, b, c):
         """Calculate angle between three points"""
         try:
             ang = math.degrees(math.atan2(c[1]-b[1], c[0]-b[0]) - 
@@ -28,97 +39,172 @@ class PostureAnalyzer:
         except Exception as e:
             print(f"Angle calculation error: {e}")
             return 0
-
-    def check_bended_arms(self, keypoints):
-        """Check for proper arm positioning (returns warnings)"""
+    
+    def _check_bended_right_arm(self, keypoints):
+        """Check for right arm bending (returns warning)"""
         warnings = []
         try:
-            # Right arm analysis
             shoulder = keypoints[CocoKeypoints.RIGHT_SHOULDER.value]
             elbow = keypoints[CocoKeypoints.RIGHT_ELBOW.value]
             wrist = keypoints[CocoKeypoints.RIGHT_WRIST.value]
-            right_angle = self.calculate_angle(wrist, elbow, shoulder)
-            self.right_arm_angles.append(right_angle)
             
-            # Left arm analysis
+            right_angle = self._calculate_angle(wrist, elbow, shoulder)
+            
+            self.right_arm_angles.append(right_angle)
+
+            avg_right = np.mean(self.right_arm_angles[-self.history_length_to_average:] if self.right_arm_angles else 0)
+
+            if avg_right > self.right_arm_angle_threshold:
+                warnings.append("Right arm bent")
+
+            return warnings
+                
+        except Exception as e:
+            print(f"Right arm check error: {e}")
+        
+        return warnings
+    
+    def _check_bended_left_arm(self, keypoints):
+        """Check for left arm bending (returns warning)"""
+        warnings = []
+        try:
             shoulder = keypoints[CocoKeypoints.LEFT_SHOULDER.value]
             elbow = keypoints[CocoKeypoints.LEFT_ELBOW.value]
             wrist = keypoints[CocoKeypoints.LEFT_WRIST.value]
-            left_angle = self.calculate_angle(wrist, elbow, shoulder)
-            self.left_arm_angles.append(left_angle)
             
-            # Analyze angles with moving average
-            avg_right = np.mean(self.right_arm_angles[-10:] if self.right_arm_angles else 0)
-            avg_left = np.mean(self.left_arm_angles[-10:] if self.left_arm_angles else 0)
+            left_angle = self._calculate_angle(wrist, elbow, shoulder)
             
-            if avg_right > self.right_arm_angle_threshold:
-                warnings.append("Right arm bent")
+            self.left_arm_angles.append(left_angle)
+
+            avg_left = np.mean(self.left_arm_angles[-self.history_length_to_average:] if self.left_arm_angles else 0)
+
             if avg_left < self.left_arm_angle_threshold:
                 warnings.append("Left arm bent")
+
+            return warnings
                 
         except Exception as e:
-            print(f"Arm angle check error: {e}")
+            print(f"Left arm check error: {e}")
         
         return warnings
 
-    def check_missing_arms(self, keypoints):
+    def _check_one_handed_cpr(self, keypoints):
         """Check for one-handed CPR pattern (returns warning)"""
+        warnings = []
         try:
+            # Calculate wrist distance
             left_wrist = keypoints[CocoKeypoints.LEFT_WRIST.value]
             right_wrist = keypoints[CocoKeypoints.RIGHT_WRIST.value]
             
             wrist_distance = np.linalg.norm(left_wrist - right_wrist)
             self.wrist_distances.append(wrist_distance)
             
-            avg_distance = np.mean(self.wrist_distances[-10:] if self.wrist_distances else 0)
+            # Analyze distance with moving average
+            avg_distance = np.mean(self.wrist_distances[-self.history_length_to_average:] if self.wrist_distances else 0)
             
             if avg_distance > self.wrist_distance_threshold:
-                return ["One-handed CPR detected!"]
+                warnings.append("One-handed CPR detected!")
+                
         except Exception as e:
-            print(f"One-handed check error: {e}")
+            print(f"One-handed CPR check error: {e}")
         
-        return []
+        return warnings
 
-    def check_correct_hand_position(self, keypoints, chest_point):
-        """Check if hands are in correct position (returns warning)"""
+    def _check_hands_on_chest(self, wrists_midpoint, chest_params):  # (cx, cy, cw, ch)
+        """Check if hands are on the chest (returns warning)"""
+        warnings = []
         try:
-            left_wrist = keypoints[CocoKeypoints.LEFT_WRIST.value]
-            right_wrist = keypoints[CocoKeypoints.RIGHT_WRIST.value]
+            # Check if hands are on the chest
+            if wrists_midpoint is None or chest_params is None:
+                return ["Hands not on chest"]
             
-            # Calculate distance from chest to wrists
-            left_distance = np.linalg.norm(left_wrist - chest_point)
-            right_distance = np.linalg.norm(right_wrist - chest_point)
-
-            print(f"Left wrist distance: {left_distance}, Right wrist distance: {right_distance}")
+            # Unpack parameters
+            wrist_x, wrist_y = wrists_midpoint
+            cx, cy, cw, ch = chest_params
             
-            if left_distance > 100 and right_distance > 100:
-                return ["Hands not in correct position"]
+            if not ((cx - cw/2 < wrist_x < cx + cw/2) and (cy - ch/2 < wrist_y < cy + ch/2)):
+                warnings.append("Hands not on chest")
+                
         except Exception as e:
-            print(f"Hand position check error: {e}")
+            print(f"Hands on chest check error: {e}")
         
-        return []
+        return warnings
 
-    def validate_posture(self, keypoints, chest_point):
+    def validate_posture(self, keypoints, wrists_midpoint, chest_params):
         """Run all posture validations (returns aggregated warnings)"""
         warnings = []
-        warnings += self.check_bended_arms(keypoints)
-        warnings += self.check_missing_arms(keypoints)
-        warnings += self.check_correct_hand_position(keypoints, chest_point)
+        warnings += self._check_bended_right_arm(keypoints)
+        warnings += self._check_bended_left_arm(keypoints)
+        warnings += self._check_one_handed_cpr(keypoints)
+        warnings += self._check_hands_on_chest(wrists_midpoint, chest_params)
         return warnings
 
-    def display_warnings(self, frame, warnings):
+    def display_warnings(self, frame):
+        """Display posture warnings with colored background rectangles
+        
+        Args:
+            frame: Input image frame to draw warnings on
+            
+        Returns:
+            Frame with warnings and background rectangles drawn
+        """
+        if not self.warnings:
+            return frame
 
-        """Display all posture warnings at the top of the frame"""
+        warning_config = {
+            "Right arm bent": {
+                "color": (0, 0, 255),  # Red
+                "position": self.warning_positions['right_arm_angle'],
+                "text": "Right arm bent!"
+            },
+            "Left arm bent": {
+                "color": (0, 255, 255),  # Yellow
+                "position": self.warning_positions['left_arm_angle'],
+                "text": "Left arm bent!"
+            },
+            "One-handed": {
+                "color": (0, 255, 0),  # Green
+                "position": self.warning_positions['one_handed'],
+                "text": "One-handed CPR detected!"
+            },
+            "Hands not on chest": {
+                "color": (255, 0, 0),  # Blue
+                "position": self.warning_positions['hands_not_on_chest'],
+                "text": "Hands not on chest!"
+            }
+        }
 
         try:
-            if warnings:
-                # Join all warnings with commas
-                warning_text = ", ".join(warnings)
-                # Display the combined warning text at the top
-                cv2.putText(frame, warning_text,
-                            (10, 30),  # Top-left corner
-                            cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 2)
+            for warning_text, config in warning_config.items():
+                if any(warning_text in w for w in self.warnings):
+                    self._draw_warning_banner(
+                        frame=frame,
+                        text=config['text'],
+                        color=config['color'],
+                        position=config['position']
+                    )
+            
         except Exception as e:
             print(f"Warning display error: {e}")
-
+        
         return frame
+
+    def _draw_warning_banner(self, frame, text, color, position):
+        """Helper function to draw a single warning banner"""
+        (text_width, text_height), _ = cv2.getTextSize(
+            text, cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2)
+        
+        x, y = position
+        # Calculate background rectangle coordinates
+        x1 = x - 10
+        y1 = y - text_height - 10
+        x2 = x + text_width + 10
+        y2 = y + 10
+        
+        # Draw background rectangle
+        cv2.rectangle(frame, (x1, y1), (x2, y2), color, -1)
+        
+        # Draw warning text
+        cv2.putText(frame, text, (x, y),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2,
+                    cv2.LINE_AA)

CPR/quick_test.ipynb

@@ -1,37 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c819609e",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Example notebook usage\n",
-    "from pose_estimation import PoseEstimator\n",
-    "from role_classifier import RoleClassifier\n",
-    "from metrics_calculator import MetricsCalculator\n",
-    "\n",
-    "# Test pose estimation\n",
-    "estimator = PoseEstimator()\n",
-    "frame = cv2.imread(\"test_frame.jpg\")\n",
-    "results = estimator.detect_poses(frame)\n",
-    "annotated = estimator.draw_keypoints(frame, results)\n",
-    "cv2.imshow(\"Pose Test\", annotated)\n",
-    "\n",
-    "# Test metrics calculation\n",
-    "calculator = MetricsCalculator()\n",
-    "calculator.smooth_midpoints(midpoints_data)\n",
-    "calculator.detect_peaks()\n",
-    "calculator.plot_motion_curve()"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

CPR/role_classifier.py

@@ -1,81 +1,176 @@
 # role_classifier.py
 import cv2
 import numpy as np
+from ultralytics.utils.plotting import Annotator  # Import YOLO's annotator
 from CPR.keypoints import CocoKeypoints
 
+
 class RoleClassifier:
     """Role classification and tracking using image processing"""
     
     def __init__(self, proximity_thresh=0.3):
         self.proximity_thresh = proximity_thresh
         self.rescuer_id = None
-        self.midpoints = []
-        self.shoulder_distances = []
-        self.rescuer_keypoints = None
+        self.rescuer_processed_results = None
+        self.patient_processed_results = None
 
-    def find_rescuer(self, pose_results, frame_shape):
-        """Identify rescuer based on proximity to horizontal objects"""
+    def _calculate_verticality_score(self, bounding_box):
+        """Calculate posture verticality score (0=horizontal, 1=vertical) using bounding box aspect ratio."""
         try:
-            boxes = pose_results.boxes.xywh.cpu().numpy()
-            horizontal_objects = [b for b in boxes if b[2] > b[3]*1.5]
+            x1, y1, x2, y2 = bounding_box
+            width = abs(x2 - x1)
+            height = abs(y2 - y1)
+            
+            # Handle edge cases with invalid dimensions
+            if width == 0 or height == 0:
+                return -1
+            
+            return 1 if height > width else 0  # 1 for vertical, 0 for horizontal
             
-            if not horizontal_objects:
-                return None
+        except (TypeError, ValueError) as e:
+            print(f"Verticality score calculation error: {e}")
+            return -1
+        
+    def _calculate_bounding_box_center(self, bounding_box):
+        """Calculate the center coordinates of a bounding box.
+        """
+        x1, y1, x2, y2 = bounding_box
+        return (x1 + x2) / 2, (y1 + y2) / 2
 
-            people = []
-            for i, box in enumerate(boxes):
-                if box[3] > box[2]*1.2 and len(pose_results.keypoints) > i:
-                    people.append((i, box[0], box[1]))
+    def _calculate_distance(self, point1, point2):
+        """Calculate Euclidean distance between two points"""
+        return ((point1[0]-point2[0])**2 + (point1[1]-point2[1])**2)**0.5
+ 
+    def _calculate_bbox_areas(self, rescuer_bbox, patient_bbox):
+        """
+        Calculate bounding box areas for rescuer and patient.
+        
+        Args:
+            rescuer_bbox: [x1, y1, x2, y2] coordinates of rescuer's bounding box
+            patient_bbox: [x1, y1, x2, y2] coordinates of patient's bounding box
+        
+        Returns:
+            Tuple: (rescuer_area, patient_area) in pixels
+        """
+        def compute_area(bbox):
+            if bbox is None:
+                return 0
+            width = bbox[2] - bbox[0]  # x2 - x1
+            height = bbox[3] - bbox[1]  # y2 - y1
+            return abs(width * height)  # Absolute value to handle negative coordinates
+        
+        return compute_area(rescuer_bbox), compute_area(patient_bbox)
+    
+    def classify_roles(self, results, prev_rescuer_processed_results=None, prev_patient_processed_results=None):
+        """
+        Classify roles of rescuer and patient based on detected keypoints and bounding boxes.
+        """
 
-            min_distance = float('inf')
-            for (i, px, py) in people:
-                for (hx, hy, hw, hh) in horizontal_objects:
-                    distance = np.sqrt(((px-hx)/frame_shape[1])**2 + ((py-hy)/frame_shape[0])**2)
-                    if distance < min_distance and distance < self.proximity_thresh:
-                        min_distance = distance
-                        self.rescuer_id = i
-            return self.rescuer_id
-        except Exception as e:
-            print(f"Rescuer finding error: {e}")
-            return None
+        processed_results = []
         
-    def track_rescuer_midpoints(self, keypoints, frame):
-        """Track and draw rescuer's wrist midpoints (using absolute pixel coordinates)"""
-        try:
-            # Store keypoints for shoulder distance calculation
-            self.rescuer_keypoints = keypoints
-            
-            # Get wrist coordinates directly in pixels
-            lw = keypoints[CocoKeypoints.LEFT_WRIST.value]
-            rw = keypoints[CocoKeypoints.RIGHT_WRIST.value]
+        # Calculate combined area threshold if previous boxes exist
+        threshold = None
+        if prev_rescuer_processed_results and prev_patient_processed_results:
+            prev_rescuer_bbox = prev_rescuer_processed_results["bounding_box"]
+            prev_patient_bbox = prev_patient_processed_results["bounding_box"]
+
+            rescuer_area = (prev_rescuer_bbox[2]-prev_rescuer_bbox[0])*(prev_rescuer_bbox[3]-prev_rescuer_bbox[1])
+            patient_area = (prev_patient_bbox[2]-prev_patient_bbox[0])*(prev_patient_bbox[3]-prev_patient_bbox[1])
+            threshold = rescuer_area + patient_area
+        
+        for i, (box, keypoints) in enumerate(zip(results.boxes.xywh.cpu().numpy(), 
+                                            results.keypoints.xy.cpu().numpy())):
+            try:
+                # Convert box to [x1,y1,x2,y2] format
+                x_center, y_center, width, height = box
+                bounding_box = [
+                    x_center - width/2,  # x1
+                    y_center - height/2,  # y1 
+                    x_center + width/2,   # x2
+                    y_center + height/2   # y2
+                ]
+                
+                # Skip if box exceeds area threshold (when threshold exists)
+                if threshold:
+                    box_area = width * height
+                    if box_area > threshold * 1.2:  # 20% tolerance
+                        print(f"Filtered oversized box {i} (area: {box_area:.1f} > threshold: {threshold:.1f})")
+                        continue
+                
+                # Calculate features
+                verticality_score = self._calculate_verticality_score(bounding_box)
+                bounding_box_center = self._calculate_bounding_box_center(bounding_box)
+                
+                # Store valid results
+                processed_results.append({
+                    'original_index': i,
+                    'bounding_box': bounding_box,
+                    'bounding_box_center': bounding_box_center,
+                    'verticality_score': verticality_score,
+                    'keypoints': keypoints,
+                })
             
-            # Calculate midpoint in pixel space
-            midpoint = (
-                int((lw[0] + rw[0]) / 2),
-                int((lw[1] + rw[1]) / 2)
-            )
-            self.midpoints.append(midpoint)
+            except Exception as e:
+                print(f"Error processing detection {i}: {e}")
+                continue
+
+        # Step 2: Identify the patient (horizontal posture)
+        patient_candidates = [res for res in processed_results 
+                            if res['verticality_score'] == 0]
+        
+        # If more than one horizontal person, select person with lowest center (likely lying down)
+        if len(patient_candidates) > 1:
+            patient_candidates = sorted(patient_candidates, 
+                                    key=lambda x: x['bounding_box_center'][1])[:1]  # Sort by y-coordinate
+        
+        patient = patient_candidates[0] if patient_candidates else None
+        
+        # Step 3: Identify the rescuer
+        rescuer = None
+        if patient:
+            # Find vertical people who aren't the patient
+            potential_rescuers = [
+                res for res in processed_results 
+                if res['verticality_score'] == 1 
+                and res['original_index'] != patient['original_index']
+            ]
             
-            # Draw tracking
-            cv2.circle(frame, midpoint, 8, (0,255,0), -1)
-            cv2.putText(frame, "MIDPOINT", (midpoint[0]+5, midpoint[1]-10),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0,255,0), 2)
-            return frame
-        except Exception as e:
-            print(f"Midpoint tracking error: {e}")
-            return frame
+            if potential_rescuers:
+                # Select rescuer closest to patient
+                rescuer = min(potential_rescuers,
+                            key=lambda x: self._calculate_distance(
+                                x['bounding_box_center'], 
+                                patient['bounding_box_center']))
+        
+        return rescuer, patient
+    
+    def draw_rescuer_and_patient(self, frame):        
+        # Create annotator object
+        annotator = Annotator(frame)
+        
+        # Draw rescuer (A) with green box and keypoints
+        if self.rescuer_processed_results:
+            try:
+                x1, y1, x2, y2 = map(int, self.rescuer_processed_results["bounding_box"])
+                annotator.box_label((x1, y1, x2, y2), "Rescuer A", color=(0, 255, 0))
+                
+                if "keypoints" in self.rescuer_processed_results:
+                    keypoints = self.rescuer_processed_results["keypoints"]
+                    annotator.kpts(keypoints, shape=frame.shape[:2])
+            except Exception as e:
+                print(f"Error drawing rescuer: {str(e)}")
 
-    def update_shoulder_distance(self):
-        """Helper function to calculate and store shoulder distance"""
-        if self.rescuer_keypoints is None:
-            return
+        # Draw patient (B) with red box and keypoints
+        if self.patient_processed_results:
+            try:
+                x1, y1, x2, y2 = map(int, self.patient_processed_results["bounding_box"])
+                annotator.box_label((x1, y1, x2, y2), "Patient B", color=(0, 0, 255))
+                
+                if "keypoints" in self.patient_processed_results:
+                    keypoints = self.patient_processed_results["keypoints"]
+                    annotator.kpts(keypoints, shape=frame.shape[:2])
+            except Exception as e:
+                print(f"Error drawing patient: {str(e)}")
 
-        try:
-            left_shoulder = self.rescuer_keypoints[CocoKeypoints.LEFT_SHOULDER.value]
-            right_shoulder = self.rescuer_keypoints[CocoKeypoints.RIGHT_SHOULDER.value]
-            
-            shoulder_dist = np.linalg.norm(left_shoulder - right_shoulder)
-            self.shoulder_distances.append(shoulder_dist)
-            print(f"Shoulder distance: {shoulder_dist:.2f} pixels")
-        except Exception as e:
-            print(f"Shoulder distance calculation error: {e}")
+        return annotator.result()
+    

CPR/shoulders_analyzer.py

@@ -0,0 +1,31 @@
+# analyzers.py
+import cv2
+import numpy as np
+from CPR.keypoints import CocoKeypoints
+
+class ShouldersAnalyzer:
+    """Analyzes shoulder distances and posture"""
+    
+    def __init__(self):
+        self.shoulder_distance = None
+        self.shoulder_distance_history = []
+
+    def calculate_shoulder_distance(self, rescuer_keypoints):
+        """Calculate and store shoulder distance"""
+        if rescuer_keypoints is None:
+            return
+            
+        try:
+            left = rescuer_keypoints[CocoKeypoints.LEFT_SHOULDER.value]
+            right = rescuer_keypoints[CocoKeypoints.RIGHT_SHOULDER.value]
+            
+            distance = np.linalg.norm(np.array(left) - np.array(right))
+            
+            return distance
+        except Exception as e:
+            print(f"Shoulder distance error: {e}")
+            return
+    
+    def reset_shoulder_distances(self):
+        """Reset shoulder distances"""
+        self.shoulder_distance_history = []

CPR/wrists_midpoint_analyzer.py

@@ -0,0 +1,62 @@
+import cv2
+import numpy as np
+from CPR.keypoints import CocoKeypoints
+
+class WristsMidpointAnalyzer:
+    """Analyzes and tracks wrist midpoints for rescuer"""
+    
+    def __init__(self, allowed_distance_between_wrists=170):
+        self.allowed_distance_between_wrists = allowed_distance_between_wrists
+        self.midpoint = None
+        self.midpoint_history = []
+
+    def detect_wrists_midpoint(self, rescuer_keypoints):
+        """Calculate midpoint between wrists in pixel coordinates"""
+        try:
+            if rescuer_keypoints is None:
+                return None
+                
+            # Get wrist coordinates
+            lw = rescuer_keypoints[CocoKeypoints.LEFT_WRIST.value]
+            rw = rescuer_keypoints[CocoKeypoints.RIGHT_WRIST.value]
+
+            # If the distance between wrists is too large, return None
+            distance = np.linalg.norm(np.array(lw) - np.array(rw))
+            if distance > self.allowed_distance_between_wrists:
+                return None
+            
+            # Calculate midpoint
+            midpoint = (
+                int((lw[0] + rw[0]) / 2),
+                int((lw[1] + rw[1]) / 2)
+            )
+            
+            return midpoint
+            
+        except Exception as e:
+            print(f"Midpoint tracking error: {e}")
+            return None
+
+    def draw_midpoint(self, frame):
+        """Visualize the midpoint on frame"""
+        
+        if self.midpoint is None:
+            return frame
+                    
+        try:
+            # Draw visualization
+            cv2.circle(frame, self.midpoint, 8, (0, 255, 0), -1)
+            cv2.putText(
+                frame, "MIDPOINT", 
+                (self.midpoint[0] + 5, self.midpoint[1] - 10),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2
+            )
+
+            return frame
+        except Exception as e:
+            print(f"Midpoint drawing error: {e}")
+            return frame
+    
+    def reset_midpoint_history(self):
+        """Reset midpoint history"""
+        self.midpoint_history = []

CPRRealTime/analysis_socket_server.py

@@ -0,0 +1,65 @@
+import socket
+import json
+from threading import Thread
+from queue import Queue
+import threading
+from CPRRealTime.logging_config import cpr_logger
+import queue
+
+class AnalysisSocketServer:
+    def __init__(self, host='localhost', port=5000):
+        self.host = host
+        self.port = port
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.conn = None
+        self.running = False
+        self.warning_queue = Queue()
+        self.connection_event = threading.Event()
+        cpr_logger.info(f"[SOCKET] Server initialized on {host}:{port}")
+
+    def start_server(self):
+        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        self.sock.bind((self.host, self.port))
+        self.sock.listen()
+        self.running = True
+        Thread(target=self._accept_connections, daemon=True).start()
+
+    def _accept_connections(self):
+        while self.running:
+            try:
+                self.conn, addr = self.sock.accept()
+                cpr_logger.info(f"[SOCKET] Connected by {addr}")
+                self.connection_event.set()  # Signal that connection was made
+                Thread(target=self._handle_client, args=(self.conn,), daemon=True).start()
+            except Exception as e:
+                #! Not an error
+                cpr_logger.error(f"[SOCKET] Connection error: {str(e)}")
+
+    def wait_for_connection(self, timeout=None):
+        """Block until a client connects"""
+        #^ Set as an error for cleaner logging purposes
+        cpr_logger.error("[SOCKET] Waiting for client connection...")
+        self.connection_event.clear()  # Reset the event
+        return self.connection_event.wait(timeout)
+
+    def _handle_client(self, conn):
+        while self.running:
+            try:
+                # Block until a warning is available (reduces CPU usage)
+                warnings = self.warning_queue.get(block=True, timeout=0.1)
+                serialized = json.dumps(warnings) + "\n"
+                conn.sendall(serialized.encode('utf-8'))
+            except queue.Empty:
+                continue  # Timeout allows checking self.running periodically
+            except (BrokenPipeError, ConnectionResetError):
+                cpr_logger.error("[SOCKET] Client disconnected")
+                break
+            except Exception as e:
+                cpr_logger.error(f"[SOCKET] Error: {str(e)}")
+                break
+        conn.close()
+
+    def stop_server(self):
+        self.running = False
+        self.sock.close()
+        cpr_logger.info("[SOCKET] Server stopped")

CPRRealTime/chest_initializer.py

@@ -0,0 +1,154 @@
+import cv2
+import numpy as np
+from CPRRealTime.keypoints import CocoKeypoints
+from CPRRealTime.logging_config import cpr_logger
+
+class ChestInitializer:
+    """Handles chest point detection with validations in estimation."""
+    
+    def __init__(self):
+        self.chest_params = None
+        self.chest_params_history = []
+        self.expected_chest_params = None
+
+    def estimate_chest_region(self, keypoints, bounding_box, frame_width, frame_height):
+        """Estimate and validate chest region. Returns (cx, cy, cw, ch) or None."""
+        try:
+            # Unpack bounding box and calculate shoulder dimensions
+            bbox_x1, bbox_y1, bbox_x2, bbox_y2 = bounding_box
+            bbox_delta_y = abs(bbox_y2 - bbox_y1)
+
+            # Keypoints for shoulders
+            left_shoulder = keypoints[CocoKeypoints.LEFT_SHOULDER.value]
+            right_shoulder = keypoints[CocoKeypoints.RIGHT_SHOULDER.value]
+
+            # Midpoints calculation
+            shoulder_center = np.array([(left_shoulder[0] + right_shoulder[0]) / 2,
+                                        (left_shoulder[1] + right_shoulder[1]) / 2])
+            
+            #& Handing different patient positions
+            # If the x-coordinate shoulder center is closer to that of the Bottom-Right bbox corner (2)
+            # then the orientation is "right"
+            # If the x-coordinate shoulder center is closer to that of the Top-Left bbox corner (1)
+            # then the orientation is "left"
+
+            if abs(shoulder_center[0] - bbox_x2) < abs(shoulder_center[0] - bbox_x1): # Orientation is "right"
+                chest_center_from_shoulder_x = shoulder_center[0] - 0.3 * bbox_delta_y
+                chest_center_from_shoulder_y = shoulder_center[1] - 0.1 * bbox_delta_y
+                chest_center_from_shoulder = np.array([chest_center_from_shoulder_x, chest_center_from_shoulder_y])
+            else: # Orientation is "left"
+                chest_center_from_shoulder_x = shoulder_center[0] + 1.0 * bbox_delta_y
+                chest_center_from_shoulder_y = shoulder_center[1] - 0.1 * bbox_delta_y
+                chest_center_from_shoulder = np.array([chest_center_from_shoulder_x, chest_center_from_shoulder_y])
+
+            # Chest dimensions (85% of shoulder width, 40% height)
+            chest_dx = bbox_delta_y * 0.8
+            chest_dy = bbox_delta_y * 1.75
+
+            # Calculate region coordinates
+            x1 = chest_center_from_shoulder[0] - chest_dx / 2
+            y1 = chest_center_from_shoulder[1] - chest_dy / 2
+            x2 = chest_center_from_shoulder[0] + chest_dx / 2
+            y2 = chest_center_from_shoulder[1] + chest_dy / 2
+
+            # Clamp to frame boundaries
+            x1 = max(0, min(x1, frame_width - 1))
+            y1 = max(0, min(y1, frame_height - 1))
+            x2 = max(0, min(x2, frame_width - 1))
+            y2 = max(0, min(y2, frame_height - 1))
+
+            # Check validity
+            if x2 <= x1 or y2 <= y1:
+                return None
+
+            # Adjusted parameters
+            cx = (x1 + x2) / 2
+            cy = (y1 + y2) / 2
+            cw = x2 - x1
+            ch = y2 - y1
+
+            return (cx, cy, cw, ch)
+
+        except (IndexError, TypeError, ValueError) as e:
+            cpr_logger.error(f"Chest estimation error: {e}")
+            return None
+
+    def estimate_chest_region_weighted_avg(self, frame_width, frame_height, window_size=60, min_samples=3):
+        """
+        Calculate stabilized chest parameters using weighted averaging with boundary checks.
+        
+        Args:
+            self.chest_params_history: List of recent chest parameters [(cx, cy, cw, ch), ...]
+            frame_width: Width of the video frame
+            frame_height: Height of the video frame
+            window_size: Number of recent frames to consider (default: 5)
+            min_samples: Minimum valid samples required (default: 3)
+            
+        Returns:
+            Tuple of (cx, cy, cw, ch) as integers within frame boundaries,
+            or None if insufficient data or invalid rectangle
+        """
+        if not self.chest_params_history:
+            return None
+        
+        # Filter out None values and get recent frames
+        valid_history = [h for h in self.chest_params_history[-window_size:] if h is not None]
+        
+        if len(valid_history) < min_samples:
+            return None
+        
+        # Convert to numpy array (preserve floating-point precision)
+        history_array = np.array(valid_history, dtype=np.float32)
+        
+        # Exponential weights (stronger emphasis on recent frames)
+        weights = np.exp(np.linspace(1, 3, len(history_array)))
+        weights /= weights.sum()
+        
+        try:
+            # Calculate weighted average in float space
+            cx, cy, cw, ch = np.average(history_array, axis=0, weights=weights)
+            
+            # Convert to rectangle coordinates (still floating point)
+            x1 = max(0.0, cx - cw/2)
+            y1 = max(0.0, cy - ch/2)
+            x2 = min(float(frame_width - 1), cx + cw/2)
+            y2 = min(float(frame_height - 1), cy + ch/2)
+            
+            # Only round to integers after all calculations
+            x1, y1, x2, y2 = map(round, [x1, y1, x2, y2])
+            
+            # Validate rectangle
+            if x2 <= x1 or y2 <= y1:
+                return None
+                
+            return (
+                (x1 + x2) // 2,  # cx
+                (y1 + y2) // 2,  # cy
+                x2 - x1,         # cw
+                y2 - y1          # ch
+            )
+            
+        except Exception as e:
+            cpr_logger.error(f"Chest region estimation error: {e}")
+            return None
+    
+    def draw_expected_chest_region(self, frame):
+        """Draws the chest region without validation."""
+        if self.expected_chest_params is None:
+            return frame
+
+        cx, cy, cw, ch = self.expected_chest_params
+        x1 = int(cx - cw / 2)
+        y1 = int(cy - ch / 2)
+        x2 = int(cx + cw / 2)
+        y2 = int(cy + ch / 2)
+
+        # Draw rectangle and center
+        cv2.rectangle(frame, (x1, y1), (x2, y2), (128, 128, 0), 5)
+
+        cv2.circle(frame, (int(cx), int(cy)), 8, (128, 128, 0), -1)
+
+        cv2.putText(frame, "EXPECTED CHEST", (x1, max(10, y1 - 5)), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.8, (128, 128, 0), 2)
+        
+        return frame

CPRRealTime/client.py

@@ -0,0 +1,34 @@
+import socket
+import json
+
+from CPRRealTime.logging_config import cpr_logger
+
+HOST = 'localhost'  # The server's hostname or IP address
+PORT = 5000        # The port used by the server
+
+#! Not an error
+
+with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+    s.connect((HOST, PORT))
+    #^ Set as an error for cleaner logging purposes
+    cpr_logger.error(f"Connected to {HOST}:{PORT}")
+    
+    try:
+        while True:
+            data = s.recv(1024)
+            if not data:
+                break
+                
+            # Split messages (in case multiple JSONs in buffer)
+            for line in data.decode('utf-8').split('\n'):
+                if line.strip():
+                    try:
+                        warnings = json.loads(line)
+                        cpr_logger.error("\nReceived warnings:")
+                        cpr_logger.error(f"Status: {warnings['status']}")
+                        cpr_logger.error(f"Posture Warnings: {warnings['posture_warnings']}")
+                        cpr_logger.error(f"Rate/Depth Warnings: {warnings['rate_and_depth_warnings']}")
+                    except json.JSONDecodeError:
+                        cpr_logger.error("Received invalid JSON")
+    except KeyboardInterrupt:
+        cpr_logger.error("Disconnecting...")

CPRRealTime/graph_plotter.py

@@ -0,0 +1,306 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import sys
+import cv2
+from CPRRealTime.logging_config import cpr_logger
+from matplotlib.ticker import MultipleLocator
+import os
+
+class GraphPlotter:
+    """Class to plot graphs for various metrics"""
+   
+    def __init__(self):
+        self.chunks_y_preprocessed = []
+        self.chunks_peaks = []
+        self.chunks_depth = []
+        self.chunks_rate = []
+        self.chunks_start_and_end_indices = []
+        self.posture_warnings_regions = []
+        self.sampling_interval_in_frames = 0
+        self.fps = None  
+
+        self.error_symbols = {
+            "Right arm bent!": ('o', '#A61D1D'), # circle
+            "Left arm bent!": ('s', '#A61D1D'), # square
+            "Left hand not on chest!": ('P', '#A61D1D'), # plus
+            "Right hand not on chest!": ('*', '#A61D1D'), # star
+            "Both hands not on chest!": ('D', '#A61D1D') # diamond
+        }
+
+        self.annotation_y_level = None  # Will store our target y-position
+
+    def _assign_graph_data(self, chunks_y_preprocessed, chunks_peaks, chunks_depth, chunks_rate, chunks_start_and_end_indices, posture_warnings_regions, sampling_interval_in_frames, fps):
+        """Assign data members for the class"""
+        self.chunks_y_preprocessed = chunks_y_preprocessed
+        self.chunks_peaks = chunks_peaks
+        self.chunks_depth = chunks_depth
+        self.chunks_rate = chunks_rate
+        self.chunks_start_and_end_indices = chunks_start_and_end_indices
+        self.posture_warnings_regions = posture_warnings_regions
+        self.sampling_interval_in_frames = sampling_interval_in_frames
+        self.fps = fps  # Store FPS
+
+        cpr_logger.info(f"[Graph Plotter] Data members assigned with {len(self.chunks_start_and_end_indices)} chunks and {len(self.posture_warnings_regions)} error regions for a sampling interval of {self.sampling_interval_in_frames} frames and FPS {self.fps}")
+
+    def _plot_single_chunk(self, ax, chunk, idx, prev_last_point, prev_chunk_end):
+        (start_frame, end_frame), depth, rate = chunk
+        # Convert frames to time
+        chunk_frames = np.arange(start_frame, end_frame + 1, self.sampling_interval_in_frames)
+        chunk_times = chunk_frames / self.fps  # Convert to seconds
+        y_preprocessed = self.chunks_y_preprocessed[idx]
+        peaks = self.chunks_peaks[idx]
+        
+        # Check if chunks are contiguous and need connection (frame-based logic)
+        if (prev_chunk_end is not None and 
+            start_frame == prev_chunk_end + self.sampling_interval_in_frames and
+            prev_last_point is not None):
+            
+            # Convert connection points to seconds
+            connect_start = prev_chunk_end / self.fps
+            connect_end = start_frame / self.fps
+            connect_times = [connect_start, connect_end]
+            
+            cpr_logger.info(f"[Graph Plotter] Connecting chunk {idx+1} to previous chunk (time {connect_start:.2f}-{connect_end:.2f}s)")
+            ax.plot(connect_times, [prev_last_point['y_preprocessed'], y_preprocessed[0]], 
+                color="#2F5597", linewidth=2.5)
+        
+        # Plot current chunk data
+        cpr_logger.info(f"[Graph Plotter] Plotting chunk {idx+1} (time {chunk_times[0]:.2f}-{chunk_times[-1]:.2f}s)")
+        smooth_label = "Motion" if idx == 0 else ""
+        peaks_label = "Peaks" if idx == 0 else ""
+
+        # Updated motion plot
+        ax.plot(chunk_times, y_preprocessed,
+                color="#2F5597", linewidth=2.5,
+                marker='o', markersize=4,
+                markerfacecolor='#2F5597', markeredgecolor='#2F5597',
+                label=smooth_label)
+        
+        # Updated peaks
+        if peaks.size > 0:
+            ax.plot(chunk_times[peaks], y_preprocessed[peaks],
+                    "x", color="#ED7D31", markersize=8,
+                    label=peaks_label)
+
+       # Annotate chunk metrics (time-based)
+        if (depth is not None and rate is not None) and (depth > 0 and rate > 0):
+            mid_time = (start_frame + end_frame) / (2 * self.fps)
+            cpr_logger.info(f"[Graph Plotter] Chunk {idx+1} metrics: {depth:.1f}cm depth, {rate:.1f}cpm rate")
+            
+            # Calculate or use stored annotation y-level
+            if self.annotation_y_level is None:
+                # For first chunk, calculate midpoint between min and max of y_preprocessed
+                y_range = np.max(y_preprocessed) - np.min(y_preprocessed)
+                self.annotation_y_level = np.min(y_preprocessed) + y_range * 0.5  # 70% up from bottom
+                cpr_logger.info(f"[Graph Plotter] Setting annotation y-level to {self.annotation_y_level:.2f}")
+            
+            # Updated annotation box using consistent y-level
+            ax.annotate(f"Depth: {depth:.1f}cm\nRate: {rate:.1f}cpm",
+                    xy=(mid_time, self.annotation_y_level),
+                    xytext=(0, 10), textcoords='offset points',
+                    ha='center', va='bottom', fontsize=9,
+                    bbox=dict(boxstyle='round,pad=0.5', 
+                            fc='#F2F2F2', ec='#595959', alpha=0.8))
+        
+        return {'y_preprocessed': y_preprocessed[-1]}, end_frame
+
+    def _plot_error_regions(self, ax, computed_error_regions):
+        """Visualize error regions with adaptive symbol sizing"""
+        cpr_logger.info("[Graph Plotter] Rendering error regions:")
+
+        # Size parameters
+        target_width_ratio = 0.7  # Max 80% of region width
+        legend_size = 80  # Fixed legend symbol size (points²)
+        
+        legend_handles = []
+        y_mid = np.mean(ax.get_ylim())
+        
+        # Get figure dimensions for size conversion
+        fig = ax.figure
+        fig_width_points = fig.get_figwidth() * fig.dpi
+        x_min, x_max = ax.get_xlim()
+        data_range = x_max - x_min
+        points_per_second = fig_width_points / data_range
+
+        for idx, (start_sec, end_sec) in enumerate(computed_error_regions):
+            region_width = end_sec - start_sec
+            region_data = self.posture_warnings_regions[idx]
+            warnings = region_data.get('posture_warnings', [])
+
+            # Calculate max allowed width in data units (seconds)
+            max_data_width = region_width * target_width_ratio
+            
+            # Convert legend size to data units
+            legend_data_width = (np.sqrt(legend_size) / points_per_second)
+            
+            # Determine final symbol width (data units)
+            symbol_data_width = min(legend_data_width, max_data_width)
+            
+            # Convert back to points² for matplotlib
+            symbol_point_width = symbol_data_width * points_per_second
+            symbol_size = symbol_point_width ** 2
+
+            for error in warnings:
+                if error in self.error_symbols:
+                    marker, color = self.error_symbols[error]
+                    
+                    ax.scatter(
+                        x=(start_sec + end_sec)/2,
+                        y=y_mid,
+                        s=symbol_size,
+                        marker=marker,
+                        color=color,
+                        alpha=0.7,
+                        edgecolors='black',
+                        linewidths=0.5,
+                        zorder=5
+                    )
+
+                    # Create legend entry once
+                    if not any(error == h.get_label() for h in legend_handles):
+                        legend_handles.append(
+                            ax.scatter([], [], 
+                                    s=legend_size,
+                                    marker=marker,
+                                    color=color,
+                                    edgecolors='black',
+                                    linewidths=0.5,
+                                    alpha=0.7,
+                                    label=error)
+                        )
+
+            # Updated error region fill
+            ax.axvspan(start_sec, end_sec, 
+                    color='#FCE4D6', alpha=0.3, zorder=1)
+
+        if not ax.get_xlabel():
+            ax.set_xlabel("Time (seconds)", fontsize=10)
+        if not ax.get_ylabel():
+            ax.set_ylabel("Signal Value", fontsize=10)
+
+        return legend_handles
+
+    def plot_motion_curve_for_all_chunks(self, chunks_y_preprocessed, chunks_peaks, chunks_depth, chunks_rate, chunks_start_and_end_indices, posture_warnings_regions, sampling_interval_in_frames, fps, plot_output_path):
+        """Plot combined analysis with connected chunks and proper error regions"""
+        
+        self._assign_graph_data(chunks_y_preprocessed, chunks_peaks, chunks_depth, chunks_rate, chunks_start_and_end_indices, posture_warnings_regions, sampling_interval_in_frames, fps)
+        cpr_logger.info("[Graph Plotter] Starting to plot motion curve for all chunks")
+        
+        # Create figure even if there's only error regions to plot
+        plt.figure(figsize=(16, 8))
+        ax = plt.gca()
+        ax.xaxis.set_major_locator(MultipleLocator(5))
+
+        # Plot CPR chunks if they exist
+        if self.chunks_start_and_end_indices:
+            sorted_chunks = sorted(zip(self.chunks_start_and_end_indices, 
+                                self.chunks_depth, 
+                                self.chunks_rate),
+                                key=lambda x: x[0][0])
+            cpr_logger.info(f"[Graph Plotter] Processing {len(sorted_chunks)} CPR chunks")
+
+            prev_last_point = None
+            prev_chunk_end = None
+
+            for idx, chunk in enumerate(sorted_chunks):
+                cpr_logger.info(f"[Graph Plotter] Rendering chunk {idx+1}/{len(sorted_chunks)}")
+                prev_last_point, prev_chunk_end = self._plot_single_chunk(ax, chunk, idx, prev_last_point, prev_chunk_end)
+            
+            self._print_analysis_details(sorted_chunks)
+        else:
+            cpr_logger.info("[Graph Plotter] No chunk data available for plotting")
+            # Set reasonable default axis if only plotting errors
+            ax.set_ylim(0, 100)  # Example default Y-axis range for position
+
+        # Always plot error regions if they exist
+        computed_error_regions = [(er['start_frame']/self.fps, er['end_frame']/self.fps) 
+                                for er in self.posture_warnings_regions]
+        
+        # In the "Configure remaining elements" section (replace existing legend code):
+        handles, labels = ax.get_legend_handles_labels()
+
+        # Collect error handles from _plot_error_regions (modified to return them)
+        error_legend_handles = self._plot_error_regions(ax, computed_error_regions)
+
+        # Merge both sets of handles/labels
+        if error_legend_handles:
+            handles += error_legend_handles
+            labels += [h.get_label() for h in error_legend_handles]
+
+        # Remove duplicate labels
+        unique = [(h, l) for i, (h, l) in enumerate(zip(handles, labels)) if l not in labels[:i]]
+
+        # Create single horizontal legend at bottom
+        if unique:
+           ax.legend(
+            *zip(*unique),
+            loc='upper center',
+            bbox_to_anchor=(0.5, -0.08),
+            ncol=len(unique),
+            fontsize=8,
+            handletextpad=0.3,
+            columnspacing=1.5,
+            framealpha=0.9,
+            borderpad=0.7
+        )
+        plt.tight_layout(rect=[0, 0.025, 1, 1])
+
+        plt.xlabel("Time (seconds)")
+        plt.ylabel("Vertical Position (px)")
+        plt.title("Complete CPR Analysis with Metrics", pad=20)  # Added pad parameter
+        
+        plt.grid(True)
+        cpr_logger.info(f"\n[Graph Plotter] Finalizing plot layout")
+        
+        # Adjust tight_layout with additional padding
+        plt.tight_layout(rect=[0, 0.025, 1, 0.95])  # Reduced top from 1 to 0.95 to make space
+
+        if plot_output_path:
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(plot_output_path), exist_ok=True)
+            plt.savefig(plot_output_path, dpi=300, bbox_inches='tight')
+            cpr_logger.info(f"[Graph Plotter] Plot saved to {plot_output_path}")
+        
+        plt.show()
+        cpr_logger.info("[Graph Plotter] Plot display complete")
+       
+    def _print_analysis_details(self, sorted_chunks):
+        """Combined helper for printing chunks and error regions in seconds"""
+        cpr_logger.info(f"\n\n=== CPR Chunk Analysis ===")
+        display_idx = 0  # Separate counter for displayed indices
+        
+        # Convert frame numbers to seconds using video FPS
+        fps = self.fps  # Get FPS from class instance
+        
+        for ((start_frame, end_frame), depth, rate) in sorted_chunks:
+            # Skip chunks with both values at 0
+            if depth == 0 and rate == 0:
+                continue
+                
+            # Convert frames to seconds
+            start_sec = start_frame / fps
+            end_sec = end_frame / fps
+            duration_sec = (end_frame - start_frame + 1) / fps  # +1 to include both endpoints
+            
+            cpr_logger.info(f"[Graph Plotter] Chunk {display_idx+1}: "
+                f"Time {start_sec:.2f}s - {end_sec:.2f}s ({duration_sec:.2f}s), "
+                f"Depth: {depth:.1f}cm, Rate: {rate:.1f}cpm")
+            
+            display_idx += 1
+
+        cpr_logger.info(f"\n\n=== Error Region Analysis ===")
+        
+        for i, region in enumerate(self.posture_warnings_regions):  # Updated to match actual attribute name
+            start_frame = region['start_frame']
+            end_frame = region['end_frame']
+            errors = region['posture_warnings']
+            
+            # Convert to seconds
+            start_sec = start_frame / fps
+            end_sec = end_frame / fps
+            error_str = ", ".join(errors) if errors else "No errors detected"
+            
+            cpr_logger.info(f"[Graph Plotter] Region {i+1}: "
+                f"Time {start_sec:.2f}s - {end_sec:.2f}s - {error_str}")
+        
+        cpr_logger.info(f"\n\n")

CPRRealTime/keypoints.py

@@ -0,0 +1,22 @@
+# keypoints.py
+from enum import Enum
+
+class CocoKeypoints(Enum):
+    """Enum for COCO keypoints (17 points)"""
+    NOSE = 0
+    LEFT_EYE = 1
+    RIGHT_EYE = 2
+    LEFT_EAR = 3
+    RIGHT_EAR = 4
+    LEFT_SHOULDER = 5
+    RIGHT_SHOULDER = 6
+    LEFT_ELBOW = 7
+    RIGHT_ELBOW = 8
+    LEFT_WRIST = 9
+    RIGHT_WRIST = 10
+    LEFT_HIP = 11
+    RIGHT_HIP = 12
+    LEFT_KNEE = 13
+    RIGHT_KNEE = 14
+    LEFT_ANKLE = 15
+    RIGHT_ANKLE = 16

CPRRealTime/logging_config.py

@@ -0,0 +1,20 @@
+# logging_config.py
+import logging
+
+# 1. Set default log level here (change this value as needed)
+DEFAULT_LOG_LEVEL = logging.INFO  # Switch to logging.ERROR for errors-only by default
+
+# 2. Configure logger with default level
+cpr_logger = logging.getLogger("CPR-Analyzer")
+cpr_logger.setLevel(DEFAULT_LOG_LEVEL)
+
+# 3. Create console handler with formatter
+console_handler = logging.StreamHandler()
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+console_handler.setFormatter(formatter)
+
+# 4. Add handler to logger
+cpr_logger.addHandler(console_handler)
+
+# 5. Prevent propagation to root logger
+cpr_logger.propagate = False

CPRRealTime/main.py

@@ -0,0 +1,723 @@
+# main.py
+import cv2
+import time
+import math
+import numpy as np
+import os  # Added for path handling
+import sys
+
+from CPRRealTime.pose_estimation import PoseEstimator
+from CPRRealTime.role_classifier import RoleClassifier
+from CPRRealTime.chest_initializer import ChestInitializer
+from CPRRealTime.metrics_calculator import MetricsCalculator
+from CPRRealTime.posture_analyzer import PostureAnalyzer
+from CPRRealTime.wrists_midpoint_analyzer import WristsMidpointAnalyzer
+from CPRRealTime.shoulders_analyzer import ShouldersAnalyzer
+from CPRRealTime.graph_plotter import GraphPlotter
+from CPRRealTime.warnings_overlayer import WarningsOverlayer
+from CPRRealTime.threaded_camera import ThreadedCamera
+from CPRRealTime.analysis_socket_server import AnalysisSocketServer
+from CPRRealTime.logging_config import cpr_logger
+
+class CPRAnalyzer:
+    """Main CPR analysis pipeline with execution tracing"""
+    
+    def __init__(self, input_video, video_output_path, plot_output_path, requested_fps):
+        
+        cpr_logger.info(f"[INIT] Initializing CPR Analyzer")
+
+        #& Frame counter
+        self.frame_counter = -1
+        cpr_logger.info(f"[INIT] Frame counter initialized")
+
+        self.processed_frame_counter = 0
+        cpr_logger.info(f"[INIT] Processed frame counter initialized")
+
+        #!$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+        #& Add socket server
+        self.socket_server = AnalysisSocketServer()
+        self.socket_server.start_server()
+        cpr_logger.info(f"[INIT] Socket server started")
+        
+        #& Open the camera source and get the FPS
+        self.cap = ThreadedCamera(input_video, requested_fps)
+        self.fps = self.cap.fps
+        cpr_logger.info(f"[INIT] Camera FPS: {self.fps}")
+
+        #& Generate output path with MP4 extension
+        self.video_output_path = video_output_path
+        self.video_writer = None
+        self._writer_initialized = False
+        cpr_logger.info(f"[INIT] Output path: {self.video_output_path}")
+
+        #& For the graph plotter
+        self.plot_output_path = plot_output_path
+        
+        #& Initialize system components
+        self.pose_estimator = PoseEstimator(min_confidence=0.2)
+        self.role_classifier = RoleClassifier()
+        self.chest_initializer = ChestInitializer()
+        self.metrics_calculator = MetricsCalculator(shoulder_width_cm=45*0.65)
+        
+        # Remeber the conditions if you need to adjust the thresholds
+        # if avg_right > self.right_arm_angle_threshold: error
+        # if avg_left < self.left_arm_angle_threshold: error
+
+        self.posture_analyzer = PostureAnalyzer(right_arm_angle_threshold=220, left_arm_angle_threshold=160, wrist_distance_threshold=170, history_length_to_average=10)
+        self.wrists_midpoint_analyzer = WristsMidpointAnalyzer()
+        self.shoulders_analyzer = ShouldersAnalyzer()
+        self.graph_plotter = GraphPlotter()
+        self.warnings_overlayer = WarningsOverlayer()
+        cpr_logger.info("[INIT] System components initialized")
+
+        #& Warm up pose estimator with dummy data
+        dummy_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        self.pose_estimator.detect_poses(dummy_frame)  # Force model loading
+        cpr_logger.info("[INIT] Pose estimator warmed up with dummy data")
+
+        #& Keep track of previous results for continuity
+        self.prev_rescuer_processed_results = None
+        self.prev_patient_processed_results = None
+        self.prev_chest_params = None
+        self.prev_midpoint = None
+        self.prev_pose_results = None
+        cpr_logger.info("[INIT] Previous results initialized")
+
+        #& Fundamental timing parameters (in seconds)
+        self.MIN_ERROR_DURATION = 1.0    # Require sustained errors for 1 second
+        self.REPORTING_INTERVAL = 5.0    # Generate reports every 5 seconds
+        self.SAMPLING_INTERVAL = 0.2     # Analyze every 0.2 seconds
+        self.KEEP_RATE_AND_DEPTH_WARNINGS_INTERVAL = 3.0
+        self.MIN_CHUNK_LENGTH_TO_REPORT = 3.0
+
+        # Derived frame counts 
+        self.sampling_interval_frames = int(round(self.fps * self.SAMPLING_INTERVAL))
+        self.error_threshold_frames = int(self.MIN_ERROR_DURATION / self.SAMPLING_INTERVAL)
+        self.reporting_interval_frames = int(self.REPORTING_INTERVAL / self.SAMPLING_INTERVAL)
+        self.return_rate_and_depth_warnings_interval_frames = int(self.KEEP_RATE_AND_DEPTH_WARNINGS_INTERVAL / self.SAMPLING_INTERVAL)
+        self.min_chunk_length_to_report_frames = int(self.MIN_CHUNK_LENGTH_TO_REPORT / self.SAMPLING_INTERVAL)
+
+        # For cleaner feedback, the reporting interval must be an exact multiple of the sampling interval.
+        ratio = self.REPORTING_INTERVAL / self.SAMPLING_INTERVAL
+        assert math.isclose(ratio, round(ratio)), \
+            f"Reporting interval ({self.REPORTING_INTERVAL}) must be an exact multiple of "\
+            f"sampling interval ({self.SAMPLING_INTERVAL}). Actual ratio: {ratio:.2f}"
+
+        # To be able to detect an error, the error detection window must be greater than or equal to the sampling interval.
+        assert self.MIN_ERROR_DURATION >= self.SAMPLING_INTERVAL, \
+            f"Error detection window ({self.MIN_ERROR_DURATION}s) must be ≥ sampling interval ({self.SAMPLING_INTERVAL}s)"
+
+        cpr_logger.info(f"[INIT] Temporal alignment:")
+        cpr_logger.info(f" - {self.SAMPLING_INTERVAL}s sampling → {self.sampling_interval_frames} frames")
+        cpr_logger.info(f" - {self.MIN_ERROR_DURATION}s error detection → {self.error_threshold_frames} samples")
+        cpr_logger.info(f" - {self.REPORTING_INTERVAL}s reporting → {self.reporting_interval_frames} samples")
+
+        #& Workaround for minor glitches
+        # A frame is accepted as long as this counter does not exceed the error_threshold_frames set above.
+        #! These (and those in the warnings_overlayer) should exactly match the ones appended in the PostureAnalyzer.
+        self.possible_warnings = [
+            "Right arm bent!",
+            "Left arm bent!",
+            "Left hand not on chest!",
+            "Right hand not on chest!",
+            "Both hands not on chest!",
+        ]
+        self.consecutive_frames_with_posture_errors_counters = {warning: 0 for warning in self.possible_warnings}
+
+        #& Initialize variables for reporting warnings
+
+        self.rate_and_depth_warnings_from_the_last_report = []
+        cpr_logger.info("[INIT] Rate and depth warnings from the last report initialized")
+
+        #& Chunk and mini chunk management (Indexes and Flags) 
+        self.has_not_processed_a_frame_successfully_before = True
+        self.waiting_to_start_new_chunk = False
+
+        self.chunk_start_frame_index = None
+        self.chunk_end_frame_index = None
+
+        #& Posture warnings region management
+        self.prev_is_part_of_a_posture_warnings_region = False
+        self.posture_warnings_region_start_frame_index = None
+        self.posture_warnings_region_end_frame_index = None
+
+        self.posture_warnings = []
+        self.rate_and_depth_warnings = []
+
+        #& For Formated Warnings
+        self.cached_posture_warnings = []
+        self.cached_rate_and_depth_warnings = []
+        self.return_rate_and_depth_warnings_interval_frames_counter = self.return_rate_and_depth_warnings_interval_frames
+        cpr_logger.info("[INIT] Formatted warnings initialized")
+
+    def _initialize_video_writer(self, frame):
+        """Initialize writer with safe fallback options"""
+        height, width = frame.shape[:2]
+        effective_fps = self.fps / max(1, self.sampling_interval_frames)
+        
+        # Try different codec/container combinations
+        for codec, ext, fmt in [('avc1', 'mp4', 'mp4v'),  # H.264
+                                ('MJPG', 'avi', 'avi'), 
+                                ('XVID', 'avi', 'avi')]:
+            fourcc = cv2.VideoWriter_fourcc(*codec)
+            writer = cv2.VideoWriter(self.video_output_path, fourcc, effective_fps, (width, height))
+            
+            if writer.isOpened():
+                self.video_writer = writer
+                self._writer_initialized = True
+                cpr_logger.info(f"[VIDEO WRITER] Initialized with {codec} codec")
+                return
+            else:
+                writer.release()
+        
+        cpr_logger.info("[ERROR] Failed to initialize any video writer!")
+        self._writer_initialized = False
+        
+    def _handle_chunk_end(self):
+        """Helper to handle chunk termination logic"""
+        self._calculate_rate_and_depth_for_chunk()
+        cpr_logger.info(f"[RUN ANALYSIS] Calculated rate and depth for the chunk")
+
+        rate_and_depth_warnings = self._get_rate_and_depth_warnings()
+
+        # If the chunk is too short, we don't want to report any warnings it might contain.
+        if (self.chunk_end_frame_index - self.chunk_start_frame_index) < self.min_chunk_length_to_report_frames:
+            rate_and_depth_warnings = []
+
+        self.cached_rate_and_depth_warnings = rate_and_depth_warnings
+        self.return_rate_and_depth_warnings_interval_frames_counter = self.return_rate_and_depth_warnings_interval_frames
+        cpr_logger.info(f"[RUN ANALYSIS] Retrieved rate and depth warnings for the chunk")
+
+        self.rate_and_depth_warnings.append({
+            'start_frame': self.chunk_start_frame_index,
+            'end_frame': self.chunk_end_frame_index,
+            'rate_and_depth_warnings': rate_and_depth_warnings,
+        })
+        cpr_logger.info(f"[RUN ANALYSIS] Assigned rate and depth warnings region data")
+        cpr_logger.info(f"[RUN ANALYSIS] Start frame: {self.chunk_start_frame_index}, End frame: {self.chunk_end_frame_index}, Rate and depth warnings: {rate_and_depth_warnings}")
+        sys.exit(1)
+
+        self.shoulders_analyzer.reset_shoulder_distances()
+        self.wrists_midpoint_analyzer.reset_midpoint_history()
+        cpr_logger.info(f"[RUN ANALYSIS] Reset shoulder distances and midpoint history for the chunk")
+    
+    def _handle_posture_warnings_region_end(self):
+        """Helper to handle posture warnings region termination"""
+        self.posture_warnings.append({
+            'start_frame': self.posture_warnings_region_start_frame_index,
+            'end_frame': self.posture_warnings_region_end_frame_index,
+            'posture_warnings': self.cached_posture_warnings.copy(),
+        })
+        cpr_logger.info(f"[RUN ANALYSIS] Assigned posture warnings region data")
+
+    def _start_new_chunk(self, chunk_type="chunk"):
+        """Helper to initialize new chunk"""
+        self.chunk_start_frame_index = self.frame_counter
+        self.waiting_to_start_new_chunk = False
+        cpr_logger.info(f"[CHUNK] New {chunk_type} started at {self.frame_counter}")
+    
+    def _start_new_posture_warnings_region(self):
+        """Helper to initialize new posture warnings region"""
+        self.posture_warnings_region_start_frame_index = self.frame_counter
+        cpr_logger.info(f"[POSTURE WARNINGS] New region started at {self.frame_counter}")
+    
+    def run_analysis(self):
+        try:
+            cpr_logger.info("[RUN ANALYSIS] Starting analysis")
+            
+            #& Video Capture
+            # Start camera capture AFTER client connects
+            self.cap.start_capture()
+            cpr_logger.info("[RUN ANALYSIS] Camera capture started")
+
+            #& Main execution loop
+            main_loop_start_time = time.time()
+            cpr_logger.info("[RUN ANALYSIS] Main loop started")
+            while True:
+                #& Read Frame
+                # Get frame from camera queue
+                frame = self.cap.read()
+
+                # Check for termination sentinel
+                if frame is None:
+                    cpr_logger.info("Camera stream ended")
+                    
+                    # Handle any open regions before breaking
+                    if self.prev_is_part_of_a_posture_warnings_region:
+                        # End the posture warnings region
+                        self.posture_warnings_region_end_frame_index = self.frame_counter
+                        cpr_logger.info(f"[RUN ANALYSIS] End of posture warnings region detected")
+                        cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region start frame: {self.posture_warnings_region_start_frame_index}")
+                        cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region end frame: {self.posture_warnings_region_end_frame_index}")
+                        self._handle_posture_warnings_region_end()
+                    
+                    elif self.chunk_start_frame_index is not None:
+                        # End the current chunk
+                        self.chunk_end_frame_index = self.frame_counter
+                        cpr_logger.info(f"[RUN ANALYSIS] End of chunk detected")
+                        cpr_logger.info(f"[RUN ANALYSIS] Chunk start frame: {self.chunk_start_frame_index}")
+                        cpr_logger.info(f"[RUN ANALYSIS] Chunk end frame: {self.chunk_end_frame_index}")
+                        self._handle_chunk_end()
+                    break
+                
+                #& Increment frame counter
+                self.frame_counter += 1
+
+                cpr_logger.info(f"\n[FRAME {int(self.frame_counter)}]")
+                
+                #& Check if you want to skip the frame
+                if self.frame_counter % self.sampling_interval_frames != 0:  
+                    #^ Formated Warnings
+                    # Return the cashed warnings
+                    formatted_warnings = self._format_warnings()
+                    cpr_logger.info(f"[RUN ANALYSIS] Formatted warnings: {formatted_warnings}")
+                    
+                    #!$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+                    self.socket_server.warning_queue.put(formatted_warnings)
+                    cpr_logger.info(f"[RUN ANALYSIS] Sent warnings to socket server")
+                    
+                    cpr_logger.info(f"[SKIP FRAME] Skipping frame") 
+                    continue
+                
+                #& Rotate frame
+                frame = self._handle_frame_rotation(frame)
+                cpr_logger.info(f"[RUN ANALYSIS] Rotated frame")
+
+                #& Process frame
+                # If there are (sustained) posture warnings, then we did not even attempt to detect the midpoint.
+                # If there were no (sustained) posture warnings, we attempt to detect the midpoint which might either succeed or fail.
+                # This is why we need two variables to indicated what happened inside the process_frame function.
+                posture_warnings, has_appended_midpoint = self._process_frame(frame)
+                cpr_logger.info(f"[RUN ANALYSIS] Processed frame")
+
+                #& Posture Warnings Region Setting Flags
+                # When a frame is accepted, its warnings -if any- are reset.
+                # So if the function did return any errors this means that the frame is not accepted and is part of an posture warnings region.
+                is_part_of_a_posture_warnings_region = len(posture_warnings) > 0
+
+                # Then we need to decide if the frame marks a transition between a chunk region and an posture warnings region.
+                is_start_of_posture_warnings_region = (not self.prev_is_part_of_a_posture_warnings_region) and is_part_of_a_posture_warnings_region
+                is_end_of_posture_warnings_region = self.prev_is_part_of_a_posture_warnings_region and not is_part_of_a_posture_warnings_region
+                
+                # Update the cached value for the next iteration
+                self.prev_is_part_of_a_posture_warnings_region = is_part_of_a_posture_warnings_region
+
+                cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region flags updated")
+
+                #& Chunks and Posture Warnings Regions Management
+                #~ Case 1: posture warnings region after a chunk
+                if is_start_of_posture_warnings_region:
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 1: posture warnings region after a chunk")
+
+                    # Start a new posture warnings region
+                    self._start_new_posture_warnings_region()
+
+                    # End the previous chunk if it exists
+                    if self.chunk_start_frame_index is not None:
+                        self.chunk_end_frame_index = self.frame_counter - 1
+                        cpr_logger.info(f"[RUN ANALYSIS] End of chunk detected")
+                        cpr_logger.info(f"[RUN ANALYSIS] Chunk start frame: {self.chunk_start_frame_index}")
+                        cpr_logger.info(f"[RUN ANALYSIS] Chunk end frame: {self.chunk_end_frame_index}")
+                        self._handle_chunk_end()
+
+                #~ Case 2: posture warnings region after a posture warnings region
+                if (self.cached_posture_warnings != posture_warnings) and (is_part_of_a_posture_warnings_region) and (not is_start_of_posture_warnings_region) and (not is_end_of_posture_warnings_region):
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 2: posture warnings region after a posture warnings region")
+
+                    # End the previous posture warnings region
+                    self.posture_warnings_region_end_frame_index = self.frame_counter - 1
+                    cpr_logger.info(f"[RUN ANALYSIS] End of posture warnings region detected")
+                    cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region start frame: {self.posture_warnings_region_start_frame_index}")
+                    cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region end frame: {self.posture_warnings_region_end_frame_index}")
+                    self._handle_posture_warnings_region_end()
+
+                    # Start a new posture warnings region
+                    self._start_new_posture_warnings_region()
+                
+                #~ Case 3: chunk after a posture warnings region
+                if is_end_of_posture_warnings_region:
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 3: chunk after a posture warnings region")
+
+                    # Start a new chunk
+                    self.waiting_to_start_new_chunk = True
+                    cpr_logger.info(f"[RUN ANALYSIS] Waiting to start a new chunk")
+                    new_chunk_type = "chunk"
+
+                    # End the previous posture warnings region
+                    self.posture_warnings_region_end_frame_index = self.frame_counter - 1
+                    cpr_logger.info(f"[RUN ANALYSIS] End of posture warnings region detected")
+                    cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region start frame: {self.posture_warnings_region_start_frame_index}")
+                    cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region end frame: {self.posture_warnings_region_end_frame_index}")
+                    self._handle_posture_warnings_region_end()
+                
+                #~ Case 4: chunk after a chunk
+                if (not is_part_of_a_posture_warnings_region) and (not is_end_of_posture_warnings_region) and (self.processed_frame_counter % self.reporting_interval_frames == 0):    
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 4: chunk after a chunk")
+
+                    # End the previous chunk if it exists
+                    if self.chunk_start_frame_index is not None and self.chunk_start_frame_index != self.frame_counter:
+                        self.chunk_end_frame_index = self.frame_counter
+                        cpr_logger.info(f"[RUN ANALYSIS] End of chunk detected")
+                        cpr_logger.info(f"[RUN ANALYSIS] Chunk start frame: {self.chunk_start_frame_index}")
+                        cpr_logger.info(f"[RUN ANALYSIS] Chunk end frame: {self.chunk_end_frame_index}")
+                        self._handle_chunk_end()
+
+                    # Start a new chunk
+                    self.waiting_to_start_new_chunk = True
+                    cpr_logger.info(f"[RUN ANALYSIS] Waiting to start a new chunk")
+
+                    new_chunk_type = "mini chunk"
+                
+                #~ Follow up on cases 3 and 4
+                if (self.waiting_to_start_new_chunk) and (has_appended_midpoint):
+                    cpr_logger.info(f"[RUN ANALYSIS] Follow up on cases 3 and 4")
+
+                    if (new_chunk_type == "chunk") or (new_chunk_type == "mini chunk" and self.frame_counter != self.chunk_end_frame_index):
+                        self._start_new_chunk()
+
+                #& Compose frame
+                # This function is responsible for drawing the the chest region and the midpoint.
+                # The frame would not be displayed yet, just composed.
+                composed_frame = self._compose_frame(frame, is_part_of_a_posture_warnings_region)
+
+                if composed_frame is not None:
+                    frame = composed_frame
+                    cpr_logger.info(f"[RUN ANALYSIS] Frame composed successfully")
+                else:
+                    cpr_logger.info(f"[RUN ANALYSIS] Frame composition failed")
+
+                #& Initialize video writer if not done yet
+                if frame is not None and not self._writer_initialized:
+                    self._initialize_video_writer(frame)
+                    cpr_logger.info(f"[VIDEO WRITER] Initialized video writer")
+
+                #& Write frame if writer is functional
+                if self._writer_initialized:
+                    # Convert frame to BGR if needed
+                    if frame.dtype != np.uint8:
+                        frame = frame.astype(np.uint8)
+                    if len(frame.shape) == 2:  # Grayscale
+                        frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
+                    
+                    try:
+                        self.video_writer.write(frame)
+                    except Exception as e:
+                        cpr_logger.error(f"[WRITE ERROR] {str(e)}")
+                        self._writer_initialized = False
+                
+                #& Update the cached posture warnings
+                # Don't update it before handling the four cases because the old cached warnings might be needed.
+                self.cached_posture_warnings = posture_warnings
+                
+                #^ Formated Warnings
+                formatted_warnings = self._format_warnings()
+                cpr_logger.info(f"[RUN ANALYSIS] Formatted warnings: {formatted_warnings}")
+
+                #!$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$
+                self.socket_server.warning_queue.put(formatted_warnings)
+                cpr_logger.info(f"[RUN ANALYSIS] Sent warnings to socket server")
+
+                self.processed_frame_counter += 1
+                cpr_logger.info(f"[RUN ANALYSIS] Processed frame counter: {self.processed_frame_counter}")
+                                
+                #& Check if the user wants to quit
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    cpr_logger.info("[RUN ANALYSIS] 'q' pressed, exiting loop.")
+                    break
+
+            main_loop_end_time = time.time()
+            elapsed_time = main_loop_end_time - main_loop_start_time
+            cpr_logger.info(f"[TIMING] Main loop elapsed time: {elapsed_time:.2f}s")
+
+        except Exception as e:
+            cpr_logger.error(f"[ERROR] An error occurred during main execution loop: {str(e)}")
+
+        finally:
+            report_and_plot_start_time = time.time()
+            
+            self.cap.release()
+            self.cap = None
+            
+            if self.video_writer is not None:
+                self.video_writer.release()
+                cpr_logger.info(f"[VIDEO WRITER] Released writer. File should be at: {os.path.abspath(self.video_output_path)}")
+            cv2.destroyAllWindows()
+            cpr_logger.info("[RUN ANALYSIS] Released video capture and destroyed all windows")         
+
+            self._calculate_rate_and_depth_for_all_chunks()
+            cpr_logger.info("[RUN ANALYSIS] Calculated weighted averages of the metrics across all chunks")
+
+            self._plot_full_motion_curve_for_all_chunks()
+            cpr_logger.info("[RUN ANALYSIS] Plotted full motion curve")
+
+            self.warnings_overlayer.add_warnings_to_processed_video(self.video_output_path, self.sampling_interval_frames, self.rate_and_depth_warnings, self.posture_warnings)
+            cpr_logger.info("[RUN ANALYSIS] Added warnings to processed video")
+
+            try:
+                if os.path.exists(self.video_output_path):
+                    os.remove(self.video_output_path)
+                    cpr_logger.info(f"[CLEANUP] Successfully deleted video file: {self.video_output_path}")
+                else:
+                    cpr_logger.warning(f"[CLEANUP] Video file not found at: {self.video_output_path}")
+            except Exception as e:
+                cpr_logger.error(f"[ERROR] Failed to delete video file: {str(e)}")
+
+            report_and_plot_end_time = time.time()
+            report_and_plot_elapsed_time = report_and_plot_end_time - report_and_plot_start_time
+            cpr_logger.info(f"[TIMING] Report and plot elapsed time: {report_and_plot_elapsed_time:.2f}s")
+
+    def _format_warnings(self):
+        """Combine warnings into a simple structured response"""
+
+        if self.cached_posture_warnings:
+            return {
+                "status": "warning",
+                "posture_warnings": self.cached_posture_warnings,
+                "rate_and_depth_warnings": [],
+            }
+        
+        if (self.cached_rate_and_depth_warnings) and (self.return_rate_and_depth_warnings_interval_frames_counter > 0):
+            self.return_rate_and_depth_warnings_interval_frames_counter -= 1
+
+            return {
+                "status": "warning",
+                "posture_warnings": [],
+                "rate_and_depth_warnings": self.cached_rate_and_depth_warnings,
+            }
+        
+        return {
+            "status": "ok",
+            "posture_warnings": [],
+            "rate_and_depth_warnings": [],
+        }
+
+    def _handle_frame_rotation(self, frame):
+        if frame.shape[1] > frame.shape[0]:  # Width > Height
+            frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
+        return frame
+
+    def _process_frame(self, frame):
+        #* Warnings for real time feedback
+        warnings = []
+
+        #* Chunk Completion Check
+        has_appended_midpoint = False
+        
+        #& Pose Estimation
+        pose_results = self.pose_estimator.detect_poses(frame)
+
+        #~ Handle Failed Detection or Update Previous Results
+        if not pose_results:
+            pose_results = self.prev_pose_results
+            cpr_logger.info("[POSE ESTIMATION] No pose detected, using previous results (could be None)")
+        else:
+            self.prev_pose_results = pose_results
+        
+        if not pose_results:
+            cpr_logger.info("[POSE ESTIMATION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
+        
+        #& Rescuer and Patient Classification
+        rescuer_processed_results, patient_processed_results = self.role_classifier.classify_roles(pose_results, self.prev_rescuer_processed_results, self.prev_patient_processed_results)
+
+        #~ Handle Failed Classifications OR Update Previous Results
+        if not rescuer_processed_results:
+            rescuer_processed_results = self.prev_rescuer_processed_results
+            cpr_logger.info("[ROLE CLASSIFICATION] No rescuer detected, using previous results (could be None)")
+        else:
+            self.prev_rescuer_processed_results = rescuer_processed_results
+
+        if not patient_processed_results:
+            patient_processed_results = self.prev_patient_processed_results
+            cpr_logger.info("[ROLE CLASSIFICATION] No patient detected, using previous results (could be None)")
+        else:
+            self.prev_patient_processed_results = patient_processed_results
+        
+        if not rescuer_processed_results or not patient_processed_results:
+            cpr_logger.info("[ROLE CLASSIFICATION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
+             
+        #^ Set Params in Role Classifier (to draw later)
+        self.role_classifier.rescuer_processed_results = rescuer_processed_results
+        self.role_classifier.patient_processed_results = patient_processed_results
+        cpr_logger.info(f"[ROLE CLASSIFICATION] Updated role classifier with new results")
+    
+        #& Chest Estimation
+        chest_params = self.chest_initializer.estimate_chest_region(patient_processed_results["keypoints"], patient_processed_results["bounding_box"], frame_width=frame.shape[1], frame_height=frame.shape[0])
+       
+        #~ Handle Failed Estimation or Update Previous Results
+        if not chest_params:
+            chest_params = self.prev_chest_params
+            cpr_logger.info("[CHEST ESTIMATION] No chest region detected, using previous results (could be None)")
+        else:
+            self.prev_chest_params = chest_params
+
+        if not chest_params:
+            cpr_logger.info("[CHEST ESTIMATION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
+
+        #^ Set Params in Chest Initializer (to draw later)
+        self.chest_initializer.chest_params = chest_params
+        self.chest_initializer.chest_params_history.append(self.chest_initializer.chest_params)
+
+        #& Chest Expectation
+        # The estimation up to the last frame
+        expected_chest_params = self.chest_initializer.estimate_chest_region_weighted_avg(frame_width=frame.shape[1], frame_height=frame.shape[0])
+
+        #~ First "window_size" detections can't avg
+        if not expected_chest_params:
+            self.chest_initializer.expected_chest_params = self.chest_initializer.chest_params
+        else:
+            self.chest_initializer.expected_chest_params = expected_chest_params
+
+        #& Posture Analysis
+        cpr_logger.info(f"[POSTURE ANALYSIS] Analyzing posture")
+        current_warnings = self.posture_analyzer.validate_posture(rescuer_processed_results["keypoints"], self.chest_initializer.expected_chest_params)
+        cpr_logger.info(f"[POSTURE ANALYSIS] Posture analysis completed")
+
+        # Update individual warning counters
+        for warning in self.possible_warnings:
+            if warning in current_warnings:
+                self.consecutive_frames_with_posture_errors_counters[warning] += 1
+            else:
+                self.consecutive_frames_with_posture_errors_counters[warning] = 0
+
+        # Filter warnings that meet/exceed threshold
+        warnings = [
+            warning for warning in self.possible_warnings
+            if self.consecutive_frames_with_posture_errors_counters[warning] >= self.error_threshold_frames
+        ]
+
+        #^ Set Params in Posture Analyzer (to draw later)
+        self.posture_analyzer.warnings = warnings  
+        cpr_logger.info(f"[POSTURE ANALYSIS] Updated posture analyzer with new results")
+
+        #& Wrist Midpoint Detection
+        midpoint = self.wrists_midpoint_analyzer.detect_wrists_midpoint(rescuer_processed_results["keypoints"])
+
+        #~ Handle Failed Detection or Update Previous Results
+        if not midpoint:
+            midpoint = self.prev_midpoint
+            cpr_logger.info("[WRIST MIDPOINT DETECTION] No midpoint detected, using previous results (could be None)")
+        else:
+            self.prev_midpoint = midpoint
+        
+        if not midpoint:
+            cpr_logger.info("[WRIST MIDPOINT DETECTION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
+        cpr_logger.error(f"[WRIST MIDPOINT DETECTION] Midpoint detected: {midpoint}")    
+        if len(warnings) == 0:
+            #^ Set Params in Role Classifier (to draw later)
+            has_appended_midpoint = True
+            self.wrists_midpoint_analyzer.midpoint = midpoint
+            self.wrists_midpoint_analyzer.midpoint_history.append(midpoint)
+            cpr_logger.info(f"[WRIST MIDPOINT DETECTION] Updated wrist midpoint analyzer with new results")
+
+            #& Shoulder Distance Calculation
+            shoulder_distance = self.shoulders_analyzer.calculate_shoulder_distance(rescuer_processed_results["keypoints"])
+            if shoulder_distance is not None:
+                self.shoulders_analyzer.shoulder_distance = shoulder_distance
+                self.shoulders_analyzer.shoulder_distance_history.append(shoulder_distance)
+            cpr_logger.info(f"[SHOULDER DISTANCE] Updated shoulder distance analyzer with new results")
+
+        return warnings, has_appended_midpoint
+    
+    def _compose_frame(self, frame, is_part_of_a_posture_warnings_region):
+        # Chest Region
+        if frame is not None:
+            frame = self.chest_initializer.draw_expected_chest_region(frame)
+            cpr_logger.info(f"[VISUALIZATION] Drawn chest region")
+        
+        if frame is not None:
+            if not is_part_of_a_posture_warnings_region:
+                frame = self.wrists_midpoint_analyzer.draw_midpoint(frame)   
+                cpr_logger.info(f"[VISUALIZATION] Drawn midpoint")  
+    
+        return frame
+
+    def _calculate_rate_and_depth_for_chunk(self):
+        try:
+            result = self.metrics_calculator.handle_chunk(np.array(self.wrists_midpoint_analyzer.midpoint_history), self.chunk_start_frame_index, self.chunk_end_frame_index, self.fps, np.array(self.shoulders_analyzer.shoulder_distance_history), self.sampling_interval_frames)
+
+            if result == False:
+                cpr_logger.info("[ERROR] Failed to calculate metrics for the chunk")
+                return
+            
+        except Exception as e:
+            cpr_logger.error(f"[ERROR] Metric calculation failed: {str(e)}")
+
+    def _calculate_rate_and_depth_for_all_chunks(self):
+        try:
+            self.metrics_calculator.calculate_rate_and_depth_for_all_chunk()
+            cpr_logger.info(f"[METRICS] Weighted averages calculated")
+        except Exception as e:
+            cpr_logger.error(f"[ERROR] Failed to calculate weighted averages: {str(e)}")
+            
+    def _plot_full_motion_curve_for_all_chunks(self):
+        try:
+            self.graph_plotter.plot_motion_curve_for_all_chunks(self.metrics_calculator.chunks_y_preprocessed, 
+                                                  self.metrics_calculator.chunks_peaks, 
+                                                  self.metrics_calculator.chunks_depth, 
+                                                  self.metrics_calculator.chunks_rate, 
+                                                  self.metrics_calculator.chunks_start_and_end_indices, 
+                                                  self.posture_warnings, 
+                                                  self.sampling_interval_frames,
+                                                  self.fps,
+                                                  self.plot_output_path)
+            cpr_logger.info("[PLOT] Full motion curve plotted")
+        except Exception as e:
+            cpr_logger.error(f"[ERROR] Failed to plot full motion curve: {str(e)}")
+  
+    def _get_rate_and_depth_warnings(self):
+        rate_and_depth_warnings = self.metrics_calculator.get_rate_and_depth_warnings()
+        cpr_logger.info(f"[VISUALIZATION] Rate and depth warnings data: {rate_and_depth_warnings}")
+
+        return rate_and_depth_warnings
+
+if __name__ == "__main__":
+    cpr_logger.info(f"[MAIN] CPR Analysis Started")
+    
+    # Configuration
+    requested_fps = 30
+    base_dir = r"C:\Users\Fatema Kotb\Documents\CUFE 25\Year 04\GP\Spring\El7a2ny-Graduation-Project"
+    
+    # Define input path
+    input_video = os.path.join(base_dir, "CPR", "Dataset", "Batch 2", "14.mp4")
+    
+    # Validate input file exists
+    if not os.path.exists(input_video):
+        cpr_logger.error(f"[ERROR] Input video not found at: {input_video}")
+        sys.exit(1)
+    
+    # Extract original filename without extension
+    original_name = os.path.splitext(os.path.basename(input_video))[0]
+    cpr_logger.info(f"[CONFIG] Original video name: {original_name}")
+    
+    # Create output directory if it doesn't exist
+    output_dir = os.path.join(base_dir, "CPR", "End to End", "Code Refactor", "Output")
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Set output paths using original name
+    video_output_path = os.path.join(output_dir, f"{original_name}_output.mp4")
+    plot_output_path = os.path.join(output_dir, f"{original_name}_output.png")
+    
+    # Log paths for verification
+    cpr_logger.info(f"[CONFIG] Input video: {input_video}")
+    cpr_logger.info(f"[CONFIG] Video output: {video_output_path}")
+    cpr_logger.info(f"[CONFIG] Plot output: {plot_output_path}")
+    
+    # Initialize and run analyzer
+    initialization_start_time = time.time()
+    analyzer = CPRAnalyzer(input_video, video_output_path, plot_output_path, requested_fps)
+    
+    # Set plot output path in the analyzer
+    analyzer.plot_output_path = plot_output_path
+    
+    initialization_end_time = time.time()
+    initialization_elapsed_time = initialization_end_time - initialization_start_time
+    cpr_logger.info(f"[TIMING] Initialization time: {initialization_elapsed_time:.2f}s")
+    
+    try:
+        analyzer.run_analysis()
+    finally:
+        analyzer.socket_server.stop_server()

CPRRealTime/metrics_calculator.py

@@ -0,0 +1,480 @@
+# metrics_calculator.py
+import numpy as np
+from scipy.signal import savgol_filter, find_peaks
+import matplotlib.pyplot as plt
+import sys
+import cv2
+import os
+from CPRRealTime.logging_config import cpr_logger
+
+class MetricsCalculator:
+    """Rate and depth calculation from motion data with improved peak detection"""
+    
+    def __init__(self, shoulder_width_cm):
+        # Configuration parameters
+        self.shoulder_width_cm = shoulder_width_cm
+
+        # Parameters for cleaning the smoothed midpoints
+        self.removing_impulse_noise_window_size = 5
+        self.removing_impulse_noise_threshold = 3.0
+
+        # Parameters for one chunk
+        self.y_preprocessed = np.array([])
+
+        self.peaks = np.array([])
+        self.peaks_max = np.array([])
+        self.peaks_min = np.array([])
+                
+        self.cm_px_ratio = None
+
+        self.depth = None
+        self.rate = None
+
+        self.rate_and_depth_warnings = []
+        
+        # Parameters for all chunks
+        self.chunks_y_preprocessed = []
+
+        self.chunks_peaks = []
+
+        self.chunks_depth = []
+        self.chunks_rate = []
+
+        self.weighted_depth = None
+        self.weighted_rate = None
+
+        self.chunks_start_and_end_indices = []
+
+        self.chunks_rate_and_depth_warnings = []
+
+        # Parameters for validation
+        self.min_depth_threshold = 3.0  # cm
+        self.max_depth_threshold = 6.0  # cm
+
+        self.min_rate_threshold = 100.0  # cpm
+        self.max_rate_threshold = 120.0  # cpm
+        
+#^ ################# Validating #######################
+
+    def validate_midpoints_and_frames_count_in_chunk(self, y_exact, chunk_start_frame_index, chunk_end_frame_index, sampling_interval_in_frames):
+        """
+        Validate the number of midpoints and frames in a chunk
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+            chunk_start_frame_index (int): The starting frame index of the chunk.
+            chunk_end_frame_index (int): The ending frame index of the chunk.
+            sampling_interval_in_frames (int): The interval at which frames are sampled.
+        
+        Raises:
+            ValueError: If the number of midpoints does not match the expected number for the given chunk.        
+        """
+        try:
+            # Calculate expected number of sampled frames
+            start = chunk_start_frame_index
+            end = chunk_end_frame_index
+            interval = sampling_interval_in_frames
+            
+            # Mathematical formula to count sampled frames
+            expected_samples = (end // interval) - ((start - 1) // interval)
+
+            # Validate
+            actual_y_exact_length = len(y_exact)
+            if actual_y_exact_length != expected_samples:
+                cpr_logger.info(f"\nERROR: Mismatch in expected and actual samples")
+                cpr_logger.info(f"Expected: {expected_samples} samples (frames {start}-{end} @ every {interval} frames)")
+                cpr_logger.info(f"Actual: {actual_y_exact_length} midoints points recieived")
+                sys.exit(1)
+
+        except Exception as e:
+            cpr_logger.error(f"\nCRITICAL VALIDATION ERROR: {str(e)}")
+            sys.exit(1)
+
+#^ ################# Preprocessing #######################
+
+    def _smooth_midpoints(self, midpoints):
+        """
+        Smooth the y-values of the midpoints using Savitzky-Golay filter
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+
+        Returns:
+            np.ndarray: The smoothed y-values.
+        """
+        
+        if len(midpoints) > 5:  # Ensure enough data points
+            try:
+                y_smooth = savgol_filter(
+                    midpoints[:, 1], 
+                    window_length=3, 
+                    polyorder=2, 
+                    mode='nearest'
+                )
+                return y_smooth
+            except Exception as e:
+                cpr_logger.error(f"Smoothing error: {e}")
+                y_smooth = midpoints[:, 1]  # Fallback to original
+                return y_smooth
+        else:
+            y_smooth = midpoints[:, 1]  # Not enough points
+            return y_smooth
+
+    def _clean_midpoints(self, y_smooth):
+        """
+        Clean the smoothed y-values to remove impulse noise using median filtering
+
+        Args:
+            y_smooth (np.ndarray): The smoothed y-values.
+
+        Returns:
+            np.ndarray: The cleaned y-values.
+        """
+
+        if len(y_smooth) < self.removing_impulse_noise_window_size:
+            return y_smooth  # Not enough points for processing
+        
+        y_clean = np.array(y_smooth, dtype=float)  # Copy to avoid modifying original
+        half_window = self.removing_impulse_noise_window_size // 2
+        
+        for i in range(len(y_smooth)):
+            # Get local window (handle boundaries)
+            start = max(0, i - half_window)
+            end = min(len(y_smooth), i + half_window + 1)
+            window = y_smooth[start:end]
+            
+            # Calculate local median and MAD (robust statistics)
+            med = np.median(window)
+            mad = 1.4826 * np.median(np.abs(window - med))  # Median Absolute Deviation
+            
+            # Detect and replace outliers
+            if abs(y_smooth[i] - med) > self.removing_impulse_noise_threshold * mad:
+                # Replace with median of immediate neighbors (better than global median)
+                left = y_smooth[max(0, i-1)]
+                right = y_smooth[min(len(y_smooth)-1, i+1)]
+                y_clean[i] = np.median([left, right])
+        
+        return y_clean
+
+    def preprocess_midpoints(self, midpoints):
+        """
+        Preprocess the y-values of the midpoints by smoothing and cleaning
+
+        Sets:
+            y_preprocessed (np.ndarray): The preprocessed y-values.
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+        
+        Returns:
+            bool: True if preprocessing was successful, False otherwise.
+        """
+
+        y_smooth = self._smooth_midpoints(midpoints)
+        y_clean = self._clean_midpoints(y_smooth)
+
+        self.y_preprocessed = y_clean
+
+        return len(self.y_preprocessed) > 0  # Return True if preprocessing was successful
+
+#^ ################# Processing #######################
+
+    def detect_midpoints_peaks(self):
+        """
+        Detect peaks in the preprocessed y-values using dynamic distance
+        
+        Sets:
+            peaks (np.ndarray): The detected peaks.
+            peaks_max (np.ndarray): The detected max peaks.
+            peaks_min (np.ndarray): The detected min peaks.
+
+        Returns:
+            bool: True if peaks were detected, False otherwise.
+        """
+
+        if self.y_preprocessed.size == 0:
+            cpr_logger.info("No smoothed values found for peak detection")
+            return False
+            
+        try:
+            distance = min(1, len(self.y_preprocessed))  # Dynamic distance based on data length
+
+            # Detect max peaks with default prominence
+            self.peaks_max, _ = find_peaks(self.y_preprocessed, distance=distance)
+            
+            # Detect min peaks with reduced or no prominence requirement
+            self.peaks_min, _ = find_peaks(
+                -self.y_preprocessed, 
+                distance=distance, 
+                prominence=(0.2, None)  # Adjust based on your data's characteristics
+            )
+            
+            self.peaks = np.sort(np.concatenate((self.peaks_max, self.peaks_min)))
+
+            # Log the smoothed values and detected peaks
+            cpr_logger.info(f"Smoothed values: {self.y_preprocessed}")
+            cpr_logger.info(f"Detected peaks: {self.peaks}")
+            cpr_logger.info(f"Detected max peaks: {self.peaks_max}")
+            cpr_logger.info(f"Detected min peaks: {self.peaks_min}")
+
+            return len(self.peaks) > 0
+        except Exception as e:
+            cpr_logger.error(f"Peak detection error: {e}")
+            return False
+
+    def calculate_cm_px_ratio(self, shoulder_distances):
+        """
+        Calculate the ratio of cm to pixels based on shoulder distances
+
+        Sets:
+            cm_px_ratio (float): The ratio of cm to pixels.
+
+        Args:
+            shoulder_distances (list): List of shoulder distances in pixels.
+        """
+
+        if len(shoulder_distances) > 0:
+            avg_shoulder_width_px = np.mean(shoulder_distances)
+            self.cm_px_ratio = self.shoulder_width_cm / avg_shoulder_width_px
+        else:
+            self.cm_px_ratio = None
+            cpr_logger.info("No shoulder distances available for cm/px ratio calculation")
+        
+    def calculate_rate_and_depth_for_chunk(self, original_fps, sampling_interval_in_frames=1):
+        """
+        Calculate the rate and depth of the motion data for a chunk.
+
+        Sets:
+            depth (float): The calculated depth in cm.
+            rate (float): The calculated rate in cpm.
+
+        Args:
+            original_fps (float): The original frames per second of the video.
+            sampling_interval_in_frames (int): Number of frames skipped between samples.
+        """   
+        try:
+
+            # Without Adjustment: A peak distance of 5 (downsampled frames) would incorrectly be interpreted as 5/30 = 0.167 sec (too short).
+            # With Adjustment: The same peak distance 5 (downsampled frames) correctly represents 5/10 = 0.5 sec.
+
+            effective_fps = original_fps / sampling_interval_in_frames  # Correctly reduced FPS
+
+            # Depth calculation (unchanged)
+            depth = None
+            if len(self.peaks) > 1:
+                depth = np.mean(np.abs(np.diff(self.y_preprocessed[self.peaks]))) * self.cm_px_ratio
+
+            # Rate calculation (now uses effective_fps)
+            rate = None
+            if len(self.peaks_max) > 1:
+                # Peak indices are from the downsampled signal, so we use effective_fps
+                peak_intervals = np.diff(self.peaks_max)  # Already in downsampled frames
+                rate = (1 / (np.mean(peak_intervals) / effective_fps)) * 60  # Correct CPM
+                
+            # Handle cases with no valid data
+            if depth is None or rate is None:
+                depth = 0
+                rate = 0
+                self.peaks = np.array([])
+
+            self.depth = depth
+            self.rate = rate
+        except Exception as e:
+            cpr_logger.error(f"Error calculating rate and depth: {e}")
+    
+    def assign_chunk_data(self, chunk_start_frame_index, chunk_end_frame_index):
+        """
+        Capture chunk data for later analysis
+
+        Sets:
+            chunks_depth (list): List of depths for each chunk.
+            chunks_rate (list): List of rates for each chunk.
+            chunks_start_and_end_indices (list): List of start and end indices for each chunk.
+            chunks_y_preprocessed (list): List of preprocessed y-values for each chunk.
+            chunks_peaks (list): List of detected peaks for each chunk.
+
+        Args:
+            chunk_start_frame_index (int): The starting frame index of the chunk.
+            chunk_end_frame_index (int): The ending frame index of the chunk.
+        """
+        self.chunks_depth.append(self.depth)
+        self.chunks_rate.append(self.rate)
+        self.chunks_start_and_end_indices.append((chunk_start_frame_index, chunk_end_frame_index))
+
+        self.chunks_y_preprocessed.append(self.y_preprocessed.copy())
+        self.chunks_peaks.append(self.peaks.copy())      
+
+        self.current_chunk_start = chunk_start_frame_index
+        self.current_chunk_end = chunk_end_frame_index
+
+        self.chunks_rate_and_depth_warnings.append(self.rate_and_depth_warnings.copy())
+        
+    def calculate_rate_and_depth_for_all_chunk(self):
+        """
+        Calculate the weighted average rate and depth for all chunks
+
+        Sets:
+            weighted_depth (float): The weighted average depth in cm.
+            weighted_rate (float): The weighted average rate in cpm.
+        """
+        
+        if not self.chunks_depth or not self.chunks_rate or not self.chunks_start_and_end_indices:
+            cpr_logger.info("[WARNING] No chunk data available for averaging")
+            return None
+            
+        if not (len(self.chunks_depth) == len(self.chunks_rate) == len(self.chunks_start_and_end_indices)):
+            cpr_logger.info("[ERROR] Mismatched chunk data lists")
+            return None
+
+        total_weight = 0
+        weighted_depth_sum = 0
+        weighted_rate_sum = 0
+
+        for depth, rate, (start, end) in zip(self.chunks_depth, 
+                                        self.chunks_rate,
+                                        self.chunks_start_and_end_indices):
+            
+            # Calculate chunk duration (+1 because inclusive)
+            chunk_duration = end - start + 1
+            
+            weighted_depth_sum += depth * chunk_duration
+            weighted_rate_sum += rate * chunk_duration
+            total_weight += chunk_duration
+
+        if total_weight == 0:
+            self.weighted_depth = None
+            self.weighted_rate = None
+
+            cpr_logger.info("[ERROR] No valid chunks for averaging")
+        else:
+            self.weighted_depth = weighted_depth_sum / total_weight
+            self.weighted_rate =  weighted_rate_sum / total_weight
+        
+            cpr_logger.info(f"[RESULTS] Weighted average depth: {self.weighted_depth:.1f} cm")
+            cpr_logger.info(f"[RESULTS] Weighted average rate: {self.weighted_rate:.1f} cpm")
+
+#^ ################# Warnings #######################
+
+    def _get_rate_and_depth_status(self):
+        """Internal validation logic"""
+
+        depth_status = "normal"
+        rate_status  = "normal"
+        
+        if self.depth < self.min_depth_threshold and self.depth > 0:
+            depth_status = "low"
+        elif self.depth > self.max_depth_threshold:
+            depth_status = "high"
+            
+        if self.rate < self.min_rate_threshold and self.rate > 0:
+            rate_status = "low"
+        elif self.rate > self.max_rate_threshold:
+            rate_status = "high"
+            
+        return depth_status, rate_status
+
+    def get_rate_and_depth_warnings(self):
+        """Get performance warnings based on depth and rate"""
+
+        depth_status, rate_status = self._get_rate_and_depth_status()
+
+        warnings = []
+        if depth_status == "low":
+            warnings.append("Depth too low!")
+        elif depth_status == "high":
+            warnings.append("Depth too high!")
+
+        if rate_status == "low":
+            warnings.append("Rate too slow!")
+        elif rate_status == "high":
+            warnings.append("Rate too fast!")
+
+        self.rate_and_depth_warnings = warnings
+
+        return warnings
+
+#^ ################# Handle Chunk #######################
+
+    def handle_chunk(self, midpoints, chunk_start_frame_index, chunk_end_frame_index, fps, shoulder_distances, sampling_interval_in_frames):
+        """
+        Handle a chunk of motion data by validating, preprocessing, and calculating metrics
+        for the chunk.
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+            chunk_start_frame_index (int): The starting frame index of the chunk.
+            chunk_end_frame_index (int): The ending frame index of the chunk.
+            fps (float): The frames per second of the video.
+            shoulder_distances (list): List of shoulder distances in pixels.
+
+        Returns:
+            bool: True if the chunk was processed successfully, False otherwise.
+        """
+
+        if len(midpoints) == 0:
+            cpr_logger.info("No midpoints received, skipping chunk")
+            cpr_logger.info(f"Chunk {chunk_start_frame_index}-{chunk_end_frame_index} - No midpoints received")
+            sys.exit(1)
+
+        # The program is terminated if the validation fails
+        self.validate_midpoints_and_frames_count_in_chunk(midpoints, chunk_start_frame_index, chunk_end_frame_index, sampling_interval_in_frames)
+
+        preprocessing_reult = self.preprocess_midpoints(midpoints)
+        if not preprocessing_reult:
+            cpr_logger.info("Preprocessing failed, skipping chunk")
+            return False
+        
+        self.detect_midpoints_peaks()
+        if not self.detect_midpoints_peaks():
+            cpr_logger.info("Peak detection failed, skipping chunk")
+
+            self.peaks = np.array([])
+            self.peaks_max = np.array([])
+            self.peaks_min = np.array([])
+
+            self.depth = 0
+            self.rate = 0
+
+            return False
+        
+        self.calculate_cm_px_ratio(shoulder_distances)
+        if self.cm_px_ratio is None:
+            cpr_logger.info("cm/px ratio calculation failed, skipping chunk")
+
+            self.depth = 0
+            self.rate = 0
+            
+            return False
+        
+        self.calculate_rate_and_depth_for_chunk(fps, sampling_interval_in_frames)
+        if self.depth is None or self.rate is None:
+            cpr_logger.info("Rate and depth calculation failed, skipping chunk")
+            return False
+        else:
+            cpr_logger.info(f"Chunk {chunk_start_frame_index}-{chunk_end_frame_index} - Depth: {self.depth:.1f} cm, Rate: {self.rate:.1f} cpm")
+
+        self.get_rate_and_depth_warnings()
+
+        self.assign_chunk_data(chunk_start_frame_index, chunk_end_frame_index)
+        cpr_logger.info(f"Chunk {chunk_start_frame_index}-{chunk_end_frame_index} processed successfully")
+        return True
+
+#^ ################# Comments #######################
+# Between every two consecutive mini chunks, there wil be "sampling interval" frames unaccounted for.
+# This is because when we reach the "reporting interval" number of frames, we terminate the first mini chunk.
+# But we only start the next mini chunk when we detect the next successfully processed frame.
+# Which is "sampling interval" frames later at the earliest.
+# We can't just initialize the next mini chunk at the "reporting interval" frame, because we need to wait for the next successful frame.
+# Becuase maybe the next frame is a frame with posture errors.
+# For better visualization, we connect between the last point of the previous chunk and the first point of the next chunk if they are "sampling interval" frames apart.
+# But that is only for visualization, all calculations are done on the original frames.
+
+# Chunks that are too short can fail any stage of the "handle chunk" process.
+# If they do, we vizualize what we have and ignore the rest.
+# For example, a chunk with < 2 peaks will not be able to calculate the rate.
+# So we will set it to zero and display the midpoints and detected peaks.
+# If there are no peaks, we will set the rate to zero and display the midpoints.
+
+# Problems with chunks could be:
+# - Less than 3 seconds.
+# - Not enough peaks to calculate depth and rate

CPRRealTime/pose_estimation.py

@@ -0,0 +1,49 @@
+# pose_estimation.py
+import cv2
+import numpy as np
+from ultralytics import YOLO
+from CPRRealTime.keypoints import CocoKeypoints
+from CPRRealTime.logging_config import cpr_logger
+
+class PoseEstimator:
+    """Human pose estimation using YOLO"""
+    
+    def __init__(self, min_confidence, model_path="yolo11n-pose.pt"):
+        #self.model = YOLO(model_path).to("")
+        self.model = YOLO(model_path).to("cuda")
+
+        if next(self.model.model.parameters()).is_cuda:
+            print("✅ YOLO model successfully loaded on CUDA (GPU).")
+        else:
+            print("❌ YOLO model is not on CUDA. Check your setup.")
+
+        self.min_confidence = min_confidence
+
+    def detect_poses(self, frame):
+        """Detect human poses in a frame"""
+        try:
+            results = self.model(frame, verbose=False, conf=self.min_confidence, show=False, iou=0.2)
+            if not results or len(results[0].keypoints.xy) == 0:
+                return None
+            return results[0]
+        except Exception as e:
+            cpr_logger.error(f"Pose detection error: {e}")
+            return None
+
+    def get_keypoints(self, results, person_idx=0):
+        """Extract keypoints for a detected person"""
+        try:
+            if not results or len(results.keypoints.xy) <= person_idx:
+                return None
+            return results.keypoints.xy[person_idx].cpu().numpy()
+        except Exception as e:
+            cpr_logger.error(f"Keypoint extraction error: {e}")
+            return None
+
+    def draw_keypoints(self, frame, results):
+        """Draw detected keypoints on frame"""
+        try:
+            return results.plot()
+        except Exception as e:
+            cpr_logger.error(f"Keypoint drawing error: {e}")
+            return frame

CPRRealTime/posture_analyzer.py

@@ -0,0 +1,132 @@
+# posture_analyzer.py
+import math
+import cv2
+import numpy as np
+from CPRRealTime.keypoints import CocoKeypoints
+from CPRRealTime.logging_config import cpr_logger
+
+class PostureAnalyzer:
+    """Posture analysis and visualization with comprehensive validation"""
+    
+    def __init__(self, right_arm_angle_threshold, left_arm_angle_threshold, wrist_distance_threshold, history_length_to_average):
+        self.history_length_to_average = history_length_to_average
+        
+        self.right_arm_angles = []
+        self.left_arm_angles = []
+        self.wrist_distances = []
+        
+        self.right_arm_angle_threshold = right_arm_angle_threshold
+        self.left_arm_angle_threshold = left_arm_angle_threshold
+        self.wrist_distance_threshold = wrist_distance_threshold
+        
+    def _calculate_angle(self, a, b, c):
+        """Calculate angle between three points"""
+        try:
+            ang = math.degrees(math.atan2(c[1]-b[1], c[0]-b[0]) - 
+                         math.atan2(a[1]-b[1], a[0]-b[0]))
+            return ang + 360 if ang < 0 else ang
+        except Exception as e:
+            cpr_logger.error(f"Angle calculation error: {e}")
+            return 0
+    
+    def _check_bended_right_arm(self, keypoints):
+        """Check for right arm bending (returns warning)"""
+        warnings = []
+        try:
+            shoulder = keypoints[CocoKeypoints.RIGHT_SHOULDER.value]
+            elbow = keypoints[CocoKeypoints.RIGHT_ELBOW.value]
+            wrist = keypoints[CocoKeypoints.RIGHT_WRIST.value]
+            
+            right_angle = self._calculate_angle(wrist, elbow, shoulder)
+            
+            self.right_arm_angles.append(right_angle)
+
+            avg_right = np.mean(self.right_arm_angles[-self.history_length_to_average:] if self.right_arm_angles else 0)
+
+            if avg_right > self.right_arm_angle_threshold:
+                warnings.append("Right arm bent!")
+
+            return warnings
+                
+        except Exception as e:
+            cpr_logger.error(f"Right arm check error: {e}")
+        
+        return warnings
+    
+    def _check_bended_left_arm(self, keypoints):
+        """Check for left arm bending (returns warning)"""
+        warnings = []
+        try:
+            shoulder = keypoints[CocoKeypoints.LEFT_SHOULDER.value]
+            elbow = keypoints[CocoKeypoints.LEFT_ELBOW.value]
+            wrist = keypoints[CocoKeypoints.LEFT_WRIST.value]
+            
+            left_angle = self._calculate_angle(wrist, elbow, shoulder)
+            
+            self.left_arm_angles.append(left_angle)
+
+            avg_left = np.mean(self.left_arm_angles[-self.history_length_to_average:] if self.left_arm_angles else 0)
+
+            if avg_left < self.left_arm_angle_threshold:
+                warnings.append("Left arm bent!")
+
+            return warnings
+                
+        except Exception as e:
+            cpr_logger.error(f"Left arm check error: {e}")
+        
+        return warnings
+
+    def _check_hands_on_chest(self, keypoints, chest_params):
+        """Check individual hand positions and return specific warnings"""
+
+        # Get the wrist keypoints
+        left_wrist = keypoints[CocoKeypoints.LEFT_WRIST.value]
+        right_wrist = keypoints[CocoKeypoints.RIGHT_WRIST.value]
+
+        warnings = []
+        try:
+            if chest_params is None:
+                return ["Both hands not on chest!"]  # Fallback warning
+            
+            cx, cy, cw, ch = chest_params
+            left_in = right_in = False
+
+            # Check left hand
+            if left_wrist is not None:
+                left_in = (cx - cw/2 < left_wrist[0] < cx + cw/2) and \
+                          (cy - ch/2 < left_wrist[1] < cy + ch/2)
+            
+            # Check right hand
+            if right_wrist is not None:
+                right_in = (cx - cw/2 < right_wrist[0] < cx + cw/2) and \
+                            (cy - ch/2 < right_wrist[1] < cy + ch/2)
+
+            # Determine warnings
+            if not left_in and not right_in:
+                warnings.append("Both hands not on chest!")
+            else:
+                if not left_in:
+                    warnings.append("Left hand not on chest!")
+                if not right_in:
+                    warnings.append("Right hand not on chest!")
+
+        except Exception as e:
+            cpr_logger.error(f"Hands check error: {e}")
+        
+        return warnings
+
+
+    def validate_posture(self, keypoints, chest_params):
+        """Run all posture validations (returns aggregated warnings)"""
+        warnings = []
+
+        warnings += self._check_hands_on_chest(keypoints, chest_params)
+
+        if ("Right hand not on chest!" not in warnings) and ("Both hands not on chest!" not in warnings):
+            warnings += self._check_bended_right_arm(keypoints)
+        
+        if ("Left hand not on chest!" not in warnings) and ("Both hands not on chest!" not in warnings):
+            warnings += self._check_bended_left_arm(keypoints)
+       
+        return warnings

CPRRealTime/role_classifier.py

@@ -0,0 +1,178 @@
+# role_classifier.py
+import cv2
+import numpy as np
+from ultralytics.utils.plotting import Annotator  # Import YOLO's annotator
+from CPRRealTime.logging_config import cpr_logger
+
+
+class RoleClassifier:
+    """Role classification and tracking using image processing"""
+    
+    def __init__(self, proximity_thresh=0.3):
+        self.proximity_thresh = proximity_thresh
+        self.rescuer_id = None
+        self.rescuer_processed_results = None
+        self.patient_processed_results = None
+
+    def _calculate_verticality_score(self, bounding_box):
+        """Calculate posture verticality score (0=horizontal, 1=vertical) using bounding box aspect ratio."""
+        try:
+            x1, y1, x2, y2 = bounding_box
+            width = abs(x2 - x1)
+            height = abs(y2 - y1)
+            
+            # Handle edge cases with invalid dimensions
+            if width == 0 or height == 0:
+                return -1
+            
+            return 1 if height > width else 0  # 1 for vertical, 0 for horizontal
+            
+        except (TypeError, ValueError) as e:
+            cpr_logger.error(f"Verticality score calculation error: {e}")
+            return -1
+        
+    def _calculate_bounding_box_center(self, bounding_box):
+        """Calculate the center coordinates of a bounding box.
+        """
+        x1, y1, x2, y2 = bounding_box
+        return (x1 + x2) / 2, (y1 + y2) / 2
+
+    def _calculate_distance(self, point1, point2):
+        """Calculate Euclidean distance between two points"""
+        return ((point1[0]-point2[0])**2 + (point1[1]-point2[1])**2)**0.5
+ 
+    def _calculate_bbox_areas(self, rescuer_bbox, patient_bbox):
+        """
+        Calculate bounding box areas for rescuer and patient.
+        
+        Args:
+            rescuer_bbox: [x1, y1, x2, y2] coordinates of rescuer's bounding box
+            patient_bbox: [x1, y1, x2, y2] coordinates of patient's bounding box
+        
+        Returns:
+            Tuple: (rescuer_area, patient_area) in pixels
+        """
+        def compute_area(bbox):
+            if bbox is None:
+                return 0
+            width = bbox[2] - bbox[0]  # x2 - x1
+            height = bbox[3] - bbox[1]  # y2 - y1
+            return abs(width * height)  # Absolute value to handle negative coordinates
+        
+        return compute_area(rescuer_bbox), compute_area(patient_bbox)
+    
+    def classify_roles(self, results, prev_rescuer_processed_results=None, prev_patient_processed_results=None):
+        """
+        Classify roles of rescuer and patient based on detected keypoints and bounding boxes.
+        """
+
+        processed_results = []
+        
+        # Calculate combined area threshold if previous boxes exist
+        threshold = None
+        if prev_rescuer_processed_results and prev_patient_processed_results:
+            prev_rescuer_bbox = prev_rescuer_processed_results["bounding_box"]
+            prev_patient_bbox = prev_patient_processed_results["bounding_box"]
+
+            rescuer_area = (prev_rescuer_bbox[2]-prev_rescuer_bbox[0])*(prev_rescuer_bbox[3]-prev_rescuer_bbox[1])
+            patient_area = (prev_patient_bbox[2]-prev_patient_bbox[0])*(prev_patient_bbox[3]-prev_patient_bbox[1])
+            threshold = rescuer_area + patient_area
+        
+        for i, (box, keypoints) in enumerate(zip(results.boxes.xywh.cpu().numpy(), 
+                                            results.keypoints.xy.cpu().numpy())):
+            try:
+                # Convert box to [x1,y1,x2,y2] format
+                x_center, y_center, width, height = box
+                bounding_box = [
+                    x_center - width/2,  # x1
+                    y_center - height/2,  # y1 
+                    x_center + width/2,   # x2
+                    y_center + height/2   # y2
+                ]
+                
+                # Skip if box exceeds area threshold (when threshold exists)
+                if threshold:
+                    box_area = width * height
+                    if box_area > threshold * 1.2:  # 20% tolerance
+                        cpr_logger.info(f"Filtered oversized box {i} (area: {box_area:.1f} > threshold: {threshold:.1f})")
+                        continue
+                
+                # Calculate features
+                verticality_score = self._calculate_verticality_score(bounding_box)
+                #!We already have the center coordinates from the bounding box, no need to recalculate it.
+                bounding_box_center = self._calculate_bounding_box_center(bounding_box)
+                
+                # Store valid results
+                processed_results.append({
+                    'original_index': i,
+                    'bounding_box': bounding_box,
+                    'bounding_box_center': bounding_box_center,
+                    'verticality_score': verticality_score,
+                    'keypoints': keypoints,
+                })
+            
+            except Exception as e:
+                cpr_logger.error(f"Error processing detection {i}: {e}")
+                continue
+
+        # Step 2: Identify the patient (horizontal posture)
+        patient_candidates = [res for res in processed_results 
+                            if res['verticality_score'] == 0]
+        
+        # If more than one horizontal person, select person with lowest center (likely lying down)
+        if len(patient_candidates) > 1:
+            patient_candidates = sorted(patient_candidates, 
+                                    key=lambda x: x['bounding_box_center'][1])[:1]  # Sort by y-coordinate
+        
+        patient = patient_candidates[0] if patient_candidates else None
+        
+        # Step 3: Identify the rescuer
+        rescuer = None
+        if patient:
+            # Find vertical people who aren't the patient
+            potential_rescuers = [
+                res for res in processed_results 
+                if res['verticality_score'] == 1 
+                #! Useless condition because the patient was horizontal
+                and res['original_index'] != patient['original_index']
+            ]
+            
+            if potential_rescuers:
+                # Select rescuer closest to patient
+                rescuer = min(potential_rescuers,
+                            key=lambda x: self._calculate_distance(
+                                x['bounding_box_center'], 
+                                patient['bounding_box_center']))
+        
+        return rescuer, patient
+    
+    def draw_rescuer_and_patient(self, frame):        
+        # Create annotator object
+        annotator = Annotator(frame)
+        
+        # Draw rescuer (A) with green box and keypoints
+        if self.rescuer_processed_results:
+            try:
+                x1, y1, x2, y2 = map(int, self.rescuer_processed_results["bounding_box"])
+                annotator.box_label((x1, y1, x2, y2), "Rescuer A", color=(0, 255, 0))
+                
+                if "keypoints" in self.rescuer_processed_results:
+                    keypoints = self.rescuer_processed_results["keypoints"]
+                    annotator.kpts(keypoints, shape=frame.shape[:2])
+            except Exception as e:
+                cpr_logger.error(f"Error drawing rescuer: {str(e)}")
+
+        # Draw patient (B) with red box and keypoints
+        if self.patient_processed_results:
+            try:
+                x1, y1, x2, y2 = map(int, self.patient_processed_results["bounding_box"])
+                annotator.box_label((x1, y1, x2, y2), "Patient B", color=(0, 0, 255))
+                
+                if "keypoints" in self.patient_processed_results:
+                    keypoints = self.patient_processed_results["keypoints"]
+                    annotator.kpts(keypoints, shape=frame.shape[:2])
+            except Exception as e:
+                cpr_logger.error(f"Error drawing patient: {str(e)}")
+
+        return annotator.result()
+    

CPRRealTime/shoulders_analyzer.py

@@ -0,0 +1,30 @@
+import numpy as np
+from CPRRealTime.keypoints import CocoKeypoints
+from CPRRealTime.logging_config import cpr_logger
+
+class ShouldersAnalyzer:
+    """Analyzes shoulder distances and posture"""
+    
+    def __init__(self):
+        self.shoulder_distance = None
+        self.shoulder_distance_history = []
+
+    def calculate_shoulder_distance(self, rescuer_keypoints):
+        """Calculate and store shoulder distance"""
+        if rescuer_keypoints is None:
+            return
+            
+        try:
+            left = rescuer_keypoints[CocoKeypoints.LEFT_SHOULDER.value]
+            right = rescuer_keypoints[CocoKeypoints.RIGHT_SHOULDER.value]
+            
+            distance = np.linalg.norm(np.array(left) - np.array(right))
+            
+            return distance
+        except Exception as e:
+            cpr_logger.error(f"Shoulder distance error: {e}")
+            return
+    
+    def reset_shoulder_distances(self):
+        """Reset shoulder distances"""
+        self.shoulder_distance_history = []

CPRRealTime/threaded_camera.py

@@ -0,0 +1,103 @@
+import threading
+from queue import Queue
+import queue
+import cv2
+from CPRRealTime.logging_config import cpr_logger
+
+class ThreadedCamera:
+    def __init__(self, source, requested_fps = 30):
+
+        # The constructor of OpenCV's VideoCapture class automatically opens the camera
+        self.cap = cv2.VideoCapture(source)
+        if not self.cap.isOpened():
+            raise ValueError(f"[VIDEO CAPTURE] Unable to open camera source: {source}")
+        cpr_logger.info(f"[VIDEO CAPTURE] Camera source opened: {source}")
+
+        # Attempt to configure the camera to the requested FPS
+        # Which is set to the value we have been working on with recorded videos
+        # .set() returns True if the camera acknowledged the request, not if it actually achieved the FPS.
+        set_success = self.cap.set(cv2.CAP_PROP_FPS, requested_fps)
+
+        # Get the actual FPS from the camera
+        # This is the FPS that the camera is actually using, which may differ from the requested FPS.
+        actual_fps = self.cap.get(cv2.CAP_PROP_FPS)
+        self.fps = actual_fps
+
+        cpr_logger.info(f"[VIDEO CAPTURE] Requested FPS: {requested_fps}, Set Success: {set_success}, Actual FPS: {actual_fps}")
+
+        # The buffer should be able to hold a lag of up to 2 seconds
+        number_of_seconds_to_buffer = 5
+        queue_size = int(actual_fps * number_of_seconds_to_buffer)
+        self.q = Queue(maxsize=queue_size)
+        cpr_logger.info(f"[VIDEO CAPTURE] Queue size: {queue_size}")
+
+        # Set a flag to indicate that the camera is running
+        self.running = threading.Event()
+        self.running.set()  # Initial state = running
+        cpr_logger.info(f"[VIDEO CAPTURE] Camera running: {self.running.is_set()}")
+
+        self.number_of_total_frames = 0
+        self.number_of_dropped_frames = 0
+
+        self.thread = None
+
+    def start_capture(self):
+        # Clear any existing frames in queue
+        while not self.q.empty():
+            self.q.get()
+
+        # threading.Thread() initialize a new thread
+        # target=self._reader specify the method (_reader) the thread will execute
+        self.thread = threading.Thread(target=self._reader)
+        cpr_logger.info(f"[VIDEO CAPTURE] Thread initialized: {self.thread}")
+        
+        # Set the thread as a daemon thread:
+        #   Daemon threads automatically exit when the main program exits
+        #   They run in the background and don't block program termination
+        self.thread.daemon = True
+        cpr_logger.info(f"[VIDEO CAPTURE] Thread daemon: {self.thread.daemon}")
+
+        # Start the thread execution:
+        #   Call the _reader method in parallel with the main program
+        self.thread.start()
+
+    def _reader(self):
+        while self.running.is_set():
+            ret, frame = self.cap.read()
+            if not ret:
+                cpr_logger.info("Camera disconnected")
+                self.q.put(None)  # Sentinel for clean exit
+                break
+                
+            try:
+                self.number_of_total_frames += 1
+                self.q.put(frame, timeout=0.1)
+            except queue.Full:
+                cpr_logger.info("Frame dropped")
+                self.number_of_dropped_frames += 1
+
+    def read(self):
+        return self.q.get()
+
+    def release(self):
+        #! Not an error
+        cpr_logger.error(f"[VIDEO CAPTURE] Total frames: {self.number_of_total_frames}, Dropped frames: {self.number_of_dropped_frames}")
+        
+        self.running.clear()
+        
+        # First release the capture to unblock pending reads
+        self.cap.release()  # MOVED THIS LINE UP
+        
+        # Then join the thread
+        self.thread.join(timeout=1.0)
+        
+        if self.thread.is_alive():
+            cpr_logger.info("Warning: Thread didn't terminate cleanly")
+        # Removed redundant self.cap.release()
+
+    def isOpened(self):
+        return self.running.is_set() and self.cap.isOpened()
+
+    def __del__(self):
+        if self.running.is_set():  # Only release if not already done
+            self.release()

CPRRealTime/warnings_overlayer.py

@@ -0,0 +1,147 @@
+import cv2
+import numpy as np
+import os
+import sys
+
+from CPRRealTime.logging_config import cpr_logger
+
+class WarningsOverlayer:
+    def __init__(self):
+        self.WARNING_CONFIG = {
+            # Posture Warnings
+            "Right arm bent!": {
+                "color": (52, 110, 235),
+                "position": (50, 150)
+            },
+            "Left arm bent!": {
+                "color": (52, 110, 235),
+                "position": (50, 200)
+            },
+            "Left hand not on chest!": {
+                "color": (161, 127, 18),
+                "position": (50, 250)
+            },
+            "Right hand not on chest!": {
+                "color": (161, 127, 18),
+                "position": (50, 300)
+            },
+            "Both hands not on chest!": {
+                "color": (161, 127, 18),
+                "position": (50, 350)
+            },
+            
+            # Rate/Depth Warnings
+            "Depth too low!": {
+                "color": (125, 52, 235),
+                "position": (50, 400)
+            },
+            "Depth too high!": {
+                "color": (125, 52, 235),
+                "position": (50, 450)
+            },
+            "Rate too slow!": {
+                "color": (235, 52, 214),
+                "position": (50, 500)
+            },
+            "Rate too fast!": {
+                "color": (235, 52, 214),
+                "position": (50, 550)
+            }
+        }
+    
+    def add_warnings_to_processed_video(self, video_output_path, sampling_interval_frames, rate_and_depth_warnings, posture_warnings):
+        """Process both warning types with identical handling"""
+        cpr_logger.info("\n[POST-PROCESS] Starting warning overlay")
+        
+        # Read processed video with original parameters
+        cap = cv2.VideoCapture(video_output_path)
+        if not cap.isOpened():
+            cpr_logger.info("[ERROR] Failed to open processed video")
+            return
+
+        # Get original video properties
+        original_fourcc = int(cap.get(cv2.CAP_PROP_FOURCC))
+        processed_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))
+        
+        # Create final writer with ORIGINAL codec and parameters
+        base = os.path.splitext(video_output_path)[0]
+        final_path = os.path.abspath(f"{base}_final.mp4")
+        writer = cv2.VideoWriter(final_path, original_fourcc, processed_fps, (width, height))
+
+        # Combine all warnings into unified list
+        all_warnings = []
+        
+        # Process posture warnings
+        for entry in posture_warnings:
+            if warnings := entry.get('posture_warnings'):
+                start = entry['start_frame'] // sampling_interval_frames
+                end = entry['end_frame'] // sampling_interval_frames
+                all_warnings.append((int(start), int(end), warnings))
+        
+        # Process rate/depth warnings
+        for entry in rate_and_depth_warnings:
+            if warnings := entry.get('rate_and_depth_warnings'):
+                start = entry['start_frame'] // sampling_interval_frames
+                end = entry['end_frame'] // sampling_interval_frames
+                all_warnings.append((int(start), int(end), warnings))
+
+        # Video processing loop
+        frame_idx = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret: 
+                break
+            
+            # Check active warnings for current frame
+            active_warnings = []
+            for start, end, warnings in all_warnings:
+                if start <= frame_idx <= end:
+                    active_warnings.extend(warnings)
+            
+            # Draw all warnings using unified config
+            self._draw_warnings(frame, active_warnings)
+            
+            writer.write(frame)
+            frame_idx += 1
+        
+        cap.release()
+        writer.release()
+        cpr_logger.info(f"\n[POST-PROCESS] Final output saved to: {final_path}")
+
+    def _draw_warnings(self, frame, active_warnings):
+        """Draw warnings using unified configuration"""
+        drawn_positions = set()  # Prevent overlapping
+        
+        for warning_text in active_warnings:
+            if config := self.WARNING_CONFIG.get(warning_text):
+                x, y = config['position']
+                
+                # Auto-stack if position occupied
+                while (x, y) in drawn_positions:
+                    y += 50  # Move down by 50px
+                
+                self._draw_warning_banner(
+                    frame=frame,
+                    text=warning_text,
+                    color=config['color'],
+                    position=(x, y)
+                )
+                drawn_positions.add((x, y))
+    
+    def _draw_warning_banner(self, frame, text, color, position):
+            """Base drawing function for warning banners"""
+            (text_width, text_height), _ = cv2.getTextSize(
+                text, cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2)
+            
+            x, y = position
+            # Background rectangle
+            cv2.rectangle(frame, 
+                        (x - 10, y - text_height - 10),
+                        (x + text_width + 10, y + 10),
+                        color, -1)
+            # Text
+            cv2.putText(frame, text, (x, y),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
+   

CPRRealTime/wrists_midpoint_analyzer.py

@@ -0,0 +1,63 @@
+import cv2
+import numpy as np
+from CPRRealTime.keypoints import CocoKeypoints
+from CPRRealTime.logging_config import cpr_logger
+
+class WristsMidpointAnalyzer:
+    """Analyzes and tracks wrist midpoints for rescuer"""
+    
+    def __init__(self, allowed_distance_between_wrists=170):
+        self.allowed_distance_between_wrists = allowed_distance_between_wrists
+        self.midpoint = None
+        self.midpoint_history = []
+
+    def detect_wrists_midpoint(self, rescuer_keypoints):
+        """Calculate midpoint between wrists in pixel coordinates"""
+        try:
+            if rescuer_keypoints is None:
+                return None
+                
+            # Get wrist coordinates
+            lw = rescuer_keypoints[CocoKeypoints.LEFT_WRIST.value]
+            rw = rescuer_keypoints[CocoKeypoints.RIGHT_WRIST.value]
+
+            # If the distance between wrists is too large, return None
+            distance = np.linalg.norm(np.array(lw) - np.array(rw))
+            if distance > self.allowed_distance_between_wrists:
+                return None
+            
+            # Calculate midpoint
+            midpoint = (
+                int((lw[0] + rw[0]) / 2),
+                int((lw[1] + rw[1]) / 2)
+            )
+            
+            return midpoint
+            
+        except Exception as e:
+            cpr_logger.error(f"Midpoint tracking error: {e}")
+            return None
+
+    def draw_midpoint(self, frame):
+        """Visualize the midpoint on frame"""
+        
+        if self.midpoint is None:
+            return frame
+                    
+        try:
+            # Draw visualization
+            cv2.circle(frame, self.midpoint, 8, (0, 255, 0), -1)
+            cv2.putText(
+                frame, "MIDPOINT", 
+                (self.midpoint[0] + 5, self.midpoint[1] - 10),
+                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2
+            )
+
+            return frame
+        except Exception as e:
+            cpr_logger.error(f"Midpoint drawing error: {e}")
+            return frame
+    
+    def reset_midpoint_history(self):
+        """Reset midpoint history"""
+        self.midpoint_history = []

backupbackend.zip → CPRRealTime/yolo11n-pose.pt

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

main.py

@@ -10,11 +10,12 @@ import cloudinary
 import cloudinary.uploader
 from cloudinary.utils import cloudinary_url
 from SkinBurns_Classification import extract_features
-from SkinBurns_Segmentation import segment_skin_burns 
+from SkinBurns_Segmentation import segment_burn
 import requests
 import joblib
 import numpy as np
-from ECG import classify_new_ecg
+from ECG.ECG_Classify import classify_ecg
+from ECG.ECG_MultiClass import analyze_ecg_pdf
 from ultralytics import YOLO
 import tensorflow as tf
 from fastapi import HTTPException
@@ -22,10 +23,21 @@ from fastapi import WebSocket, WebSocketDisconnect
 import base64
 import cv2
 import time
-from CPR.CPRAnalyzer import CPRAnalyzer
+#from CPR.CPRAnalyzer import CPRAnalyzer
 import tempfile
-
-
+import matplotlib.pyplot as plt
+import json
+import asyncio
+import concurrent.futures
+from CPRRealTime.main import CPRAnalyzer
+from threading import Thread
+from starlette.responses import StreamingResponse
+import threading
+import queue
+from CPRRealTime.analysis_socket_server import AnalysisSocketServer  # adjust if needed
+from CPRRealTime.logging_config import cpr_logger
+import logging
+import sys
 
 
 app = FastAPI()
@@ -144,8 +156,52 @@ async def predict_burn(file: UploadFile = File(...)):
     except Exception as e:
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
+@app.post("/segment_burn")
+async def segment_burn_endpoint(reference: UploadFile = File(...), patient: UploadFile = File(...)):
+    try:
+        # Save the reference image temporarily
+        reference_path = f"temp_ref_{reference.filename}"
+        reference_bytes = await reference.read()
+        with open(reference_path, "wb") as ref_file:
+            ref_file.write(reference_bytes)
+
+        # Save the patient image temporarily
+        patient_path = f"temp_patient_{patient.filename}"
+        patient_bytes = await patient.read()
+        with open(patient_path, "wb") as pat_file:
+            pat_file.write(patient_bytes)
+
+        # Call the segmentation logic
+        burn_crop_clean, burn_crop_debug = segment_burn(patient_path, reference_path)
+
+        # Save the cropped outputs
+        burn_crop_clean_path = f"temp_burn_crop_clean_{uuid.uuid4()}.png"
+        burn_crop_debug_path = f"temp_burn_crop_debug_{uuid.uuid4()}.png"
+  
+
+        plt.imsave(burn_crop_clean_path, burn_crop_clean)
+        plt.imsave(burn_crop_debug_path, burn_crop_debug)
+
+        # Upload to Cloudinary
+        crop_clean_upload = cloudinary.uploader.upload(burn_crop_clean_path, public_id=f"ref_{reference.filename}")
+        crop_debug_upload = cloudinary.uploader.upload(burn_crop_debug_path, public_id=f"pat_{patient.filename}")
+        crop_clean_url = crop_clean_upload["secure_url"]
+        crop_debug_url = crop_debug_upload["secure_url"]
+
+        # Clean up temp files
+        
+        os.remove(burn_crop_clean_path)
+        os.remove(burn_crop_debug_path)
 
 
+        return {
+            "crop_clean_url": crop_clean_url,
+            "crop_debug_url": crop_debug_url
+        }
+
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
 # ✅ Optimize and transform image URL
 @app.get("/cloudinary/transform")
 def transform_image():
@@ -160,35 +216,60 @@ def transform_image():
         return {"error": str(e)}
     
 @app.post("/classify-ecg")
-async def classify_ecg(files: list[UploadFile] = File(...)):
+async def classify_ecg_endpoint(file: UploadFile = File(...)):
     model = joblib.load('voting_classifier.pkl')
-
-    temp_dir = f"temp_ecg_{uuid.uuid4()}"
-    os.makedirs(temp_dir, exist_ok=True)
+    # Load the model
 
     try:
-        for file in files:
-            file_path = os.path.join(temp_dir, file.filename)
-            with open(file_path, "wb") as f:
-                f.write(file.file.read())  # Replacing shutil.copyfileobj
+        # Save the uploaded file temporarily
+        temp_file_path = f"temp_{file.filename}"
+        with open(temp_file_path, "wb") as temp_file:
+            temp_file.write(await file.read())
 
-        # Assume both .hea and .dat have same base name
-        base_names = set(os.path.splitext(file.filename)[0] for file in files)
-        if len(base_names) != 1:
-            return JSONResponse(content={"error": "Files must have the same base name"}, status_code=400)
+        # Call the ECG classification function
+        result = classify_ecg(temp_file_path, model, debug=True, is_pdf=True)
 
-        base_name = list(base_names)[0]
-        file_path = os.path.join(temp_dir, base_name)
+        # Remove the temporary file
+        os.remove(temp_file_path)
 
-        result = classify_new_ecg(file_path, model)
         return {"result": result}
 
-    finally:
-        # Replace shutil.rmtree with os removal operations
-        for file_name in os.listdir(temp_dir):
-            file_path = os.path.join(temp_dir, file_name)
-            os.remove(file_path)
-        os.rmdir(temp_dir)
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+    
+@app.post("/diagnose-ecg")
+async def diagnose_ecg(file: UploadFile = File(...)):
+    try:
+        # Save the uploaded file temporarily
+        temp_file_path = f"temp_{file.filename}"
+        with open(temp_file_path, "wb") as temp_file:
+            temp_file.write(await file.read())
+
+        model_path = 'deep-multiclass.h5'  # Update with actual path
+        mlb_path = 'deep-multiclass.pkl'     # Update with actual path
+    
+
+        # Call the ECG classification function
+        result = analyze_ecg_pdf(
+        temp_file_path, 
+        model_path, 
+        mlb_path, 
+        cleanup=False,  # Keep the digitized file
+        debug=False,     # Print debug information
+        visualize=False  # Visualize the digitized signal
+    )
+    
+
+        # Remove the temporary file
+        os.remove(temp_file_path)
+        
+        if result and result["diagnosis"]:
+            return {"result": result["diagnosis"]}
+        else:
+            return {"result": "No diagnosis"}
+
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
 
 
 @app.post("/process_video")
@@ -204,77 +285,35 @@ async def process_video(file: UploadFile = File(...)):
     with open(video_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
 
-    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()
+    print(f"\n[API] CPR Analysis Started on {video_path}")
 
-        # Gather results
-        metrics = analyzer.get_compression_metrics()
-        warnings = analyzer.get_posture_warning_results()
+    # Run analyzer
+    start_time = time.time()
+    analyzer = CPRAnalyzer(video_path)
+    wholevideoURL, graphURL, warnings,chunks  = analyzer.run_analysis()  # Expects tuple return
 
-                # Upload each warning to cloudinary
-        for w in warnings:
+    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
-        })
+    print(f"[API] CPR Analysis Completed on {video_path}")
+    analysis_time = time.time() - start_time
+    print(f"[TIMING] Analysis time: {analysis_time:.2f}s")
 
-        chunk_index += 1
+    if wholevideoURL is None:
+        raise HTTPException(status_code=500, detail="No chunk data was generated from the video.")
 
-    cap.release()
-    print(f"[END] Total processing time: {time.time() - start_time:.2f}s")
-
-    return JSONResponse(content={"chunks": chunks})
+    # Return chunks and error regions
+    return JSONResponse(content={
+        "videoURL": wholevideoURL,
+        "graphURL": graphURL,
+        "warnings": warnings,
+        "chunks": chunks,
+        
+    })
 
 
 @app.post("/process_image")
@@ -316,43 +355,264 @@ async def process_image(file: UploadFile = File(...)):
     })
 
 
-# WebSocket endpoint to handle image processing
-@app.websocket("/ws/image")
-async def websocket_endpoint(websocket: WebSocket):
-    model = YOLO("yolo11n-pose_float16.tflite")
-    print("Model loaded successfully")
+
+
+
+@app.websocket("/ws/process_image")
+async def websocket_process_image(websocket: WebSocket):
     await websocket.accept()
     try:
         while True:
-            data = await websocket.receive_text()  # Receive base64-encoded image data
-            image_data = base64.b64decode(data)  # Decode the image data
+            # 1) Receive raw JPEG bytes from Flutter
+            data: bytes = await websocket.receive_bytes()
 
-            # Convert image bytes to numpy array and decode with OpenCV
-            np_arr = np.frombuffer(image_data, np.uint8)
+            # 2) (Optional) Decode to BGR for any pre-display or debugging
+            np_arr = np.frombuffer(data, np.uint8)
             frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-            
-            # Run YOLO pose estimation
-            if model is not None:
-                try:
-                    results = model.predict(frame, save=False, conf=0.3)
-                    
-                    if results and results[0].keypoints:
-                        keypoints = results[0].keypoints.xy.cpu().numpy().tolist()  # Extract keypoints
-                        confidences = results[0].boxes.conf.cpu().numpy().tolist() if results[0].boxes else []
-
-                        # Send the results back to the client
-                        response = {
-                            "message": "Pose detected",
-                            "KeypointsXY": keypoints[:5],  # Limit to first 5 keypoints for brevity
-                            "Confidences": confidences[:5],  # Limit to first 5 confidences
-                        }
-                        await websocket.send_text(str(response))
-                    else:
-                        await websocket.send_text("❌ No keypoints detected.")
-                except Exception as e:
-                    await websocket.send_text(f"⚠️ Error processing image: {str(e)}")
+
+            # 3) Write to temp file for YOLO ingestion
+            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
+                tmp.write(data)
+                tmp_path = tmp.name
+
+            # 4) Run inference without any built-in display
+            try:
+                results = model(source=tmp_path, show=False, save=False)
+            except Exception as e:
+                os.unlink(tmp_path)
+                await websocket.send_text(json.dumps({
+                    "error": f"YOLO error: {e}"
+                }))
+                continue
+
+            # cleanup temp file
+            os.unlink(tmp_path)
+
+            # 5) Clear any stray windows
+            cv2.destroyAllWindows()
+
+            # 6) Get the single annotated BGR image
+            annotated: np.ndarray = results[0].plot()
+
+            # 7) Show exactly one window in color
+            cv2.imshow("Pose / Segmentation", annotated)
+            cv2.waitKey(1)  # small delay to allow window refresh
+
+            # 8) Build and send JSON back to Flutter
+            if not results or len(results) == 0 or results[0].keypoints is None:
+                payload = {"message": "No keypoints detected"}
+            else:
+                keypoints = results[0].keypoints.xy.tolist()
+                confidences = (
+                    results[0].boxes.conf.tolist()
+                    if results[0].boxes is not None
+                    else []
+                )
+                payload = {
+                    "message": "Image processed successfully",
+                    "KeypointsXY": keypoints,
+                    "confidences": confidences,
+                }
+
+            await websocket.send_text(json.dumps(payload))
+
+    except WebSocketDisconnect:
+        print("Client disconnected")
+    finally:
+        # Ensure the window is closed on disconnect
+        cv2.destroyAllWindows()
+
+
+
+
+@app.websocket("/ws/process_video")
+async def websocket_process_video(websocket: WebSocket):
+
+    await websocket.accept()
+
+    frame_buffer = []
+    frame_limit = 50
+    frame_size = (640, 480)  # Adjust if needed
+    fps = 30  # Adjust if needed
+    loop = asyncio.get_event_loop()
+
+    # Progress reporting during analysis
+    async def progress_callback(data):
+        await websocket.send_text(json.dumps(data))
+
+    def sync_callback(data):
+        asyncio.run_coroutine_threadsafe(progress_callback(data), loop)
+
+    def save_frames_to_video(frames, path):
+        out = cv2.VideoWriter(path, cv2.VideoWriter_fourcc(*'mp4v'), fps, frame_size)
+        for frame in frames:
+            resized = cv2.resize(frame, frame_size)
+            out.write(resized)
+        out.release()
+
+    def run_analysis_on_buffer(frames):
+        try:
+            tmp_path = "temp_video.mp4"
+            save_frames_to_video(frames, tmp_path)
+
+            # Notify: video saved
+            asyncio.run_coroutine_threadsafe(
+                websocket.send_text(json.dumps({
+                    "status": "info",
+                    "message": "Video saved. Starting CPR analysis..."
+                })),
+                loop
+            )
+
+            # Run analysis
+            analyzer = CPRAnalyzer(video_path=tmp_path)
+            analyzer.run_analysis(progress_callback=sync_callback)
+
+        except Exception as e:
+            asyncio.run_coroutine_threadsafe(
+                websocket.send_text(json.dumps({"error": str(e)})),
+                loop
+            )
+
+    try:
+        while True:
+            data: bytes = await websocket.receive_bytes()
+            np_arr = np.frombuffer(data, np.uint8)
+            frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+            if frame is None:
+                continue
+
+            frame_buffer.append(frame)
+            print(f"Frame added to buffer: {len(frame_buffer)}")
+
+            if len(frame_buffer) == frame_limit:
+                # Notify Flutter that we're switching to processing
+                await websocket.send_text(json.dumps({
+                    "status": "ready",
+                    "message": "Prepare Right CPR: First 150 frames received. Starting processing."
+                }))
+
+                # Copy and clear buffer
+                buffer_copy = frame_buffer[:]
+                frame_buffer.clear()
+
+                # Launch background processing
+                executor = concurrent.futures.ThreadPoolExecutor()
+                loop.run_in_executor(executor, run_analysis_on_buffer, buffer_copy)
             else:
-                await websocket.send_text("⚠️ Model not loaded.")
-                
+                # Tell Flutter to send the next frame
+                await websocket.send_text(json.dumps({
+                    "status": "continue",
+                    "message": f"Frame {len(frame_buffer)} received. Send next."
+                }))
+
+    except WebSocketDisconnect:
+        print("Client disconnected")
+
+    except Exception as e:
+        await websocket.send_text(json.dumps({"error": str(e)}))
+
+    finally:
+        cv2.destroyAllWindows()
+
+
+logger = logging.getLogger("cpr_logger")
+clients = set()
+analyzer_thread = None
+analysis_started = False
+socket_server: AnalysisSocketServer = None  # Global reference
+
+
+async def forward_results_from_queue(websocket: WebSocket, warning_queue):
+    try:
+        while True:
+            warnings = await asyncio.to_thread(warning_queue.get)
+            serialized = json.dumps(warnings)
+            await websocket.send_text(serialized)
+    except asyncio.CancelledError:
+        logger.info("[WebSocket] Forwarding task cancelled")
+    except Exception as e:
+        logger.error(f"[WebSocket] Error forwarding data: {e}")
+
+
+def run_cpr_analysis(source, requested_fps, output_path):
+    global socket_server
+    cpr_logger.info(f"[MAIN] CPR Analysis Started")
+    
+    # Configuration
+    requested_fps = 30
+    input_video = source
+   
+    # Create output directory if it doesn't exist
+    output_dir = r"D:\BackendGp\Deploy_El7a2ny_Application\CPRRealTime\outputs"
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Set output paths using original name
+    video_output_path = os.path.join(output_dir, f"output.mp4")
+    plot_output_path = os.path.join(output_dir, f"output.png")
+    
+    # Log paths for verification
+    cpr_logger.info(f"[CONFIG] Input video: {input_video}")
+    cpr_logger.info(f"[CONFIG] Video output: {video_output_path}")
+    cpr_logger.info(f"[CONFIG] Plot output: {plot_output_path}")
+    
+    # Initialize and run analyzer
+    initialization_start_time = time.time()
+    analyzer = CPRAnalyzer(input_video, video_output_path, plot_output_path, requested_fps)
+    socket_server = analyzer.socket_server  # <- get reference to its queue
+
+    # Set plot output path in the analyzer
+    analyzer.plot_output_path = plot_output_path
+    
+    initialization_end_time = time.time()
+    initialization_elapsed_time = initialization_end_time - initialization_start_time
+    cpr_logger.info(f"[TIMING] Initialization time: {initialization_elapsed_time:.2f}s")
+    
+    try:
+        analyzer.run_analysis()
+    finally:
+        analyzer.socket_server.stop_server()
+
+
+@app.websocket("/ws/test")
+async def websocket_analysis(websocket: WebSocket):
+    global analyzer_thread, analysis_started, socket_server
+
+    await websocket.accept()
+    clients.add(websocket)
+    logger.info("[WebSocket] Flutter connected")
+
+    # Start the analyzer only once
+    if not analysis_started:
+        source = "http://192.168.137.33:8080/video"  # Replace with your video source
+        requested_fps = 30
+        output_path = r"D:\CPR\End to End\Code Refactor\output\output.mp4"
+
+        analyzer_thread = threading.Thread(
+            target=run_cpr_analysis,
+            args=(source, requested_fps, output_path),
+            daemon=True
+        )
+        analyzer_thread.start()
+        analysis_started = True
+
+        logger.info("[WebSocket] Analysis thread started")
+
+        # Wait until socket server is initialized
+        while socket_server is None or not socket_server.warning_queue:
+            await asyncio.sleep(0.1)
+
+    # Start async task to stream warnings from queue to Flutter
+    forward_task = asyncio.create_task(forward_results_from_queue(websocket, socket_server.warning_queue))
+
+    try:
+        while True:
+            # Keep connection alive (optional)
+            await asyncio.sleep(1)
     except WebSocketDisconnect:
-        print("🔌 Client disconnected")
+        logger.warning("[WebSocket] Client disconnected")
+        forward_task.cancel()
+    finally:
+        clients.discard(websocket)
+
+        

test.py

@@ -0,0 +1,61 @@
+import cv2
+from ultralytics import YOLO
+
+# Load YOLOv8-pose model (adjust path as needed)
+model = YOLO("yolo11n-pose.pt")
+
+# Stream URL (MJPEG HTTP stream)
+stream_url = "http://192.168.137.33:8080/video"
+
+# Open video capture from stream
+cap = cv2.VideoCapture(stream_url)
+
+if not cap.isOpened():
+    print("Error: Cannot open video stream")
+    exit()
+
+# Get properties (fallback to defaults if zero)
+width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+fps = cap.get(cv2.CAP_PROP_FPS)
+
+if width == 0 or height == 0:
+    # Typical fallback for MJPEG streams that don't report width/height properly
+    width, height = 640, 480
+if fps == 0:
+    fps = 20  # Set a reasonable default FPS for streams
+
+print(f"Stream opened: {width}x{height} at {fps} FPS")
+
+# Since we rotate 90 degrees clockwise, swap width and height for output video
+out = cv2.VideoWriter("output_pose.mp4", cv2.VideoWriter_fourcc(*"mp4v"), fps, (height, width))
+
+while True:
+    ret, frame = cap.read()
+    if not ret:
+        print("Failed to grab frame")
+        break
+
+    # Rotate frame 90 degrees clockwise
+    rotated_frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
+
+    # Run YOLO pose estimation on rotated frame
+    results = model(rotated_frame, verbose=False, conf=0.3, iou=0.1)
+
+    # Draw pose annotations
+    annotated_frame = results[0].plot()
+
+    # Write annotated frame to output video
+    out.write(annotated_frame)
+
+    # Show annotated frame
+    cv2.imshow("Pose Detection (rotated)", annotated_frame)
+
+    # Press 'q' to quit
+    if cv2.waitKey(1) & 0xFF == ord("q"):
+        break
+
+# Cleanup
+cap.release()
+out.release()
+cv2.destroyAllWindows()