Modified education to eduacation-2

CPR/CPRAnalyzer.py

@@ -1,8 +1,10 @@
 # main.py
 import cv2
 import time
-import tkinter as tk  # For screen size detection
-from datetime import datetime
+import math
+import numpy as np
+import os  # Added for path handling
+import sys
 
 from CPR.pose_estimation import PoseEstimator
 from CPR.role_classifier import RoleClassifier
@@ -11,57 +13,67 @@ from CPR.metrics_calculator import MetricsCalculator
 from CPR.posture_analyzer import PostureAnalyzer
 from CPR.wrists_midpoint_analyzer import WristsMidpointAnalyzer
 from CPR.shoulders_analyzer import ShouldersAnalyzer
-import os
-import uuid  # For unique filenames
+from CPR.graph_plotter import GraphPlotter
+from CPR.warnings_overlayer import WarningsOverlayer
 
+from CPR.logging_config import cpr_logger
 
 class CPRAnalyzer:
     """Main CPR analysis pipeline with execution tracing"""
     
-    def __init__(self, video_path):
-        print(f"\n[INIT] Initializing CPR Analyzer for: {video_path}")
+    def __init__(self, input_video, video_output_path, plot_output_path, requested_fps):
+        
+        cpr_logger.info(f"[INIT] Initializing CPR Analyzer")
+
+        #& Frame counter
+        self.frame_counter = -1
+        cpr_logger.info(f"[INIT] Frame counter initialized")
+
+        self.processed_frame_counter = 0  # Track only processed frames
+        cpr_logger.info(f"[INIT] Processed frame counter initialized")
         
-        self.video_path = video_path
         #& Open video file
-        self.cap = cv2.VideoCapture(video_path)
+        self.cap = cv2.VideoCapture(input_video)
         if not self.cap.isOpened():
-            print("[ERROR] Failed to open video file")
+            cpr_logger.error(f"[ERROR] Failed to open video file: {input_video}")
             return
-        print("[INIT] Video file opened successfully")
+        cpr_logger.info(f"[INIT] Video file opened successfully")
 
         #& Get video properties
         self.frame_count = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
         self.fps = self.cap.get(cv2.CAP_PROP_FPS)
         print(f"[INIT] Video has {self.frame_count} frames at {self.fps:.2f} FPS")
 
-        #& Get screen dimensions
-        root = tk.Tk()
-        self.screen_width = root.winfo_screenwidth()
-        self.screen_height = root.winfo_screenheight()
-        root.destroy()
-        print(f"[INIT] Detected screen resolution: {self.screen_width}x{self.screen_height}")
+        #& Generate output path with MP4 extension
+        self.video_output_path = video_output_path
+        self.video_writer = None
+        self._writer_initialized = False
+        cpr_logger.info(f"[INIT] Output path: {self.video_output_path}")
+
+        #& For the graph plotter
+        self.plot_output_path = plot_output_path
         
         #& Initialize system components
         self.pose_estimator = PoseEstimator(min_confidence=0.5)
         self.role_classifier = RoleClassifier()
         self.chest_initializer = ChestInitializer()
-        self.metrics_calculator = MetricsCalculator(self.frame_count, shoulder_width_cm=45*0.65)
+        self.metrics_calculator = MetricsCalculator(shoulder_width_cm=45*0.65)
         
+        # Remeber the conditions if you need to adjust the thresholds
         # if avg_right > self.right_arm_angle_threshold: error
         # if avg_left < self.left_arm_angle_threshold: error
 
         self.posture_analyzer = PostureAnalyzer(right_arm_angle_threshold=220, left_arm_angle_threshold=160, wrist_distance_threshold=170, history_length_to_average=10)
         self.wrists_midpoint_analyzer = WristsMidpointAnalyzer()
         self.shoulders_analyzer = ShouldersAnalyzer()
-        print("[INIT] System components initialized")
-
-        self.collected_warnings = {}
-
+        self.graph_plotter = GraphPlotter()
+        self.warnings_overlayer = WarningsOverlayer()
+        cpr_logger.info("[INIT] System components initialized")
 
-        #& Configure display window
-        self.window_name = "CPR Analysis"
-        cv2.namedWindow(self.window_name, cv2.WINDOW_NORMAL)
-        print(f"[INIT] Window '{self.window_name}' created")
+        #& Warm up pose estimator with dummy data
+        dummy_frame = np.zeros((480, 640, 3), dtype=np.uint8)
+        self.pose_estimator.detect_poses(dummy_frame)  # Force model loading
+        cpr_logger.info("[INIT] Pose estimator warmed up with dummy data")
 
         #& Keep track of previous results for continuity
         self.prev_rescuer_processed_results = None
@@ -69,175 +81,397 @@ class CPRAnalyzer:
         self.prev_chest_params = None
         self.prev_midpoint = None
         self.prev_pose_results = None
-        print("[INIT] Previous results initialized")
+        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
+
+        # Derived frame counts 
+        self.sampling_interval_frames = int(round(self.fps * self.SAMPLING_INTERVAL))
+        self.error_threshold_frames = int(self.MIN_ERROR_DURATION / self.SAMPLING_INTERVAL)
+        self.reporting_interval_frames = int(self.REPORTING_INTERVAL / self.SAMPLING_INTERVAL)
+        self.return_rate_and_depth_warnings_interval_frames = int(self.KEEP_RATE_AND_DEPTH_WARNINGS_INTERVAL / self.SAMPLING_INTERVAL)
+        self.min_chunk_length_to_report_frames = int(self.MIN_CHUNK_LENGTH_TO_REPORT / self.SAMPLING_INTERVAL)
+
+        # For cleaner feedback, the reporting interval must be an exact multiple of the sampling interval.
+        ratio = self.REPORTING_INTERVAL / self.SAMPLING_INTERVAL
+        assert math.isclose(ratio, round(ratio)), \
+            f"Reporting interval ({self.REPORTING_INTERVAL}) must be an exact multiple of "\
+            f"sampling interval ({self.SAMPLING_INTERVAL}). Actual ratio: {ratio:.2f}"
+
+        # To be able to detect an error, the error detection window must be greater than or equal to the sampling interval.
+        assert self.MIN_ERROR_DURATION >= self.SAMPLING_INTERVAL, \
+            f"Error detection window ({self.MIN_ERROR_DURATION}s) must be ≥ sampling interval ({self.SAMPLING_INTERVAL}s)"
+
+        cpr_logger.info(f"[INIT] Temporal alignment:")
+        cpr_logger.info(f" - {self.SAMPLING_INTERVAL}s sampling → {self.sampling_interval_frames} frames")
+        cpr_logger.info(f" - {self.MIN_ERROR_DURATION}s error detection → {self.error_threshold_frames} samples")
+        cpr_logger.info(f" - {self.REPORTING_INTERVAL}s reporting → {self.reporting_interval_frames} samples")
 
         #& Workaround for minor glitches
-        self.consecutive_frames_with_posture_errors = 0
-        self.max_consecutive_frames_with_posture_errors = 10
+        # A frame is accepted as long as this counter does not exceed the error_threshold_frames set above.
+        #! These (and those in the warnings_overlayer) should exactly match the ones appended in the PostureAnalyzer.
+        self.possible_warnings = [
+            "Right arm bent!",
+            "Left arm bent!",
+            "Left hand not on chest!",
+            "Right hand not on chest!",
+            "Both hands not on chest!",
+        ]
+        self.consecutive_frames_with_posture_errors_counters = {warning: 0 for warning in self.possible_warnings}
 
         #& Initialize variables for reporting warnings
-        self.posture_errors_for_current_error_region = set()
 
-        #& Frequent depth and rate calculations
-        self.reporting_interval_in_seconds = 5
-        self.reporting_interval_in_frames = int(self.fps * self.reporting_interval_in_seconds)
-        print(f"[INIT] Reporting interval set to {self.reporting_interval_in_seconds} seconds ({self.reporting_interval_in_frames} frames)")
+        self.rate_and_depth_warnings_from_the_last_report = []
+        cpr_logger.info("[INIT] Rate and depth warnings from the last report initialized")
 
-    def run_analysis(self):
-        try:
-            print("\n[RUN ANALYSIS] Starting analysis")
+        #& Chunk and mini chunk management (Indexes and Flags) 
+        self.has_not_processed_a_frame_successfully_before = True
+        self.waiting_to_start_new_chunk = False
 
-            main_loop_start_time = time.time()
+        self.chunk_start_frame_index = None
+        self.chunk_end_frame_index = None
+
+        #& Posture warnings region management
+        self.prev_is_part_of_a_posture_warnings_region = False
+        self.posture_warnings_region_start_frame_index = None
+        self.posture_warnings_region_end_frame_index = None
+
+        self.posture_warnings = []
+        self.rate_and_depth_warnings = []
+
+        #& For Formated Warnings
+        self.cached_posture_warnings = []
+        self.cached_rate_and_depth_warnings = []
+        self.return_rate_and_depth_warnings_interval_frames_counter = self.return_rate_and_depth_warnings_interval_frames
+        cpr_logger.info("[INIT] Formatted warnings initialized")
 
-            #& Initialize Variables
-            # Handling chunks
-            first_time_to_have_a_proccessed_frame = True
-            waiting_to_start_new_chunk = False
-            # Hndling mini chunks
-            mini_chunk_start_frame_index = None
+    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")
 
-            print("[RUN ANALYSIS] Starting main execution loop")
             #& Main execution loop
+            main_loop_start_time = time.time()
+            cpr_logger.info("[RUN ANALYSIS] Main loop started")
             while self.cap.isOpened():
-                #& Get frame number
-                # Retrieve the current position of the video frame being processed in the video capture object (self.cap).
-                frame_counter = self.cap.get(cv2.CAP_PROP_POS_FRAMES)
-                print(f"\n[FRAME {int(frame_counter)}/{self.frame_count}]")
+                #& Always advance to next frame first
+                ret = self.cap.grab()  # Faster than read() for skipping
+                if not ret: break
+             
+                #& Increment frame counter
+                self.frame_counter += 1
+
+                cpr_logger.info(f"\n[FRAME {int(self.frame_counter)}]")
                 
-                #& Read frame
-                ret, frame = self.cap.read()
-                if not ret:
-                    print("[ERROR] Failed to read frame or end of video reached")
-                    break
-                print(f"[RUN ANALYSIS] Read frame")
+                #& Check if you want to skip the frame
+                if self.frame_counter % self.sampling_interval_frames != 0:                      
+                    cpr_logger.info(f"[SKIP FRAME] Skipping frame") 
+                    continue
+
+                #& Retrieve and process frame
+                _, frame = self.cap.retrieve()
+                cpr_logger.info(f"[RUN ANALYSIS] Retrieved frame")
                 
+                #& Check for termination sentinel
+                if frame is None:
+                    cpr_logger.info("Camera stream ended")
+                    
+                    # Handle any open regions before breaking
+                    if self.prev_is_part_of_a_posture_warnings_region:
+                        # End the posture warnings region
+                        self.posture_warnings_region_end_frame_index = self.frame_counter
+                        cpr_logger.info(f"[RUN ANALYSIS] End of posture warnings region detected")
+                        self._handle_posture_warnings_region_end()
+                    
+                    elif self.chunk_start_frame_index is not None:
+                        # End the current chunk
+                        self.chunk_end_frame_index = self.frame_counter
+                        cpr_logger.info(f"[RUN ANALYSIS] End of chunk detected")
+                        self._handle_chunk_end()
+                    break
+
                 #& Rotate frame
                 frame = self._handle_frame_rotation(frame)
-                print(f"[RUN ANALYSIS] Rotated frame")
+                cpr_logger.info(f"[RUN ANALYSIS] Rotated frame")
 
                 #& Process frame
-                # Processing a frame means updating the values for the current and previous detections both in the CPR Analyzer and the system components it includes.
-                # The returned flags are:
-                # - is_complete_chunk: True if a "Posture Error" occurs in the frame, False otherwise.
-                # - accept_frame: True if the frame is accepted for further processing, False otherwise.
-                # Not that a frame containing an error could be accepted if the number of consecutive frames with errors is less than the threshold.
-                is_complete_chunk, accept_frame = self._process_frame(frame)
-                print(f"[RUN ANALYSIS] Processed frame")
+                # If there are (sustained) posture warnings, then we did not even attempt to detect the midpoint.
+                # If there were no (sustained) posture warnings, we attempt to detect the midpoint which might either succeed or fail.
+                # This is why we need two variables to indicated what happened inside the process_frame function.
+                posture_warnings, has_appended_midpoint = self._process_frame(frame)
+                cpr_logger.info(f"[RUN ANALYSIS] Processed frame")
+
+                #& Posture Warnings Region Setting Flags
+                # When a frame is accepted, its warnings -if any- are reset.
+                # So if the function did return any errors this means that the frame is not accepted and is part of an posture warnings region.
+                is_part_of_a_posture_warnings_region = len(posture_warnings) > 0
+
+                # Then we need to decide if the frame marks a transition between a chunk region and an posture warnings region.
+                is_start_of_posture_warnings_region = (not self.prev_is_part_of_a_posture_warnings_region) and is_part_of_a_posture_warnings_region
+                is_end_of_posture_warnings_region = self.prev_is_part_of_a_posture_warnings_region and not is_part_of_a_posture_warnings_region
+                
+                # Update the cached value for the next iteration
+                self.prev_is_part_of_a_posture_warnings_region = is_part_of_a_posture_warnings_region
+                cpr_logger.info(f"[RUN ANALYSIS] Posture warnings region flags updated")
+
+                #& Chunks and Posture Warnings Regions Management
+                #~ Case 1: posture warnings region after a chunk
+                if is_start_of_posture_warnings_region:
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 1: posture warnings region after a chunk")
+
+                    # Start a new posture warnings region
+                    self._start_new_posture_warnings_region()
+
+                    # End the previous chunk if it exists
+                    if self.chunk_start_frame_index is not None:
+                        self.chunk_end_frame_index = self.frame_counter - 1
+                        cpr_logger.info(f"[RUN ANALYSIS] End of chunk detected")
+                        self._handle_chunk_end()
+
+                #~ Case 2: posture warnings region after a posture warnings region
+                if (self.cached_posture_warnings != posture_warnings) and (is_part_of_a_posture_warnings_region) and (not is_start_of_posture_warnings_region) and (not is_end_of_posture_warnings_region):
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 2: posture warnings region after a posture warnings region")
+
+                    # End the previous posture warnings region
+                    self.posture_warnings_region_end_frame_index = self.frame_counter - 1
+                    cpr_logger.info(f"[RUN ANALYSIS] End of posture warnings region detected")
+                    self._handle_posture_warnings_region_end()
+
+                    # Start a new posture warnings region
+                    self._start_new_posture_warnings_region()
+                
+                #~ Case 3: chunk after a posture warnings region
+                if is_end_of_posture_warnings_region:
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 3: chunk after a posture warnings region")
+
+                    # Start a new chunk
+                    self.waiting_to_start_new_chunk = True
+                    cpr_logger.info(f"[RUN ANALYSIS] Waiting to start a new chunk")
+                    new_chunk_type = "chunk"
+
+                    # End the previous posture warnings region
+                    self.posture_warnings_region_end_frame_index = self.frame_counter - 1
+                    cpr_logger.info(f"[RUN ANALYSIS] End of posture warnings region detected")
+                    self._handle_posture_warnings_region_end()
+                
+                #~ Case 4: chunk after a chunk
+                if (not is_part_of_a_posture_warnings_region) and (not is_end_of_posture_warnings_region) and (self.processed_frame_counter % self.reporting_interval_frames == 0):    
+                    cpr_logger.info(f"[RUN ANALYSIS] Case 4: chunk after a chunk")
+
+                    # End the previous chunk if it exists
+                    if self.chunk_start_frame_index is not None and self.chunk_start_frame_index != self.frame_counter:
+                        self.chunk_end_frame_index = self.frame_counter
+                        cpr_logger.info(f"[RUN ANALYSIS] End of chunk detected")
+                        self._handle_chunk_end()
+
+                    # Start a new chunk
+                    self.waiting_to_start_new_chunk = True
+                    cpr_logger.info(f"[RUN ANALYSIS] Waiting to start a new chunk")
+
+                    new_chunk_type = "mini chunk"
                 
+                #~ Follow up on cases 3 and 4
+                if (self.waiting_to_start_new_chunk) and (has_appended_midpoint):
+                    cpr_logger.info(f"[RUN ANALYSIS] Follow up on cases 3 and 4")
+
+                    if (new_chunk_type == "chunk") or (new_chunk_type == "mini chunk" and (self.frame_counter != self.chunk_end_frame_index)):
+                        self._start_new_chunk()
+
                 #& Compose frame
-                # This function is responsible for drawing the data detected during the processing of the frame on it.
+                # This function is responsible for drawing the the chest region and the midpoint.
                 # The frame would not be displayed yet, just composed.
-                processed_frame = self._compose_frame(frame, accept_frame)
-                print(f"[RUN ANALYSIS] Composed frame")
-                
-                #& Set the chunk start frame index for the first chunk
-                # Along the video when a failure  in any step of the processing occurs, the variables are populated with the previous results to keep the analysis going.
-                # The problem occurs when the first few frames have a failure in the processing, and the variables are not populated yet.
-                # This is why the first chunk starts from the first frame that has been processed successfully.
-                if (processed_frame is not None) and first_time_to_have_a_proccessed_frame:
-                    first_time_to_have_a_proccessed_frame = False
-                    chunk_start_frame_index = frame_counter
-                    mini_chunk_start_frame_index = frame_counter
-                    print(f"[RUN ANALYSIS] First processed frame detected")
-
-                #& Set the chunk start frame index for the all chunks after the first one & append the errors detected in the error region before this chunk if any
-                # When a "Posture Error" occurs, a chunk is considered complete, and the program becomes ready to start a new chunk.
-                # is_complete_chunk is returned as true for every frame that has a "Posture Error" in it, and false for every other frame.
-                # This is why we need to wait for a frame with a false is_complete_chunk to start a new chunk.
-                if (waiting_to_start_new_chunk) and (not is_complete_chunk):
-                    waiting_to_start_new_chunk = False
-                    chunk_start_frame_index = frame_counter
-                    mini_chunk_start_frame_index = frame_counter
-                    print(f"[RUN ANALYSIS] A new chunk is starting")
-
-                    if len(self.posture_errors_for_current_error_region) > 0:
-                        self.posture_analyzer.posture_errors_for_all_error_region.append(self.posture_errors_for_current_error_region.copy())
-                        self.posture_errors_for_current_error_region.clear()
-                        print(f"[RUN ANALYSIS] Reset posture errors for current error region")
-
-                #& Process the current chunk or mini chunk if the conditions are met
-                process_chunk = (is_complete_chunk or frame_counter == self.frame_count - 1) and (not waiting_to_start_new_chunk)
-                process_mini_chunk = (frame_counter % self.reporting_interval_in_frames == 0) and (frame_counter != 0) and (mini_chunk_start_frame_index is not None) and (not is_complete_chunk)                     
-
-                if process_chunk: 
-                    print(f"[RUN ANALYSIS] Chunk completion detected")
-
-                    # The difference here results from the fact a first middle chunk is terminated by a "Posture Error" which is a frame not included in the chunk.
-                    # While the last chunk is terminated by the end of the video, which is a frame included in the chunk.
-                    if is_complete_chunk:
-                        chunk_end_frame_index = frame_counter - 1                
-                    elif frame_counter == self.frame_count - 1:
-                        chunk_end_frame_index = frame_counter
-                    print(f"[RUN ANALYSIS] Determined the last frame of the chunk")
-
-                    depth, rate = self._calculate_rate_and_depth_for_chunk(chunk_start_frame_index, chunk_end_frame_index)
-                    print(f"[RUN ANALYSIS] Calculated metrics for the chunk")
-
-                elif process_mini_chunk:
-                    print(f"[RUN ANALYSIS] Mini chunk completion detected")
-
-                    mini_chunk_end_frame_index = frame_counter
-                    print(f"[RUN ANALYSIS] Determined the last frame of the mini chunk")
-
-                    depth, rate = self._calculate_rate_and_depth_for_chunk(mini_chunk_start_frame_index, mini_chunk_end_frame_index)
-                    print(f"[RUN ANALYSIS] Calculated metrics for the mini chunk")                       
-                        
-                if process_chunk or process_mini_chunk:
-                    waiting_to_start_new_chunk = True
-
-                    self.shoulders_analyzer.reset_shoulder_distances()
-                    self.wrists_midpoint_analyzer.reset_midpoint_history()
-                    print(f"[RUN ANALYSIS] Reset shoulder distances and midpoint history")
-
-                #& Display frame
-                if processed_frame is not None:
-                    self._display_frame(processed_frame)
+                composed_frame = self._compose_frame(frame, is_part_of_a_posture_warnings_region)
+
+                if composed_frame is not None:
+                    frame = composed_frame
+                    cpr_logger.info(f"[RUN ANALYSIS] Frame composed successfully")
                 else:
-                    self._display_frame(frame)
-                print(f"[RUN ANALYSIS] Displayed frame")
-                                
+                    cpr_logger.info(f"[RUN ANALYSIS] Frame composition failed")
+
+                #& Initialize video writer if not done yet
+                if frame is not None and not self._writer_initialized:
+                    self._initialize_video_writer(frame)
+                    cpr_logger.info(f"[VIDEO WRITER] Initialized video writer")
+
+                #& Write frame if writer is functional
+                if self._writer_initialized:
+                    # Convert frame to BGR if needed
+                    if frame.dtype != np.uint8:
+                        frame = frame.astype(np.uint8)
+                    if len(frame.shape) == 2:  # Grayscale
+                        frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2BGR)
+                    
+                    try:
+                        self.video_writer.write(frame)
+                    except Exception as e:
+                        cpr_logger.error(f"[WRITE ERROR] {str(e)}")
+                        self._writer_initialized = False
+                
+                #& Update the cached posture warnings
+                # Don't update it before handling the four cases because the old cached warnings might be needed.
+                self.cached_posture_warnings = posture_warnings
+
+                #& Increment processed frame counter
+                self.processed_frame_counter += 1  # Increment here
+                cpr_logger.info(f"[RUN ANALYSIS] Processed frame counter incremented")
+
                 #& Check if the user wants to quit
-                if cv2.waitKey(1) == ord('q'):
-                    print("\n[RUN ANALYSIS] Analysis interrupted by user")
+                if cv2.waitKey(1) & 0xFF == ord('q'):
+                    cpr_logger.info("[RUN ANALYSIS] 'q' pressed, exiting loop.")
                     break
 
             main_loop_end_time = time.time()
             elapsed_time = main_loop_end_time - main_loop_start_time
-            print(f"[TIMING] Main loop elapsed time: {elapsed_time:.2f}s")
+            cpr_logger.info(f"[TIMING] Main loop elapsed time: {elapsed_time:.2f}s")
 
         except Exception as e:
-            print(f"[ERROR] An error occurred during main execution loop: {str(e)}")
+            cpr_logger.error(f"[ERROR] An error occurred during main execution loop: {str(e)}")
 
         finally:
             report_and_plot_start_time = time.time()
 
-            #& Cleanup, calculate averages, and plot full motion curve
             self.cap.release()
+            self.cap = None
+            
+            if self.video_writer is not None:
+                self.video_writer.release()
+                cpr_logger.info(f"[VIDEO WRITER] Released writer. File should be at: {os.path.abspath(self.video_output_path)}")
             cv2.destroyAllWindows()
-            print("[RUN ANALYSIS] Released video capture and destroyed all windows")         
+            cpr_logger.info("[RUN ANALYSIS] Released video capture and destroyed all windows")         
 
             self._calculate_rate_and_depth_for_all_chunks()
-            print("[RUN ANALYSIS] Calculated weighted averages of the metrics across all chunks")
+            cpr_logger.info("[RUN ANALYSIS] Calculated weighted averages of the metrics across all chunks")
+
+            self._plot_full_motion_curve_for_all_chunks()
+            cpr_logger.info("[RUN ANALYSIS] Plotted full motion curve")
+            
 
-            graphResults = self._plot_full_motion_curve_for_all_chunks()
-            print("[RUN ANALYSIS] Plotted full motion curve")
+            self.warnings_overlayer.add_warnings_to_processed_video(self.video_output_path, self.sampling_interval_frames, self.rate_and_depth_warnings, self.posture_warnings)
+            cpr_logger.info("[RUN ANALYSIS] Added warnings to processed video")
+
+            try:
+                if os.path.exists(self.video_output_path):
+                    os.remove(self.video_output_path)
+                    cpr_logger.info(f"[CLEANUP] Successfully deleted video file: {self.video_output_path}")
+                else:
+                    cpr_logger.warning(f"[CLEANUP] Video file not found at: {self.video_output_path}")
+            except Exception as e:
+                cpr_logger.error(f"[ERROR] Failed to delete video file: {str(e)}")
 
             report_and_plot_end_time = time.time()
             report_and_plot_elapsed_time = report_and_plot_end_time - report_and_plot_start_time
-            print(f"[TIMING] Report and plot elapsed time: {report_and_plot_elapsed_time:.2f}s")
-
-            return self.metrics_calculator.annotate_video_with_chunks(self.video_path, self.posture_analyzer.posture_errors_for_all_error_region), graphResults, self.get_posture_warning_results(), self.metrics_calculator.get_json_chunk_data()
+            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):
-        #! Till now, the code has only been testes on portrait videos.
         if frame.shape[1] > frame.shape[0]:  # Width > Height
             frame = cv2.rotate(frame, cv2.ROTATE_90_CLOCKWISE)
         return frame
 
     def _process_frame(self, frame):
+        #* Warnings for real time feedback
+        warnings = []
+
         #* Chunk Completion Check
-        is_complete_chunk = False
-        accept_frame = True
+        has_appended_midpoint = False
         
         #& Pose Estimation
         pose_results = self.pose_estimator.detect_poses(frame)
@@ -245,13 +479,13 @@ class CPRAnalyzer:
         #~ Handle Failed Detection or Update Previous Results
         if not pose_results:
             pose_results = self.prev_pose_results
-            print("[POSE ESTIMATION] No pose detected, using previous results (could be None)")
+            cpr_logger.info("[POSE ESTIMATION] No pose detected, using previous results (could be None)")
         else:
             self.prev_pose_results = pose_results
         
         if not pose_results:
-            print("[POSE ESTIMATION] Insufficient data for processing")
-            return is_complete_chunk, accept_frame
+            cpr_logger.info("[POSE ESTIMATION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
         
         #& Rescuer and Patient Classification
         rescuer_processed_results, patient_processed_results = self.role_classifier.classify_roles(pose_results, self.prev_rescuer_processed_results, self.prev_patient_processed_results)
@@ -259,24 +493,24 @@ class CPRAnalyzer:
         #~ Handle Failed Classifications OR Update Previous Results
         if not rescuer_processed_results:
             rescuer_processed_results = self.prev_rescuer_processed_results
-            print("[ROLE CLASSIFICATION] No rescuer detected, using previous results (could be None)")
+            cpr_logger.info("[ROLE CLASSIFICATION] No rescuer detected, using previous results (could be None)")
         else:
             self.prev_rescuer_processed_results = rescuer_processed_results
 
         if not patient_processed_results:
             patient_processed_results = self.prev_patient_processed_results
-            print("[ROLE CLASSIFICATION] No patient detected, using previous results (could be None)")
+            cpr_logger.info("[ROLE CLASSIFICATION] No patient detected, using previous results (could be None)")
         else:
             self.prev_patient_processed_results = patient_processed_results
         
         if not rescuer_processed_results or not patient_processed_results:
-            print("[ROLE CLASSIFICATION] Insufficient data for processing")
-            return is_complete_chunk, accept_frame
+            cpr_logger.info("[ROLE CLASSIFICATION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
              
         #^ Set Params in Role Classifier (to draw later)
         self.role_classifier.rescuer_processed_results = rescuer_processed_results
         self.role_classifier.patient_processed_results = patient_processed_results
-        print(f"[ROLE CLASSIFICATION] Updated role classifier with new results")
+        cpr_logger.info(f"[ROLE CLASSIFICATION] Updated role classifier with new results")
     
         #& Chest Estimation
         chest_params = self.chest_initializer.estimate_chest_region(patient_processed_results["keypoints"], patient_processed_results["bounding_box"], frame_width=frame.shape[1], frame_height=frame.shape[0])
@@ -284,13 +518,13 @@ class CPRAnalyzer:
         #~ Handle Failed Estimation or Update Previous Results
         if not chest_params:
             chest_params = self.prev_chest_params
-            print("[CHEST ESTIMATION] No chest region detected, using previous results (could be None)")
+            cpr_logger.info("[CHEST ESTIMATION] No chest region detected, using previous results (could be None)")
         else:
             self.prev_chest_params = chest_params
 
         if not chest_params:
-            print("[CHEST ESTIMATION] Insufficient data for processing")
-            return is_complete_chunk, accept_frame
+            cpr_logger.info("[CHEST ESTIMATION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
 
         #^ Set Params in Chest Initializer (to draw later)
         self.chest_initializer.chest_params = chest_params
@@ -307,39 +541,26 @@ class CPRAnalyzer:
             self.chest_initializer.expected_chest_params = expected_chest_params
 
         #& Posture Analysis
-        # The midpoind of the last frame
-        warnings = self.posture_analyzer.validate_posture(rescuer_processed_results["keypoints"], self.prev_midpoint, self.chest_initializer.expected_chest_params)
-        
-        ##############################################################
-        for warning in warnings:
-            if warning not in self.collected_warnings:
-                self.collected_warnings[warning] = []
-            if len(self.collected_warnings[warning]) < 2:
-                # Save the frame to disk or memory
-                filename = f"warning_{uuid.uuid4().hex}.jpg"
-                file_path = os.path.join("screenshots", filename)
-                os.makedirs("screenshots", exist_ok=True)
-                cv2.imwrite(file_path, frame)
-                self.collected_warnings[warning].append(file_path)
-                print(f"[CAPTURE] Saved warning screenshot: {file_path}")
-            
-        ##############################################################
-
-        if warnings:
-            print(f"[POSTURE ANALYSIS] Posture issues: {', '.join(warnings)}")
-            self.consecutive_frames_with_posture_errors += 1
-        else:
-            print("[POSTURE ANALYSIS] No posture issues detected")
-            self.consecutive_frames_with_posture_errors = 0
-        
-        accept_frame = self.consecutive_frames_with_posture_errors < self.max_consecutive_frames_with_posture_errors
-
-        if accept_frame:
-            warnings = []  # Reset warnings if the frame is accepted
+        cpr_logger.info(f"[POSTURE ANALYSIS] Analyzing posture")
+        current_warnings = self.posture_analyzer.validate_posture(rescuer_processed_results["keypoints"], self.chest_initializer.expected_chest_params)
+        cpr_logger.info(f"[POSTURE ANALYSIS] Posture analysis completed")
+
+        # Update individual warning counters
+        for warning in self.possible_warnings:
+            if warning in current_warnings:
+                self.consecutive_frames_with_posture_errors_counters[warning] += 1
+            else:
+                self.consecutive_frames_with_posture_errors_counters[warning] = 0
+
+        # Filter warnings that meet/exceed threshold
+        warnings = [
+            warning for warning in self.possible_warnings
+            if self.consecutive_frames_with_posture_errors_counters[warning] >= self.error_threshold_frames
+        ]
 
         #^ Set Params in Posture Analyzer (to draw later)
         self.posture_analyzer.warnings = warnings  
-        print(f"[POSTURE ANALYSIS] Updated posture analyzer with new results")
+        cpr_logger.info(f"[POSTURE ANALYSIS] Updated posture analyzer with new results")
 
         #& Wrist Midpoint Detection
         midpoint = self.wrists_midpoint_analyzer.detect_wrists_midpoint(rescuer_processed_results["keypoints"])
@@ -347,136 +568,117 @@ class CPRAnalyzer:
         #~ Handle Failed Detection or Update Previous Results
         if not midpoint:
             midpoint = self.prev_midpoint
-            print("[WRIST MIDPOINT DETECTION] No midpoint detected, using previous results (could be None)")
+            cpr_logger.info("[WRIST MIDPOINT DETECTION] No midpoint detected, using previous results (could be None)")
         else:
             self.prev_midpoint = midpoint
         
         if not midpoint:
-            print("[WRIST MIDPOINT DETECTION] Insufficient data for processing")
-            return is_complete_chunk, accept_frame
-
-        if accept_frame:
+            cpr_logger.info("[WRIST MIDPOINT DETECTION] Insufficient data for processing")
+            return warnings, has_appended_midpoint
+            
+        if len(warnings) == 0:
             #^ Set Params in Role Classifier (to draw later)
+            has_appended_midpoint = True
             self.wrists_midpoint_analyzer.midpoint = midpoint
             self.wrists_midpoint_analyzer.midpoint_history.append(midpoint)
-            print(f"[WRIST MIDPOINT DETECTION] Updated wrist midpoint analyzer with new results")
+            cpr_logger.info(f"[WRIST MIDPOINT DETECTION] Updated wrist midpoint analyzer with new results")
 
             #& Shoulder Distance Calculation
             shoulder_distance = self.shoulders_analyzer.calculate_shoulder_distance(rescuer_processed_results["keypoints"])
             if shoulder_distance is not None:
                 self.shoulders_analyzer.shoulder_distance = shoulder_distance
                 self.shoulders_analyzer.shoulder_distance_history.append(shoulder_distance)
-            print(f"[SHOULDER DISTANCE] Updated shoulder distance analyzer with new results")
-        else:
-            #* Chunk Completion Check
-            is_complete_chunk = True
-            num_warnings_before = len(self.posture_errors_for_current_error_region)
+            cpr_logger.info(f"[SHOULDER DISTANCE] Updated shoulder distance analyzer with new results")
 
-            for warning in warnings:
-                self.posture_errors_for_current_error_region.add(warning)
-                
-                num_warnings_after = len(self.posture_errors_for_current_error_region)
-                
-                if num_warnings_after > num_warnings_before:
-                    print(f"[POSTURE ANALYSIS] Added warning to current error region: {warning}") 
+        return warnings, has_appended_midpoint
     
-        return is_complete_chunk, accept_frame
-    
-    def _compose_frame(self, frame, accept_frame):
+    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)
-            print(f"[VISUALIZATION] Drawn chest region")
-
-        # Warning Messages
-        if frame is not None:
-            frame = self.posture_analyzer.display_warnings(frame)
-            print(f"[VISUALIZATION] Drawn warnings")
+            cpr_logger.info(f"[VISUALIZATION] Drawn chest region")
         
         if frame is not None:
-            if accept_frame:
-                # Midpoint
+            if not is_part_of_a_posture_warnings_region:
                 frame = self.wrists_midpoint_analyzer.draw_midpoint(frame)   
-                print(f"[VISUALIZATION] Drawn midpoint")  
-        
+                cpr_logger.info(f"[VISUALIZATION] Drawn midpoint")  
+    
         return frame
 
-    def _display_frame(self, frame):        
-        # Get original frame dimensions
-        h, w = frame.shape[:2]
-        if w == 0 or h == 0:
-            return
-
-        # Calculate maximum possible scale while maintaining aspect ratio
-        scale_w = self.screen_width / w
-        scale_h = self.screen_height / h
-        scale = min(scale_w, scale_h) * 0.9  # 90% of max to leave some margin
-
-        # Calculate new dimensions
-        new_w = int(w * scale)
-        new_h = int(h * scale)
-
-        # Resize and display
-        resized = cv2.resize(frame, (new_w, new_h), interpolation=cv2.INTER_AREA)
-        
-        # Center window
-        pos_x = (self.screen_width - new_w) // 2
-        pos_y = (self.screen_height - new_h) // 2
-        cv2.moveWindow(self.window_name, pos_x, pos_y)
-        
-        cv2.imshow(self.window_name, resized)
-        print(f"[DISPLAY FRAME] Resized to {new_w}x{new_h} (scale: {scale:.2f})")
-
-    def _calculate_rate_and_depth_for_chunk(self, chunk_start_frame_index, chunk_end_frame_index):
+    def _calculate_rate_and_depth_for_chunk(self):
         try:
-            self.metrics_calculator.smooth_midpoints(self.wrists_midpoint_analyzer.midpoint_history)
-            print("[METRICS] Smoothed midpoints")
-            
-            self.metrics_calculator.detect_peaks()
-            print("[METRICS] Detected peaks")
-            
-            depth, rate = self.metrics_calculator.calculate_metrics(
-                self.shoulders_analyzer.shoulder_distance_history,
-                self.cap.get(cv2.CAP_PROP_FPS),
-                chunk_start_frame_index, 
-                chunk_end_frame_index)
-            print("[METRICS] Calculated metrics")
-
-            if depth is None or rate is None:
-                print("[ERROR] Depth or rate calculation failed, likely due to insufficient data points (<2 peaks)")
-            
-            return depth, rate
+            result = self.metrics_calculator.handle_chunk(np.array(self.wrists_midpoint_analyzer.midpoint_history), self.chunk_start_frame_index, self.chunk_end_frame_index, self.fps, np.array(self.shoulders_analyzer.shoulder_distance_history), self.sampling_interval_frames)
+
+            if result == False:
+                cpr_logger.info("[ERROR] Failed to calculate metrics for the chunk")
+                return
             
         except Exception as e:
-            print(f"[ERROR] Metric calculation failed: {str(e)}")
+            cpr_logger.error(f"[ERROR] Metric calculation failed: {str(e)}")
 
     def _calculate_rate_and_depth_for_all_chunks(self):
         try:
-            self.metrics_calculator.calculate_weighted_averages()
-            print(f"[METRICS] Weighted averages calculated")
+            self.metrics_calculator.calculate_rate_and_depth_for_all_chunk()
+            cpr_logger.info(f"[METRICS] Weighted averages calculated")
         except Exception as e:
-            print(f"[ERROR] Failed to calculate weighted averages: {str(e)}")
+            cpr_logger.error(f"[ERROR] Failed to calculate weighted averages: {str(e)}")
             
     def _plot_full_motion_curve_for_all_chunks(self):
         try:
-            print("[PLOT] Full motion curve plotted")
-            return self.metrics_calculator.plot_motion_curve_for_all_chunks(self.posture_analyzer.posture_errors_for_all_error_region)
+            self.graph_plotter.plot_motion_curve_for_all_chunks(self.metrics_calculator.chunks_y_preprocessed, 
+                                                  self.metrics_calculator.chunks_peaks, 
+                                                  self.metrics_calculator.chunks_depth, 
+                                                  self.metrics_calculator.chunks_rate, 
+                                                  self.metrics_calculator.chunks_start_and_end_indices, 
+                                                  self.posture_warnings, 
+                                                  self.sampling_interval_frames,
+                                                  self.fps,
+                                                  self.plot_output_path)
+            cpr_logger.info("[PLOT] Full motion curve plotted")
         except Exception as e:
-            print(f"[ERROR] Failed to plot full motion curve: {str(e)}")
+            cpr_logger.error(f"[ERROR] Failed to plot full motion curve: {str(e)}")
+  
+    def _get_rate_and_depth_warnings(self):
+        rate_and_depth_warnings = self.metrics_calculator.get_rate_and_depth_warnings()
+        cpr_logger.info(f"[VISUALIZATION] Rate and depth warnings data: {rate_and_depth_warnings}")
+
+        return rate_and_depth_warnings
+
+if __name__ == "__main__":
+    cpr_logger.info(f"[MAIN] CPR Analysis Started")
     
+    # Configuration
+    requested_fps = 30
+    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)
     
-    def get_posture_warning_results(self):
-            """Return a list of posture warning entries with image URLs and descriptions"""
-            result = []
-             
-            for description, paths in self.collected_warnings.items():
-                for path in paths:
-                    # You might want to convert local paths to URLs if you're serving them via FastAPI
-                    if (len(self.posture_analyzer.posture_errors_for_all_error_region) > 0):
-                        # If the error region is not empty, append the image URL and description
-                        result.append({
-                            "image_url": f"{os.path.basename(path)}",  # Adjust if hosted elsewhere
-                            "description": description
-                        })
-                    
-            return result
+    output_dir = r"D:\CPR_education\CPR\End to End\Code Refactor\Output"
+
+    # 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")

CPR/analysis_socket_server.py

@@ -0,0 +1,65 @@
+import socket
+import json
+from threading import Thread
+from queue import Queue
+import threading
+from CPR.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")

CPR/chest_initializer.py

@@ -1,6 +1,7 @@
 import cv2
 import numpy as np
 from CPR.keypoints import CocoKeypoints
+from CPR.logging_config import cpr_logger
 
 class ChestInitializer:
     """Handles chest point detection with validations in estimation."""
@@ -25,10 +26,20 @@ class ChestInitializer:
             shoulder_center = np.array([(left_shoulder[0] + right_shoulder[0]) / 2,
                                         (left_shoulder[1] + right_shoulder[1]) / 2])
             
-            # Calculate chest center by applying directional adjustment separately for x and y
-            chest_center_from_shoulder_x = shoulder_center[0] - 0.3 * bbox_delta_y
-            chest_center_from_shoulder_y = shoulder_center[1] - 0.1 * bbox_delta_y
-            chest_center_from_shoulder = np.array([chest_center_from_shoulder_x, chest_center_from_shoulder_y])
+            #& 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
@@ -59,7 +70,7 @@ class ChestInitializer:
             return (cx, cy, cw, ch)
 
         except (IndexError, TypeError, ValueError) as e:
-            print(f"Chest estimation error: {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):
@@ -118,7 +129,7 @@ class ChestInitializer:
             )
             
         except Exception as e:
-            print(f"Chest region estimation error: {e}")
+            cpr_logger.error(f"Chest region estimation error: {e}")
             return None
     
     def draw_expected_chest_region(self, frame):

CPR/client.py

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

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

CPR/logging_config.py

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

CPR/metrics_calculator.py

@@ -4,230 +4,320 @@ from scipy.signal import savgol_filter, find_peaks
 import matplotlib.pyplot as plt
 import sys
 import cv2
-import cloudinary as cld
-import cloudinary.uploader
-import tempfile
-import json
 import os
+from CPR.logging_config import cpr_logger
 
 class MetricsCalculator:
     """Rate and depth calculation from motion data with improved peak detection"""
     
-    def __init__(self, frame_count, shoulder_width_cm):
+    def __init__(self, shoulder_width_cm):
+        # Configuration parameters
         self.shoulder_width_cm = shoulder_width_cm
+
+        # Parameters for cleaning the smoothed midpoints
+        self.removing_impulse_noise_window_size = 5
+        self.removing_impulse_noise_threshold = 3.0
+
+        # Parameters for one chunk
+        self.y_preprocessed = np.array([])
+
         self.peaks = np.array([])
         self.peaks_max = np.array([])
         self.peaks_min = np.array([])
-        self.y_smoothed = np.array([])
+                
         self.cm_px_ratio = None
-        self.midpoints_list = np.array([])
-        self.shoulder_distances = []
 
-        # Parameters for the final report
+        self.depth = None
+        self.rate = None
+
+        self.rate_and_depth_warnings = []
+        
+        # Parameters for all chunks
+        self.chunks_y_preprocessed = []
+
+        self.chunks_peaks = []
+
         self.chunks_depth = []
         self.chunks_rate = []
-        self.chunks_start_and_end_indices = []
 
-        self.chunks_midpoints = []
-        self.chunks_smoothed = []
-        self.chunks_peaks = []
+        self.weighted_depth = None
+        self.weighted_rate = None
 
-        self.frame_count = frame_count
+        self.chunks_start_and_end_indices = []
 
-        # Validation thresholds
-        self.depth = None
-        self.rate = None
+        self.chunks_rate_and_depth_warnings = []
 
+        # Parameters for validation
         self.min_depth_threshold = 3.0  # cm
         self.max_depth_threshold = 6.0  # cm
 
         self.min_rate_threshold = 100.0  # cpm
         self.max_rate_threshold = 120.0  # cpm
         
+#^ ################# Validating #######################
+
+    def validate_midpoints_and_frames_count_in_chunk(self, y_exact, chunk_start_frame_index, chunk_end_frame_index, sampling_interval_in_frames):
+        """
+        Validate the number of midpoints and frames in a chunk
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+            chunk_start_frame_index (int): The starting frame index of the chunk.
+            chunk_end_frame_index (int): The ending frame index of the chunk.
+            sampling_interval_in_frames (int): The interval at which frames are sampled.
+        
+        Raises:
+            ValueError: If the number of midpoints does not match the expected number for the given chunk.        
+        """
+        try:
+            # Calculate expected number of sampled frames
+            start = chunk_start_frame_index
+            end = chunk_end_frame_index
+            interval = sampling_interval_in_frames
+            
+            # Mathematical formula to count sampled frames
+            expected_samples = (end // interval) - ((start - 1) // interval)
+
+            # Validate
+            actual_y_exact_length = len(y_exact)
+            if actual_y_exact_length != expected_samples:
+                cpr_logger.info(f"\nERROR: Mismatch in expected and actual samples")
+                cpr_logger.info(f"Expected: {expected_samples} samples (frames {start}-{end} @ every {interval} frames)")
+                cpr_logger.info(f"Actual: {actual_y_exact_length} midoints points recieived")
+                sys.exit(1)
+
+        except Exception as e:
+            cpr_logger.error(f"\nCRITICAL VALIDATION ERROR: {str(e)}")
+            sys.exit(1)
+
+#^ ################# Preprocessing #######################
 
-    def smooth_midpoints(self, midpoints):
-        """Apply Savitzky-Golay filter to smooth motion data"""
-        self.midpoints_list = np.array(midpoints)
+    def _smooth_midpoints(self, midpoints):
+        """
+        Smooth the y-values of the midpoints using Savitzky-Golay filter
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+
+        Returns:
+            np.ndarray: The smoothed y-values.
+        """
         
-        if len(self.midpoints_list) > 5:  # Ensure enough data points
+        if len(midpoints) > 5:  # Ensure enough data points
             try:
-                self.y_smoothed = savgol_filter(
-                    self.midpoints_list[:, 1], 
-                    window_length=10, 
+                y_smooth = savgol_filter(
+                    midpoints[:, 1], 
+                    window_length=3, 
                     polyorder=2, 
                     mode='nearest'
                 )
-                return True
+                return y_smooth
             except Exception as e:
-                print(f"Smoothing error: {e}")
-                self.y_smoothed = self.midpoints_list[:, 1]  # Fallback to original
-                return False
+                cpr_logger.error(f"Smoothing error: {e}")
+                y_smooth = midpoints[:, 1]  # Fallback to original
+                return y_smooth
         else:
-            self.y_smoothed = self.midpoints_list[:, 1]  # Not enough points
-            return False
+            y_smooth = midpoints[:, 1]  # Not enough points
+            return y_smooth
+
+    def _clean_midpoints(self, y_smooth):
+        """
+        Clean the smoothed y-values to remove impulse noise using median filtering
 
-    def detect_peaks(self):
-        """Improved peak detection with adjusted prominence for min peaks"""
-        if self.y_smoothed.size == 0:
-            print("No smoothed values found for peak detection")
+        Args:
+            y_smooth (np.ndarray): The smoothed y-values.
+
+        Returns:
+            np.ndarray: The cleaned y-values.
+        """
+
+        if len(y_smooth) < self.removing_impulse_noise_window_size:
+            return y_smooth  # Not enough points for processing
+        
+        y_clean = np.array(y_smooth, dtype=float)  # Copy to avoid modifying original
+        half_window = self.removing_impulse_noise_window_size // 2
+        
+        for i in range(len(y_smooth)):
+            # Get local window (handle boundaries)
+            start = max(0, i - half_window)
+            end = min(len(y_smooth), i + half_window + 1)
+            window = y_smooth[start:end]
+            
+            # Calculate local median and MAD (robust statistics)
+            med = np.median(window)
+            mad = 1.4826 * np.median(np.abs(window - med))  # Median Absolute Deviation
+            
+            # Detect and replace outliers
+            if abs(y_smooth[i] - med) > self.removing_impulse_noise_threshold * mad:
+                # Replace with median of immediate neighbors (better than global median)
+                left = y_smooth[max(0, i-1)]
+                right = y_smooth[min(len(y_smooth)-1, i+1)]
+                y_clean[i] = np.median([left, right])
+        
+        return y_clean
+
+    def preprocess_midpoints(self, midpoints):
+        """
+        Preprocess the y-values of the midpoints by smoothing and cleaning
+
+        Sets:
+            y_preprocessed (np.ndarray): The preprocessed y-values.
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+        
+        Returns:
+            bool: True if preprocessing was successful, False otherwise.
+        """
+
+        y_smooth = self._smooth_midpoints(midpoints)
+        y_clean = self._clean_midpoints(y_smooth)
+
+        self.y_preprocessed = y_clean
+
+        return len(self.y_preprocessed) > 0  # Return True if preprocessing was successful
+
+#^ ################# Processing #######################
+
+    def detect_midpoints_peaks(self):
+        """
+        Detect peaks in the preprocessed y-values using dynamic distance
+        
+        Sets:
+            peaks (np.ndarray): The detected peaks.
+            peaks_max (np.ndarray): The detected max peaks.
+            peaks_min (np.ndarray): The detected min peaks.
+
+        Returns:
+            bool: True if peaks were detected, False otherwise.
+        """
+
+        if self.y_preprocessed.size == 0:
+            cpr_logger.info("No smoothed values found for peak detection")
             return False
             
         try:
-            distance = min(10, len(self.y_smoothed))  # Dynamic distance based on data length
+            distance = min(1, len(self.y_preprocessed))  # Dynamic distance based on data length
 
             # Detect max peaks with default prominence
-            self.peaks_max, _ = find_peaks(self.y_smoothed, distance=distance)
+            self.peaks_max, _ = find_peaks(self.y_preprocessed, distance=distance)
             
             # Detect min peaks with reduced or no prominence requirement
             self.peaks_min, _ = find_peaks(
-                -self.y_smoothed, 
+                -self.y_preprocessed, 
                 distance=distance, 
-                prominence=(0.3, None)  # Adjust based on your data's characteristics
+                prominence=(0.5, None)  # Adjust based on your data's characteristics
             )
             
             self.peaks = np.sort(np.concatenate((self.peaks_max, self.peaks_min)))
 
             return len(self.peaks) > 0
         except Exception as e:
-            print(f"Peak detection error: {e}")
+            cpr_logger.error(f"Peak detection error: {e}")
             return False
 
-    def _validate_chunk(self, chunk_start_frame_index, chunk_end_frame_index):
-        """Validate that the data length matches the expected frame range.
-        Terminates the program with error code 1 if validation fails.
-        
+    def calculate_cm_px_ratio(self, shoulder_distances):
+        """
+        Calculate the ratio of cm to pixels based on shoulder distances
+
+        Sets:
+            cm_px_ratio (float): The ratio of cm to pixels.
+
         Args:
-            chunk_start_frame_index: Start frame index of the chunk
-            chunk_end_frame_index: End frame index of the chunk
-            
-        Exits:
-            If validation fails, prints error message and exits with code 1
+            shoulder_distances (list): List of shoulder distances in pixels.
         """
-        try:
-            # Calculate expected number of frames
-            num_frames = chunk_end_frame_index - chunk_start_frame_index + 1
-            
-            # Validate midpoints data
-            if len(self.midpoints_list[:, 1]) != num_frames:
-                print(f"\nERROR: Data length mismatch in midpoints_list")
-                print(f"Expected: {num_frames} frames ({chunk_start_frame_index}-{chunk_end_frame_index})")
-                print(f"Actual: {len(self.midpoints_list[:, 1])} frames")
-                sys.exit(1)
-                
-            # Validate smoothed data
-            if len(self.y_smoothed) != num_frames:
-                print(f"\nERROR: Data length mismatch in y_smoothed")
-                print(f"Expected: {num_frames} frames ({chunk_start_frame_index}-{chunk_end_frame_index})")
-                print(f"Actual: {len(self.y_smoothed)} frames")
-                sys.exit(1)
-                
-        except Exception as e:
-            print(f"\nCRITICAL VALIDATION ERROR: {str(e)}")
-            sys.exit(1)
 
-    def calculate_metrics(self, shoulder_distances, fps, chunk_start_frame_index, chunk_end_frame_index):
-        """Calculate compression metrics with improved calculations"""        
+        if len(shoulder_distances) > 0:
+            avg_shoulder_width_px = np.mean(shoulder_distances)
+            self.cm_px_ratio = self.shoulder_width_cm / avg_shoulder_width_px
+        else:
+            self.cm_px_ratio = None
+            cpr_logger.info("No shoulder distances available for cm/px ratio calculation")
         
-        self._validate_chunk(chunk_start_frame_index, chunk_end_frame_index)
-                
-        self.shoulder_distances = shoulder_distances
+    def calculate_rate_and_depth_for_chunk(self, original_fps, sampling_interval_in_frames=1):
+        """
+        Calculate the rate and depth of the motion data for a chunk.
+
+        Sets:
+            depth (float): The calculated depth in cm.
+            rate (float): The calculated rate in cpm.
 
+        Args:
+            original_fps (float): The original frames per second of the video.
+            sampling_interval_in_frames (int): Number of frames skipped between samples.
+        """   
         try:
-            # Calculate pixel to cm ratio
-            if len(self.shoulder_distances) > 0:
-                avg_dist = np.mean(self.shoulder_distances)
-                self.cm_px_ratio = self.shoulder_width_cm / avg_dist
-            else:
-                print("No shoulder distances available")
-                return None, None
-
-            # Depth calculation using all peaks
+
+            # Without Adjustment: A peak distance of 5 (downsampled frames) would incorrectly be interpreted as 5/30 = 0.167 sec (too short).
+            # With Adjustment: The same peak distance 5 (downsampled frames) correctly represents 5/10 = 0.5 sec.
+
+            effective_fps = original_fps / sampling_interval_in_frames  # Correctly reduced FPS
+
+            # Depth calculation (unchanged)
             depth = None
             if len(self.peaks) > 1:
-                depth = np.mean(np.abs(np.diff(self.y_smoothed[self.peaks]))) * self.cm_px_ratio
+                depth = np.mean(np.abs(np.diff(self.y_preprocessed[self.peaks]))) * self.cm_px_ratio
 
-            # Rate calculation using only compression peaks (peaks_max)
+            # Rate calculation (now uses effective_fps)
             rate = None
             if len(self.peaks_max) > 1:
-                rate = 1 / (np.mean(np.diff(self.peaks_max)) / fps) * 60  # Convert to CPM
-
+                # Peak indices are from the downsampled signal, so we use effective_fps
+                peak_intervals = np.diff(self.peaks_max)  # Already in downsampled frames
+                rate = (1 / (np.mean(peak_intervals) / effective_fps)) * 60  # Correct CPM
+                
+            # Handle cases with no valid data
             if depth is None or rate is None:
                 depth = 0
                 rate = 0
-                self.peaks = np.array([])  # Reset peaks if no valid data
+                self.peaks = np.array([])
 
-            # Store the results of this chunk for the final report if they are not None
             self.depth = depth
             self.rate = rate
+        except Exception as e:
+            cpr_logger.error(f"Error calculating rate and depth: {e}")
+    
+    def assign_chunk_data(self, chunk_start_frame_index, chunk_end_frame_index):
+        """
+        Capture chunk data for later analysis
 
-            self.chunks_depth.append(depth)
-            self.chunks_rate.append(rate)
-            self.chunks_start_and_end_indices.append((chunk_start_frame_index, chunk_end_frame_index))
-
-            self.chunks_midpoints.append(self.midpoints_list.copy())
-            self.chunks_smoothed.append(self.y_smoothed.copy())
-            self.chunks_peaks.append(self.peaks.copy())      
-
+        Sets:
+            chunks_depth (list): List of depths for each chunk.
+            chunks_rate (list): List of rates for each chunk.
+            chunks_start_and_end_indices (list): List of start and end indices for each chunk.
+            chunks_y_preprocessed (list): List of preprocessed y-values for each chunk.
+            chunks_peaks (list): List of detected peaks for each chunk.
 
-            return depth, rate
-            
-        except Exception as e:
-            print(f"Metric calculation error: {e}")
-            return None, None
-
-    def plot_motion_curve(self, chunk_start_frame_index, chunk_end_frame_index):
-        """Enhanced visualization with original and smoothed data"""
-        if self.midpoints_list.size == 0:
-            print("No midpoint data to plot")
-            return
-        
-        self._validate_chunk(chunk_start_frame_index, chunk_end_frame_index)
+        Args:
+            chunk_start_frame_index (int): The starting frame index of the chunk.
+            chunk_end_frame_index (int): The ending frame index of the chunk.
+        """
+        self.chunks_depth.append(self.depth)
+        self.chunks_rate.append(self.rate)
+        self.chunks_start_and_end_indices.append((chunk_start_frame_index, chunk_end_frame_index))
 
-        # Create frame index array for x-axis
-        frame_indices = np.arange(chunk_start_frame_index, chunk_end_frame_index + 1)
+        self.chunks_y_preprocessed.append(self.y_preprocessed.copy())
+        self.chunks_peaks.append(self.peaks.copy())      
 
+        self.current_chunk_start = chunk_start_frame_index
+        self.current_chunk_end = chunk_end_frame_index
 
-        plt.figure(figsize=(12, 6))
+        self.chunks_rate_and_depth_warnings.append(self.rate_and_depth_warnings.copy())
         
-        # Plot original and smoothed data with correct frame indices
-        plt.plot(frame_indices, self.midpoints_list[:, 1], 
-                label="Original Motion", 
-                color="red", 
-                linestyle="dashed", 
-                alpha=0.6)
-    
-        plt.plot(frame_indices, self.y_smoothed, 
-                label="Smoothed Motion", 
-                color="blue", 
-                linewidth=2)
-
-        # Plot peaks if detected
-        if self.peaks.size > 0:
-            plt.plot(frame_indices[self.peaks], 
-                    self.y_smoothed[self.peaks], 
-                    "x", 
-                    color="green", 
-                    markersize=10, 
-                    label="Peaks")
-        else:
-            print("No peaks to plot")
-
-        plt.xlabel("Frame Number")
-        plt.ylabel("Vertical Position (px)")
-        plt.title("Compression Motion Analysis")
-        plt.grid(True)
-        plt.legend()
-        plt.show()
-    
-    def calculate_weighted_averages(self):
-        """Calculate weighted averages based on chunk durations
+    def calculate_rate_and_depth_for_all_chunk(self):
         """
+        Calculate the weighted average rate and depth for all chunks
+
+        Sets:
+            weighted_depth (float): The weighted average depth in cm.
+            weighted_rate (float): The weighted average rate in cpm.
+        """
+        
         if not self.chunks_depth or not self.chunks_rate or not self.chunks_start_and_end_indices:
-            print("[WARNING] No chunk data available for averaging")
+            cpr_logger.info("[WARNING] No chunk data available for averaging")
             return None
             
         if not (len(self.chunks_depth) == len(self.chunks_rate) == len(self.chunks_start_and_end_indices)):
-            print("[ERROR] Mismatched chunk data lists")
+            cpr_logger.info("[ERROR] Mismatched chunk data lists")
             return None
 
         total_weight = 0
@@ -246,306 +336,134 @@ class MetricsCalculator:
             total_weight += chunk_duration
 
         if total_weight == 0:
-            print("[ERROR] Total chunk durations is zero")
-            return None
+            self.weighted_depth = None
+            self.weighted_rate = None
 
-        weighted_depth = weighted_depth_sum / total_weight
-        weighted_rate = weighted_rate_sum / total_weight
-
-        print(f"[RESULTS] Weighted average depth: {weighted_depth:.1f} cm")
-        print(f"[RESULTS] Weighted average rate: {weighted_rate:.1f} cpm")
-        
-        return weighted_depth, weighted_rate
-
-    def plot_motion_curve_for_all_chunks(self, posture_errors_for_all_error_region):
-        """Plot combined analysis with metrics annotations and posture error labels"""
-        if not self.chunks_start_and_end_indices:
-            print("No chunk data available for plotting")
-            return
-
-        # Print chunk information before plotting
-        print("\n=== Chunk Ranges ===")
-        for i, (start_end, depth, rate) in enumerate(zip(self.chunks_start_and_end_indices, 
-                                                    self.chunks_depth, 
-                                                    self.chunks_rate)):
-            print(f"Chunk {i+1}: Frames {start_end[0]}-{start_end[1]} | "
-                f"Depth: {depth:.1f}cm | Rate: {rate:.1f}cpm")
-
-        plt.figure(figsize=(16, 8))
-        ax = plt.gca()
+            cpr_logger.info("[ERROR] No valid chunks for averaging")
+        else:
+            self.weighted_depth = weighted_depth_sum / total_weight
+            self.weighted_rate =  weighted_rate_sum / total_weight
         
-        # Sort chunks chronologically
-        sorted_chunks = sorted(zip(self.chunks_start_and_end_indices, 
-                        self.chunks_depth, 
-                        self.chunks_rate),
-                        key=lambda x: x[0][0])
+            cpr_logger.info(f"[RESULTS] Weighted average depth: {self.weighted_depth:.1f} cm")
+            cpr_logger.info(f"[RESULTS] Weighted average rate: {self.weighted_rate:.1f} cpm")
+
+#^ ################# Warnings #######################
+
+    def _get_rate_and_depth_status(self):
+        """Internal validation logic"""
+
+        depth_status = "normal"
+        rate_status  = "normal"
         
-        # 1. Plot all valid chunks with metrics
-        prev_chunk_end = None  # Track previous chunk's end position
-
-        for idx, ((start, end), depth, rate) in enumerate(sorted_chunks):
-            chunk_frames = np.arange(start, end + 1)
-            midpoints = self.chunks_midpoints[idx]
-            smoothed = self.chunks_smoothed[idx]
-            peaks = self.chunks_peaks[idx]
-            
-            # Add separator line between chunks
-            if prev_chunk_end is not None:
-                separator_x = prev_chunk_end + 0.5  # Midpoint between chunks
-                ax.axvline(x=separator_x, color='orange', linestyle=':', linewidth=1.5)
+        if self.depth < self.min_depth_threshold and self.depth > 0:
+            depth_status = "low"
+        elif self.depth > self.max_depth_threshold:
+            depth_status = "high"
             
-            # Plot data
-            ax.plot(chunk_frames, midpoints[:, 1], 
-                color="red", linestyle="dashed", alpha=0.6,
-                label="Original Motion" if idx == 0 else "")
-            ax.plot(chunk_frames, smoothed,
-                color="blue", linewidth=2,
-                label="Smoothed Motion" if idx == 0 else "")
+        if self.rate < self.min_rate_threshold and self.rate > 0:
+            rate_status = "low"
+        elif self.rate > self.max_rate_threshold:
+            rate_status = "high"
             
-            # Plot peaks
-            if peaks.size > 0:
-                ax.plot(chunk_frames[peaks], smoothed[peaks],
-                    "x", color="green", markersize=8,
-                    label="Peaks" if idx == 0 else "")
-
-            # Annotate chunk metrics
-            mid_frame = (start + end) // 2
-            ax.annotate(f"Depth: {depth:.1f}cm\nRate: {rate:.1f}cpm",
-                    xy=(mid_frame, np.max(smoothed)),
-                    xytext=(0, 10), textcoords='offset points',
-                    ha='center', va='bottom', fontsize=9,
-                    bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5))
-
-            # Update previous chunk end tracker
-            prev_chunk_end = end
-        # 2. Identify and label posture error regions
-        error_regions = []
-        
-        # Before first chunk
-        if sorted_chunks[0][0][0] > 0:
-            error_regions.append((0, sorted_chunks[0][0][0]-1))
-        
-        # Between chunks
-        for i in range(1, len(sorted_chunks)):
-            prev_end = sorted_chunks[i-1][0][1]
-            curr_start = sorted_chunks[i][0][0]
-            if curr_start - prev_end > 1:
-                error_regions.append((prev_end + 1, curr_start - 1))
-        
-        # After last chunk
-        last_end = sorted_chunks[-1][0][1]
-        if last_end < self.frame_count - 1:
-            error_regions.append((last_end + 1, self.frame_count - 1))
-
-        # Print error regions information
-        print("\n=== Error Regions ===")
-        for i, (start, end) in enumerate(error_regions):
-            # Get errors for this region if available
-            try:
-                errors = posture_errors_for_all_error_region[i]
-                error_str = ", ".join(errors) if errors else "No errors detected"
-            except IndexError:
-                error_str = "No error data"
-                
-            print(f"Error Region {i+1}: Frames {start}-{end} | Errors: {error_str}")
+        return depth_status, rate_status
 
-        # Shade and label error regions
-        for error_region_index, region in enumerate (error_regions):
-            ax.axvspan(region[0], region[1], 
-                    color='gray', alpha=0.2,
-                    label='Posture Errors' if region == error_regions[0] else "")
-            
-            # Add vertical dotted lines at boundaries
-            ax.axvline(x=region[0], color='black', linestyle=':', alpha=0.5)
-            ax.axvline(x=region[1], color='black', linestyle=':', alpha=0.5)
-            
-            # Add frame number labels - properly aligned
-            y_pos = ax.get_ylim()[0] + 0.02 * (ax.get_ylim()[1] - ax.get_ylim()[0])
-            
-            # Start frame label - right aligned before the line
-            ax.text(region[0] - 1, y_pos, 
-                f"Frame {region[0]}",
-                rotation=90, va='bottom', ha='right',
-                fontsize=8, alpha=0.7)
-            
-            # End frame label - left aligned after the line
-            ax.text(region[1] + 1, y_pos,
-                f"Frame {region[1]}",
-                rotation=90, va='bottom', ha='left',
-                fontsize=8, alpha=0.7)
-            
-            # Add error labels if available
-            if posture_errors_for_all_error_region:
-                try:
-                    # Get errors for this specific error region
-                    region_errors = posture_errors_for_all_error_region[error_region_index]
-                    
-                    # Format errors text
-                    error_text = "Errors:\n" + "\n".join(region_errors) if region_errors else ""
-                    
-                    # Position text in middle of the error region
-                    mid_frame = (region[0] + region[1]) // 2
-                    ax.text(mid_frame, np.mean(ax.get_ylim()), 
-                        error_text,
-                        ha='center', va='center', 
-                        fontsize=9, color='red', alpha=0.8,
-                        bbox=dict(boxstyle='round,pad=0.3', 
-                                fc='white', ec='red', alpha=0.7))               
-                except IndexError:
-                    print(f"No error data for region {error_region_index}")
-
-        # 3. Add weighted averages
-        if hasattr(self, 'weighted_depth') and hasattr(self, 'weighted_rate'):
-            ax.annotate(f"Weighted Averages:\nDepth: {self.weighted_depth:.1f}cm\nRate: {self.weighted_rate:.1f}cpm",
-                    xy=(0.98, 0.98), xycoords='axes fraction',
-                    ha='right', va='top', fontsize=10,
-                    bbox=dict(boxstyle='round,pad=0.5', fc='white', ec='black'))
-
-        # 4. Configure legend and layout
-        handles, labels = ax.get_legend_handles_labels()
-        unique = [(h, l) for i, (h, l) in enumerate(zip(handles, labels)) if l not in labels[:i]]
-        ax.legend(*zip(*unique), loc='upper right')
-
-        plt.xlabel("Frame Number")
-        plt.ylabel("Vertical Position (px)")
-        plt.title("Complete CPR Analysis with Metrics")
-        plt.grid(True)
-        plt.tight_layout()
-
-        os.makedirs("plots", exist_ok=True)
-        plot_path = "plots/cpr_analysis.png"
-        plt.savefig("plots/cpr_analysis.png", dpi=300)
-        response = cloudinary.uploader.upload(plot_path, resource_type="image")
-        plt.close()
-        plt.show()
-        return response['secure_url']
-
-    def validate_calculate_metrics(self):
-        """Validate the calculated metrics against thresholds"""
-        if self.depth is None or self.rate is None:
-            print("[ERROR] Depth and rate must be calculated before validation")
-            return False
+    def get_rate_and_depth_warnings(self):
+        """Get performance warnings based on depth and rate"""
 
-        depth_valid = self.min_depth_threshold <= self.depth <= self.max_depth_threshold
-        rate_valid = self.min_rate_threshold <= self.rate <= self.max_rate_threshold
+        depth_status, rate_status = self._get_rate_and_depth_status()
 
-        if not depth_valid:
-            print(f"[WARNING] Depth {self.depth:.1f}cm is out of range ({self.min_depth_threshold}-{self.max_depth_threshold})")
-        if not rate_valid:
-            print(f"[WARNING] Rate {self.rate:.1f}cpm is out of range ({self.min_rate_threshold}-{self.max_rate_threshold})")
+        warnings = []
+        if depth_status == "low":
+            warnings.append("Depth too low!")
+        elif depth_status == "high":
+            warnings.append("Depth too high!")
 
-        return depth_valid and rate_valid
-    
-    def get_json_chunk_data(self):
-        """Get chunk data in JSON format for external use"""
-        if not self.chunks_start_and_end_indices:
-            print("No chunk data available")
-            return None
+        if rate_status == "low":
+            warnings.append("Rate too slow!")
+        elif rate_status == "high":
+            warnings.append("Rate too fast!")
 
-        chunk_data = [
-            {
-                "start": round(start / 30, 2),
-                "end": round(end / 30, 2),
-                "depth": depth,
-                "rate": rate
-            }
-            for (start, end), depth, rate in zip(
-                self.chunks_start_and_end_indices,
-                self.chunks_depth,
-                self.chunks_rate
-            )
-            if (end - start) >= 60
-        ]
+        self.rate_and_depth_warnings = warnings
 
-        return chunk_data
-    
-    
-    def annotate_video_with_chunks(self, input_video_path, posture_errors_for_all_error_region):
-        cap = cv2.VideoCapture(input_video_path)
-        fps = cap.get(cv2.CAP_PROP_FPS)
-        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-
-        # Validate video opened
-        if not cap.isOpened() or fps == 0 or width == 0 or height == 0:
-            raise ValueError("Failed to open input video or invalid video properties.")
-
-        # Create named temp file for cloudinary upload (must not be open during writing on Windows)
-        temp_video = tempfile.NamedTemporaryFile(suffix='.mp4', delete=False)
-        temp_video_path = temp_video.name
-        temp_video.close()
-
-        # ALSO save a local version for inspection
-        #os.makedirs("temp_output", exist_ok=True)
-        #local_output_path = os.path.join("temp_output", "annotated_output.mp4")
-
-        out = cv2.VideoWriter(temp_video_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
-        #local_out = cv2.VideoWriter(local_output_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
-
-        frame_idx = 0
-        current_chunk = 0
-
-        # Generate error regions
-        error_regions = []
-        # Before first chunk
-        if self.chunks_start_and_end_indices[0][0] > 0:
-            error_regions.append((0, self.chunks_start_and_end_indices[0][0] - 1))
-
-        # Between chunks
-        for i in range(1, len(self.chunks_start_and_end_indices)):
-            prev_end = self.chunks_start_and_end_indices[i - 1][1]
-            curr_start = self.chunks_start_and_end_indices[i][0]
-            if curr_start - prev_end > 1:
-                error_regions.append((prev_end + 1, curr_start - 1))
-
-        # After last chunk
-        last_end = self.chunks_start_and_end_indices[-1][1]
-        if last_end < self.frame_count - 1:
-            error_regions.append((last_end + 1, self.frame_count - 1))
-
-        # Iterate over the video frames and annotate
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-
-            # Handle chunk annotation
-            if current_chunk < len(self.chunks_start_and_end_indices):
-                start_idx, end_idx = self.chunks_start_and_end_indices[current_chunk]
-                if start_idx <= frame_idx <= end_idx:
-                    rate = self.chunks_rate[current_chunk]
-                    depth = self.chunks_depth[current_chunk]
-
-                    text1 = f"Rate: {rate:.1f}cpm"
-                    text2 = f"Depth: {depth:.1f}cm"
-                    cv2.putText(frame, text1, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
-                    cv2.putText(frame, text2, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
-
-                if frame_idx > end_idx:
-                    current_chunk += 1
-
-            # Annotate error regions
-            for i, (start, end) in enumerate(error_regions):
-                if start <= frame_idx <= end:
-                    region_errors = posture_errors_for_all_error_region[i]
-                    
-                    # Format errors text
-                    error_text = "Errors: ".join(region_errors) if region_errors else ""
-                    cv2.putText(frame, error_text, (20, 40), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 0, 255), 2)
-
-            out.write(frame)
-            #local_out.write(frame)
-            frame_idx += 1
-
-        cap.release()
-        out.release()
-        #local_out.release()
-
-        # Upload to Cloudinary
-        response = cloudinary.uploader.upload(temp_video_path, resource_type="video")
-
-        # Clean up temp file
-        os.remove(temp_video_path)
-
-        #print(f"✅ Local saved video at: {local_output_path}")
-        return response['secure_url']
+        return warnings
+
+#^ ################# Handle Chunk #######################
+
+    def handle_chunk(self, midpoints, chunk_start_frame_index, chunk_end_frame_index, fps, shoulder_distances, sampling_interval_in_frames):
+        """
+        Handle a chunk of motion data by validating, preprocessing, and calculating metrics
+        for the chunk.
+
+        Args:
+            y_exact (np.ndarray): The exact y-values of the midpoints.
+            chunk_start_frame_index (int): The starting frame index of the chunk.
+            chunk_end_frame_index (int): The ending frame index of the chunk.
+            fps (float): The frames per second of the video.
+            shoulder_distances (list): List of shoulder distances in pixels.
+
+        Returns:
+            bool: True if the chunk was processed successfully, False otherwise.
+        """
+
+        # The program is terminated if the validation fails
+        self.validate_midpoints_and_frames_count_in_chunk(midpoints, chunk_start_frame_index, chunk_end_frame_index, sampling_interval_in_frames)
+
+        preprocessing_reult = self.preprocess_midpoints(midpoints)
+        if not preprocessing_reult:
+            cpr_logger.info("Preprocessing failed, skipping chunk")
+            return False
+        
+        self.detect_midpoints_peaks()
+        if not self.detect_midpoints_peaks():
+            cpr_logger.info("Peak detection failed, skipping chunk")
+
+            self.peaks = np.array([])
+            self.peaks_max = np.array([])
+            self.peaks_min = np.array([])
+
+            self.depth = 0
+            self.rate = 0
+
+            return False
+        
+        self.calculate_cm_px_ratio(shoulder_distances)
+        if self.cm_px_ratio is None:
+            cpr_logger.info("cm/px ratio calculation failed, skipping chunk")
+
+            self.depth = 0
+            self.rate = 0
+            
+            return False
+        
+        self.calculate_rate_and_depth_for_chunk(fps, sampling_interval_in_frames)
+        if self.depth is None or self.rate is None:
+            cpr_logger.info("Rate and depth calculation failed, skipping chunk")
+            return False
+        else:
+            cpr_logger.info(f"Chunk {chunk_start_frame_index}-{chunk_end_frame_index} - Depth: {self.depth:.1f} cm, Rate: {self.rate:.1f} cpm")
+
+        self.get_rate_and_depth_warnings()
+
+        self.assign_chunk_data(chunk_start_frame_index, chunk_end_frame_index)
+        cpr_logger.info(f"Chunk {chunk_start_frame_index}-{chunk_end_frame_index} processed successfully")
+        return True
+
+#^ ################# Comments #######################
+# Between every two consecutive mini chunks, there wil be "sampling interval" frames unaccounted for.
+# This is because when we reach the "reporting interval" number of frames, we terminate the first mini chunk.
+# But we only start the next mini chunk when we detect the next successfully processed frame.
+# Which is "sampling interval" frames later at the earliest.
+# We can't just initialize the next mini chunk at the "reporting interval" frame, because we need to wait for the next successful frame.
+# Becuase maybe the next frame is a frame with posture errors.
+# For better visualization, we connect between the last point of the previous chunk and the first point of the next chunk if they are "sampling interval" frames apart.
+# But that is only for visualization, all calculations are done on the original frames.
+
+# Chunks that are too short can fail any stage of the "handle chunk" process.
+# If they do, we vizualize what we have and ignore the rest.
+# For example, a chunk with < 2 peaks will not be able to calculate the rate.
+# So we will set it to zero and display the midpoints and detected peaks.
+# If there are no peaks, we will set the rate to zero and display the midpoints.
+
+# Problems with chunks could be:
+# - Less than 3 seconds.
+# - Not enough peaks to calculate depth and rate

CPR/pose_estimation.py

@@ -3,13 +3,13 @@ import cv2
 import numpy as np
 from ultralytics import YOLO
 from CPR.keypoints import CocoKeypoints
-import torch
+from CPR.logging_config import cpr_logger
 
 class PoseEstimator:
     """Human pose estimation using YOLO"""
     
     def __init__(self, model_path="yolo11n-pose.pt", min_confidence=0.2):
-        self.model = YOLO(model_path).to("cuda:0" if torch.cuda.is_available() else "cpu")
+        self.model = YOLO(model_path)
         self.min_confidence = min_confidence
 
     def detect_poses(self, frame):
@@ -20,7 +20,7 @@ class PoseEstimator:
                 return None
             return results[0]
         except Exception as e:
-            print(f"Pose detection error: {e}")
+            cpr_logger.error(f"Pose detection error: {e}")
             return None
 
     def get_keypoints(self, results, person_idx=0):
@@ -30,7 +30,7 @@ class PoseEstimator:
                 return None
             return results.keypoints.xy[person_idx].cpu().numpy()
         except Exception as e:
-            print(f"Keypoint extraction error: {e}")
+            cpr_logger.error(f"Keypoint extraction error: {e}")
             return None
 
     def draw_keypoints(self, frame, results):
@@ -38,5 +38,5 @@ class PoseEstimator:
         try:
             return results.plot()
         except Exception as e:
-            print(f"Keypoint drawing error: {e}")
+            cpr_logger.error(f"Keypoint drawing error: {e}")
             return frame

CPR/posture_analyzer.py

@@ -3,12 +3,10 @@ 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"""
-
-    #! The warnings depend on the average readings from the last 10 frames
-    #! This "10" should be adjusted according to the sampling rate of the video
     
     def __init__(self, right_arm_angle_threshold, left_arm_angle_threshold, wrist_distance_threshold, history_length_to_average):
         self.history_length_to_average = history_length_to_average
@@ -21,15 +19,6 @@ class PostureAnalyzer:
         self.left_arm_angle_threshold = left_arm_angle_threshold
         self.wrist_distance_threshold = wrist_distance_threshold
         
-        self.warning_positions = {
-            'right_arm_angle': (50, 50),
-            'left_arm_angle': (50, 100),
-            'one_handed': (50, 150),
-            'hands_not_on_chest': (50, 200)
-        }
-
-        self.posture_errors_for_all_error_region = []
-
     def _calculate_angle(self, a, b, c):
         """Calculate angle between three points"""
         try:
@@ -37,7 +26,7 @@ class PostureAnalyzer:
                          math.atan2(a[1]-b[1], a[0]-b[0]))
             return ang + 360 if ang < 0 else ang
         except Exception as e:
-            print(f"Angle calculation error: {e}")
+            cpr_logger.error(f"Angle calculation error: {e}")
             return 0
     
     def _check_bended_right_arm(self, keypoints):
@@ -55,12 +44,12 @@ class PostureAnalyzer:
             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")
+                warnings.append("Right arm bent!")
 
             return warnings
                 
         except Exception as e:
-            print(f"Right arm check error: {e}")
+            cpr_logger.error(f"Right arm check error: {e}")
         
         return warnings
     
@@ -79,132 +68,65 @@ class PostureAnalyzer:
             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")
+                warnings.append("Left arm bent!")
 
             return warnings
                 
         except Exception as e:
-            print(f"Left arm check error: {e}")
+            cpr_logger.error(f"Left arm check error: {e}")
         
         return warnings
 
-    def _check_one_handed_cpr(self, keypoints):
-        """Check for one-handed CPR pattern (returns warning)"""
-        warnings = []
-        try:
-            # Calculate wrist distance
-            left_wrist = keypoints[CocoKeypoints.LEFT_WRIST.value]
-            right_wrist = keypoints[CocoKeypoints.RIGHT_WRIST.value]
-            
-            wrist_distance = np.linalg.norm(left_wrist - right_wrist)
-            self.wrist_distances.append(wrist_distance)
-            
-            # Analyze distance with moving average
-            avg_distance = np.mean(self.wrist_distances[-self.history_length_to_average:] if self.wrist_distances else 0)
-            
-            if avg_distance > self.wrist_distance_threshold:
-                warnings.append("One-handed CPR detected!")
-                
-        except Exception as e:
-            print(f"One-handed CPR 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]
 
-    def _check_hands_on_chest(self, wrists_midpoint, chest_params):  # (cx, cy, cw, ch)
-        """Check if hands are on the chest (returns warning)"""
         warnings = []
         try:
-            # Check if hands are on the chest
-            if wrists_midpoint is None or chest_params is None:
-                return ["Hands not on chest"]
+            if chest_params is None:
+                return ["Both hands not on chest!"]  # Fallback warning
             
-            # Unpack parameters
-            wrist_x, wrist_y = wrists_midpoint
             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)
             
-            if not ((cx - cw/2 < wrist_x < cx + cw/2) and (cy - ch/2 < wrist_y < cy + ch/2)):
-                warnings.append("Hands not on chest")
-                
+            # 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:
-            print(f"Hands on chest check error: {e}")
+            cpr_logger.error(f"Hands check error: {e}")
         
         return warnings
 
-    def validate_posture(self, keypoints, wrists_midpoint, chest_params):
+
+    def validate_posture(self, keypoints, chest_params):
         """Run all posture validations (returns aggregated warnings)"""
         warnings = []
-        warnings += self._check_bended_right_arm(keypoints)
-        warnings += self._check_bended_left_arm(keypoints)
-        warnings += self._check_one_handed_cpr(keypoints)
-        warnings += self._check_hands_on_chest(wrists_midpoint, chest_params)
-        return warnings
-
-    def display_warnings(self, frame):
-        """Display posture warnings with colored background rectangles
-        
-        Args:
-            frame: Input image frame to draw warnings on
-            
-        Returns:
-            Frame with warnings and background rectangles drawn
-        """
-        if not self.warnings:
-            return frame
-
-        warning_config = {
-            "Right arm bent": {
-                "color": (0, 0, 255),  # Red
-                "position": self.warning_positions['right_arm_angle'],
-                "text": "Right arm bent!"
-            },
-            "Left arm bent": {
-                "color": (0, 255, 255),  # Yellow
-                "position": self.warning_positions['left_arm_angle'],
-                "text": "Left arm bent!"
-            },
-            "One-handed": {
-                "color": (0, 255, 0),  # Green
-                "position": self.warning_positions['one_handed'],
-                "text": "One-handed CPR detected!"
-            },
-            "Hands not on chest": {
-                "color": (255, 0, 0),  # Blue
-                "position": self.warning_positions['hands_not_on_chest'],
-                "text": "Hands not on chest!"
-            }
-        }
 
-        try:
-            for warning_text, config in warning_config.items():
-                if any(warning_text in w for w in self.warnings):
-                    self._draw_warning_banner(
-                        frame=frame,
-                        text=config['text'],
-                        color=config['color'],
-                        position=config['position']
-                    )
-            
-        except Exception as e:
-            print(f"Warning display error: {e}")
-        
-        return frame
+        warnings += self._check_hands_on_chest(keypoints, chest_params)
 
-    def _draw_warning_banner(self, frame, text, color, position):
-        """Helper function to draw a single warning banner"""
-        (text_width, text_height), _ = cv2.getTextSize(
-            text, cv2.FONT_HERSHEY_SIMPLEX, 0.8, 2)
+        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)
         
-        x, y = position
-        # Calculate background rectangle coordinates
-        x1 = x - 10
-        y1 = y - text_height - 10
-        x2 = x + text_width + 10
-        y2 = y + 10
-        
-        # Draw background rectangle
-        cv2.rectangle(frame, (x1, y1), (x2, y2), color, -1)
-        
-        # Draw warning text
-        cv2.putText(frame, text, (x, y),
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2,
-                    cv2.LINE_AA)
+        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/role_classifier.py

@@ -2,7 +2,7 @@
 import cv2
 import numpy as np
 from ultralytics.utils.plotting import Annotator  # Import YOLO's annotator
-from CPR.keypoints import CocoKeypoints
+from CPR.logging_config import cpr_logger
 
 
 class RoleClassifier:
@@ -28,7 +28,7 @@ class RoleClassifier:
             return 1 if height > width else 0  # 1 for vertical, 0 for horizontal
             
         except (TypeError, ValueError) as e:
-            print(f"Verticality score calculation error: {e}")
+            cpr_logger.error(f"Verticality score calculation error: {e}")
             return -1
         
     def _calculate_bounding_box_center(self, bounding_box):
@@ -94,11 +94,12 @@ class RoleClassifier:
                 if threshold:
                     box_area = width * height
                     if box_area > threshold * 1.2:  # 20% tolerance
-                        print(f"Filtered oversized box {i} (area: {box_area:.1f} > threshold: {threshold:.1f})")
+                        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
@@ -111,7 +112,7 @@ class RoleClassifier:
                 })
             
             except Exception as e:
-                print(f"Error processing detection {i}: {e}")
+                cpr_logger.error(f"Error processing detection {i}: {e}")
                 continue
 
         # Step 2: Identify the patient (horizontal posture)
@@ -132,6 +133,7 @@ class RoleClassifier:
             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']
             ]
             
@@ -158,7 +160,7 @@ class RoleClassifier:
                     keypoints = self.rescuer_processed_results["keypoints"]
                     annotator.kpts(keypoints, shape=frame.shape[:2])
             except Exception as e:
-                print(f"Error drawing rescuer: {str(e)}")
+                cpr_logger.error(f"Error drawing rescuer: {str(e)}")
 
         # Draw patient (B) with red box and keypoints
         if self.patient_processed_results:
@@ -170,7 +172,7 @@ class RoleClassifier:
                     keypoints = self.patient_processed_results["keypoints"]
                     annotator.kpts(keypoints, shape=frame.shape[:2])
             except Exception as e:
-                print(f"Error drawing patient: {str(e)}")
+                cpr_logger.error(f"Error drawing patient: {str(e)}")
 
         return annotator.result()
     

CPR/shoulders_analyzer.py

@@ -1,7 +1,6 @@
-# analyzers.py
-import cv2
 import numpy as np
 from CPR.keypoints import CocoKeypoints
+from CPR.logging_config import cpr_logger
 
 class ShouldersAnalyzer:
     """Analyzes shoulder distances and posture"""
@@ -23,7 +22,7 @@ class ShouldersAnalyzer:
             
             return distance
         except Exception as e:
-            print(f"Shoulder distance error: {e}")
+            cpr_logger.error(f"Shoulder distance error: {e}")
             return
     
     def reset_shoulder_distances(self):

CPR/threaded_camera.py

@@ -0,0 +1,103 @@
+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()

CPR/warnings_overlayer.py

@@ -0,0 +1,151 @@
+import cv2
+import numpy as np
+import os
+import sys
+
+from CPR.logging_config import cpr_logger
+
+class WarningsOverlayer:
+    def __init__(self):
+        # Single drawer configuration
+        self.DRAWER_CONFIG = {
+            "base_position": (0.05, 0.15),  # 5% from left, 15% from top
+            "vertical_spacing": 0.06  # 6% of frame height between warnings
+        }
+
+        # Warning config (colors only)
+        self.WARNING_CONFIG = {
+            # Posture Warnings
+            "Right arm bent!": {"color": (52, 110, 235)},
+            "Left arm bent!": {"color": (52, 110, 235)},
+            "Left hand not on chest!": {"color": (161, 127, 18)},
+            "Right hand not on chest!": {"color": (161, 127, 18)},
+            "Both hands not on chest!": {"color": (161, 127, 18)},
+            
+            # Rate/Depth Warnings
+            "Depth too low!": {"color": (125, 52, 235)},
+            "Depth too high!": {"color": (125, 52, 235)},
+            "Rate too slow!": {"color": (235, 52, 214)},
+            "Rate too fast!": {"color": (235, 52, 214)}
+        }
+    
+    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 = []
+        
+        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))
+        
+        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))
+
+        # Screenshot tracking
+        os.makedirs("screenshots", exist_ok=True)
+        screenshot_counts = {}
+
+        # Warnings to skip for screenshots
+        skip_warnings = {
+            "Depth too low!",
+            "Depth too high!",
+            "Rate too slow!",
+            "Rate too fast!"
+        }
+
+        # Video processing loop
+        frame_idx = 0
+        while True:
+            ret, frame = cap.read()
+            if not ret: 
+                break
+            
+            active_warnings = []
+            for start, end, warnings in all_warnings:
+                if start <= frame_idx <= end:
+                    active_warnings.extend(warnings)
+            
+            # Draw and optionally screenshot active warnings
+            self._draw_warnings(frame, active_warnings)
+
+            for warning_text in set(active_warnings):
+                if warning_text in skip_warnings:
+                    continue
+                count = screenshot_counts.get(warning_text, 0)
+                if count < 2:
+                    screenshot_path = os.path.join("screenshots", f"{warning_text.replace(' ', '_')}_{frame_idx}.jpg")
+                    cv2.imwrite(screenshot_path, frame)
+                    screenshot_counts[warning_text] = count + 1
+
+            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 all warnings in a single vertical drawer"""
+        frame_height = frame.shape[0]
+        frame_width = frame.shape[1]
+        
+        # Calculate starting position
+        base_x = int(self.DRAWER_CONFIG["base_position"][0] * frame_width)
+        current_y = int(self.DRAWER_CONFIG["base_position"][1] * frame_height)
+        
+        # Calculate spacing between warnings
+        y_spacing = int(self.DRAWER_CONFIG["vertical_spacing"] * frame_height)
+
+        # Draw all active warnings vertically
+        for warning_text in active_warnings:
+            if color := self.WARNING_CONFIG.get(warning_text, {}).get("color"):
+                # Draw warning at current position
+                self._draw_warning_banner(
+                    frame=frame,
+                    text=warning_text,
+                    color=color,
+                    position=(base_x, current_y))
+                
+                # Move down for next warning
+                current_y += y_spacing
+    
+    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)
+   

CPR/wrists_midpoint_analyzer.py

@@ -1,6 +1,7 @@
 import cv2
 import numpy as np
 from CPR.keypoints import CocoKeypoints
+from CPR.logging_config import cpr_logger
 
 class WristsMidpointAnalyzer:
     """Analyzes and tracks wrist midpoints for rescuer"""
@@ -34,7 +35,7 @@ class WristsMidpointAnalyzer:
             return midpoint
             
         except Exception as e:
-            print(f"Midpoint tracking error: {e}")
+            cpr_logger.error(f"Midpoint tracking error: {e}")
             return None
 
     def draw_midpoint(self, frame):
@@ -54,7 +55,7 @@ class WristsMidpointAnalyzer:
 
             return frame
         except Exception as e:
-            print(f"Midpoint drawing error: {e}")
+            cpr_logger.error(f"Midpoint drawing error: {e}")
             return frame
     
     def reset_midpoint_history(self):

main.py

@@ -23,13 +23,13 @@ from fastapi import WebSocket, WebSocketDisconnect
 import base64
 import cv2
 import time
-#from CPR.CPRAnalyzer import CPRAnalyzer
+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
+from CPRRealTime.main import CPRAnalyzer as RealtimeAnalyzer
 from threading import Thread
 from starlette.responses import StreamingResponse
 import threading
@@ -38,10 +38,13 @@ from CPRRealTime.analysis_socket_server import AnalysisSocketServer  # adjust if
 from CPRRealTime.logging_config import cpr_logger
 import logging
 import sys
+import re
 
 
 app = FastAPI()
 
+SCREENSHOTS_DIR = "screenshots"  # Folder containing screenshots to upload
+OUTPUT_DIR = "Output"            # Folder containing the .mp4 video and graph .png
 UPLOAD_DIR = "uploads"
 os.makedirs(UPLOAD_DIR, exist_ok=True)
 
@@ -79,30 +82,6 @@ cloudinary.config(
 def greet_json():
     return {"Hello": "World!"}
 
-# ✅ MongoDB document count route for Images collection
-@app.get("/count")
-def count_docs():
-    collection = db["Images"]
-    count = collection.count_documents({})
-    return {"document_count": count}
-
-# ✅ Upload image to Cloudinary and save URL to MongoDB
-@app.post("/cloudinary/upload")
-async def upload_sample(file: UploadFile = File(...)):
-    try:
-        # Upload the file to Cloudinary
-        result = cloudinary.uploader.upload(file.file, public_id=file.filename)
-        uploaded_url = result["secure_url"]
-
-        # Save image URL to MongoDB
-        collection = db["Images"]
-        doc = {"filename": file.filename, "url": uploaded_url}
-        collection.insert_one(doc)
-
-        return {"uploaded_url": uploaded_url}
-    except Exception as e:
-        return {"error": str(e)}
-    
 @app.post("/predict_burn")
 async def predict_burn(file: UploadFile = File(...)):
     try:
@@ -202,19 +181,7 @@ async def segment_burn_endpoint(reference: UploadFile = File(...), patient: Uplo
     except Exception as e:
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
-# ✅ Optimize and transform image URL
-@app.get("/cloudinary/transform")
-def transform_image():
-    try:
-        optimized_url, _ = cloudinary_url("shoes", fetch_format="auto", quality="auto")
-        auto_crop_url, _ = cloudinary_url("shoes", width=500, height=500, crop="auto", gravity="auto")
-        return {
-            "optimized_url": optimized_url,
-            "auto_crop_url": auto_crop_url
-        }
-    except Exception as e:
-        return {"error": str(e)}
-    
+
 @app.post("/classify-ecg")
 async def classify_ecg_endpoint(file: UploadFile = File(...)):
     model = joblib.load('voting_classifier.pkl')
@@ -272,6 +239,18 @@ async def diagnose_ecg(file: UploadFile = File(...)):
         return JSONResponse(content={"error": str(e)}, status_code=500)
 
 
+def clean_warning_name(filename: str) -> str:
+    """
+    Remove frame index and underscores from filename base
+    E.g. "posture_001.png" -> "posture"
+    """
+    name, _ = os.path.splitext(filename)
+    # Remove trailing underscore + digits
+    cleaned = re.sub(r'_\d+$', '', name)
+    # Remove all underscores in the name for description
+    cleaned_desc = cleaned.replace('_', ' ')
+    return cleaned, cleaned_desc
+
 @app.post("/process_video")
 async def process_video(file: UploadFile = File(...)):
     if not file.content_type.startswith("video/"):
@@ -280,24 +259,84 @@ async def process_video(file: UploadFile = File(...)):
     print("File content type:", file.content_type)
     print("File filename:", file.filename)
 
-    # Save uploaded file
+    # Prepare directories
+    os.makedirs(UPLOAD_DIR, exist_ok=True)
+    os.makedirs(SCREENSHOTS_DIR, exist_ok=True)
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    folders = ["screenshots", "uploads", "Output"]
+
+    for folder in folders:
+        if os.path.exists(folder):
+            for filename in os.listdir(folder):
+                file_path = os.path.join(folder, filename)
+                if os.path.isfile(file_path):
+                    os.remove(file_path)
+
+    # Save uploaded video file
     video_path = os.path.join(UPLOAD_DIR, file.filename)
     with open(video_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
 
     print(f"\n[API] CPR Analysis Started on {video_path}")
 
-    # Run analyzer
+    # Prepare output paths for the analyzer
+    video_output_path = os.path.join(OUTPUT_DIR, "Myoutput.mp4")
+    plot_output_path = os.path.join(OUTPUT_DIR, "Myoutput.png")
+
+    # Initialize analyzer with input video and output paths
     start_time = time.time()
-    analyzer = CPRAnalyzer(video_path)
-    wholevideoURL, graphURL, warnings,chunks  = analyzer.run_analysis()  # Expects tuple return
+    analyzer = OfflineAnalyzer(video_path, video_output_path, plot_output_path, requested_fps=30)
+
+    # Run the analysis (choose your method)
+    chunks = analyzer.run_analysis_video()
+
+    warnings = []  # Start empty list
 
-    for w in warnings:
-            filename = w['image_url']  # just the filename
-            local_path = os.path.join("screenshots", filename)
-            upload_result = cloudinary.uploader.upload(local_path, folder="posture_warnings")
-            w['image_url'] = upload_result['secure_url']
+    # Upload screenshots and build warnings list with descriptions and URLs
+    if os.path.exists(SCREENSHOTS_DIR):
+        for filename in os.listdir(SCREENSHOTS_DIR):
+            if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
+                local_path = os.path.join(SCREENSHOTS_DIR, filename)
+                cleaned_name, description = clean_warning_name(filename)
+
+                upload_result = cloudinary.uploader.upload(
+                    local_path,
+                    folder="posture_warnings",
+                    public_id=cleaned_name,
+                    overwrite=True
+                )
 
+                # Add new warning with image_url and description
+                warnings.append({
+                    "image_url": upload_result['secure_url'],
+                    "description": description
+                })
+
+    video_path = "Output/Myoutput_final.mp4"
+
+    if os.path.isfile(video_path):
+        upload_result = cloudinary.uploader.upload_large(
+            video_path,
+            resource_type="video",
+            folder="output_videos",
+            public_id="Myoutput_final",
+            overwrite=True
+        )
+        wholevideoURL = upload_result['secure_url']
+    else:
+        wholevideoURL = None
+
+    # Upload graph output
+    graphURL = None
+    if os.path.isfile(plot_output_path):
+        upload_graph_result = cloudinary.uploader.upload(
+            plot_output_path,
+            folder="output_graphs",
+            public_id=os.path.splitext(os.path.basename(plot_output_path))[0],
+            overwrite=True
+        )
+        graphURL = upload_graph_result['secure_url']
 
     print(f"[API] CPR Analysis Completed on {video_path}")
     analysis_time = time.time() - start_time
@@ -306,220 +345,112 @@ async def process_video(file: UploadFile = File(...)):
     if wholevideoURL is None:
         raise HTTPException(status_code=500, detail="No chunk data was generated from the video.")
 
-    # Return chunks and error regions
     return JSONResponse(content={
         "videoURL": wholevideoURL,
         "graphURL": graphURL,
         "warnings": warnings,
         "chunks": chunks,
-        
     })
 
 
-@app.post("/process_image")
-async def process_image(file: UploadFile = File(...)):
-    if not file.content_type.startswith("image/"):
-        raise HTTPException(status_code=400, detail="File must be an image.")
-
-    print("File content type:", file.content_type)
-    print("File filename:", file.filename)
+# @app.websocket("/ws/process_video")
+# async def websocket_process_video(websocket: WebSocket):
 
-    # Save uploaded image
-    image_path = os.path.join(UPLOAD_DIR, file.filename)
-    with open(image_path, "wb") as buffer:
-        shutil.copyfileobj(file.file, buffer)
-
-  
-
-    # Run YOLO detection on the image
-    try:
-        results = model(
-            source=image_path,
-            show=False,
-            save=False
-        )
+#     await websocket.accept()
 
-        if not results or len(results) == 0 or results[0].keypoints is None or results[0].keypoints.xy is None:
-            return JSONResponse(content={"message": "No keypoints detected"}, status_code=200)
+#     frame_buffer = []
+#     frame_limit = 50
+#     frame_size = (640, 480)  # Adjust if needed
+#     fps = 30  # Adjust if needed
+#     loop = asyncio.get_event_loop()
 
-        keypoints = results[0].keypoints.xy
-        confidences = results[0].boxes.conf if results[0].boxes is not None else []
+#     # Progress reporting during analysis
+#     async def progress_callback(data):
+#         await websocket.send_text(json.dumps(data))
 
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"YOLO processing error: {str(e)}")
+#     def sync_callback(data):
+#         asyncio.run_coroutine_threadsafe(progress_callback(data), loop)
 
-    return JSONResponse(content={
-        "message": "Image processed successfully",
-        "KeypointsXY": keypoints.tolist(),
-        "confidences": confidences.tolist()
-    })
+#     def save_frames_to_video(frames, path):
+#         out = cv2.VideoWriter(path, cv2.VideoWriter_fourcc(*'mp4v'), fps, frame_size)
+#         for frame in frames:
+#             resized = cv2.resize(frame, frame_size)
+#             out.write(resized)
+#         out.release()
 
+#     def run_analysis_on_buffer(frames):
+#         try:
+#             tmp_path = "temp_video.mp4"
+#             save_frames_to_video(frames, tmp_path)
 
+#             # Notify: video saved
+#             asyncio.run_coroutine_threadsafe(
+#                 websocket.send_text(json.dumps({
+#                     "status": "info",
+#                     "message": "Video saved. Starting CPR analysis..."
+#                 })),
+#                 loop
+#             )
 
+#             # Run analysis
+#             analyzer = CPRAnalyzer(video_path=tmp_path)
+#             analyzer.run_analysis(progress_callback=sync_callback)
 
+#         except Exception as e:
+#             asyncio.run_coroutine_threadsafe(
+#                 websocket.send_text(json.dumps({"error": str(e)})),
+#                 loop
+#             )
 
-@app.websocket("/ws/process_image")
-async def websocket_process_image(websocket: WebSocket):
-    await websocket.accept()
-    try:
-        while True:
-            # 1) Receive raw JPEG bytes from Flutter
-            data: bytes = await websocket.receive_bytes()
-
-            # 2) (Optional) Decode to BGR for any pre-display or debugging
-            np_arr = np.frombuffer(data, np.uint8)
-            frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-
-            # 3) Write to temp file for YOLO ingestion
-            with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
-                tmp.write(data)
-                tmp_path = tmp.name
-
-            # 4) Run inference without any built-in display
-            try:
-                results = model(source=tmp_path, show=False, save=False)
-            except Exception as e:
-                os.unlink(tmp_path)
-                await websocket.send_text(json.dumps({
-                    "error": f"YOLO error: {e}"
-                }))
-                continue
-
-            # cleanup temp file
-            os.unlink(tmp_path)
-
-            # 5) Clear any stray windows
-            cv2.destroyAllWindows()
-
-            # 6) Get the single annotated BGR image
-            annotated: np.ndarray = results[0].plot()
-
-            # 7) Show exactly one window in color
-            cv2.imshow("Pose / Segmentation", annotated)
-            cv2.waitKey(1)  # small delay to allow window refresh
-
-            # 8) Build and send JSON back to Flutter
-            if not results or len(results) == 0 or results[0].keypoints is None:
-                payload = {"message": "No keypoints detected"}
-            else:
-                keypoints = results[0].keypoints.xy.tolist()
-                confidences = (
-                    results[0].boxes.conf.tolist()
-                    if results[0].boxes is not None
-                    else []
-                )
-                payload = {
-                    "message": "Image processed successfully",
-                    "KeypointsXY": keypoints,
-                    "confidences": confidences,
-                }
+#     try:
+#         while True:
+#             data: bytes = await websocket.receive_bytes()
+#             np_arr = np.frombuffer(data, np.uint8)
+#             frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
+#             if frame is None:
+#                 continue
 
-            await websocket.send_text(json.dumps(payload))
+#             frame_buffer.append(frame)
+#             print(f"Frame added to buffer: {len(frame_buffer)}")
 
-    except WebSocketDisconnect:
-        print("Client disconnected")
-    finally:
-        # Ensure the window is closed on disconnect
-        cv2.destroyAllWindows()
+#             if len(frame_buffer) == frame_limit:
+#                 # Notify Flutter that we're switching to processing
+#                 await websocket.send_text(json.dumps({
+#                     "status": "ready",
+#                     "message": "Prepare Right CPR: First 150 frames received. Starting processing."
+#                 }))
 
+#                 # Copy and clear buffer
+#                 buffer_copy = frame_buffer[:]
+#                 frame_buffer.clear()
 
+#                 # Launch background processing
+#                 executor = concurrent.futures.ThreadPoolExecutor()
+#                 loop.run_in_executor(executor, run_analysis_on_buffer, buffer_copy)
+#             else:
+#                 # Tell Flutter to send the next frame
+#                 await websocket.send_text(json.dumps({
+#                     "status": "continue",
+#                     "message": f"Frame {len(frame_buffer)} received. Send next."
+#                 }))
 
+#     except WebSocketDisconnect:
+#         print("Client disconnected")
 
-@app.websocket("/ws/process_video")
-async def websocket_process_video(websocket: WebSocket):
+#     except Exception as e:
+#         await websocket.send_text(json.dumps({"error": str(e)}))
 
-    await websocket.accept()
+#     finally:
+#         cv2.destroyAllWindows()
 
-    frame_buffer = []
-    frame_limit = 50
-    frame_size = (640, 480)  # Adjust if needed
-    fps = 30  # Adjust if needed
-    loop = asyncio.get_event_loop()
 
-    # Progress reporting during analysis
-    async def progress_callback(data):
-        await websocket.send_text(json.dumps(data))
-
-    def sync_callback(data):
-        asyncio.run_coroutine_threadsafe(progress_callback(data), loop)
-
-    def save_frames_to_video(frames, path):
-        out = cv2.VideoWriter(path, cv2.VideoWriter_fourcc(*'mp4v'), fps, frame_size)
-        for frame in frames:
-            resized = cv2.resize(frame, frame_size)
-            out.write(resized)
-        out.release()
-
-    def run_analysis_on_buffer(frames):
-        try:
-            tmp_path = "temp_video.mp4"
-            save_frames_to_video(frames, tmp_path)
-
-            # Notify: video saved
-            asyncio.run_coroutine_threadsafe(
-                websocket.send_text(json.dumps({
-                    "status": "info",
-                    "message": "Video saved. Starting CPR analysis..."
-                })),
-                loop
-            )
-
-            # Run analysis
-            analyzer = CPRAnalyzer(video_path=tmp_path)
-            analyzer.run_analysis(progress_callback=sync_callback)
-
-        except Exception as e:
-            asyncio.run_coroutine_threadsafe(
-                websocket.send_text(json.dumps({"error": str(e)})),
-                loop
-            )
-
-    try:
-        while True:
-            data: bytes = await websocket.receive_bytes()
-            np_arr = np.frombuffer(data, np.uint8)
-            frame = cv2.imdecode(np_arr, cv2.IMREAD_COLOR)
-            if frame is None:
-                continue
-
-            frame_buffer.append(frame)
-            print(f"Frame added to buffer: {len(frame_buffer)}")
-
-            if len(frame_buffer) == frame_limit:
-                # Notify Flutter that we're switching to processing
-                await websocket.send_text(json.dumps({
-                    "status": "ready",
-                    "message": "Prepare Right CPR: First 150 frames received. Starting processing."
-                }))
-
-                # Copy and clear buffer
-                buffer_copy = frame_buffer[:]
-                frame_buffer.clear()
-
-                # Launch background processing
-                executor = concurrent.futures.ThreadPoolExecutor()
-                loop.run_in_executor(executor, run_analysis_on_buffer, buffer_copy)
-            else:
-                # Tell Flutter to send the next frame
-                await websocket.send_text(json.dumps({
-                    "status": "continue",
-                    "message": f"Frame {len(frame_buffer)} received. Send next."
-                }))
-
-    except WebSocketDisconnect:
-        print("Client disconnected")
-
-    except Exception as e:
-        await websocket.send_text(json.dumps({"error": str(e)}))
-
-    finally:
-        cv2.destroyAllWindows()
 
 
 logger = logging.getLogger("cpr_logger")
 clients = set()
 analyzer_thread = None
 analysis_started = False
+analyzer_lock = threading.Lock()
 socket_server: AnalysisSocketServer = None  # Global reference
 
 
@@ -537,44 +468,38 @@ async def forward_results_from_queue(websocket: WebSocket, warning_queue):
 
 def run_cpr_analysis(source, requested_fps, output_path):
     global socket_server
-    cpr_logger.info(f"[MAIN] CPR Analysis Started")
-    
-    # Configuration
+    logger.info(f"[MAIN] CPR Analysis Started")
+
     requested_fps = 30
     input_video = source
-   
-    # Create output directory if it doesn't exist
+
     output_dir = r"D:\BackendGp\Deploy_El7a2ny_Application\CPRRealTime\outputs"
     os.makedirs(output_dir, exist_ok=True)
-    
-    # Set output paths using original name
-    video_output_path = os.path.join(output_dir, f"output.mp4")
-    plot_output_path = os.path.join(output_dir, f"output.png")
-    
-    # Log paths for verification
-    cpr_logger.info(f"[CONFIG] Input video: {input_video}")
-    cpr_logger.info(f"[CONFIG] Video output: {video_output_path}")
-    cpr_logger.info(f"[CONFIG] Plot output: {plot_output_path}")
-    
-    # Initialize and run analyzer
-    initialization_start_time = time.time()
-    analyzer = CPRAnalyzer(input_video, video_output_path, plot_output_path, requested_fps)
-    socket_server = analyzer.socket_server  # <- get reference to its queue
 
-    # Set plot output path in the analyzer
+    video_output_path = os.path.join(output_dir, "output.mp4")
+    plot_output_path = os.path.join(output_dir, "output.png")
+
+    logger.info(f"[CONFIG] Input video: {input_video}")
+    logger.info(f"[CONFIG] Video output: {video_output_path}")
+    logger.info(f"[CONFIG] Plot output: {plot_output_path}")
+
+    initialization_start_time = time.time()
+    analyzer = RealtimeAnalyzer(input_video, video_output_path, plot_output_path, requested_fps)
+    socket_server = analyzer.socket_server
     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")
-    
+
+    elapsed_time = time.time() - initialization_start_time
+    logger.info(f"[TIMING] Initialization time: {elapsed_time:.2f}s")
+
     try:
         analyzer.run_analysis()
     finally:
-        analyzer.socket_server.stop_server()
+        if analyzer.socket_server:
+            analyzer.socket_server.stop_server()
+        logger.info("[MAIN] Analyzer stopped")
 
 
-@app.websocket("/ws/test")
+@app.websocket("/ws/real")
 async def websocket_analysis(websocket: WebSocket):
     global analyzer_thread, analysis_started, socket_server
 
@@ -582,37 +507,59 @@ async def websocket_analysis(websocket: WebSocket):
     clients.add(websocket)
     logger.info("[WebSocket] Flutter connected")
 
-    # Start the analyzer only once
-    if not analysis_started:
-        source = "http://192.168.137.33:8080/video"  # Replace with your video source
-        requested_fps = 30
-        output_path = r"D:\CPR\End to End\Code Refactor\output\output.mp4"
-
-        analyzer_thread = threading.Thread(
-            target=run_cpr_analysis,
-            args=(source, requested_fps, output_path),
-            daemon=True
-        )
-        analyzer_thread.start()
-        analysis_started = True
-
-        logger.info("[WebSocket] Analysis thread started")
+    # Ensure analyzer starts only once using a thread-safe lock
+    with analyzer_lock:
+        if not analysis_started:
+            source = "http://192.168.1.16:8080/video"
+            requested_fps = 30
+            output_path = r"D:\CPR\End to End\Code Refactor\output\output.mp4"
+
+            analyzer_thread = threading.Thread(
+                target=run_cpr_analysis,
+                args=(source, requested_fps, output_path),
+                daemon=True
+            )
+            analyzer_thread.start()
+            analysis_started = True
+            logger.info("[WebSocket] Analysis thread started")
 
-        # Wait until socket server is initialized
-        while socket_server is None or not socket_server.warning_queue:
-            await asyncio.sleep(0.1)
+    # Wait until the socket server and queue are initialized
+    while socket_server is None or socket_server.warning_queue is None:
+        await asyncio.sleep(0.1)
 
-    # Start async task to stream warnings from queue to Flutter
-    forward_task = asyncio.create_task(forward_results_from_queue(websocket, socket_server.warning_queue))
+    # Start async task to stream data to client
+    forward_task = asyncio.create_task(
+        forward_results_from_queue(websocket, socket_server.warning_queue)
+    )
 
     try:
         while True:
-            # Keep connection alive (optional)
-            await asyncio.sleep(1)
+            await asyncio.sleep(1)  # Keep alive
     except WebSocketDisconnect:
         logger.warning("[WebSocket] Client disconnected")
         forward_task.cancel()
     finally:
         clients.discard(websocket)
+        logger.info(f"[WebSocket] Active clients: {len(clients)}")
+
+        # Optional: stop analysis if no clients remain
+        if not clients and socket_server:
+            logger.info("[WebSocket] No clients left. Stopping analyzer.")
+            socket_server.stop_server()
+            analysis_started = False
+            socket_server = None
+
+
+import signal
+
+def shutdown_handler(signum, frame):
+    logger.info("Received shutdown signal")
+    if socket_server:
+        try:
+            socket_server.stop_server()
+        except Exception as e:
+            logger.warning(f"Error during socket server shutdown: {e}")
+    os._exit(0)
 
-        
+signal.signal(signal.SIGINT, shutdown_handler)
+signal.signal(signal.SIGTERM, shutdown_handler)