Rename run.py to app.py

app.py

@@ -0,0 +1,141 @@
+
+import gradio as gr
+import cv2
+import numpy as np
+from collections import deque
+import time
+
+# Length of signal history to display (in samples)
+MAX_LEN = 500
+
+# 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 process_frame(frame, state):
+    """
+    frame: numpy array (BGR or RGB, Gradio passes RGB by default)
+    state: dict holding rolling signals
+    """
+    if frame is None:
+        return None, state["red"], state["green"], state["time"]
+
+    img = frame.copy()
+    h, w, _ = img.shape
+
+    # Ensure image is in RGB
+    # If needed, convert from BGR to RGB; Gradio webcam is usually RGB already
+    # img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+    # 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
+    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)
+        # img shape: (H, W, 3) -> channels: R=0, G=1, B=2 if RGB
+        # If your frame is BGR, swap indices accordingly.
+        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)
+
+    # Convert to list for plotting
+    red_list = list(state["red"])
+    green_list = list(state["green"])
+    time_list = list(state["time"])
+
+    # Optional: normalize time to start at 0
+    if len(time_list) > 0:
+        t0 = time_list[0]
+        time_list = [ti - t0 for ti in time_list]
+
+    # Return:
+    # - processed image with box
+    # - data for plots (as lists)
+    return img, red_list, green_list, time_list
+
+
+def snap(frame, state):
+    """
+    Wrapper for Gradio streaming.
+    Gradio passes latest frame, we update state and return:
+    - video frame with bounding box
+    - red PPG
+    - green PPG
+    """
+    img, red_list, green_list, time_list = process_frame(frame, state)
+
+    # Build plot data for Gradio Plot component:
+    # each as { "x": [...], "y": [...] }
+    red_plot = {
+        "x": time_list,
+        "y": red_list,
+        "mode": "lines",
+        "name": "Red PPG",
+    }
+    green_plot = {
+        "x": time_list,
+        "y": green_list,
+        "mode": "lines",
+        "name": "Green PPG",
+    }
+
+    # Plotly-style dict
+    plot_data = {
+        "data": [red_plot, green_plot],
+        "layout": {
+            "title": "Red & Green PPG",
+            "xaxis": {"title": "Time (s)"},
+            "yaxis": {"title": "Intensity"},
+        },
+    }
+
+    return img, plot_data, state
+
+
+with gr.Blocks() as demo:
+    # Stateful object to store signals across frames
+    state = gr.State({"red": red_signal, "green": green_signal, "time": timestamps})
+
+    with gr.Row():
+        cam = gr.Image(
+            source="webcam",
+            streaming=True,  # continuous streaming
+            label="Webcam with ROI",
+        )
+        plot = gr.Plot(label="PPG Signals (Red & Green)")
+
+    # When webcam streams, call snap continuously
+    cam.stream(
+        fn=snap,
+        inputs=[cam, state],
+        outputs=[cam, plot, state],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

run.py

@@ -1,16 +0,0 @@
-
-import gradio as gr
-
-
-def snap(image, video):
-    return [image, video]
-
-
-demo = gr.Interface(
-    snap,
-    [gr.Image(source="webcam", tool=None), gr.Video(source="webcam")],
-    ["image", "video"],
-)
-
-if __name__ == "__main__":
-    demo.launch()