Latest ECG

deep-multiclass.h5 → Arrhythmia_Model_with_SMOTE.h5

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a2fdc1bcbf7820ae426a9a74f0210c738884ee2bb872bccff55a4036e2c642e1
-size 8941912
+oid sha256:7145bc906536b54953df3e7034d0da786c24261ec4080fbfd51031d19895e713
+size 8923320

ECG/ECG_Classify.py

@@ -1,57 +1,113 @@
-import wfdb                          # To read the ECG files
-from wfdb import processing          # For QRS detection
-import numpy as np                   # Numerical operations
-import joblib                        # To load the saved model
-import pywt                          # For wavelet feature extraction
-import os                            # For file operations
-import cv2                           # For image processing
-from pdf2image import convert_from_path  # For PDF to image conversion
+import wfdb
+from wfdb import processing
+import numpy as np
+import joblib
+import pywt
+import os
+import cv2
+from pdf2image import convert_from_path
 import warnings
 import pickle
-import sklearn
+from scipy import signal as sg
+warnings.filterwarnings('ignore')
 
-# Let's modify the digitize_ecg_from_pdf function to return segment information
-def digitize_ecg_from_pdf(pdf_path, output_file='calibrated_ecg.dat', debug=False, save_segments=True):
+
+def extract_hrv_features(rr_intervals):
+    """
+    Extract heart rate variability features from RR intervals.
+    
+    Args:
+        rr_intervals (numpy.ndarray): RR intervals in seconds
+        
+    Returns:
+        list: Four HRV features [sdnn, rmssd, pnn50, tri_index]
+    """
+    if len(rr_intervals) < 2:
+        return [0, 0, 0, 0]
+    
+    sdnn = np.std(rr_intervals)
+    diff_rr = np.diff(rr_intervals)
+    rmssd = np.sqrt(np.mean(diff_rr**2)) if len(diff_rr) > 0 else 0
+    pnn50 = 100 * np.sum(np.abs(diff_rr) > 0.05) / len(diff_rr) if len(diff_rr) > 0 else 0
+    
+    if len(rr_intervals) > 2:
+        bin_width = 1/128
+        bins = np.arange(min(rr_intervals), max(rr_intervals) + bin_width, bin_width)
+        n, _ = np.histogram(rr_intervals, bins=bins)
+        tri_index = len(rr_intervals) / np.max(n) if np.max(n) > 0 else 0
+    else:
+        tri_index = 0
+    
+    return [sdnn, rmssd, pnn50, tri_index]
+
+
+def extract_qrs_features(signal, r_peaks, fs):
+    """
+    Extract QRS complex features from ECG signal and detected R peaks.
+    
+    Args:
+        signal (numpy.ndarray): ECG signal
+        r_peaks (numpy.ndarray): Array of R peak indices
+        fs (int): Sampling frequency in Hz
+        
+    Returns:
+        list: Three QRS features [qrs_width_mean, qrs_width_std, qrs_amplitude_mean]
+    """
+    if len(r_peaks) < 2:
+        return [0, 0, 0]
+    
+    qrs_width = []
+    for i in range(len(r_peaks)):
+        r_pos = r_peaks[i]
+        window_before = max(0, r_pos - int(0.1 * fs))
+        window_after = min(len(signal) - 1, r_pos + int(0.1 * fs))
+        
+        if r_pos > window_before:
+            q_pos = window_before + np.argmin(signal[window_before:r_pos])
+        else:
+            q_pos = window_before
+            
+        if r_pos < window_after:
+            s_pos = r_pos + np.argmin(signal[r_pos:window_after])
+        else:
+            s_pos = r_pos
+        
+        if s_pos > q_pos:
+            qrs_width.append((s_pos - q_pos) / fs)
+    
+    qrs_width_mean = np.mean(qrs_width) if qrs_width else 0
+    qrs_width_std = np.std(qrs_width) if qrs_width else 0
+    qrs_amplitude_mean = np.mean([signal[r] for r in r_peaks]) if r_peaks.size > 0 else 0
+    
+    return [qrs_width_mean, qrs_width_std, qrs_amplitude_mean]
+
+
+def digitize_ecg_from_pdf(pdf_path, output_file=None):
     """
     Process an ECG PDF file and convert it to a .dat signal file.
     
     Args:
         pdf_path (str): Path to the ECG PDF file
-        output_file (str): Path to save the output .dat file (default: 'calibrated_ecg.dat')
-        debug (bool): Whether to print debug information
-        save_segments (bool): Whether to save individual segments
+        output_file (str, optional): Path to save the output .dat file
     
     Returns:
         tuple: (path to the created .dat file, list of paths to segment files)
     """
-    if debug:
-        print(f"Starting ECG digitization from PDF: {pdf_path}")
+    if output_file is None:
+        output_file = 'calibrated_ecg.dat'
     
-    # Convert PDF to image
     images = convert_from_path(pdf_path)
     temp_image_path = 'temp_ecg_image.jpg'
     images[0].save(temp_image_path, 'JPEG')
     
-    if debug:
-        print(f"Converted PDF to image: {temp_image_path}")
-    
-    # Load the image
     img = cv2.imread(temp_image_path, cv2.IMREAD_GRAYSCALE)
     height, width = img.shape
     
-    if debug:
-        print(f"Image dimensions: {width}x{height}")
-    
-    # Fixed calibration parameters
     calibration = {
-        'seconds_per_pixel': 2.0 / 197.0,  # 197 pixels = 2 seconds
-        'mv_per_pixel': 1.0 / 78.8,        # 78.8 pixels = 1 mV
+        'seconds_per_pixel': 2.0 / 197.0,
+        'mv_per_pixel': 1.0 / 78.8,
     }
     
-    if debug:
-        print(f"Calibration parameters: {calibration}")
-    
-    # Calculate layer boundaries using percentages
     layer1_start = int(height * 35.35 / 100)
     layer1_end = int(height * 51.76 / 100)
     layer2_start = int(height * 51.82 / 100)
@@ -59,210 +115,123 @@ def digitize_ecg_from_pdf(pdf_path, output_file='calibrated_ecg.dat', debug=Fals
     layer3_start = int(height * 69.47 / 100)
     layer3_end = int(height * 87.06 / 100)
     
-    if debug:
-        print(f"Layer 1 boundaries: {layer1_start}-{layer1_end}")
-        print(f"Layer 2 boundaries: {layer2_start}-{layer2_end}")
-        print(f"Layer 3 boundaries: {layer3_start}-{layer3_end}")
-    
-    # Crop each layer
     layers = [
-        img[layer1_start:layer1_end, :],  # Layer 1
-        img[layer2_start:layer2_end, :],  # Layer 2
-        img[layer3_start:layer3_end, :]   # Layer 3
+        img[layer1_start:layer1_end, :],
+        img[layer2_start:layer2_end, :],
+        img[layer3_start:layer3_end, :]
     ]
     
-    # Process each layer to extract waveform contours
     signals = []
     time_points = []
-    layer_duration = 10.0  # Each layer is 10 seconds long
+    layer_duration = 10.0
     
     for i, layer in enumerate(layers):
-        if debug:
-            print(f"Processing layer {i+1}...")
-        
-        # Binary thresholding
         _, binary = cv2.threshold(layer, 200, 255, cv2.THRESH_BINARY_INV)
         
-        # Detect contours
         contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        waveform_contour = max(contours, key=cv2.contourArea)  # Largest contour is the ECG
-        
-        if debug:
-            print(f"  - Found {len(contours)} contours")
-            print(f"  - Selected contour with {len(waveform_contour)} points")
+        waveform_contour = max(contours, key=cv2.contourArea)
         
-        # Sort contour points and extract coordinates
         sorted_contour = sorted(waveform_contour, key=lambda p: p[0][0])
         x_coords = np.array([point[0][0] for point in sorted_contour])
         y_coords = np.array([point[0][1] for point in sorted_contour])
         
-        # Calculate isoelectric line (one-third from the bottom)
         isoelectric_line_y = layer.shape[0] * 0.6
         
-        # Convert to time using fixed layer duration
         x_min, x_max = np.min(x_coords), np.max(x_coords)
         time = (x_coords - x_min) / (x_max - x_min) * layer_duration
         
-        # Calculate signal in millivolts and apply baseline correction
         signal_mv = (isoelectric_line_y - y_coords) * calibration['mv_per_pixel']
         signal_mv = signal_mv - np.mean(signal_mv)
         
-        if debug:
-            print(f"  - Layer {i+1} signal range: {np.min(signal_mv):.2f} mV to {np.max(signal_mv):.2f} mV")
-        
-        # Store the time points and calibrated signal
         time_points.append(time)
         signals.append(signal_mv)
     
-    # Save individual segments if requested
-    segment_files = []
-    sampling_frequency = 500  # Standard ECG frequency
-    samples_per_segment = int(layer_duration * sampling_frequency)  # 5000 samples per 10-second segment
-    
-    if save_segments:
-        base_name = os.path.splitext(output_file)[0]
-        
-        for i, signal in enumerate(signals):
-            # Interpolate to get evenly sampled signal
-            segment_time = np.linspace(0, layer_duration, samples_per_segment)
-            interpolated_signal = np.interp(segment_time, time_points[i], signals[i])
-            
-            # Normalize and scale
-            interpolated_signal = interpolated_signal - np.mean(interpolated_signal)
-            signal_peak = np.max(np.abs(interpolated_signal))
-            
-            if signal_peak > 0 and (signal_peak < 0.5 or signal_peak > 4.0):
-                scaling_factor = 2.0 / signal_peak  # Target peak amplitude of 2.0 mV
-                interpolated_signal = interpolated_signal * scaling_factor
-            
-            # Convert to 16-bit integers
-            adc_gain = 1000.0
-            int_signal = (interpolated_signal * adc_gain).astype(np.int16)
-            
-            # Save segment
-            segment_file = f"{base_name}_segment{i+1}.dat"
-            int_signal.reshape(-1, 1).tofile(segment_file)
-            segment_files.append(segment_file)
-            
-            if debug:
-                print(f"Saved segment {i+1} to {segment_file}")
-    
-    # Combine signals with proper time alignment for the full record
     total_duration = layer_duration * len(layers)
+    sampling_frequency = 500
     num_samples = int(total_duration * sampling_frequency)
     combined_time = np.linspace(0, total_duration, num_samples)
     combined_signal = np.zeros(num_samples)
     
-    if debug:
-        print(f"Combining signals with {sampling_frequency} Hz sampling rate, total duration: {total_duration}s")
-    
-    # Place each lead at the correct time position
     for i, (time, signal) in enumerate(zip(time_points, signals)):
         start_time = i * layer_duration
         mask = (combined_time >= start_time) & (combined_time < start_time + layer_duration)
         relevant_times = combined_time[mask]
         interpolated_signal = np.interp(relevant_times, start_time + time, signal)
         combined_signal[mask] = interpolated_signal
-        
-        if debug:
-            print(f"  - Added layer {i+1} signal from {start_time}s to {start_time + layer_duration}s")
     
-    # Baseline correction and amplitude scaling
     combined_signal = combined_signal - np.mean(combined_signal)
     signal_peak = np.max(np.abs(combined_signal))
-    target_amplitude = 2.0  # Target peak amplitude in mV
-    
-    if debug:
-        print(f"Signal peak before scaling: {signal_peak:.2f} mV")
+    target_amplitude = 2.0
     
     if signal_peak > 0 and (signal_peak < 0.5 or signal_peak > 4.0):
         scaling_factor = target_amplitude / signal_peak
         combined_signal = combined_signal * scaling_factor
-        if debug:
-            print(f"Applied scaling factor: {scaling_factor:.2f}")
-            print(f"Signal peak after scaling: {np.max(np.abs(combined_signal)):.2f} mV")
     
-    # Convert to 16-bit integers and save as .dat file
-    adc_gain = 1000.0  # Standard gain: 1000 units per mV
+    adc_gain = 1000.0
     int_signal = (combined_signal * adc_gain).astype(np.int16)
     int_signal.tofile(output_file)
     
-    if debug:
-        print(f"Saved signal to {output_file} with {len(int_signal)} samples")
-        print(f"Integer signal range: {np.min(int_signal)} to {np.max(int_signal)}")
-    
-    # Clean up temporary files
     if os.path.exists(temp_image_path):
         os.remove(temp_image_path)
-        if debug:
-            print(f"Removed temporary image: {temp_image_path}")
+    
+    segment_files = []
+    samples_per_segment = int(layer_duration * sampling_frequency)
+    
+    base_name = os.path.splitext(output_file)[0]
+    for i in range(3):
+        start_idx = i * samples_per_segment
+        end_idx = (i + 1) * samples_per_segment
+        segment = combined_signal[start_idx:end_idx]
+        
+        segment_file = f"{base_name}_segment{i+1}.dat"
+        (segment * adc_gain).astype(np.int16).tofile(segment_file)
+        segment_files.append(segment_file)
     
     return output_file, segment_files
 
-# Add a function to split a DAT file into segments
-def split_dat_into_segments(file_path, segment_duration=10.0, debug=False):
+
+def split_dat_into_segments(file_path, segment_duration=10.0):
     """
     Split a DAT file into equal segments.
     
     Args:
         file_path (str): Path to the DAT file (without extension)
         segment_duration (float): Duration of each segment in seconds
-        debug (bool): Whether to print debug information
         
     Returns:
         list: Paths to the segment files
     """
-    try:
-        # Load the signal
-        signal_all_leads, fs = load_dat_signal(file_path, debug=debug)
-        
-        if debug:
-            print(f"Loaded signal with shape {signal_all_leads.shape}")
-        
-        # Choose a lead
-        if signal_all_leads.shape[1] == 1:
-            lead_index = 0
-        else:
-            lead_priority = [1, 0]  # Try Lead II (index 1), then I (index 0)
-            lead_index = next((i for i in lead_priority if i < signal_all_leads.shape[1]), 0)
-            
-        signal = signal_all_leads[:, lead_index]
-        
-        # Calculate samples per segment
-        samples_per_segment = int(segment_duration * fs)
-        total_samples = len(signal)
-        num_segments = total_samples // samples_per_segment
-        
-        if debug:
-            print(f"Splitting signal into {num_segments} segments of {segment_duration} seconds each")
-            
-        segment_files = []
-        
-        # Split and save each segment
-        base_name = os.path.splitext(file_path)[0]
+    signal_all_leads, fs = load_dat_signal(file_path)
+    
+    if signal_all_leads.shape[1] == 1:
+        lead_index = 0
+    else:
+        lead_priority = [1, 0]  # Try Lead II (index 1), then I (index 0)
+        lead_index = next((i for i in lead_priority if i < signal_all_leads.shape[1]), 0)
         
-        for i in range(num_segments):
-            start_idx = i * samples_per_segment
-            end_idx = (i + 1) * samples_per_segment
-            segment = signal[start_idx:end_idx]
-            
-            # Save segment
-            segment_file = f"{base_name}_segment{i+1}.dat"
-            segment.reshape(-1, 1).tofile(segment_file)
-            segment_files.append(segment_file)
+    signal = signal_all_leads[:, lead_index]
+    
+    samples_per_segment = int(segment_duration * fs)
+    total_samples = len(signal)
+    num_segments = total_samples // samples_per_segment
+    
+    segment_files = []
+    
+    base_name = os.path.splitext(file_path)[0]
+    
+    for i in range(num_segments):
+        start_idx = i * samples_per_segment
+        end_idx = (i + 1) * samples_per_segment
+        segment = signal[start_idx:end_idx]
+        
+        segment_file = f"{base_name}_segment{i+1}.dat"
+        segment.reshape(-1, 1).tofile(segment_file)
+        segment_files.append(segment_file)
             
-            if debug:
-                print(f"Saved segment {i+1} to {segment_file}")
-                
-        return segment_files
-        
-    except Exception as e:
-        if debug:
-            print(f"Error splitting DAT file: {str(e)}")
-        return []
+    return segment_files
+
 
-# Add function to load DAT signals
-def load_dat_signal(file_path, n_leads=12, n_samples=5000, dtype=np.int16, debug=False):
+def load_dat_signal(file_path, n_leads=12, n_samples=5000, dtype=np.int16):
     """
     Load a DAT file containing ECG signal data.
     
@@ -271,79 +240,46 @@ def load_dat_signal(file_path, n_leads=12, n_samples=5000, dtype=np.int16, debug
         n_leads (int): Number of leads in the signal
         n_samples (int): Number of samples per lead
         dtype: Data type of the signal
-        debug (bool): Whether to print debug information
         
     Returns:
         tuple: (numpy array of signal data, sampling frequency)
     """
-    try:
-        # Handle both cases: with and without .dat extension
-        if file_path.endswith('.dat'):
-            dat_path = file_path
-        else:
-            dat_path = file_path + '.dat'
-            
-        if debug:
-            print(f"Loading signal from: {dat_path}")
-            
-        raw = np.fromfile(dat_path, dtype=dtype)
+    if file_path.endswith('.dat'):
+        dat_path = file_path
+    else:
+        dat_path = file_path + '.dat'
         
-        if debug:
-            print(f"Raw data size: {raw.size}")
-            
-        # Try to infer number of leads if read size doesn't match expected
-        if raw.size != n_leads * n_samples:
-            if debug:
-                print(f"Unexpected size: {raw.size}, expected {n_leads * n_samples}")
-                print("Attempting to infer number of leads...")
-                
-            # Check if single lead
-            if raw.size == n_samples:
-                if debug:
-                    print("Detected single lead signal")
-                signal = raw.reshape(n_samples, 1)
-                return signal, 500
-                
-            # Try common lead counts
-            possible_leads = [1, 2, 3, 6, 12]
-            for possible_lead_count in possible_leads:
-                if raw.size % possible_lead_count == 0:
-                    actual_samples = raw.size // possible_lead_count
-                    if debug:
-                        print(f"Inferred {possible_lead_count} leads with {actual_samples} samples each")
-                    signal = raw.reshape(actual_samples, possible_lead_count)
-                    return signal, 500
-            
-            # If we can't determine it reliably, reshape as single lead
-            if debug:
-                print("Could not infer lead count, reshaping as single lead")
-            signal = raw.reshape(-1, 1)
+    raw = np.fromfile(dat_path, dtype=dtype)
+    
+    if raw.size != n_leads * n_samples:
+        if raw.size == n_samples:
+            signal = raw.reshape(n_samples, 1)
             return signal, 500
             
-        # Normal case when size matches expectation
-        signal = raw.reshape(n_samples, n_leads)
-        return signal, 500  # Signal + sampling frequency
-    except Exception as e:
-        if debug:
-            print(f"Error loading DAT file: {str(e)}")
-        # Return empty signal with single channel
-        return np.zeros((n_samples, 1)), 500
+        possible_leads = [1, 2, 3, 6, 12]
+        for possible_lead_count in possible_leads:
+            if raw.size % possible_lead_count == 0:
+                actual_samples = raw.size // possible_lead_count
+                signal = raw.reshape(actual_samples, possible_lead_count)
+                return signal, 500
+        
+        signal = raw.reshape(-1, 1)
+        return signal, 500
+        
+    signal = raw.reshape(n_samples, n_leads)
+    return signal, 500
+
 
-# Add the feature extraction function
-def extract_features_from_signal(signal, debug=False):
+def extract_features_from_signal(signal):
     """
     Extract features from an ECG signal.
     
     Args:
         signal (numpy.ndarray): ECG signal
-        debug (bool): Whether to print debug information
         
     Returns:
-        list: Features extracted from the signal
+        list: Basic features extracted from the signal (32 features)
     """
-    if debug:
-        print("Extracting features from signal...")
-        
     features = []
     features.append(np.mean(signal))
     features.append(np.std(signal))
@@ -354,129 +290,108 @@ def extract_features_from_signal(signal, debug=False):
     features.append(np.percentile(signal, 75))
     features.append(np.mean(np.diff(signal)))
 
-    if debug:
-        print("Computing wavelet decomposition...")
-        
     coeffs = pywt.wavedec(signal, 'db4', level=5)
-    for i, coeff in enumerate(coeffs):
+    for coeff in coeffs:
         features.append(np.mean(coeff))
         features.append(np.std(coeff))
         features.append(np.min(coeff))
         features.append(np.max(coeff))
-        
-        if debug and i == 0:
-            print(f"Wavelet features for level {i}: mean={np.mean(coeff):.4f}, std={np.std(coeff):.4f}")
 
-    if debug:
-        print(f"Extracted {len(features)} features")
-        
     return features
 
-# Add the classify_new_ecg function
-def classify_new_ecg(file_path, model, debug=False):
+
+def classify_new_ecg(file_path, model):
     """
     Classify a new ECG file.
     
     Args:
         file_path (str): Path to the ECG file (without extension)
         model: The trained model for classification
-        debug (bool): Whether to print debug information
         
     Returns:
         str: Classification result ("Normal", "Abnormal", or error message)
     """
-    try:
-        if debug:
-            print(f"Classifying ECG from: {file_path}")
-            
-        signal_all_leads, fs = load_dat_signal(file_path, debug=debug)
-        
-        if debug:
-            print(f"Loaded signal with shape {signal_all_leads.shape}, sampling rate {fs} Hz")
-            
-        # Choose lead for analysis - priority order
-        if signal_all_leads.shape[1] == 1:
-            lead_index = 0
-            if debug:
-                print("Using single lead")
-        else:
-            lead_priority = [1, 0]  # Try Lead II (index 1), then I (index 0)
-            lead_index = next((i for i in lead_priority if i < signal_all_leads.shape[1]), 0)
-            if debug:
-                print(f"Using lead index {lead_index}")
-
-        # Extract the signal
-        signal = signal_all_leads[:, lead_index]
-        
-        # Normalize signal
-        signal = (signal - np.mean(signal)) / np.std(signal)
-        
-        if debug:
-            print("Signal normalized")
-            print(f"Detecting QRS complexes...")
-
-        # Detect QRS complexes
-        try:
-            xqrs = processing.XQRS(sig=signal, fs=fs)
-            xqrs.detect()
-            r_peaks = xqrs.qrs_inds
-            if debug:
-                print(f"Detected {len(r_peaks)} QRS complexes with XQRS method")
-        except Exception as e:
-            if debug:
-                print(f"XQRS detection failed: {str(e)}")
-                print("Falling back to GQRS detector")
-            r_peaks = processing.gqrs_detect(sig=signal, fs=fs)
-            if debug:
-                print(f"Detected {len(r_peaks)} QRS complexes with GQRS method")
+    signal_all_leads, fs = load_dat_signal(file_path)
+    
+    if signal_all_leads.shape[1] == 1:
+        lead_index = 0
+    else:
+        lead_priority = [1, 0]  # Try Lead II (index 1), then I (index 0)
+        lead_index = next((i for i in lead_priority if i < signal_all_leads.shape[1]), 0)
 
-        # Check if we found enough QRS complexes
-        if len(r_peaks) < 5:
-            if debug:
-                print(f"Insufficient beats detected: {len(r_peaks)}")
-            return "Insufficient beats"
+    signal = signal_all_leads[:, lead_index]
+    signal = (signal - np.mean(signal)) / np.std(signal)
+    
+    try:
+        r_peaks = processing.gqrs_detect(sig=signal, fs=fs)
+    except:
+        r_peaks = np.array([])
 
-        # Calculate RR intervals and QRS durations
+    if len(r_peaks) < 2:
+        basic_features = extract_features_from_signal(signal)
+        record_features = basic_features + [0] * (45 - len(basic_features))
+    else:
         rr_intervals = np.diff(r_peaks) / fs
         qrs_durations = np.array([r_peaks[i] - r_peaks[i - 1] for i in range(1, len(r_peaks))])
-        
-        if debug:
-            print(f"Mean RR interval: {np.mean(rr_intervals):.4f} s")
-            print(f"Mean QRS duration: {np.mean(qrs_durations) / fs:.4f} s")
 
-        # Extract features
-        features = extract_features_from_signal(signal, debug=debug)
+        record_features = []
+        basic_features = extract_features_from_signal(signal)
+        record_features.extend(basic_features)
         
-        # Add rhythm features
-        features.extend([
+        record_features.extend([
             len(r_peaks),
             np.mean(rr_intervals) if len(rr_intervals) > 0 else 0,
             np.std(rr_intervals) if len(rr_intervals) > 0 else 0,
             np.median(rr_intervals) if len(rr_intervals) > 0 else 0,
-            np.mean(qrs_durations) if len(qrs_durations) > 0 else 0,
-            np.std(qrs_durations) if len(qrs_durations) > 0 else 0
+            np.mean(qrs_durations) / fs if len(qrs_durations) > 0 else 0,
+            np.std(qrs_durations) / fs if len(qrs_durations) > 0 else 0
         ])
         
-        if debug:
-            print(f"Final feature vector length: {len(features)}")
-            
-        # Make prediction
-        prediction = model.predict([features])[0]
-        result = "Abnormal" if prediction == 1 else "Normal"
+        hrv_features = extract_hrv_features(rr_intervals)
+        record_features.extend(hrv_features)
         
-        if debug:
-            print(f"Classification result: {result} (prediction value: {prediction})")
+        qrs_features = extract_qrs_features(signal, r_peaks, fs)
+        record_features.extend(qrs_features)
+        
+        if len(rr_intervals) >= 4:
+            try:
+                rr_times = np.cumsum(rr_intervals)
+                rr_times = np.insert(rr_times, 0, 0)
+                
+                fs_interp = 4.0
+                t_interp = np.arange(0, rr_times[-1], 1/fs_interp)
+                rr_interp = np.interp(t_interp, rr_times[:-1], rr_intervals)
+                
+                freq, psd = sg.welch(rr_interp, fs=fs_interp, nperseg=min(256, len(rr_interp)))
+                
+                vlf_mask = (freq >= 0.0033) & (freq < 0.04)
+                lf_mask = (freq >= 0.04) & (freq < 0.15)
+                hf_mask = (freq >= 0.15) & (freq < 0.4)
+                
+                lf_power = np.trapz(psd[lf_mask], freq[lf_mask]) if np.any(lf_mask) else 0
+                hf_power = np.trapz(psd[hf_mask], freq[hf_mask]) if np.any(hf_mask) else 0
+                
+                lf_hf_ratio = lf_power / hf_power if hf_power > 0 else 0
+                normalized_lf = lf_power / (lf_power + hf_power) if (lf_power + hf_power) > 0 else 0
+            except:
+                lf_power = hf_power = lf_hf_ratio = normalized_lf = 0
+        else:
+            lf_power = hf_power = lf_hf_ratio = normalized_lf = 0
             
-        return result
+        record_features.extend([lf_power, hf_power, lf_hf_ratio, normalized_lf])
+    
+    if len(record_features) < 45:
+        record_features.extend([0] * (45 - len(record_features)))
+    elif len(record_features) > 45:
+        record_features = record_features[:45]
+        
+    prediction = model.predict([record_features])[0]
+    result = "Abnormal" if prediction == 1 else "Normal"
+    
+    return result
 
-    except Exception as e:
-        error_msg = f"Error: {str(e)}"
-        if debug:
-            print(error_msg)
-        return error_msg
 
-# Modify the classify_ecg wrapper function to use the voting approach
-def classify_ecg(file_path, model, is_pdf=False, debug=False):
+def classify_ecg(file_path, model, is_pdf=False):
     """
     Wrapper function that handles both PDF and DAT ECG files with segment voting.
     
@@ -484,86 +399,44 @@ def classify_ecg(file_path, model, is_pdf=False, debug=False):
         file_path (str): Path to the ECG file (.pdf or without extension for .dat)
         model: The trained model for classification
         is_pdf (bool): Whether the input file is a PDF (True) or DAT (False)
-        debug (bool): Enable debug output
         
     Returns:
         str: Classification result ("Normal", "Abnormal", or error message)
     """
     try:
-        # Check if model is valid
         if model is None:
             return "Error: Model not loaded. Please check model compatibility."
             
         if is_pdf:
-            if debug:
-                print(f"Processing PDF file: {file_path}")
-            
-            # Extract file name without extension for output
             base_name = os.path.splitext(os.path.basename(file_path))[0]
             output_dat = f"{base_name}_digitized.dat"
             
-            # Digitize the PDF to a DAT file and get segment files
             dat_path, segment_files = digitize_ecg_from_pdf(
                 pdf_path=file_path, 
-                output_file=output_dat, 
-                debug=debug
+                output_file=output_dat
             )
-            
-            if debug:
-                print(f"Digitized ECG saved to: {dat_path}")
-                print(f"Created {len(segment_files)} segment files")
         else:
-            if debug:
-                print(f"Processing DAT file: {file_path}")
-            
-            # For DAT files, we need to split into segments
-            segment_files = split_dat_into_segments(file_path, debug=debug)
+            segment_files = split_dat_into_segments(file_path)
             
             if not segment_files:
-                # If splitting failed, try classifying the whole file
-                return classify_new_ecg(file_path, model, debug=debug)
+                return classify_new_ecg(file_path, model)
         
-        # Process each segment and collect votes
         segment_results = []
         
-        for i, segment_file in enumerate(segment_files):
-            if debug:
-                print(f"\n--- Processing Segment {i+1} ---")
-                
-            # Get file path without extension
+        for segment_file in segment_files:
             segment_path = os.path.splitext(segment_file)[0]
-            
-            # Classify this segment
-            result = classify_new_ecg(segment_path, model, debug=debug)
-            
-            if debug:
-                print(f"Segment {i+1} classification: {result}")
-                
+            result = classify_new_ecg(segment_path, model)
             segment_results.append(result)
             
-            # Remove temporary segment files
             try:
                 os.remove(segment_file)
-                if debug:
-                    print(f"Removed temporary segment file: {segment_file}")
             except:
                 pass
         
-        # Count results and use majority voting
         if segment_results:
             normal_count = segment_results.count("Normal")
             abnormal_count = segment_results.count("Abnormal")
-            error_count = len(segment_results) - normal_count - abnormal_count
             
-            if debug:
-                print(f"\n--- Voting Results ---")
-                print(f"Normal votes: {normal_count}")
-                print(f"Abnormal votes: {abnormal_count}")
-                print(f"Errors/Inconclusive: {error_count}")
-            
-            # Decision rules:
-            # 1. If any segment is abnormal, classify as abnormal
-            # 2. Only classify as normal if majority of segments are normal
             if abnormal_count > normal_count:
                 final_result = "Abnormal"
             elif normal_count > abnormal_count:
@@ -571,41 +444,14 @@ def classify_ecg(file_path, model, is_pdf=False, debug=False):
             else:
                 final_result = "Inconclusive"
                 
-            if debug:
-                print(f"Final decision: {final_result}")
-                
             return final_result
         else:
             return "Error: No valid segments to classify"
         
     except Exception as e:
         error_msg = f"Classification error: {str(e)}"
-        if debug:
-            print(error_msg)
         return error_msg
-# Load the saved model
-try:
-    model_path = 'voting_classifier.pkl'
-    if os.path.exists(model_path):
-        voting_loaded = joblib.load(model_path)
-    else:
-        # Try to find the model in the current or parent directories
-        for root, dirs, files in os.walk('.'):
-            for file in files:
-                if file.endswith('.pkl') and 'voting' in file.lower():
-                    model_path = os.path.join(root, file)
-                    voting_loaded = joblib.load(model_path)
-                    break
-            if 'voting_loaded' in locals():
-                break
-                
-        if 'voting_loaded' not in locals():
-            voting_loaded = None
-except Exception as e:
-    voting_loaded = None
+    
+
 
-# Simple test for the classify_ecg function
-test_pdf_path = "sample.pdf"
-if os.path.exists(test_pdf_path) and voting_loaded is not None:
-    result_pdf = classify_ecg(test_pdf_path, voting_loaded, is_pdf=True)
-    print(f"Classification result: {result_pdf}")
+    

ECG/ECG_MultiClass.py

@@ -1,10 +1,10 @@
 """
-ECG Analysis Pipeline: From PDF to Diagnosis
--------------------------------------------
+ECG Analysis Pipeline: From PDF to Arrhythmia Classification
+-----------------------------------------------------------
 This module provides functions to:
 1. Digitize ECG from PDF files
 2. Process the digitized ECG signal
-3. Make diagnoses using a trained model
+3. Classify arrhythmias using a trained CNN model
 """
 
 import cv2
@@ -13,50 +13,42 @@ import os
 import tensorflow as tf
 import pickle
 from scipy.interpolate import interp1d
-from collections import Counter
 from pdf2image import convert_from_path
-import matplotlib.pyplot as plt  # Added for visualization
 
-def digitize_ecg_from_pdf(pdf_path, output_file='calibrated_ecg.dat', debug=False):
+ARRHYTHMIA_CLASSES = ["Conduction Abnormalities", "Atrial Arrhythmias", "Tachyarrhythmias", "Normal"]
+SAMPLING_RATE = 500
+SEGMENT_DURATION = 10.0
+TARGET_SEGMENT_LENGTH = 5000
+DEFAULT_OUTPUT_FILE = 'calibrated_ecg.dat'
+DAT_SCALE_FACTOR = 0.001
+
+
+def digitize_ecg_from_pdf(pdf_path, output_file=None):
     """
     Process an ECG PDF file and convert it to a .dat signal file.
     
     Args:
         pdf_path (str): Path to the ECG PDF file
-        output_file (str): Path to save the output .dat file (default: 'calibrated_ecg.dat')
-        debug (bool): Whether to print debug information
+        output_file (str, optional): Path to save the output .dat file
     
     Returns:
-        str: Path to the created .dat file
+        tuple: (path to the created .dat file, list of paths to segment files)
     """
-    if debug:
-        print(f"Starting ECG digitization from PDF: {pdf_path}")
+    if output_file is None:
+        output_file = DEFAULT_OUTPUT_FILE
     
-    # Convert PDF to image
     images = convert_from_path(pdf_path)
     temp_image_path = 'temp_ecg_image.jpg'
     images[0].save(temp_image_path, 'JPEG')
     
-    if debug:
-        print(f"Converted PDF to image: {temp_image_path}")
-    
-    # Load the image
     img = cv2.imread(temp_image_path, cv2.IMREAD_GRAYSCALE)
     height, width = img.shape
     
-    if debug:
-        print(f"Image dimensions: {width}x{height}")
-    
-    # Fixed calibration parameters
     calibration = {
-        'seconds_per_pixel': 2.0 / 197.0,  # 197 pixels = 2 seconds
-        'mv_per_pixel': 1.0 / 78.8,        # 78.8 pixels = 1 mV
+        'seconds_per_pixel': 2.0 / 197.0,
+        'mv_per_pixel': 1.0 / 78.8,
     }
     
-    if debug:
-        print(f"Calibration parameters: {calibration}")
-    
-    # Calculate layer boundaries using percentages
     layer1_start = int(height * 35.35 / 100)
     layer1_end = int(height * 51.76 / 100)
     layer2_start = int(height * 51.82 / 100)
@@ -64,239 +56,126 @@ def digitize_ecg_from_pdf(pdf_path, output_file='calibrated_ecg.dat', debug=Fals
     layer3_start = int(height * 69.47 / 100)
     layer3_end = int(height * 87.06 / 100)
     
-    if debug:
-        print(f"Layer 1 boundaries: {layer1_start}-{layer1_end}")
-        print(f"Layer 2 boundaries: {layer2_start}-{layer2_end}")
-        print(f"Layer 3 boundaries: {layer3_start}-{layer3_end}")
-    
-    # Crop each layer
     layers = [
-        img[layer1_start:layer1_end, :],  # Layer 1
-        img[layer2_start:layer2_end, :],  # Layer 2
-        img[layer3_start:layer3_end, :]   # Layer 3
+        img[layer1_start:layer1_end, :],
+        img[layer2_start:layer2_end, :],
+        img[layer3_start:layer3_end, :]
     ]
     
-    # Process each layer to extract waveform contours
     signals = []
     time_points = []
-    layer_duration = 10.0  # Each layer is 10 seconds long
+    layer_duration = 10.0
     
     for i, layer in enumerate(layers):
-        if debug:
-            print(f"Processing layer {i+1}...")
-        
-        # Binary thresholding
         _, binary = cv2.threshold(layer, 200, 255, cv2.THRESH_BINARY_INV)
         
-        # Detect contours
         contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        waveform_contour = max(contours, key=cv2.contourArea)  # Largest contour is the ECG
-        
-        if debug:
-            print(f"  - Found {len(contours)} contours")
-            print(f"  - Selected contour with {len(waveform_contour)} points")
+        waveform_contour = max(contours, key=cv2.contourArea)
         
-        # Sort contour points and extract coordinates
         sorted_contour = sorted(waveform_contour, key=lambda p: p[0][0])
         x_coords = np.array([point[0][0] for point in sorted_contour])
         y_coords = np.array([point[0][1] for point in sorted_contour])
         
-        # Calculate isoelectric line (one-third from the bottom)
         isoelectric_line_y = layer.shape[0] * 0.6
         
-        # Convert to time using fixed layer duration
         x_min, x_max = np.min(x_coords), np.max(x_coords)
         time = (x_coords - x_min) / (x_max - x_min) * layer_duration
         
-        # Calculate signal in millivolts and apply baseline correction
         signal_mv = (isoelectric_line_y - y_coords) * calibration['mv_per_pixel']
         signal_mv = signal_mv - np.mean(signal_mv)
         
-        if debug:
-            print(f"  - Layer {i+1} signal range: {np.min(signal_mv):.2f} mV to {np.max(signal_mv):.2f} mV")
-        
-        # Store the time points and calibrated signal
         time_points.append(time)
         signals.append(signal_mv)
     
-    # Combine signals with proper time alignment
     total_duration = layer_duration * len(layers)
-    sampling_frequency = 500  # Standard ECG frequency
+    sampling_frequency = 500
     num_samples = int(total_duration * sampling_frequency)
     combined_time = np.linspace(0, total_duration, num_samples)
     combined_signal = np.zeros(num_samples)
     
-    if debug:
-        print(f"Combining signals with {sampling_frequency} Hz sampling rate, total duration: {total_duration}s")
-    
-    # Place each lead at the correct time position
     for i, (time, signal) in enumerate(zip(time_points, signals)):
         start_time = i * layer_duration
         mask = (combined_time >= start_time) & (combined_time < start_time + layer_duration)
         relevant_times = combined_time[mask]
         interpolated_signal = np.interp(relevant_times, start_time + time, signal)
         combined_signal[mask] = interpolated_signal
-        
-        if debug:
-            print(f"  - Added layer {i+1} signal from {start_time}s to {start_time + layer_duration}s")
     
-    # Baseline correction and amplitude scaling
     combined_signal = combined_signal - np.mean(combined_signal)
     signal_peak = np.max(np.abs(combined_signal))
-    target_amplitude = 2.0  # Target peak amplitude in mV
-    
-    if debug:
-        print(f"Signal peak before scaling: {signal_peak:.2f} mV")
+    target_amplitude = 2.0
     
     if signal_peak > 0 and (signal_peak < 0.5 or signal_peak > 4.0):
         scaling_factor = target_amplitude / signal_peak
         combined_signal = combined_signal * scaling_factor
-        if debug:
-            print(f"Applied scaling factor: {scaling_factor:.2f}")
-            print(f"Signal peak after scaling: {np.max(np.abs(combined_signal)):.2f} mV")
     
-    # Convert to 16-bit integers and save as .dat file
-    adc_gain = 1000.0  # Standard gain: 1000 units per mV
+    adc_gain = 1000.0
     int_signal = (combined_signal * adc_gain).astype(np.int16)
     int_signal.tofile(output_file)
     
-    if debug:
-        print(f"Saved signal to {output_file} with {len(int_signal)} samples")
-        print(f"Integer signal range: {np.min(int_signal)} to {np.max(int_signal)}")
-    
-    # Clean up temporary files
     if os.path.exists(temp_image_path):
         os.remove(temp_image_path)
-        if debug:
-            print(f"Removed temporary image: {temp_image_path}")
     
-    return output_file
-
-def visualize_ecg_signal(signal, sampling_rate=500, title="Digitized ECG Signal"):
-    """
-    Visualize an ECG signal with proper time axis.
+    segment_files = []
+    samples_per_segment = int(layer_duration * sampling_frequency)
     
-    Parameters:
-    -----------
-    signal : numpy.ndarray
-        ECG signal data
-    sampling_rate : int
-        Sampling rate in Hz
-    title : str
-        Plot title
-    """
-    # Calculate time axis
-    time = np.arange(len(signal)) / sampling_rate
-    
-    # Create figure with appropriate size
-    plt.figure(figsize=(15, 5))
-    plt.plot(time, signal)
-    plt.title(title)
-    plt.xlabel('Time (seconds)')
-    plt.ylabel('Amplitude (mV)')
-    plt.grid(True)
-    
-    # Add 1mV scale bar
-    plt.plot([1, 1], [-0.5, 0.5], 'r-', linewidth=2)
-    plt.text(1.1, 0, '1mV', va='center')
-    
-    # Add time scale bar (1 second)
-    y_min = np.min(signal)
-    plt.plot([1, 2], [y_min, y_min], 'r-', linewidth=2)
-    plt.text(1.5, y_min - 0.1, '1s', ha='center')
-    
-    plt.tight_layout()
-    plt.show()
+    base_name = os.path.splitext(output_file)[0]
+    for i in range(3):
+        start_idx = i * samples_per_segment
+        end_idx = (i + 1) * samples_per_segment
+        segment = combined_signal[start_idx:end_idx]
+        
+        segment_file = f"{base_name}_segment{i+1}.dat"
+        (segment * adc_gain).astype(np.int16).tofile(segment_file)
+        segment_files.append(segment_file)
+    
+    return output_file, segment_files
 
-def read_lead_i_long_dat_file(dat_file_path, sampling_rate=500, data_format='16', scale_factor=0.001):
+
+def read_ecg_dat_file(dat_file_path):
     """
-    Read a 30-second pure Lead I .dat file directly and properly scale it
+    Read a DAT file directly and properly scale it
     
     Parameters:
     -----------
     dat_file_path : str
         Path to the .dat file (with or without .dat extension)
-    sampling_rate : int
-        Sampling rate in Hz (default 500Hz)
-    data_format : str
-        Data format of the binary file: '16' for 16-bit integers, '32' for 32-bit floats
-    scale_factor : float
-        Scale factor to convert units (0.001 for converting µV to mV)
         
     Returns:
     --------
     numpy.ndarray
-        ECG signal data for Lead I with shape (total_samples,)
+        ECG signal data with shape (total_samples,)
     """
-    # Ensure the path ends with .dat
     if not dat_file_path.endswith('.dat'):
         dat_file_path += '.dat'
     
-    # Expected samples for full 30 seconds
-    expected_samples = sampling_rate * 30
-    
-    # Read the binary data
     try:
-        if data_format == '16':
-            # 16-bit signed integers (common format for ECG)
-            data = np.fromfile(dat_file_path, dtype=np.int16)
-        elif data_format == '32':
-            # 32-bit floating point (less common)
-            data = np.fromfile(dat_file_path, dtype=np.float32)
-        else:
-            raise ValueError(f"Unsupported data format: {data_format}")
-    
-        # Apply scaling to convert µV to mV
-        signal = data * scale_factor
-        
-        # Handle if signal is not exactly 30 seconds
-        if len(signal) < expected_samples:
-            # Pad with zeros if too short
-            padded_signal = np.zeros(expected_samples)
-            padded_signal[:len(signal)] = signal
-            signal = padded_signal
-        elif len(signal) > expected_samples:
-            # Truncate if too long
-            signal = signal[:expected_samples]
-        
+        data = np.fromfile(dat_file_path, dtype=np.int16)
+        signal = data * DAT_SCALE_FACTOR
         return signal
         
     except Exception as e:
         raise
 
-def segment_signal(signal, sampling_rate=500):
+def segment_signal(signal):
     """
-    Segment a 30-second signal into three 10-second segments
+    Segment a signal into equal-length segments
     
     Parameters:
     -----------
     signal : numpy.ndarray
         The full signal to segment
-    sampling_rate : int
-        Sampling rate in Hz
         
     Returns:
     --------
     list
-        List of three 10-second signal segments
+        List of signal segments
     """
-    # Calculate samples per segment (10 seconds)
-    segment_samples = sampling_rate * 10
-    
-    # Expected samples for full 30 seconds
-    expected_samples = sampling_rate * 30
-    
-    # Ensure the signal is 30 seconds long
-    if len(signal) != expected_samples:
-        # Resample to 30 seconds
-        x = np.linspace(0, 1, len(signal))
-        x_new = np.linspace(0, 1, expected_samples)
-        f = interp1d(x, signal, kind='linear', bounds_error=False, fill_value="extrapolate")
-        signal = f(x_new)
+    segment_samples = int(SAMPLING_RATE * SEGMENT_DURATION)
     
-    # Split the signal into three 10-second segments
     segments = []
-    for i in range(3):
+    num_segments = len(signal) // segment_samples
+    
+    for i in range(num_segments):
         start_idx = i * segment_samples
         end_idx = (i + 1) * segment_samples
         segment = signal[start_idx:end_idx]
@@ -304,7 +183,7 @@ def segment_signal(signal, sampling_rate=500):
         
     return segments
 
-def process_segment(segment, sampling_rate=500):
+def process_segment(segment):
     """
     Process a segment of ECG data to ensure it's properly formatted for the model
     
@@ -312,243 +191,123 @@ def process_segment(segment, sampling_rate=500):
     -----------
     segment : numpy.ndarray
         Raw ECG segment
-    sampling_rate : int
-        Sampling rate of the ECG
         
     Returns:
     --------
     numpy.ndarray
         Processed segment ready for model input
     """
-    # Ensure correct length (5000 samples for 10 seconds)
-    if len(segment) != 5000:
+    if len(segment) != TARGET_SEGMENT_LENGTH:
         x = np.linspace(0, 1, len(segment))
-        x_new = np.linspace(0, 1, 5000)
+        x_new = np.linspace(0, 1, TARGET_SEGMENT_LENGTH)
         f = interp1d(x, segment, kind='linear', bounds_error=False, fill_value="extrapolate")
         segment = f(x_new)
     
+    segment = (segment - np.mean(segment)) / (np.std(segment) + 1e-8)
+    
     return segment
 
-def predict_with_voting(dat_file_path, model_path, mlb_path=None, sampling_rate=500, scale_factor=0.001, debug=False):
+
+def predict_with_cnn_model(signal_data, model):
     """
-    Process a 30-second .dat file, properly scale it, split it into three 10-second segments,
-    make predictions on each segment, and return the class with highest average probability.
+    Process signal data and make predictions using the CNN model.
     
     Parameters:
     -----------
-    dat_file_path : str
-        Path to the .dat file
-    model_path : str
-        Path to the saved model (.h5 file)
-    mlb_path : str, optional
-        Path to the saved MultiLabelBinarizer pickle file for label decoding
-    sampling_rate : int
-        Sampling rate in Hz (default 500Hz)
-    scale_factor : float
-        Scale factor to convert units (0.001 for converting µV to mV)
-    debug : bool
-        Whether to print debug information
+    signal_data : numpy.ndarray
+        Raw signal data
+    model : tensorflow.keras.Model
+        Loaded CNN model
         
     Returns:
     --------
     dict
-        Dictionary containing segment predictions and final class probabilities
+        Dictionary containing predictions for each segment and final averaged prediction
     """
-    try:
-        # Step 1: Read the 30-second ECG data (pure Lead I) and apply scaling
-        if debug:
-            print(f"Reading signal from {dat_file_path}")
-        
-        full_signal = read_lead_i_long_dat_file(
-            dat_file_path, 
-            sampling_rate=sampling_rate,
-            scale_factor=scale_factor
-        )
-        
-        if debug:
-            print(f"Signal loaded: {len(full_signal)} samples, range: {np.min(full_signal):.2f} to {np.max(full_signal):.2f} mV")
-        
-        # Step 2: Split into three 10-second segments
-        segments = segment_signal(full_signal, sampling_rate)
-        
-        if debug:
-            print(f"Split into {len(segments)} segments of {len(segments[0])} samples each")
-        
-        # Step 3: Load the model (load once to improve performance)
-        if debug:
-            print(f"Loading model from {model_path}")
-        
-        model = tf.keras.models.load_model(model_path)
-        
-        # Load MLB if provided
-        mlb = None
-        if mlb_path and os.path.exists(mlb_path):
-            if debug:
-                print(f"Loading label binarizer from {mlb_path}")
-            with open(mlb_path, 'rb') as f:
-                mlb = pickle.load(f)
-        
-        # Step 4: Process each segment and collect predictions
-        segment_results = []
-        all_predictions = []
-        
-        for i, segment in enumerate(segments):
-            if debug:
-                print(f"Processing segment {i+1}...")
-            
-            # Process the segment to ensure it's properly formatted
-            processed_segment = process_segment(segment)
-            
-            # Reshape for model input (batch, time, channels)
-            X = processed_segment.reshape(1, 5000, 1)
-            
-            # Make predictions
-            predictions = model.predict(X, verbose=0)
-            all_predictions.append(predictions[0])
-            
-            # Process segment results
-            segment_result = {"raw_predictions": predictions[0].tolist()}
-            
-            # Decode labels if MLB is provided
-            if mlb is not None:
-                # Add class probabilities
-                class_probs = {}
-                for j, class_name in enumerate(mlb.classes_):
-                    class_probs[class_name] = float(predictions[0][j])
-                
-                segment_result["class_probabilities"] = class_probs
-            
-            segment_results.append(segment_result)
+    segments = segment_signal(signal_data)
+    
+    all_predictions = []
+    
+    for i, segment in enumerate(segments):
+        processed_segment = process_segment(segment)
         
-        # Step 5: Calculate average probabilities across all segments
-        final_result = {"segment_results": segment_results}
+        X = processed_segment.reshape(1, TARGET_SEGMENT_LENGTH, 1)
         
-        # Average the raw predictions
-        avg_predictions = np.mean(all_predictions, axis=0)
-        final_result["averaged_raw_predictions"] = avg_predictions.tolist()
+        prediction = model.predict(X, verbose=0)
+        all_predictions.append(prediction[0])
+    
+    if all_predictions:
+        avg_prediction = np.mean(all_predictions, axis=0)
+        top_class_idx = np.argmax(avg_prediction)
         
-        # Calculate final class probabilities (average across segments)
-        if mlb is not None:
-            # Calculate average probability for each class
-            final_class_probs = {}
-            for cls_idx, cls_name in enumerate(mlb.classes_):
-                final_class_probs[cls_name] = float(np.mean([pred[cls_idx] for pred in all_predictions]))
-            
-            # Find the class with highest average probability
-            top_class = max(final_class_probs.items(), key=lambda x: x[1])
-            top_class_name = top_class[0]
-            
-            final_result["final_class_probabilities"] = final_class_probs
-            final_result["top_class"] = top_class_name
+        results = {
+            "segment_predictions": all_predictions,
+            "averaged_prediction": avg_prediction,
+            "top_class_index": top_class_idx,
+            "top_class": ARRHYTHMIA_CLASSES[top_class_idx],
+            "probability": float(avg_prediction[top_class_idx])
+        }
             
-            if debug:
-                print(f"Top class by average probability: {top_class_name} ({top_class[1]:.2f})")
-        
-        return final_result
-        
-    except Exception as e:
-        if debug:
-            print(f"Error in predict_with_voting: {str(e)}")
-        return {"error": str(e)}
+        return results
+    else:
+        return {"error": "No valid segments for prediction"}
 
-def analyze_ecg_pdf(pdf_path, model_path, mlb_path=None, temp_dat_file='calibrated_ecg.dat', cleanup=True, debug=False, visualize=False):
+def analyze_ecg_pdf(pdf_path, model_path, cleanup=True):
     """
     Complete ECG analysis pipeline: digitizes a PDF ECG, analyzes it with the model,
-    and returns the diagnosis with highest probability.
+    and returns the arrhythmia classification with highest probability.
     
     Args:
         pdf_path (str): Path to the ECG PDF file
         model_path (str): Path to the model (.h5) file
-        mlb_path (str, optional): Path to the MultiLabelBinarizer file
-        temp_dat_file (str, optional): Path to save the temporary digitized file
         cleanup (bool, optional): Whether to remove temporary files after processing
-        debug (bool, optional): Whether to print debug information
-        visualize (bool, optional): Whether to visualize the digitized signal
     
     Returns:
         dict: {
-            "diagnosis": str,  # Top diagnosis (highest average probability)
-            "probability": float,  # Probability of top diagnosis
-            "all_probabilities": dict,  # All diagnoses with probabilities
+            "arrhythmia_class": str,  # Top arrhythmia class
+            "probability": float,  # Probability of top class
+            "all_probabilities": dict,  # All classes with probabilities
             "digitized_file": str  # Path to digitized file (if cleanup=False)
         }
     """
-    # Silence TensorFlow warnings
     os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
     
-    if debug:
-        print(f"Starting ECG analysis pipeline for {pdf_path}")
-    
-    # 1. Digitize ECG from PDF to DAT file
-    dat_file_path = digitize_ecg_from_pdf(pdf_path, output_file=temp_dat_file, debug=debug)
-    
-    # Visualize the digitized signal if requested
-    if visualize:
-        signal = read_lead_i_long_dat_file(dat_file_path, scale_factor=0.001)
-        visualize_ecg_signal(signal, title=f"Digitized ECG from {os.path.basename(pdf_path)}")
-    
-    # 2. Process DAT file with model
-    if debug:
-        print("Processing digitized signal with model...")
-    
-    results = predict_with_voting(
-        dat_file_path,
-        model_path,
-        mlb_path,
-        scale_factor=0.001,  # Convert microvolts to millivolts
-        debug=debug
-    )
-    
-    # 3. Extract top diagnosis (highest probability)
-    top_diagnosis = {
-        "diagnosis": None,
-        "probability": 0.0,
-        "all_probabilities": {},
-        "digitized_file": dat_file_path
-    }
-    
-    # If we have class probabilities, find the highest one
-    if "final_class_probabilities" in results:
-        probs = results["final_class_probabilities"]
-        top_diagnosis["all_probabilities"] = probs
+    try:
+        dat_file_path, segment_files = digitize_ecg_from_pdf(pdf_path)
+        
+        ecg_model = tf.keras.models.load_model(model_path)
+        
+        ecg_signal = read_ecg_dat_file(dat_file_path)
+        
+        classification_results = predict_with_cnn_model(ecg_signal, ecg_model)
         
-        # Use the top class directly from the results
-        if "top_class" in results:
-            top_diagnosis["diagnosis"] = results["top_class"]
-            top_diagnosis["probability"] = probs[results["top_class"]]
+        arrhythmia_result = {
+            "arrhythmia_class": classification_results.get("top_class"),
+            "probability": classification_results.get("probability", 0.0),
+            "all_probabilities": {}
+        }
+        
+        if "averaged_prediction" in classification_results:
+            for idx, class_name in enumerate(ARRHYTHMIA_CLASSES):
+                arrhythmia_result["all_probabilities"][class_name] = float(classification_results["averaged_prediction"][idx])
+        
+        if not cleanup:
+            arrhythmia_result["digitized_file"] = dat_file_path
+        
+        if cleanup:
+            if os.path.exists(dat_file_path):
+                os.remove(dat_file_path)
             
-    # Clean up temporary files if requested
-    if cleanup and os.path.exists(dat_file_path):
-        if debug:
-            print(f"Cleaning up temporary file: {dat_file_path}")
-        os.remove(dat_file_path)
-        top_diagnosis.pop("digitized_file")
-    
-    if debug:
-        print(f"Analysis complete. Diagnosis: {top_diagnosis['diagnosis']} (Probability: {top_diagnosis['probability']:.2f})")
+            for segment_file in segment_files:
+                if os.path.exists(segment_file):
+                    os.remove(segment_file)
+        
+        return arrhythmia_result
+        
+    except Exception as e:
+        error_msg = f"Error in ECG analysis: {str(e)}"
+        return {"error": error_msg}
     
-    return top_diagnosis
 
-# Example usage
-if __name__ == "__main__":
-    # Path configuration
-    sample_pdf = 'samplebayez.pdf'
-    model_path = 'deep-multiclass.h5'  # Update with actual path
-    mlb_path = 'deep-multiclass.pkl'     # Update with actual path
-    
-    # Analyze ECG with debug output and visualization
-    result = analyze_ecg_pdf(
-        sample_pdf, 
-        model_path, 
-        mlb_path, 
-        cleanup=False,  # Keep the digitized file
-        debug=False,     # Print debug information
-        visualize=False  # Visualize the digitized signal
-    )
-    
-    # Display result
-    if result["diagnosis"]:
-        print(f"Diagnosis: {result['diagnosis']} ")
 
-    else:
-        print("No clear diagnosis found")
+    

app.py

@@ -9,8 +9,8 @@ from pymongo.server_api import ServerApi
 import cloudinary
 import cloudinary.uploader
 from cloudinary.utils import cloudinary_url
-from SkinBurns_Classification import FullFeautures
-from SkinBurns_Segmentation import segment_burn
+from SkinBurns.SkinBurns_Classification import FullFeautures
+from SkinBurns.SkinBurns_Segmentation import segment_burn
 import requests
 import joblib
 import numpy as np
@@ -63,7 +63,7 @@ except Exception as e:
 cloudinary.config( 
     cloud_name = "darumyfpl", 
     api_key = "493972437417214", 
-    api_secret = "jjOScVGochJYA7IxDam7L4HU2Ig",  # Replace in production
+    api_secret = "jjOScVGochJYA7IxDam7L4HU2Ig",  
     secure=True
 )
 
@@ -148,14 +148,14 @@ async def segment_burn_endpoint(reference: UploadFile = File(...), patient: Uplo
 
 @app.post("/classify-ecg")
 async def classify_ecg_endpoint(file: UploadFile = File(...)):
-    model = joblib.load('voting_classifier.pkl')
+    model = joblib.load('voting_classifier_arrhythmia.pkl')
 
     try:
         temp_file_path = f"temp_{file.filename}"
         with open(temp_file_path, "wb") as temp_file:
             temp_file.write(await file.read())
 
-        result = classify_ecg(temp_file_path, model, debug=True, is_pdf=True)
+        result = classify_ecg(temp_file_path, model, is_pdf=True)
 
         os.remove(temp_file_path)
 
@@ -167,31 +167,22 @@ async def classify_ecg_endpoint(file: UploadFile = File(...)):
 @app.post("/diagnose-ecg")
 async def diagnose_ecg(file: UploadFile = File(...)):
     try:
-        # Save the uploaded file temporarily
         temp_file_path = f"temp_{file.filename}"
         with open(temp_file_path, "wb") as temp_file:
             temp_file.write(await file.read())
 
-        model_path = 'deep-multiclass.h5'  # Update with actual path
-        mlb_path = 'deep-multiclass.pkl'     # Update with actual path
-    
+        model_path = 'Arrhythmia_Model_with_SMOTE.h5'  
 
-        # Call the ECG classification function
         result = analyze_ecg_pdf(
         temp_file_path, 
         model_path, 
-        mlb_path, 
-        cleanup=False,  # Keep the digitized file
-        debug=False,     # Print debug information
-        visualize=False  # Visualize the digitized signal
+        cleanup=False
     )
-    
 
-        # Remove the temporary file
         os.remove(temp_file_path)
         
-        if result and result["diagnosis"]:
-            return {"result": result["diagnosis"]}
+        if result and result["arrhythmia_class"]:
+            return {"result": result["arrhythmia_class"]}
         else:
             return {"result": "No diagnosis"}
 
@@ -216,7 +207,6 @@ async def process_video(file: UploadFile = File(...)):
     print("File content type:", file.content_type)
     print("File filename:", file.filename)
 
-    # Prepare directories
     os.makedirs(UPLOAD_DIR, exist_ok=True)
     os.makedirs(SCREENSHOTS_DIR, exist_ok=True)
     os.makedirs(OUTPUT_DIR, exist_ok=True)
@@ -259,7 +249,6 @@ async def process_video(file: UploadFile = File(...)):
                     overwrite=True
                 )
 
-                # Add new warning with image_url and description
                 warnings.append({
                     "image_url": upload_result['secure_url'],
                     "description": description
@@ -279,7 +268,6 @@ async def process_video(file: UploadFile = File(...)):
     else:
         wholevideoURL = None
 
-    # Upload graph output
     graphURL = None
     if os.path.isfile(plot_output_path):
         upload_graph_result = cloudinary.uploader.upload(
@@ -310,7 +298,7 @@ clients = set()
 analyzer_thread = None
 analysis_started = False
 analyzer_lock = threading.Lock()
-socket_server: AnalysisSocketServer = None  # Global reference
+socket_server: AnalysisSocketServer = None 
 
 
 async def forward_results_from_queue(websocket: WebSocket, warning_queue):
@@ -367,11 +355,9 @@ async def websocket_analysis(websocket: WebSocket):
     logger.info("[WebSocket] Flutter connected")
 
     try:
-        # Wait for the client to send the stream URL as first message
         source = await websocket.receive_text()
         logger.info(f"[WebSocket] Received stream URL: {source}")
 
-        # Ensure analyzer starts only once using a thread-safe lock
         with analyzer_lock:
             if not analysis_started:
                 requested_fps = 30
@@ -386,7 +372,6 @@ async def websocket_analysis(websocket: WebSocket):
                 analysis_started = True
                 logger.info("[WebSocket] Analysis thread started")
 
-        # Rest of your existing code remains exactly the same...
         while socket_server is None or socket_server.warning_queue is None:
             await asyncio.sleep(0.1)
 
@@ -395,7 +380,7 @@ async def websocket_analysis(websocket: WebSocket):
         )
 
         while True:
-            await asyncio.sleep(1)  # Keep alive
+            await asyncio.sleep(1)  
 
     except WebSocketDisconnect:
         logger.warning("[WebSocket] Client disconnected")
@@ -403,7 +388,7 @@ async def websocket_analysis(websocket: WebSocket):
             forward_task.cancel()
     except Exception as e:
         logger.error(f"[WebSocket] Error receiving stream URL: {str(e)}")
-        await websocket.close(code=1011)  # 1011 = Internal Error
+        await websocket.close(code=1011)
     finally:
         clients.discard(websocket)
         logger.info(f"[WebSocket] Active clients: {len(clients)}")

voting_classifier.pkl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:52e5d9789c5a5f6b42f595fceb67948bc15e9c9035de9c02f72cf29ff42c9d93
-size 4084247

deep-multiclass.pkl → voting_classifier_arrhythmia.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a6bd3507a56fc3e77f54e6fe0772888f61b22a2273021a04c288170237e1bc4b
-size 346
+oid sha256:1f1a2aff5dffb25a19be3bcaa4db79373dcad23355ba9b166ca1d2a8978e3600
+size 50223409