Update app.py

app.py

@@ -2,180 +2,116 @@ import gradio as gr
 import numpy as np
 import cv2
 import plotly.graph_objects as go
-from sklearn.decomposition import PCA
 from sklearn.metrics.pairwise import cosine_distances
 
-# ===============================
-# FACE DETECTION
-# ===============================
+# =========================
+# FACE UTILITIES
+# =========================
 
 face_cascade = cv2.CascadeClassifier(
     cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
 )
 
-def detect_face(image):
+def detect(image):
     if image is None:
-        return None, None
+        return image, None
 
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     faces = face_cascade.detectMultiScale(gray, 1.3, 5)
-
     if len(faces) == 0:
         return image, None
 
     x, y, w, h = faces[0]
-    cv2.rectangle(image, (x, y), (x+w, y+h), (0,255,0), 2)
-
-    face = gray[y:y+h, x:x+w]
-    face = cv2.resize(face, (64,64))
+    cv2.rectangle(image, (x,y), (x+w,y+h), (0,255,0), 2)
+    face = cv2.resize(gray[y:y+h, x:x+w], (64,64))
     return image, face.flatten()
 
-def face_to_embedding(face_vector):
-    np.random.seed(42)
-    proj = np.random.randn(face_vector.shape[0], 128)
-    emb = face_vector @ proj
-    emb = emb / np.linalg.norm(emb)
-    return emb
-
-# ===============================
-# VISUALS
-# ===============================
-
-def plot_embedding(embedding):
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        y=embedding[:50],
-        mode="lines+markers"
-    ))
-    fig.update_layout(
-        title="Face Embedding (Vector Representation)",
-        height=300
-    )
-    return fig
-
-def plot_3d(enroll, live):
-    pca = PCA(n_components=3)
-    reduced = pca.fit_transform(np.vstack([enroll, live]))
-
-    fig = go.Figure()
-    fig.add_trace(go.Scatter3d(
-        x=[reduced[0,0]], y=[reduced[0,1]], z=[reduced[0,2]],
-        mode="markers+text",
-        text=["Enrolled"],
-        marker=dict(size=6)
-    ))
-    fig.add_trace(go.Scatter3d(
-        x=[reduced[1,0]], y=[reduced[1,1]], z=[reduced[1,2]],
-        mode="markers+text",
-        text=["Live"],
-        marker=dict(size=6)
-    ))
-
-    fig.update_layout(title="3D Face Embedding Space")
-    return fig
+def embed(face):
+    vec = face @ np.random.randn(face.shape[0], 128)
+    return vec / np.linalg.norm(vec)
 
-# ===============================
+# =========================
 # LOGIC
-# ===============================
+# =========================
 
-def enroll(image):
-    img, face = detect_face(image)
+def enroll(img):
+    img, face = detect(img)
     if face is None:
-        return img, None, "❌ No face detected", None
+        return img, None, "❌ No face detected"
+    return img, embed(face), "✅ Face enrolled"
 
-    emb = face_to_embedding(face)
-    return img, emb, "✅ Face enrolled", plot_embedding(emb)
-
-def verify(image, stored, threshold):
-    img, face = detect_face(image)
+def verify(img, stored):
+    img, face = detect(img)
     if face is None or stored is None:
-        return img, "❌ Missing face or enrollment", None, None
-
-    live = face_to_embedding(face)
-    dist = cosine_distances([stored], [live])[0][0]
+        return img, "❌ Missing data", None
 
-    status = "🔓 UNLOCKED" if dist < threshold else "🔒 DENIED"
+    live = embed(face)
+    dist = cosine_distances([stored],[live])[0][0]
+    status = "🔓 UNLOCKED" if dist < 0.35 else "🔒 DENIED"
 
-    gauge = go.Figure(go.Indicator(
+    fig = go.Figure(go.Indicator(
         mode="gauge+number",
         value=dist,
-        gauge={
-            "axis": {"range": [0,1]},
-            "threshold": {"value": threshold}
-        },
+        gauge={"axis":{"range":[0,1]}},
         title={"text": status}
     ))
+    return img, f"Distance: {dist:.3f}", fig
 
-    return img, f"Distance: {dist:.3f}", gauge, plot_3d(stored, live)
-
-# ===============================
-# NAVIGATION
-# ===============================
-
-def next_tab(t): return min(t+1, 2)
-def prev_tab(t): return max(t-1, 0)
-
-# ===============================
+# =========================
 # UI
-# ===============================
+# =========================
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🔐 How Face Unlock Works (Visual)")
-    tab_state = gr.State(0)
+    page = gr.State(0)
+    emb_state = gr.State()
+
+    gr.Markdown("# 🔐 Face Unlock – How It Works")
 
     with gr.Row():
         back = gr.Button("⬅ Back")
         nextb = gr.Button("Next ➡")
 
-    with gr.Tabs(selected=0) as tabs:
-
-        with gr.Tab("📸 Capture"):
-            cam1 = gr.Image(
-                sources=["webcam"],
-                type="numpy",
-                streaming=True
-            )
-            out1 = gr.Image()
-            gr.Button("Detect").click(detect_face, cam1, [out1, gr.State()])
-
-        with gr.Tab("🧠 Enroll"):
-            cam2 = gr.Image(
-                sources=["webcam"],
-                type="numpy"
-            )
-            out2 = gr.Image()
-            msg2 = gr.Markdown()
-            emb_state = gr.State()
-            plot2 = gr.Plot()
-
-            gr.Button("Enroll Face").click(
-                enroll,
-                cam2,
-                [out2, emb_state, msg2, plot2]
-            )
-
-        with gr.Tab("🔓 Verify"):
-            cam3 = gr.Image(
-                sources=["webcam"],
-                type="numpy"
-            )
-            out3 = gr.Image()
-            threshold = gr.Slider(0.1, 0.8, 0.35)
-            msg3 = gr.Markdown()
-            gauge = gr.Plot()
-            space3d = gr.Plot()
-
-            gr.Button("Verify").click(
-                verify,
-                [cam3, emb_state, threshold],
-                [out3, msg3, gauge, space3d]
-            )
-
-    back.click(prev_tab, tab_state, tab_state).then(
-        lambda i: i, tab_state, tabs
-    )
-    nextb.click(next_tab, tab_state, tab_state).then(
-        lambda i: i, tab_state, tabs
-    )
+    # ---------- PAGE 0 ----------
+    page0 = gr.Column(visible=True)
+    with page0:
+        gr.Markdown("## 📸 Capture Face")
+        cam0 = gr.Image(sources=["webcam"], type="numpy")
+        out0 = gr.Image()
+        gr.Button("Detect").click(detect, cam0, out0)
+
+    # ---------- PAGE 1 ----------
+    page1 = gr.Column(visible=False)
+    with page1:
+        gr.Markdown("## 🧠 Enroll Face")
+        cam1 = gr.Image(sources=["webcam"], type="numpy")
+        out1 = gr.Image()
+        msg1 = gr.Markdown()
+        gr.Button("Enroll").click(enroll, cam1, [out1, emb_state, msg1])
+
+    # ---------- PAGE 2 ----------
+    page2 = gr.Column(visible=False)
+    with page2:
+        gr.Markdown("## 🔓 Verify Face")
+        cam2 = gr.Image(sources=["webcam"], type="numpy")
+        out2 = gr.Image()
+        msg2 = gr.Markdown()
+        gauge = gr.Plot()
+        gr.Button("Verify").click(verify, [cam2, emb_state], [out2, msg2, gauge])
+
+    # =========================
+    # NAVIGATION
+    # =========================
+
+    def nav(p, step):
+        p = min(2, max(0, p+step))
+        return (
+            p,
+            gr.update(visible=p==0),
+            gr.update(visible=p==1),
+            gr.update(visible=p==2)
+        )
+
+    back.click(nav, [page, gr.State(-1)], [page, page0, page1, page2])
+    nextb.click(nav, [page, gr.State(1)], [page, page0, page1, page2])
 
 demo.launch()