CPR Code Refactor

.gitignore

@@ -1,5 +1,6 @@
 __pycache__/*
 venv/*
+backendEnv/*
 uploads/*
 runs/*
 screenshots/*

CPR/client.py

@@ -1,34 +0,0 @@
-import socket
-import json
-
-from CPR.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...")

CPR/posture_analyzer.py

@@ -1,132 +0,0 @@
-# posture_analyzer.py
-import math
-import cv2
-import numpy as np
-from CPR.keypoints import CocoKeypoints
-from CPR.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

CPR/shoulders_analyzer.py

@@ -1,30 +0,0 @@
-import numpy as np
-from CPR.keypoints import CocoKeypoints
-from CPR.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 = []

CPR/threaded_camera.py

@@ -1,103 +0,0 @@
-import threading
-from queue import Queue
-import queue
-import cv2
-from CPR.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/analysis_socket_server.py

@@ -1,65 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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/keypoints.py

@@ -1,22 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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/role_classifier.py

@@ -1,178 +0,0 @@
-# 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/warnings_overlayer.py

@@ -1,147 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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 = []

CPRRealTime/yolo11n-pose.pt

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

{CPR → CPR_Module/Common}/analysis_socket_server.py

@@ -3,9 +3,10 @@ import json
 from threading import Thread
 from queue import Queue
 import threading
-from CPR.logging_config import cpr_logger
 import queue
 
+from CPR_Module.Common.logging_config import cpr_logger
+
 class AnalysisSocketServer:
     def __init__(self, host='localhost', port=5000):
         self.host = host

{CPR → CPR_Module/Common}/chest_initializer.py

@@ -1,7 +1,8 @@
 import cv2
 import numpy as np
-from CPR.keypoints import CocoKeypoints
-from CPR.logging_config import cpr_logger
+
+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."""

{CPRRealTime → CPR_Module/Common}/posture_analyzer.py

@@ -2,8 +2,9 @@
 import math
 import cv2
 import numpy as np
-from CPRRealTime.keypoints import CocoKeypoints
-from CPRRealTime.logging_config import cpr_logger
+
+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"""

{CPR → CPR_Module/Common}/role_classifier.py

@@ -1,9 +1,9 @@
 # role_classifier.py
 import cv2
 import numpy as np
-from ultralytics.utils.plotting import Annotator  # Import YOLO's annotator
-from CPR.logging_config import cpr_logger
+from ultralytics.utils.plotting import Annotator
 
+from CPR_Module.Common.logging_config import cpr_logger
 
 class RoleClassifier:
     """Role classification and tracking using image processing"""

{CPRRealTime → CPR_Module/Common}/shoulders_analyzer.py

@@ -1,6 +1,7 @@
 import numpy as np
-from CPRRealTime.keypoints import CocoKeypoints
-from CPRRealTime.logging_config import cpr_logger
+
+from CPR_Module.Common.keypoints import CocoKeypoints
+from CPR_Module.Common.logging_config import cpr_logger
 
 class ShouldersAnalyzer:
     """Analyzes shoulder distances and posture"""

{CPRRealTime → CPR_Module/Common}/threaded_camera.py

@@ -2,7 +2,8 @@ import threading
 from queue import Queue
 import queue
 import cv2
-from CPRRealTime.logging_config import cpr_logger
+
+from CPR_Module.Common.logging_config import cpr_logger
 
 class ThreadedCamera:
     def __init__(self, source, requested_fps = 30):

{CPR → CPR_Module/Common}/warnings_overlayer.py

@@ -3,7 +3,7 @@ import numpy as np
 import os
 import sys
 
-from CPR.logging_config import cpr_logger
+from CPR_Module.Common.logging_config import cpr_logger
 
 class WarningsOverlayer:
     def __init__(self):

{CPR → CPR_Module/Common}/wrists_midpoint_analyzer.py

@@ -1,7 +1,8 @@
 import cv2
 import numpy as np
-from CPR.keypoints import CocoKeypoints
-from CPR.logging_config import cpr_logger
+
+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"""

{CPR → CPR_Module/Educational_Mode}/CPRAnalyzer.py

@@ -3,20 +3,21 @@ import cv2
 import time
 import math
 import numpy as np
-import os  # Added for path handling
+import os 
 import sys
 
-from CPR.pose_estimation import PoseEstimator
-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
-from CPR.graph_plotter import GraphPlotter
-from CPR.warnings_overlayer import WarningsOverlayer
-
-from CPR.logging_config import cpr_logger
+from CPR_Module.Educational_Mode.pose_estimation import PoseEstimator
+from CPR_Module.Educational_Mode.metrics_calculator import MetricsCalculator
+from CPR_Module.Educational_Mode.graph_plotter import GraphPlotter
+
+from CPR_Module.Common.role_classifier import RoleClassifier
+from CPR_Module.Common.chest_initializer import ChestInitializer
+from CPR_Module.Common.posture_analyzer import PostureAnalyzer
+from CPR_Module.Common.wrists_midpoint_analyzer import WristsMidpointAnalyzer
+from CPR_Module.Common.shoulders_analyzer import ShouldersAnalyzer
+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"""

{CPR → CPR_Module/Educational_Mode}/graph_plotter.py

@@ -2,10 +2,11 @@ import numpy as np
 import matplotlib.pyplot as plt
 import sys
 import cv2
-from CPR.logging_config import cpr_logger
-from matplotlib.ticker import MultipleLocator
+from CPR_Module.Common.logging_config import cpr_logger
 import os
 
+from matplotlib.ticker import MultipleLocator
+
 class GraphPlotter:
     """Class to plot graphs for various metrics"""
    

{CPR → CPR_Module/Educational_Mode}/metrics_calculator.py

@@ -5,7 +5,8 @@ import matplotlib.pyplot as plt
 import sys
 import cv2
 import os
-from CPR.logging_config import cpr_logger
+
+from CPR_Module.Common.logging_config import cpr_logger
 
 class MetricsCalculator:
     """Rate and depth calculation from motion data with improved peak detection"""

{CPR → CPR_Module/Educational_Mode}/pose_estimation.py

@@ -2,13 +2,14 @@
 import cv2
 import numpy as np
 from ultralytics import YOLO
-from CPR.keypoints import CocoKeypoints
-from CPR.logging_config import cpr_logger
+
+from CPR_Module.Common.keypoints import CocoKeypoints
+from CPR_Module.Common.logging_config import cpr_logger
 
 class PoseEstimator:
     """Human pose estimation using YOLO"""
     
-    def __init__(self, model_path="yolo11n-pose.pt", min_confidence=0.2):
+    def __init__(self, model_path="CPR_Module\Common\yolo11n-pose.pt", min_confidence=0.2):
         self.model = YOLO(model_path)
         self.min_confidence = min_confidence
 

{CPRRealTime → CPR_Module/Emergency_Mode}/graph_plotter.py

@@ -2,10 +2,11 @@ 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
 
+from CPR_Module.Common.logging_config import cpr_logger
+
 class GraphPlotter:
     """Class to plot graphs for various metrics"""
    

{CPRRealTime → CPR_Module/Emergency_Mode}/main.py

@@ -6,18 +6,19 @@ 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
+from CPR_Module.Emergency_Mode.pose_estimation import PoseEstimator
+from CPR_Module.Emergency_Mode.metrics_calculator import MetricsCalculator
+from CPR_Module.Emergency_Mode.graph_plotter import GraphPlotter
+
+from CPR_Module.Common.role_classifier import RoleClassifier
+from CPR_Module.Common.chest_initializer import ChestInitializer
+from CPR_Module.Common.posture_analyzer import PostureAnalyzer
+from CPR_Module.Common.wrists_midpoint_analyzer import WristsMidpointAnalyzer
+from CPR_Module.Common.shoulders_analyzer import ShouldersAnalyzer
+from CPR_Module.Common.warnings_overlayer import WarningsOverlayer
+from CPR_Module.Common.threaded_camera import ThreadedCamera
+from CPR_Module.Common.analysis_socket_server import AnalysisSocketServer
+from CPR_Module.Common.logging_config import cpr_logger
 
 class CPRAnalyzer:
     """Main CPR analysis pipeline with execution tracing"""

{CPRRealTime → CPR_Module/Emergency_Mode}/metrics_calculator.py

@@ -5,7 +5,8 @@ import matplotlib.pyplot as plt
 import sys
 import cv2
 import os
-from CPRRealTime.logging_config import cpr_logger
+
+from CPR_Module.Common.logging_config import cpr_logger
 
 class MetricsCalculator:
     """Rate and depth calculation from motion data with improved peak detection"""

{CPRRealTime → CPR_Module/Emergency_Mode}/pose_estimation.py

@@ -2,20 +2,20 @@
 import cv2
 import numpy as np
 from ultralytics import YOLO
-from CPRRealTime.keypoints import CocoKeypoints
-from CPRRealTime.logging_config import cpr_logger
+
+from CPR_Module.Common.keypoints import CocoKeypoints
+from CPR_Module.Common.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("")
+    def __init__(self, min_confidence, model_path="CPR_Module\Common\yolo11n-pose.pt"):
         self.model = YOLO(model_path).to("cuda")
 
         if next(self.model.model.parameters()).is_cuda:
-            print("✅ YOLO model successfully loaded on CUDA (GPU).")
+            cpr_logger.info("YOLO model loaded on CUDA (GPU).")
         else:
-            print("❌ YOLO model is not on CUDA. Check your setup.")
+            cpr_logger.warning("YOLO model is not on CUDA. Check your setup.")
 
         self.min_confidence = min_confidence
 

Demo/demo.py

@@ -0,0 +1,75 @@
+import os
+import sys
+import time
+import argparse
+
+from CPR_Module.Common.logging_config import cpr_logger
+from CPR_Module.Educational_Mode.CPRAnalyzer import CPRAnalyzer
+
+cpr_logger.info("TEST LOG: Script started successfully")  
+
+def main(input_video, output_dir=None):
+    # Configuration
+    requested_fps = 30
+    base_dir = os.getcwd()
+    cpr_logger.info(f"[CONFIG] Base directory: {base_dir}")
+    
+    # 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
+    if output_dir:
+        os.makedirs(output_dir, exist_ok=True)
+        cpr_logger.info(f"[CONFIG] Output will be saved to: {output_dir}")
+    
+    # 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] Video input: {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)
+    
+    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_video()
+    finally:
+        cpr_logger.info(f"[MAIN] CPR Analysis Terminated")
+
+    
+if __name__ == "__main__":
+    cpr_logger.info("Starting CPR Analysis Tool")
+    parser = argparse.ArgumentParser(description="CPR Analysis Tool")
+
+    cpr_logger.info("Parsing command line arguments")
+    parser.add_argument(
+        "-i", "--input", 
+        required=True,
+        help="Path to input video file"
+    )
+    parser.add_argument(
+        "-o", "--output", 
+        default=None,
+        help="Optional output directory path"
+    )
+    args = parser.parse_args()
+    
+    cpr_logger.info(f"Input video: {args.input}")
+    cpr_logger.info(f"Output directory: {args.output if args.output else 'Not specified, using current directory'}")
+    
+    cpr_logger.info("Starting main function")
+    main(args.input, args.output)

README.md

@@ -1,40 +1,168 @@
-# El7a2ny Backend
-
-A mobile application built using Flutter. This README provides clear instructions for both developers and non-developers to run or test the app.
-
----
-
-## El7a2ny Overview
-
-El7a2ny is an emergency mobile app that tackeles real-life emergency situations and help its users tackle them in a user-friendly way.
-
-The app includes 3 main features:
-
- - ECG Analysis, export your apple smart watch ECG PDF analysis, import it into our mobile, do a checkup and diagnose your ECG analysis to ensure it is normal or has a kind of abnormalities, and will guide you to the correct procedures accordingly.
-
- - Skin burns, got a burn at your home from a stove or boiling water? take a picture and upload it to the app, we will segment the burn, and classify the degree and prompt you with the correct guidlines accordingly.
-
- - CPR analysis, with our educational CPR mode, you will be able to do CPR at your home or at centers, capture a video of yourself doing the CPR (Cardiopulmonary resuscitation), upload it to the application, wait for a full informative analysis of the results and how we detect your rate and depth of motion along with posture warnings. Also experience the real-time feature of CPR where you can use the application in case of emergencies, mount the mobile in a portatit mode, then start your live stream, and you are good to go.
-
----
-
-## Technical Setup
-
-This backend is built using FastAPI python framwork,it can be runned locally and it is also deployed on hugging face.
-
-
-# Instructions
-
-It is easier to access this backend through its deployed version on hugging face via docker through this base url for most of the applicaiton feature, this includes: SKin Burns, ECG Analysis and CPR Education Mode.
-
-"https://husseinhadidy-deploy-el7a2ny-application.hf.space"
-
-But running real-time mode of CPR can be tried locally for latency concerns, as hugging face is a free contianer that has low specs, so real-time and socket connection is not tested on the deployed instance.
-
-You can use the requirments.txt  to install the  requirments needed and run using (Python 3.10):
-
-```bash
-
-uvicorn app:app --host 0.0.0.0 --port 8000
-
-```
+![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>
+
+# 📝 Main Features
+
+## 🫀 ECG Analysis
+Export your Apple Watch ECG PDF analysis and import it directly into our mobile application. Our advanced diagnostic system performs comprehensive checkups to determine if your ECG readings are normal or show abnormalities. Based on the analysis results, you'll receive personalized guidance and recommendations for appropriate next steps.
+
+## 🔥 Burn Assessment
+Accidentally burned yourself on a stove or with boiling water? Simply take a photo and upload it to the app. Our intelligent image processing will:
+- Automatically segment and identify the burn area
+- Classify the burn degree (1st, 2nd, or 3rd degree)
+- Provide immediate care guidelines and treatment recommendations
+
+## 🚑 CPR Training & Analysis
+
+### Educational Mode
+Perfect your CPR technique at home or in training centers:
+- Record yourself performing CPR (Cardiopulmonary Resuscitation)
+- Upload the video for comprehensive analysis
+- Receive detailed feedback on compression rate, depth, and technique
+- Get posture corrections and improvement suggestions
+
+### Real-Time Emergency Mode
+For actual emergency situations:
+- Mount your phone in portrait mode
+- Start live CPR guidance with real-time feedback
+- Get instant coaching during critical moments
+- Ensure proper technique when every second counts
+
+# 🚀 Installation
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/El7a2ny-Graduation-Project/Backend.git
+   ```
+2. Navigate to the project directory:
+   ```bash
+   cd Backend
+   ```
+3. Create a virtual environment (optional but recommended):
+   ```bash
+   python 3.10 -m venv venv	
+   ```
+4. Activate the virtual environment:
+   - On Windows:
+	 ```bash
+	 venv\Scripts\activate
+	 ```
+   - On macOS/Linux:
+	 ```bash
+	 source venv/bin/activate
+	 ```
+5. Install the required packages:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+# Technical Setup
+
+## Framework
+This backend is built using the **FastAPI** Python framework and can be run both locally and accessed through our deployed instance on Hugging Face.
+
+## Deployment Options
+
+### 🌐 Production Deployment (Recommended)
+For most application features, we recommend using our deployed instance on Hugging Face:
+
+**Base URL:** `https://husseinhadidy-deploy-el7a2ny-application.hf.space`
+
+**Supported Features:**
+- Skin Burns Analysis
+- ECG Analysis  
+- CPR Education Mode
+
+### 🏠 Local Deployment
+For the **CPR Real-Time Mode**, local deployment is recommended due to latency requirements. The Hugging Face free container has limited specifications that may not provide optimal performance for real-time socket connections.
+
+3. **Run the Application**
+   ```bash
+   uvicorn app:app --host 0.0.0.0 --port 8000
+   ```
+
+2. **Access the API**
+   - Local URL: `http://localhost:8000`
+   - API Documentation: `http://localhost:8000/docs`
+
+# 🐞 Bugs, Suggestions or Questions
+Please be welcome to submit an issue.
+
+# 🎥 Run Demo
+## CPR Module
+1. Navigate to the project directory:
+   ```bash
+   cd Backend
+   ```
+2. Run the test demo for the CPR's educational mode:
+   ```bash
+   python -m Demo.demo -i "path_to_your_video.mp4" -o "path_to_output_directory"
+   ```
+   For example:
+   ```bash
+    python -m Demo.demo -i "Demo/Dataset/02.mp4" -o "Demo/Output"
+   ```
+
+# 👥 Collaborators
+<table>
+<tr>
+    <td align="center">
+        <a href="https://github.com/FatemaKotb">
+            <img src="https://avatars.githubusercontent.com/u/101884853?v=4" width="100;" alt="Fatema-Kotb"/>
+        </a>
+    </td>
+    <td align="center">
+        <a href="https://github.com/Hussein-Hadidy">
+            <img src="https://avatars.githubusercontent.com/u/111172851?v=4" width="100;" alt="Hussein-Hadidy"/>
+        </a>
+    </td>
+    <td align="center">
+        <a href="https://github.com/rana-abdalla1">
+            <img src="https://avatars.githubusercontent.com/u/111182872?v=4" width="100;" alt="Rana-Abdalla"/>
+        </a>
+    </td>
+    <td align="center">
+        <a href="https://github.com/Sherif-Hatem1">
+            <img src="https://avatars.githubusercontent.com/u/125387417?v=4" width="100;" alt="Sherif-Hatem"/>
+        </a>
+    </td>
+</tr>
+  <tr>
+    <td align="center">
+        <a href="https://github.com/FatemaKotb">
+            Fatema Kotb
+        </a>
+    </td>
+    <td align="center">
+        <a href="https://github.com/Hussein-Hadidy">
+            Hussein Hadidy
+        </a>
+    </td>
+    <td align="center">
+        <a href="https://github.com/rana-abdalla1">
+            Rana Abdalla
+        </a>
+    </td>
+    <td align="center">
+        <a href="https://github.com/Sherif-Hatem1">
+            Sherif Hatem
+        </a>
+    </td>
+</tr>
+    <tr>
+    <td align="center">
+        CPR Module Implementation
+    </td>
+    <td align="center">
+        CPR Module Testing & Application Development
+    </td>
+    <td align="center">
+        ECG Abalysis Module Implementation
+    </td>
+    <td align="center">
+       Skin Burns Module Implementation & Application Development
+    </td>
+</tr>
+</table>

app.py

@@ -23,24 +23,24 @@ from fastapi import WebSocket, WebSocketDisconnect
 import base64
 import cv2
 import time
-from CPR.CPRAnalyzer import CPRAnalyzer as OfflineAnalyzer
 import tempfile
 import matplotlib.pyplot as plt
 import json
 import asyncio
 import concurrent.futures
-from CPRRealTime.main import CPRAnalyzer as RealtimeAnalyzer
 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
 import re
 import signal
 
+from CPR_Module.Educational_Mode.CPRAnalyzer import CPRAnalyzer as OfflineAnalyzer
+from CPR_Module.Emergency_Mode.main import CPRAnalyzer as RealtimeAnalyzer
+from CPR_Module.Common.analysis_socket_server import AnalysisSocketServer  # adjust if needed
+from CPR_Module.Common.logging_config import cpr_logger
 
 app = FastAPI()