Update app.py

app.py

@@ -1,82 +1,145 @@
-import gradio as gr
-import matplotlib.pyplot as plt
-import pandas as pd
-import neurokit2 as nk
-import cv2
 import os
+import cv2
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from flask import Flask, request, render_template
+from werkzeug.utils import secure_filename
+import biosppy.signals.ecg as ecg
+
+app = Flask(__name__)
+
+UPLOAD_FOLDER = 'uploads'
+ALLOWED_EXTENSIONS = {'csv', 'png', 'jpg', 'jpeg'}
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+
+# Load the pre-trained model
+model = load_model('ecgScratchEpoch2.hdf5')
 
-try:
-    from ecg_image_kit.digitizer import digitize_ecg  # Adjust based on actual module/function
-except ImportError as e:
-    raise ImportError(f"Failed to import ecg_image_kit: {str(e)}. Ensure the ecg_image_kit directory is included.")
+def allowed_file(filename):
+    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
 
-def load_and_digitize_ecg(image_path):
-    try:
-        image = cv2.imread(image_path)
-        if image is None:
-            raise ValueError("Failed to load image")
-        time_series = digitize_ecg(image)  # Adjust based on actual function
-        return time_series
-    except Exception as e:
-        return f"Error digitizing image: {str(e)}"
+def image_to_signal(image_path):
+    # Read and preprocess the image
+    img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
+    if img is None:
+        raise ValueError("Failed to load image")
+    
+    # Resize to a standard height for consistency (e.g., 500 pixels)
+    img = cv2.resize(img, (1000, 500))
+    
+    # Apply thresholding to isolate the waveform
+    _, binary = cv2.threshold(img, 200, 255, cv2.THRESH_BINARY_INV)
+    
+    # Find contours of the waveform
+    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        raise ValueError("No waveform detected in the image")
+    
+    # Assume the largest contour is the ECG waveform
+    contour = max(contours, key=cv2.contourArea)
+    
+    # Extract y-coordinates (signal amplitude) along x-axis
+    signal = []
+    width = img.shape[1]
+    for x in range(width):
+        column = contour[contour[:, :, 0] == x]
+        if len(column) > 0:
+            # Take the average y-coordinate if multiple points exist
+            y = np.mean(column[:, :, 1])
+            signal.append(y)
+        else:
+            # Interpolate if no point is found
+            signal.append(signal[-1] if signal else 0)
+    
+    # Normalize signal to match expected amplitude range
+    signal = np.array(signal)
+    signal = (signal - np.min(signal)) / (np.max(signal) - np.min(signal)) * 1000
+    
+    # Save to CSV
+    csv_path = os.path.join(app.config['UPLOAD_FOLDER'], 'converted_signal.csv')
+    df = pd.DataFrame(signal, columns=[' Sample Value'])
+    df.to_csv(csv_path, index=False)
+    
+    return csv_path
 
-def analyze_ecg(time_series, sampling_rate=250):
-    try:
-        results = {}
-        for lead_idx, ecg_signal in enumerate(time_series):
-            signals, info = nk.ecg_process(ecg_signal, sampling_rate=sampling_rate)
-            analysis = nk.ecg_analyze(signals, sampling_rate=sampling_rate)
-            results[f"Lead_{lead_idx+1}"] = {
-                "signals": signals,
-                "info": info,
-                "analysis": analysis
-            }
-        return results
-    except Exception as e:
-        return f"Error analyzing ECG: {str(e)}"
+def model_predict(uploaded_files, model):
+    output = []
+    for path in uploaded_files:
+        APC, NORMAL, LBB, PVC, PAB, RBB, VEB = [], [], [], [], [], [], []
+        output.append(str(path))
+        result = {"APC": APC, "Normal": NORMAL, "LBB": LBB, "PAB": PAB, "PVC": PVC, "RBB": RBB, "VEB": VEB}
+        
+        kernel = np.ones((4,4), np.uint8)
+        csv = pd.read_csv(path)
+        csv_data = csv[' Sample Value']
+        data = np.array(csv_data)
+        signals = []
+        count = 1
+        peaks = ecg.christov_segmenter(signal=data, sampling_rate=200)[0]
+        indices = []
+        
+        for i in peaks[1:-1]:
+            diff1 = abs(peaks[count - 1] - i)
+            diff2 = abs(peaks[count + 1] - i)
+            x = peaks[count - 1] + diff1 // 2
+            y = peaks[count + 1] - diff2 // 2
+            signal = data[x:y]
+            signals.append(signal)
+            count += 1
+            indices.append((x, y))
+        
+        for signal, index in zip(signals, indices):
+            if len(signal) > 10:
+                img = np.zeros((128, 128))
+                for i in range(len(signal)):
+                    img[i, int(signal[i] / 10)] = 255
+                img = cv2.dilate(img, kernel, iterations=1)
+                img = img.reshape(128, 128, 1)
+                prediction = model.predict(np.array([img])).argmax()
+                classes = ['Normal', 'APC', 'LBB', 'PAB', 'PVC', 'RBB', 'VEB']
+                result[classes[prediction]].append(index)
+        
+        output.append(result)
+    
+    return output
 
-def process_ecg_image(image):
-    try:
-        image_path = "temp_ecg_image.png"
-        image.save(image_path)
-        time_series = load_and_digitize_ecg(image_path)
-        if isinstance(time_series, str):
-            return time_series, None
-        results = analyze_ecg(time_series, sampling_rate=250)
-        if isinstance(results, str):
-            return results, None
-        plots = []
-        tables = []
-        for lead, data in results.items():
-            fig, ax = plt.subplots()
-            signals = data["signals"]
-            info = data["info"]
-            ax.plot(signals["ECG_Clean"], label="Clean ECG")
-            ax.plot(info["ECG_R_Peaks"], signals["ECG_Clean"][info["ECG_R_Peaks"]], "ro", label="R-peaks")
-            ax.set_title(f"{lead} ECG")
-            ax.legend()
-            plots.append(fig)
-            analysis = data["analysis"]
-            table = pd.DataFrame({
-                "Feature": ["Heart Rate (Mean)", "ECG Quality"],
-                "Value": [analysis.get("ECG_Rate_Mean", "N/A"), analysis.get("ECG_Quality_Mean", "N/A")]
-            })
-            tables.append(table)
-        os.remove(image_path)
-        return plots, tables
-    except Exception as e:
-        return f"Error processing image: {str(e)}", None
+@app.route('/', methods=['GET'])
+def index():
+    return render_template('index.html')
 
-iface = gr.Interface(
-    fn=process_ecg_image,
-    inputs=gr.Image(type="pil", label="Upload ECG Image"),
-    outputs=[
-        gr.Gallery(label="ECG Plots"),
-        gr.Dataframe(label="Analysis Results")
-    ],
-    title="ECG Image Analysis",
-    description="Upload a 12-lead ECG image to digitize and analyze it."
-)
+@app.route('/', methods=['POST'])
+def upload_file():
+    if 'files[]' not in request.files:
+        return render_template('index.html', message='No file part')
+    
+    files = request.files.getlist('files[]')
+    file_paths = []
+    
+    for file in files:
+        if file and allowed_file(file.filename):
+            filename = secure_filename(file.filename)
+            file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(file_path)
+            
+            # If the file is an image, convert to CSV
+            if filename.rsplit('.', 1)[1].lower() in {'png', 'jpg', 'jpeg'}:
+                try:
+                    csv_path = image_to_signal(file_path)
+                    file_paths.append(csv_path)
+                except Exception as e:
+                    return render_template('index.html', message=f'Error processing image: {str(e)}')
+            else:
+                file_paths.append(file_path)
+    
+    if not file_paths:
+        return render_template('index.html', message='No valid files uploaded')
+    
+    results = model_predict(file_paths, model)
+    return render_template('index.html', prediction=results)
 
-if __name__ == "__main__":
-    iface.launch()
+if __name__ == '__main__':
+    if not os.path.exists(UPLOAD_FOLDER):
+        os.makedirs(UPLOAD_FOLDER)
+    app.run(debug=True, host='0.0.0.0', port=5000)