CPR Partial Code Cleaning

CPR_Module/Common/chest_initializer.py

@@ -5,7 +5,7 @@ from CPR_Module.Common.keypoints import CocoKeypoints
 from CPR_Module.Common.logging_config import cpr_logger
 
 class ChestInitializer:
-    """Handles chest point detection with validations in estimation."""
+    """Estimates and stabilizes chest region parameters based on keypoints and bounding box."""
     
     def __init__(self):
         self.chest_params = None
@@ -13,7 +13,7 @@ class ChestInitializer:
         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."""
+        """Estimate chest region parameters based on keypoints and bounding box."""
         try:
             # Unpack bounding box and calculate shoulder dimensions
             bbox_x1, bbox_y1, bbox_x2, bbox_y2 = bounding_box
@@ -24,71 +24,62 @@ class ChestInitializer:
             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])
+            shoulder_center = np.array([
+                (left_shoulder[0] + right_shoulder[0]) / 2,
+                (left_shoulder[1] + right_shoulder[1]) / 2
+            ])
             
-            #& Handing different patient positions
+            #& Handling 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)
+            if abs(shoulder_center[0] - bbox_x2) < abs(shoulder_center[0] - bbox_x1): # Right orientation
+                chest_center_x = shoulder_center[0] - 0.3 * bbox_delta_y
+                chest_center_y = shoulder_center[1] - 0.1 * bbox_delta_y
+            else: # Left orientation
+                chest_center_x = shoulder_center[0] + 1.0 * bbox_delta_y
+                chest_center_y = shoulder_center[1] - 0.1 * bbox_delta_y
+
+            # Chest dimensions
             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
+            x1 = chest_center_x - chest_dx / 2
+            y1 = chest_center_y - chest_dy / 2
+            x2 = chest_center_x + chest_dx / 2
+            y2 = chest_center_y + chest_dy / 2
+
+            # First clamp the bounding box to frame boundaries
+            bbox_x1 = max(0, min(bbox_x1, frame_width - 1))
+            bbox_y1 = max(0, min(bbox_y1, frame_height - 1))
+            bbox_x2 = max(0, min(bbox_x2, frame_width - 1))
+            bbox_y2 = max(0, min(bbox_y2, frame_height - 1))
+
+            # Clamp to bounding box (which is already clamped to frame)
+            x1 = max(bbox_x1, min(x1, bbox_x2))
+            y1 = max(bbox_y1, min(y1, bbox_y2))
+            x2 = max(bbox_x1, min(x2, bbox_x2))
+            y2 = max(bbox_y1, min(y2, bbox_y2))
+
+            # Final validity check
             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)
+            return (
+                (x1 + x2) / 2,  # cx
+                (y1 + y2) / 2,  # cy
+                x2 - x1,        # cw
+                y2 - y1         # 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
-        """
+        """Estimate chest region using weighted average of recent parameters."""
         if not self.chest_params_history:
             return None
         
@@ -134,7 +125,7 @@ class ChestInitializer:
             return None
     
     def draw_expected_chest_region(self, frame):
-        """Draws the chest region without validation."""
+        """Draw the expected chest region on the frame."""
         if self.expected_chest_params is None:
             return frame
 
@@ -149,7 +140,7 @@ class ChestInitializer:
 
         cv2.circle(frame, (int(cx), int(cy)), 8, (128, 128, 0), -1)
 
-        cv2.putText(frame, "EXPECTED CHEST", (x1, max(10, y1 - 5)), 
+        cv2.putText(frame, "CHEST", (x1, max(10, y1 - 5)), 
                     cv2.FONT_HERSHEY_SIMPLEX, 0.8, (128, 128, 0), 2)
         
         return frame

CPR_Module/Common/keypoints.py

@@ -1,4 +1,3 @@
-# keypoints.py
 from enum import Enum
 
 class CocoKeypoints(Enum):

CPR_Module/Common/logging_config.py

@@ -1,4 +1,3 @@
-# logging_config.py
 import logging
 
 # 1. Set default log level here (change this value as needed)

CPR_Module/Common/posture_analyzer.py

@@ -1,13 +1,11 @@
-# posture_analyzer.py
 import math
-import cv2
 import numpy as np
 
 from CPR_Module.Common.keypoints import CocoKeypoints
 from CPR_Module.Common.logging_config import cpr_logger
 
 class PostureAnalyzer:
-    """Posture analysis and visualization with comprehensive validation"""
+    """Analyzes the Rescuer's posture during CPR based on the rescuer's keypoints and the patient's chest region."""
     
     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
@@ -79,7 +77,7 @@ class PostureAnalyzer:
         return warnings
 
     def _check_hands_on_chest(self, keypoints, chest_params):
-        """Check individual hand positions and return specific warnings"""
+        """Check if both hands are on the chest (returns warnings)"""
 
         # Get the wrist keypoints
         left_wrist = keypoints[CocoKeypoints.LEFT_WRIST.value]
@@ -87,8 +85,9 @@ class PostureAnalyzer:
 
         warnings = []
         try:
+            # Fallback
             if chest_params is None:
-                return ["Both hands not on chest!"]  # Fallback warning
+                return ["Both hands not on chest!"]
             
             cx, cy, cw, ch = chest_params
             left_in = right_in = False
@@ -117,7 +116,6 @@ class PostureAnalyzer:
         
         return warnings
 
-
     def validate_posture(self, keypoints, chest_params):
         """Run all posture validations (returns aggregated warnings)"""
         warnings = []

CPR_Module/Common/role_classifier.py

@@ -1,12 +1,9 @@
-# role_classifier.py
-import cv2
-import numpy as np
 from ultralytics.utils.plotting import Annotator
 
 from CPR_Module.Common.logging_config import cpr_logger
 
 class RoleClassifier:
-    """Role classification and tracking using image processing"""
+    """Classify roles of rescuer and patient based on detected keypoints and bounding boxes."""
     
     def __init__(self, proximity_thresh=0.3):
         self.proximity_thresh = proximity_thresh
@@ -25,15 +22,14 @@ class RoleClassifier:
             if width == 0 or height == 0:
                 return -1
             
-            return 1 if height > width else 0  # 1 for vertical, 0 for horizontal
+            return 1 if height > width else 0
             
         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.
-        """
+        """Calculate the center coordinates of a bounding box."""
         x1, y1, x2, y2 = bounding_box
         return (x1 + x2) / 2, (y1 + y2) / 2
 
@@ -42,29 +38,18 @@ class RoleClassifier:
         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
-        """
+        """ Calculate areas of rescuer and patient bounding boxes."""
         def compute_area(bbox):
             if bbox is None:
                 return 0
-            width = bbox[2] - bbox[0]  # x2 - x1
+            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.
-        """
+        """Classify rescuer and patient roles based on detection results."""
 
         processed_results = []
         
@@ -74,12 +59,10 @@ class RoleClassifier:
             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])
+            rescuer_area, patient_area = self._calculate_bbox_areas(prev_rescuer_bbox, prev_patient_bbox)
             threshold = rescuer_area + patient_area
         
-        for i, (box, keypoints) in enumerate(zip(results.boxes.xywh.cpu().numpy(), 
-                                            results.keypoints.xy.cpu().numpy())):
+        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
@@ -99,6 +82,7 @@ class RoleClassifier:
                 
                 # 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)
                 
@@ -115,24 +99,23 @@ class RoleClassifier:
                 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]
+        # 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_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
+        # 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']
             ]
@@ -150,11 +133,11 @@ class RoleClassifier:
         # Create annotator object
         annotator = Annotator(frame)
         
-        # Draw rescuer (A) with green box and keypoints
+        # Draw rescuer
         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))
+                annotator.box_label((x1, y1, x2, y2), "Rescuer", color=(0, 255, 0))
                 
                 if "keypoints" in self.rescuer_processed_results:
                     keypoints = self.rescuer_processed_results["keypoints"]
@@ -162,11 +145,11 @@ class RoleClassifier:
             except Exception as e:
                 cpr_logger.error(f"Error drawing rescuer: {str(e)}")
 
-        # Draw patient (B) with red box and keypoints
+        # Draw patient
         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))
+                annotator.box_label((x1, y1, x2, y2), "Patient", color=(0, 0, 255))
                 
                 if "keypoints" in self.patient_processed_results:
                     keypoints = self.patient_processed_results["keypoints"]

CPR_Module/Common/shoulders_analyzer.py

@@ -4,7 +4,7 @@ from CPR_Module.Common.keypoints import CocoKeypoints
 from CPR_Module.Common.logging_config import cpr_logger
 
 class ShouldersAnalyzer:
-    """Analyzes shoulder distances and posture"""
+    """Calculate and store shoulder distance for CPR rescuer"""
     
     def __init__(self):
         self.shoulder_distance = None

CPR_Module/Common/threaded_camera.py

@@ -26,7 +26,7 @@ class ThreadedCamera:
 
         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
+        # The buffer should be able to hold a lag of up to "number_of_seconds_to_buffer" seconds
         number_of_seconds_to_buffer = 5
         queue_size = int(actual_fps * number_of_seconds_to_buffer)
         self.q = Queue(maxsize=queue_size)

CPR_Module/Common/warnings_overlayer.py

@@ -1,7 +1,6 @@
 import cv2
 import numpy as np
 import os
-import sys
 
 from CPR_Module.Common.logging_config import cpr_logger
 
@@ -108,7 +107,6 @@ class WarningsOverlayer:
         writer.release()
         cpr_logger.info(f"\n[POST-PROCESS] Final output saved to: {final_path}")
 
-
     def _draw_warnings(self, frame, active_warnings):
         """Draw all warnings in a single vertical drawer"""
         frame_height = frame.shape[0]

CPR_Module/Common/wrists_midpoint_analyzer.py

@@ -5,7 +5,7 @@ from CPR_Module.Common.keypoints import CocoKeypoints
 from CPR_Module.Common.logging_config import cpr_logger
 
 class WristsMidpointAnalyzer:
-    """Analyzes and tracks wrist midpoints for rescuer"""
+    """Calculate and visualize midpoint between wrists for CPR rescuer"""
     
     def __init__(self, allowed_distance_between_wrists=170):
         self.allowed_distance_between_wrists = allowed_distance_between_wrists

CPR_Module/Educational_Mode/CPRAnalyzer.py

@@ -1,10 +1,8 @@
-# main.py
 import cv2
 import time
 import math
 import numpy as np
 import os 
-import sys
 
 from CPR_Module.Educational_Mode.pose_estimation import PoseEstimator
 from CPR_Module.Educational_Mode.metrics_calculator import MetricsCalculator
@@ -20,7 +18,7 @@ from CPR_Module.Common.warnings_overlayer import WarningsOverlayer
 from CPR_Module.Common.logging_config import cpr_logger
 
 class CPRAnalyzer:
-    """Main CPR analysis pipeline with execution tracing"""
+    """Main class for analyzing CPR performance from video input."""
     
     def __init__(self, input_video, video_output_path, plot_output_path, requested_fps):
         
@@ -85,11 +83,11 @@ class CPRAnalyzer:
         cpr_logger.info("[INIT] Previous results initialized")
 
         #& Fundamental timing parameters (in seconds)
-        self.MIN_ERROR_DURATION = 0.5    # Require sustained errors zfor 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
+        self.MIN_ERROR_DURATION = 0.5                       # Require sustained errors for X second
+        self.REPORTING_INTERVAL = 5.0                       # Generate reports every Y seconds
+        self.SAMPLING_INTERVAL = 0.2                        # Analyze every Z seconds
+        self.KEEP_RATE_AND_DEPTH_WARNINGS_INTERVAL = 3.0    # Keep rate and depth warnings for W seconds
+        self.MIN_CHUNK_LENGTH_TO_REPORT = 3.0               # Minimum chunk length to report warnings
 
         # Derived frame counts 
         self.sampling_interval_frames = int(round(self.fps * self.SAMPLING_INTERVAL))
@@ -126,7 +124,6 @@ class CPRAnalyzer:
         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")
 
@@ -151,75 +148,6 @@ class CPRAnalyzer:
         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")
-
-        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_video(self):
         try:
             cpr_logger.info("[RUN ANALYSIS] Starting analysis")
@@ -437,36 +365,7 @@ class CPRAnalyzer:
             cpr_logger.info(f"[TIMING] Report and plot elapsed time: {report_and_plot_elapsed_time:.2f}s")
             return self.graph_plotter._chunks_json_data
 
-    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
-
+#^############################## Frame Processing & Composition ##############################
     def _process_frame(self, frame):
         #* Warnings for real time feedback
         warnings = []
@@ -594,7 +493,6 @@ class CPRAnalyzer:
         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")
@@ -606,6 +504,58 @@ class CPRAnalyzer:
     
         return frame
 
+#^############################## Start/End of Chunk/Posture Warnings Region Handling ##############################
+    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")
+
+        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}")
+    
+#^############################## Rate & Depth Calculations ##############################
     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)
@@ -645,41 +595,33 @@ class CPRAnalyzer:
 
         return rate_and_depth_warnings
 
-if __name__ == "__main__":
-    cpr_logger.info(f"[MAIN] CPR Analysis Started")
-    
-    # Configuration
-    requested_fps = 30
-    input_video = r"D:\CPR_education\CPR\End to End\Code Refactor\video_2.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)
-    
-    output_dir = r"D:\CPR_education\CPR\End to End\Code Refactor\Output"
+#^############################## Video Writer ##############################
+    def _initialize_video_writer(self, frame):
+        """Initialize writer with safe fallback options"""
 
-    # Set output paths using original name
-    video_output_path = os.path.join(output_dir, f"Myoutput.mp4")
-    plot_output_path = os.path.join(output_dir, f"Myoutput.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:
-        data = analyzer.run_analysis()
-        print(data)
-    finally:
-        cpr_logger.info(f"[MAIN] CPR Analysis Terminated")
+        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
+
+#^############################## Frame Rotation ##############################  
+    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

CPR_Module/Educational_Mode/graph_plotter.py

@@ -1,14 +1,12 @@
 import numpy as np
 import matplotlib.pyplot as plt
-import sys
-import cv2
-from CPR_Module.Common.logging_config import cpr_logger
+from matplotlib.ticker import MultipleLocator
 import os
 
-from matplotlib.ticker import MultipleLocator
+from CPR_Module.Common.logging_config import cpr_logger
 
 class GraphPlotter:
-    """Class to plot graphs for various metrics"""
+    """Class to handle plotting of CPR motion curves and error regions with detailed metrics."""
    
     def __init__(self):
         self.chunks_y_preprocessed = []
@@ -33,6 +31,7 @@ class GraphPlotter:
 
     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
@@ -40,12 +39,14 @@ class GraphPlotter:
         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
+        self.fps = 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
@@ -108,11 +109,12 @@ class GraphPlotter:
 
     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²)
+        target_width_ratio = 0.7 
+        legend_size = 80 
         
         legend_handles = []
         y_mid = np.mean(ax.get_ylim())
@@ -268,6 +270,7 @@ class GraphPlotter:
        
     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
         
@@ -288,14 +291,13 @@ class GraphPlotter:
                 f"Time {start_sec:.2f}s - {end_sec:.2f}s ({duration_sec:.2f}s), "
                 f"Depth: {depth:.1f}cm, Rate: {rate:.1f}cpm")
             
-            #! Formatted json to mobile
-
+            #& Formatted json to mobile
             chunk_data = {
             "start": round(start_sec, 2),
             "end": round(end_sec, 2),
             "depth": round(depth, 1),
             "rate": round(rate, 1)
-        }
+            }
             self._chunks_json_data.append(chunk_data)
             
             display_idx += 1

CPR_Module/Educational_Mode/metrics_calculator.py

@@ -1,10 +1,6 @@
-# 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 CPR_Module.Common.logging_config import cpr_logger
 
@@ -85,11 +81,13 @@ class MetricsCalculator:
                 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)
+                return np.array([]) 
+
+            return y_exact
 
         except Exception as e:
             cpr_logger.error(f"\nCRITICAL VALIDATION ERROR: {str(e)}")
-            sys.exit(1)
+            return np.array([])  
 
 #^ ################# Preprocessing #######################
 
@@ -407,7 +405,7 @@ class MetricsCalculator:
         """
 
         # 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)
+        midpoints = 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:
@@ -448,23 +446,3 @@ class MetricsCalculator:
         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

CPR_Module/Educational_Mode/pose_estimation.py

@@ -1,9 +1,6 @@
-# pose_estimation.py
-import cv2
 import numpy as np
 from ultralytics import YOLO
 
-from CPR_Module.Common.keypoints import CocoKeypoints
 from CPR_Module.Common.logging_config import cpr_logger
 
 class PoseEstimator:

CPR_Module/Emergency_Mode/graph_plotter.py

@@ -1,7 +1,5 @@
 import numpy as np
 import matplotlib.pyplot as plt
-import sys
-import cv2
 from matplotlib.ticker import MultipleLocator
 import os
 

CPR_Module/Emergency_Mode/main.py

@@ -1,9 +1,8 @@
-# main.py
 import cv2
 import time
 import math
 import numpy as np
-import os  # Added for path handling
+import os 
 import sys
 
 from CPR_Module.Emergency_Mode.pose_estimation import PoseEstimator
@@ -698,51 +697,3 @@ class CPRAnalyzer:
         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()

CPR_Module/Emergency_Mode/metrics_calculator.py

@@ -1,10 +1,6 @@
-# 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 CPR_Module.Common.logging_config import cpr_logger
 
@@ -85,11 +81,13 @@ class MetricsCalculator:
                 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)
+                return np.array([])  # Return empty array to indicate failure
+
+            return y_exact  # Return the exact y-values if validation passes
 
         except Exception as e:
             cpr_logger.error(f"\nCRITICAL VALIDATION ERROR: {str(e)}")
-            sys.exit(1)
+            return np.array([])  # Return empty array to indicate failure
 
 #^ ################# Preprocessing #######################
 
@@ -454,23 +452,3 @@ class MetricsCalculator:
         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

CPR_Module/Emergency_Mode/pose_estimation.py

@@ -1,9 +1,5 @@
-# pose_estimation.py
-import cv2
-import numpy as np
 from ultralytics import YOLO
 
-from CPR_Module.Common.keypoints import CocoKeypoints
 from CPR_Module.Common.logging_config import cpr_logger
 
 class PoseEstimator:

README.md

@@ -1,5 +1,3 @@
-![Alt text](ReamdMeAssets/El7a2ny.png)
-
 Ever wondered what you'd do if someone **collapsed** in front of you?<br>
 El7a2ny is a mobile app that trains you to handle medical emergencies and guides you step-by-step as they happen.<br>
 No medical degree needed — just follow the app, stay calm, and become the hero someone desperately needs.<br>