Update app.py

app.py

@@ -6,103 +6,130 @@ import matplotlib.pyplot as plt
 import io
 from PIL import Image
 
-def splitnormalize_balanced(img):
-    p_lo, p_hi = np.percentile(img, [2, 98])
-    img = np.clip((img - p_lo) / (p_hi - p_lo + 1e-6), 0, 1)
-    img = exposure.equalize_adapthist(img, clip_limit=0.003, nbins=256)
-    return img
-
-def removebias(img, regionwidth=10, fraction=0.75):
+# ---------- util ----------
+def to_gray2d(arr):
+    arr = np.array(arr, dtype=np.float32)
+    if arr.ndim == 3 and arr.shape[2] in (3,4):
+        arr = arr[..., :3].mean(axis=2)
+    elif arr.ndim > 2:
+        arr = np.squeeze(arr)
+    if arr.max() > 1.0:
+        arr = arr / 255.0
+    return arr.astype(np.float32)
+
+# ---------- pipeline ----------
+def splitnormalize_balanced(img2d):
+    p_lo, p_hi = np.percentile(img2d, [2, 98])
+    x = np.clip((img2d - p_lo) / (p_hi - p_lo + 1e-6), 0, 1)
+    x = exposure.equalize_adapthist(x, clip_limit=0.003, nbins=256)
+    return x.astype(np.float32)
+
+def removebias(img2d, regionwidth=10, fraction=0.75):
     kz = 2*regionwidth + 1
     kx = 2*regionwidth + 1
-    bg = uniform_filter(img, size=(kz, kx))
-    out = img - fraction * bg
+    bg = uniform_filter(img2d, size=(kz, kx))
+    out = img2d - fraction * bg
     out = (out - out.min()) / (out.max() - out.min() + 1e-6)
-    return out
-
-def estimate_medline_intensity(img):
-    H, W = img.shape
-    p1, p99 = np.percentile(img, [1, 99])
-    norm = np.clip((img - p1) / (p99 - p1 + 1e-6), 0, 1)
-    z_low = int(0.30 * H)
-    z_high = int(0.70 * H)
-    return np.argmax(norm[z_low:z_high, :], axis=0) + z_low
-
-def detect_rpe_simple(img, medline):
-    H, W = img.shape
-    sm = gaussian_filter1d(img, sigma=4, axis=0)
+    return out.astype(np.float32)
+
+def estimate_medline_intensity(img2d):
+    H, W = img2d.shape
+    p1, p99 = np.percentile(img2d, [1, 99])
+    norm = np.clip((img2d - p1) / (p99 - p1 + 1e-6), 0, 1)
+    z_low, z_high = int(0.30*H), int(0.70*H)
+    return (np.argmax(norm[z_low:z_high, :], axis=0) + z_low).astype(np.float32)
+
+def detect_rpe_simple(img2d, medline):
+    H, W = img2d.shape
+    sm = gaussian_filter1d(img2d, sigma=4, axis=0)
     grad = np.gradient(gaussian_filter1d(sm, sigma=1, axis=0), axis=0)
-    rpe = np.argmax(-grad[int(0.30*H):int(0.85*H), :], axis=0) + int(0.30*H)
-    return rpe
+    z0, z1 = int(0.30*H), int(0.85*H)
+    return (np.argmax(-grad[z0:z1, :], axis=0) + z0).astype(np.float32)
 
 def linesweeter(y):
     from scipy.signal import savgol_filter
-    return savgol_filter(y, 9, 2)
+    return savgol_filter(y, 9, 2).astype(np.float32)
 
-def overlay(img, curve, title=""):
-    H, W = img.shape
+def overlay(img2d, curve, title=""):
+    H, W = img2d.shape
     x = np.arange(W)
     fig, ax = plt.subplots(figsize=(8,4))
-    ax.imshow(img, cmap="gray")
+    ax.imshow(img2d, cmap="gray")
     ax.plot(x, curve, 'r-', lw=2)
-    ax.set_title(title)
-    ax.axis('off')
-    buf = io.BytesIO()
-    plt.savefig(buf, format="png", bbox_inches="tight")
-    buf.seek(0)
+    ax.set_title(title); ax.axis('off')
+    buf = io.BytesIO(); plt.savefig(buf, format="png", bbox_inches="tight"); buf.seek(0)
     return Image.open(buf)
 
+# ---------- UI ----------
 with gr.Blocks(title="OCT Step-by-Step Visual Lab") as demo:
     gr.Markdown("## 🧠 OCT Step-by-Step Visual Lab — Compare cada etapa lado a lado")
 
-    img_state = gr.State()
+    img_state = gr.State()  # guarda a imagem 2D corrente (float [0,1])
 
     with gr.Tab("1) Carregar Imagem"):
         img_input = gr.Image(label="Imagem OCT", type="numpy")
         def store(img):
-            return img
+            return to_gray2d(img) if img is not None else None
         img_input.change(store, inputs=img_input, outputs=img_state)
 
     with gr.Tab("2) Normalização"):
         btn_norm = gr.Button("Aplicar splitnormalize (balanced)")
-        out_norm = gr.Image(label="Resultado")
-        btn_norm.click(splitnormalize_balanced, inputs=img_state, outputs=[out_norm,img_state])
+        before_norm = gr.Image(label="Antes")
+        after_norm  = gr.Image(label="Depois")
+        def do_norm(img2d):
+            img2d = to_gray2d(img2d)
+            out = splitnormalize_balanced(img2d)
+            return img2d, out, out  # antes, depois, novo estado
+        btn_norm.click(do_norm, inputs=img_state, outputs=[before_norm, after_norm, img_state])
 
     with gr.Tab("3) Remove Bias"):
         btn_bias = gr.Button("Aplicar removebias")
-        out_bias = gr.Image(label="Resultado")
-        btn_bias.click(removebias, inputs=img_state, outputs=out_bias)
+        before_b = gr.Image(label="Antes")
+        after_b  = gr.Image(label="Depois")
+        def do_bias(img2d):
+            img2d = to_gray2d(img2d)
+            out = removebias(img2d)
+            return img2d, out, out
+        btn_bias.click(do_bias, inputs=img_state, outputs=[before_b, after_b, img_state])
 
     with gr.Tab("4) Mediana 5×9"):
         btn_med = gr.Button("Aplicar filtro mediano (5x9)")
-        out_med = gr.Image(label="Resultado")
-        btn_med.click(lambda i: median_filter(i, size=(5,9)), inputs=img_state, outputs=out_med)
+        before_m = gr.Image(label="Antes")
+        after_m  = gr.Image(label="Depois")
+        def do_med(img2d):
+            img2d = to_gray2d(img2d)
+            out = median_filter(img2d, size=(5,9)).astype(np.float32)
+            return img2d, out, out
+        btn_med.click(do_med, inputs=img_state, outputs=[before_m, after_m, img_state])
 
     with gr.Tab("5) Estimar Medline (IS/OS)"):
         btn_medline = gr.Button("Calcular Medline")
         out_medline = gr.Image(label="Visualização")
-        def show_medline(img):
-            med = estimate_medline_intensity(img)
-            return overlay(img, med, "Medline (IS/OS)")
+        def show_medline(img2d):
+            img2d = to_gray2d(img2d)
+            med = estimate_medline_intensity(img2d)
+            return overlay(img2d, med, "Medline (IS/OS)")
         btn_medline.click(show_medline, inputs=img_state, outputs=out_medline)
 
     with gr.Tab("6) Detectar RPE"):
         btn_rpe = gr.Button("Detectar RPE simples")
         out_rpe = gr.Image(label="Visualização")
-        def step_rpe(img):
-            med = estimate_medline_intensity(img)
-            rpe = detect_rpe_simple(img, med)
-            return overlay(img, rpe, "RPE simples")
+        def step_rpe(img2d):
+            img2d = to_gray2d(img2d)
+            med = estimate_medline_intensity(img2d)
+            rpe = detect_rpe_simple(img2d, med)
+            return overlay(img2d, rpe, "RPE simples")
         btn_rpe.click(step_rpe, inputs=img_state, outputs=out_rpe)
 
     with gr.Tab("7) Suavização da RPE"):
         btn_smooth = gr.Button("Suavizar RPE (linesweeter)")
         out_smooth = gr.Image(label="Visualização")
-        def step_smooth(img):
-            med = estimate_medline_intensity(img)
-            rpe = detect_rpe_simple(img, med)
+        def step_smooth(img2d):
+            img2d = to_gray2d(img2d)
+            med = estimate_medline_intensity(img2d)
+            rpe = detect_rpe_simple(img2d, med)
             rpe_s = linesweeter(rpe)
-            return overlay(img, rpe_s, "RPE suavizada (linesweeter)")
+            return overlay(img2d, rpe_s, "RPE suavizada (linesweeter)")
         btn_smooth.click(step_smooth, inputs=img_state, outputs=out_smooth)
 
-demo.launch()
+demo.launch()