Added new endpoints for ECG

Dockerfile

@@ -1,13 +1,14 @@
 # Use the correct Python version (3.10)
 FROM python:3.10
 
-# Install system dependencies
+# Install system dependencies including poppler-utils for pdf2image
 RUN apt-get update && \
     apt-get install -y \
         build-essential \
         libssl-dev \
         ca-certificates \
         libgl1 \
+        poppler-utils \  # Add poppler-utils here
     && rm -rf /var/lib/apt/lists/*
 
 # Create a user for non-root operation

ECG.py

@@ -1,73 +0,0 @@
-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
-
-def extract_features_from_signal(signal):
-    features = []
-    features.append(np.mean(signal))
-    features.append(np.std(signal))
-    features.append(np.median(signal))
-    features.append(np.min(signal))
-    features.append(np.max(signal))
-    features.append(np.percentile(signal, 25))
-    features.append(np.percentile(signal, 75))
-    features.append(np.mean(np.diff(signal)))
-
-    coeffs = pywt.wavedec(signal, 'db4', level=5)
-    for coeff in coeffs:
-        features.append(np.mean(coeff))
-        features.append(np.std(coeff))
-        features.append(np.min(coeff))
-        features.append(np.max(coeff))
-
-    return features
-
-def classify_new_ecg(file_path, model):
-    try:
-        record = wfdb.rdrecord(file_path)
-
-        available_leads = record.sig_name
-        lead_index = next((available_leads.index(lead) for lead in ["II", "MLII", "I"] if lead in available_leads), None)
-        if lead_index is None:
-            return "Unsupported lead"
-
-        signal = record.p_signal[:, lead_index]
-        signal = (signal - np.mean(signal)) / np.std(signal)
-
-        try:
-            xqrs = processing.XQRS(sig=signal, fs=record.fs)
-            xqrs.detect()
-            r_peaks = xqrs.qrs_inds
-        except:
-            r_peaks = processing.gqrs_detect(sig=signal, fs=record.fs)
-
-        if len(r_peaks) < 5:
-            return "Insufficient beats"
-
-        rr_intervals = np.diff(r_peaks) / record.fs
-        qrs_durations = np.array([r_peaks[i] - r_peaks[i - 1] for i in range(1, len(r_peaks))])
-
-        features = extract_features_from_signal(signal)
-        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
-        ])
-
-        prediction = model.predict([features])[0]
-        return "Abnormal" if prediction == 1 else "Normal"
-
-    except Exception as e:
-        return f"Error: {str(e)}"
-
-# Load the saved model
-#voting_loaded = joblib.load('voting_classifier.pkl')
-
-#file_path = "00001_hr"
-#result = classify_new_ecg(file_path, voting_loaded)
-#print(result)

ECG/00001_hr.hea

@@ -1,13 +0,0 @@
-00001_hr 12 500 5000
-00001_hr.dat 16 1000.0(0)/mV 16 0 -115 13047 0 I
-00001_hr.dat 16 1000.0(0)/mV 16 0 -50 11561 0 II
-00001_hr.dat 16 1000.0(0)/mV 16 0 65 64050 0 III
-00001_hr.dat 16 1000.0(0)/mV 16 0 82 53190 0 AVR
-00001_hr.dat 16 1000.0(0)/mV 16 0 -90 7539 0 AVL
-00001_hr.dat 16 1000.0(0)/mV 16 0 7 5145 0 AVF
-00001_hr.dat 16 1000.0(0)/mV 16 0 -65 59817 0 V1
-00001_hr.dat 16 1000.0(0)/mV 16 0 -40 44027 0 V2
-00001_hr.dat 16 1000.0(0)/mV 16 0 -5 64232 0 V3
-00001_hr.dat 16 1000.0(0)/mV 16 0 -35 50309 0 V4
-00001_hr.dat 16 1000.0(0)/mV 16 0 -35 4821 0 V5
-00001_hr.dat 16 1000.0(0)/mV 16 0 -75 12159 0 V6

ECG/00008_hr.hea

@@ -1,13 +0,0 @@
-00008_hr 12 500 5000
-00008_hr.dat 16 1000.0(0)/mV 16 0 -40 12319 0 I
-00008_hr.dat 16 1000.0(0)/mV 16 0 -75 22545 0 II
-00008_hr.dat 16 1000.0(0)/mV 16 0 -35 10283 0 III
-00008_hr.dat 16 1000.0(0)/mV 16 0 58 47892 0 AVR
-00008_hr.dat 16 1000.0(0)/mV 16 0 -2 891 0 AVL
-00008_hr.dat 16 1000.0(0)/mV 16 0 -55 16258 0 AVF
-00008_hr.dat 16 1000.0(0)/mV 16 0 45 511 0 V1
-00008_hr.dat 16 1000.0(0)/mV 16 0 -5 64894 0 V2
-00008_hr.dat 16 1000.0(0)/mV 16 0 0 57055 0 V3
-00008_hr.dat 16 1000.0(0)/mV 16 0 -55 33262 0 V4
-00008_hr.dat 16 1000.0(0)/mV 16 0 -70 18240 0 V5
-00008_hr.dat 16 1000.0(0)/mV 16 0 -40 6332 0 V6

ECG/ECG_Classify.py

@@ -0,0 +1,611 @@
+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 warnings
+import pickle
+import sklearn
+
+# 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):
+    """
+    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
+    
+    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}")
+    
+    # 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
+    }
+    
+    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)
+    layer2_end = int(height * 69.41 / 100)
+    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
+    ]
+    
+    # Process each layer to extract waveform contours
+    signals = []
+    time_points = []
+    layer_duration = 10.0  # Each layer is 10 seconds long
+    
+    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")
+        
+        # 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)
+    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")
+    
+    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
+    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, 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):
+    """
+    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]
+        
+        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)
+            
+            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 []
+
+# Add function to load DAT signals
+def load_dat_signal(file_path, n_leads=12, n_samples=5000, dtype=np.int16, debug=False):
+    """
+    Load a DAT file containing ECG signal data.
+    
+    Args:
+        file_path (str): Path to the DAT file (without extension)
+        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 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)
+            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
+
+# Add the feature extraction function
+def extract_features_from_signal(signal, debug=False):
+    """
+    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
+    """
+    if debug:
+        print("Extracting features from signal...")
+        
+    features = []
+    features.append(np.mean(signal))
+    features.append(np.std(signal))
+    features.append(np.median(signal))
+    features.append(np.min(signal))
+    features.append(np.max(signal))
+    features.append(np.percentile(signal, 25))
+    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):
+        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):
+    """
+    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")
+
+        # 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"
+
+        # Calculate RR intervals and QRS durations
+        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)
+        
+        # Add rhythm features
+        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
+        ])
+        
+        if debug:
+            print(f"Final feature vector length: {len(features)}")
+            
+        # Make prediction
+        prediction = model.predict([features])[0]
+        result = "Abnormal" if prediction == 1 else "Normal"
+        
+        if debug:
+            print(f"Classification result: {result} (prediction value: {prediction})")
+            
+        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):
+    """
+    Wrapper function that handles both PDF and DAT ECG files with segment voting.
+    
+    Args:
+        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
+            )
+            
+            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)
+            
+            if not segment_files:
+                # If splitting failed, try classifying the whole file
+                return classify_new_ecg(file_path, model, debug=debug)
+        
+        # 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
+            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}")
+                
+            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:
+                final_result = "Normal"
+            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

@@ -0,0 +1,554 @@
+"""
+ECG Analysis Pipeline: From PDF to Diagnosis
+-------------------------------------------
+This module provides functions to:
+1. Digitize ECG from PDF files
+2. Process the digitized ECG signal
+3. Make diagnoses using a trained model
+"""
+
+import cv2
+import numpy as np
+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):
+    """
+    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
+    
+    Returns:
+        str: Path to the created .dat file
+    """
+    if debug:
+        print(f"Starting ECG digitization from PDF: {pdf_path}")
+    
+    # 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
+    }
+    
+    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)
+    layer2_end = int(height * 69.41 / 100)
+    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
+    ]
+    
+    # Process each layer to extract waveform contours
+    signals = []
+    time_points = []
+    layer_duration = 10.0  # Each layer is 10 seconds long
+    
+    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")
+        
+        # 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
+    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")
+    
+    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
+    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.
+    
+    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()
+
+def read_lead_i_long_dat_file(dat_file_path, sampling_rate=500, data_format='16', scale_factor=0.001):
+    """
+    Read a 30-second pure Lead I .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,)
+    """
+    # 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]
+        
+        return signal
+        
+    except Exception as e:
+        raise
+
+def segment_signal(signal, sampling_rate=500):
+    """
+    Segment a 30-second signal into three 10-second 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
+    """
+    # 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)
+    
+    # Split the signal into three 10-second segments
+    segments = []
+    for i in range(3):
+        start_idx = i * segment_samples
+        end_idx = (i + 1) * segment_samples
+        segment = signal[start_idx:end_idx]
+        segments.append(segment)
+        
+    return segments
+
+def process_segment(segment, sampling_rate=500):
+    """
+    Process a segment of ECG data to ensure it's properly formatted for the model
+    
+    Parameters:
+    -----------
+    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:
+        x = np.linspace(0, 1, len(segment))
+        x_new = np.linspace(0, 1, 5000)
+        f = interp1d(x, segment, kind='linear', bounds_error=False, fill_value="extrapolate")
+        segment = f(x_new)
+    
+    return segment
+
+def predict_with_voting(dat_file_path, model_path, mlb_path=None, sampling_rate=500, scale_factor=0.001, debug=False):
+    """
+    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.
+    
+    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
+        
+    Returns:
+    --------
+    dict
+        Dictionary containing segment predictions and final class probabilities
+    """
+    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)
+        
+        # Step 5: Calculate average probabilities across all segments
+        final_result = {"segment_results": segment_results}
+        
+        # Average the raw predictions
+        avg_predictions = np.mean(all_predictions, axis=0)
+        final_result["averaged_raw_predictions"] = avg_predictions.tolist()
+        
+        # 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
+            
+            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)}
+
+def analyze_ecg_pdf(pdf_path, model_path, mlb_path=None, temp_dat_file='calibrated_ecg.dat', cleanup=True, debug=False, visualize=False):
+    """
+    Complete ECG analysis pipeline: digitizes a PDF ECG, analyzes it with the model,
+    and returns the diagnosis 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
+            "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
+        
+        # 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"]]
+            
+    # 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})")
+    
+    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

@@ -14,7 +14,8 @@ from SkinBurns_Segmentation import segment_burn
 import requests
 import joblib
 import numpy as np
-from ECG import classify_new_ecg
+from ECG.ECG_Classify import classify_ecg
+from ECG.ECG_MultiClass import analyze_ecg_pdf
 from ultralytics import YOLO
 import tensorflow as tf
 from fastapi import HTTPException
@@ -208,35 +209,62 @@ def transform_image():
         return {"error": str(e)}
     
 @app.post("/classify-ecg")
-async def classify_ecg(files: list[UploadFile] = File(...)):
+async def classify_ecg_endpoint(file: UploadFile = File(...)):
     model = joblib.load('voting_classifier.pkl')
-
-    temp_dir = f"temp_ecg_{uuid.uuid4()}"
-    os.makedirs(temp_dir, exist_ok=True)
+    # Load the model
 
     try:
-        for file in files:
-            file_path = os.path.join(temp_dir, file.filename)
-            with open(file_path, "wb") as f:
-                f.write(file.file.read())  # Replacing shutil.copyfileobj
+        # Save the uploaded file temporarily
+        temp_file_path = f"temp_{file.filename}"
+        with open(temp_file_path, "wb") as temp_file:
+            temp_file.write(await file.read())
 
-        # Assume both .hea and .dat have same base name
-        base_names = set(os.path.splitext(file.filename)[0] for file in files)
-        if len(base_names) != 1:
-            return JSONResponse(content={"error": "Files must have the same base name"}, status_code=400)
+        # Call the ECG classification function
+        result = classify_ecg(temp_file_path, model, debug=True, is_pdf=True)
 
-        base_name = list(base_names)[0]
-        file_path = os.path.join(temp_dir, base_name)
+        # Remove the temporary file
+        os.remove(temp_file_path)
 
-        result = classify_new_ecg(file_path, model)
         return {"result": result}
 
-    finally:
-        # Replace shutil.rmtree with os removal operations
-        for file_name in os.listdir(temp_dir):
-            file_path = os.path.join(temp_dir, file_name)
-            os.remove(file_path)
-        os.rmdir(temp_dir)
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
+
+@app.post("/diagnose-ecg")
+async def diagnose_ecg(file: UploadFile = File(...)):
+    try:
+        # Save the uploaded file temporarily
+        temp_file_path = f"temp_{file.filename}"
+        with open(temp_file_path, "wb") as temp_file:
+            temp_file.write(await file.read())
+
+        model_path = 'deep-multiclass.h5'  # Update with actual path
+        mlb_path = 'deep-multiclass.pkl'     # Update with actual path
+    
+
+        # Call the ECG classification function
+        result = analyze_ecg_pdf(
+        temp_file_path, 
+        model_path, 
+        mlb_path, 
+        cleanup=False,  # Keep the digitized file
+        debug=False,     # Print debug information
+        visualize=False  # Visualize the digitized signal
+    )
+    
+
+        # Remove the temporary file
+        os.remove(temp_file_path)
+        
+        if result and result["diagnosis"]:
+            return {"result": result["diagnosis"]}
+        else:
+            return {"result": "No diagnosis"}
+
+    except Exception as e:
+        return JSONResponse(content={"error": str(e)}, status_code=500)
+
 
 
 @app.post("/process_video")

ECG/00008_hr.dat → deep-multiclass.h5

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:119d2eaf8e8aaa4a091f9f76523bf559691cfd8dd4d936cf724af1f630357233
-size 120000
+oid sha256:a2fdc1bcbf7820ae426a9a74f0210c738884ee2bb872bccff55a4036e2c642e1
+size 8941912

ECG/00001_hr.dat → deep-multiclass.pkl

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

requirements.txt

@@ -102,4 +102,5 @@ wfdb==4.3.0
 wrapt==1.17.2
 yarl==1.20.0
 websockets
-xgboost
+xgboost
+pdf2image