Update app.py

app.py

@@ -5,50 +5,33 @@ from collections import deque
 import time
 import matplotlib.pyplot as plt
 from scipy import signal
-from datetime import datetime
 
-# Length of signal history to display (in samples)
 MAX_LEN = 500
-FPS = 30  # Approximate frames per second
-WINDOW_SIZE = 5  # seconds of data for HR estimation
+FPS = 30
+WINDOW_SIZE = 5
 
-# Deques to store PPG samples and timestamps
 red_signal = deque(maxlen=MAX_LEN)
 green_signal = deque(maxlen=MAX_LEN)
 timestamps = deque(maxlen=MAX_LEN)
 
 def estimate_heart_rate(signal_data, fps=30, window_secs=5):
-    """
-    Estimate heart rate from PPG signal using FFT.
-    Returns BPM (beats per minute)
-    """
     if len(signal_data) < fps * window_secs:
         return None, None
-    
-    # Normalize the signal
     signal_array = np.array(list(signal_data)[-fps*window_secs:])
     if signal_array.std() == 0:
         return None, None
-    
     signal_norm = (signal_array - signal_array.mean()) / signal_array.std()
-    
-    # Apply bandpass filter (40-200 BPM = 0.67-3.33 Hz)
     nyquist = fps / 2
     low = 0.67 / nyquist
     high = 3.33 / nyquist
-    
     if low > 0 and high < 1:
         b, a = signal.butter(4, [low, high], btype='band')
         signal_filt = signal.filtfilt(b, a, signal_norm)
     else:
         signal_filt = signal_norm
-    
-    # FFT to find dominant frequency
     fft = np.fft.fft(signal_filt)
     freqs = np.fft.fftfreq(len(fft), d=1/fps)
     power = np.abs(fft) ** 2
-    
-    # Find peak in valid HR range (40-200 BPM)
     valid_range = (freqs >= 0.67) & (freqs <= 3.33)
     if valid_range.sum() > 0:
         peak_idx = np.argmax(power[valid_range])
@@ -58,150 +41,131 @@ def estimate_heart_rate(signal_data, fps=30, window_secs=5):
     else:
         bpm = None
         confidence = 0
-    
     return bpm, confidence
 
 def calculate_signal_quality(signal_data):
-    """
-    Calculate signal quality based on variance and SNR
-    Returns quality score 0-100
-    """
     if len(signal_data) < 10:
         return 0
-    
     data = np.array(list(signal_data))
     std = data.std()
     mean = data.mean()
-    
-    # Normalize standard deviation by mean
     if mean > 0:
-        cv = (std / mean) * 100  # Coefficient of variation
-        # Quality score: higher CV is better for PPG, but too high is noise
+        cv = (std / mean) * 100
         quality = min(100, max(0, 100 - abs(cv - 10)))
     else:
         quality = 0
-    
     return quality
 
+def find_peaks_simple(signal_data, fps=30, min_distance=0.4):
+    if len(signal_data) < int(fps * 1.0):
+        return []
+    data = np.array(signal_data)
+    data_norm = (data - data.mean()) / (data.std() + 1e-9)
+    min_dist = int(min_distance * fps)
+    peaks = []
+    for i in range(min_dist, len(data_norm) - min_dist):
+        if data_norm[i] > data_norm[i-1] and data_norm[i] > data_norm[i+1]:
+            if not peaks or i - peaks[-1] >= min_dist:
+                peaks.append(i)
+    return peaks
+
 def process_frame(frame, state):
-    """
-    frame: numpy array (BGR or RGB, Gradio passes RGB by default)
-    state: dict holding rolling signals and session info
-    """
     if frame is None:
         return None, state["red"], state["green"], state["time"]
-    
     img = frame.copy()
     h, w, _ = img.shape
-    
-    # Define ROI: square with side = 1/5 of frame height, centered
     box_size = h // 5
     cx, cy = w // 2, h // 2
     x1 = cx - box_size // 2
     y1 = cy - box_size // 2
     x2 = cx + box_size // 2
     y2 = cy + box_size // 2
-    
-    # Clamp to frame bounds
-    x1 = max(0, x1); y1 = max(0, y1)
-    x2 = min(w, x2); y2 = min(h, y2)
-    
-    # Draw green bounding box
+    x1 = max(0, x1)
+    y1 = max(0, y1)
+    x2 = min(w, x2)
+    y2 = min(h, y2)
     cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
-    
-    # Extract ROI
     roi = img[y1:y2, x1:x2, :]
-    
     if roi.size > 0:
-        # Compute mean intensity for R and G channels (assuming RGB)
         roi_float = roi.astype(np.float32)
         red_mean = float(np.mean(roi_float[..., 0]))
         green_mean = float(np.mean(roi_float[..., 1]))
     else:
         red_mean = 0.0
         green_mean = 0.0
-    
     t = time.time()
-    
-    # Update deques
     state["red"].append(red_mean)
     state["green"].append(green_mean)
     state["time"].append(t)
     state["frame_count"] += 1
-    
-    # Convert to list for plotting
     red_list = list(state["red"])
     green_list = list(state["green"])
     time_list = list(state["time"])
-    
-    # Normalize time to start at 0
     if len(time_list) > 0:
         t0 = time_list[0]
         time_list = [ti - t0 for ti in time_list]
-    
-    # Update session duration
     state["session_duration"] = t - state["session_start"]
-    
     return img, red_list, green_list, time_list
 
+def make_plots(time_list, red_list, green_list):
+    """2-subplot layout like app_old.py"""
+    if len(time_list) < 10:
+        return None
+    time_array = np.array(time_list)
+    red_array = np.array(red_list)
+    green_array = np.array(green_list)
+    red_norm = (red_array - red_array.mean()) / (red_array.std() + 1e-9)
+    green_norm = (green_array - green_array.mean()) / (green_array.std() + 1e-9)
+    nyquist = FPS / 2
+    low = 0.67 / nyquist
+    high = 3.33 / nyquist
+    if low > 0 and high < 1:
+        b, a = signal.butter(4, [low, high], btype='band')
+        red_filt = signal.filtfilt(b, a, red_norm)
+        green_filt = signal.filtfilt(b, a, green_norm)
+    else:
+        red_filt = red_norm
+        green_filt = green_norm
+    hr_bpm, _ = estimate_heart_rate(green_array, fps=FPS, window_secs=WINDOW_SIZE)
+    peaks_idx = find_peaks_simple(green_filt, fps=FPS)
+    fig = plt.figure(figsize=(12, 4))
+    ax1 = fig.add_subplot(1, 2, 1)
+    ax2 = fig.add_subplot(1, 2, 2)
+    ax1.plot(time_array, red_filt, label='Red (filtered)', color='red', linewidth=1.5)
+    ax1.plot(time_array, green_filt, label='Green (filtered)', color='green', linewidth=1.5)
+    ax1.set_xlabel('Time (s)')
+    ax1.set_ylabel('Normalized Intensity')
+    ax1.set_title('Filtered PPG Signals (Last 5s)')
+    ax1.legend(loc='upper right')
+    ax1.grid(True, alpha=0.3)
+    ax2.plot(time_array, green_filt, label='Green (filtered)', color='green', linewidth=1.5)
+    if len(peaks_idx) > 0:
+        ax2.scatter(time_array[peaks_idx], green_filt[peaks_idx], color='red', s=50, label='Peaks', zorder=5)
+    hr_title = f'Peak Detection (HR ≈ {hr_bpm:.1f} bpm)' if hr_bpm is not None else 'Peak Detection'
+    ax2.set_xlabel('Time (s)')
+    ax2.set_ylabel('Normalized Intensity')
+    ax2.set_title(hr_title)
+    ax2.legend(loc='upper right')
+    ax2.grid(True, alpha=0.3)
+    fig.tight_layout()
+    return fig
+
 def snap(frame, state):
-    """
-    Wrapper for Gradio streaming.
-    Gradio passes latest frame, we update state and return:
-    - video frame with bounding box
-    - matplotlib figure with both signals and stats
-    """
     img, red_list, green_list, time_list = process_frame(frame, state)
-    
-    # Estimate heart rate from red signal (more reliable)
     bpm, confidence = estimate_heart_rate(state["red"], fps=FPS, window_secs=WINDOW_SIZE)
-    
-    # Calculate signal quality
     red_quality = calculate_signal_quality(state["red"])
     green_quality = calculate_signal_quality(state["green"])
-    
-    # Create matplotlib figure with stats
-    fig = plt.figure(figsize=(10, 6))
-    gs = fig.add_gridspec(2, 2, hspace=0.3, wspace=0.3)
-    
-    # Plot 1: PPG signals
-    ax1 = fig.add_subplot(gs[0, :])
-    ax1.plot(time_list, red_list, label='Red PPG', color='red', linewidth=1.5)
-    ax1.plot(time_list, green_list, label='Green PPG', color='green', linewidth=1.5)
-    ax1.set_xlabel('Time (s)')
-    ax1.set_ylabel('Intensity')
-    ax1.set_title('PPG Signals (Red & Green)')
-    ax1.legend(loc='upper right')
-    ax1.grid(True, alpha=0.3)
-    
-    # Plot 2: HR estimation
-    ax2 = fig.add_subplot(gs[1, 0])
-    if bpm is not None:
-        ax2.text(0.5, 0.7, f'{bpm:.1f}', ha='center', va='top', fontsize=48, fontweight='bold', color='darkred', transform=ax2.transAxes)
-        ax2.text(0.5, 0.3, 'BPM', ha='center', va='top', fontsize=16, fontweight='bold', color='darkred', transform=ax2.transAxes)
-        ax2.text(0.5, 0.1, f'Conf: {confidence*100:.0f}%', ha='center', va='top', fontsize=10, color='gray', transform=ax2.transAxes)
-    else:
-        ax2.text(0.5, 0.5, 'Estimating...', ha='center', va='center', fontsize=14, color='gray', transform=ax2.transAxes)
-    ax2.axis('off')
-    ax2.set_title('Heart Rate')
-    
-    # Plot 3: Signal quality and session info
-    ax3 = fig.add_subplot(gs[1, 1])
-    stats_text = f'Signal Quality:\n  Red: {red_quality:.0f}%\n  Green: {green_quality:.0f}%\n\nSession Info:\n  Frames: {state["frame_count"]}\n  Duration: {state["session_duration"]:.1f}s\n  FPS: {state["frame_count"]/max(state["session_duration"], 0.1):.1f}\n  Samples: {len(state["red"])}/{MAX_LEN}'
-    ax3.text(0.1, 0.5, stats_text, ha='left', va='center', fontsize=10, family='monospace', transform=ax3.transAxes)
-    ax3.axis('off')
-    ax3.set_title('Monitoring Stats')
-    
-    plt.close(fig)
-    
-    return img, fig, state
+    plot_fig = make_plots(time_list, red_list, green_list)
+    hr_text = f'{bpm:.1f} bpm' if bpm is not None else 'Measuring...'
+    red_quality_text = f'Red: {red_quality:.0f}%'
+    green_quality_text = f'Green: {green_quality:.0f}%'
+    stats_text = f'Frames: {state["frame_count"]} | Duration: {state["session_duration"]:.1f}s | Samples: {len(state["red"])}/{MAX_LEN}'
+    return img, plot_fig, hr_text, red_quality_text, green_quality_text, stats_text, state
 
-# Create Gradio interface with continuous streaming
 with gr.Blocks(title="Finger Vital Sign Monitor") as demo:
     gr.Markdown("# Real-time Finger Vital Sign Monitoring")
     gr.Markdown("Place your finger on the camera and keep it steady. The system will continuously monitor PPG signals and estimate heart rate.")
     
-    # Stateful object to store signals and session info
     state = gr.State({
         "red": red_signal,
         "green": green_signal,
@@ -217,13 +181,20 @@ with gr.Blocks(title="Finger Vital Sign Monitor") as demo:
             streaming=True,
             label="Webcam with ROI",
         )
-        plot = gr.Plot(label="PPG Analysis")
+        plot = gr.Plot(label="PPG Analysis - Signals & Peaks")
+    
+    with gr.Row():
+        hr_output = gr.Textbox(label="Heart Rate (BPM)", value="Measuring...", interactive=False)
+        red_quality_output = gr.Textbox(label="Red Channel Quality", value="Measuring...", interactive=False)
+        green_quality_output = gr.Textbox(label="Green Channel Quality", value="Measuring...", interactive=False)
+    
+    with gr.Row():
+        stats_output = gr.Textbox(label="Session Statistics", value="Waiting for data...", interactive=False)
     
-    # When webcam streams, call snap continuously
     cam.stream(
         fn=snap,
         inputs=[cam, state],
-        outputs=[cam, plot, state],
+        outputs=[cam, plot, hr_output, red_quality_output, green_quality_output, stats_output, state],
     )
 
 if __name__ == "__main__":