Update app.py

app.py

@@ -6,7 +6,7 @@ from sklearn.decomposition import PCA
 from sklearn.metrics.pairwise import cosine_distances
 
 # ===============================
-# FACE & EMBEDDING UTILITIES
+# FACE DETECTION
 # ===============================
 
 face_cascade = cv2.CascadeClassifier(
@@ -23,196 +23,159 @@ def detect_face(image):
     if len(faces) == 0:
         return image, None
 
-    (x, y, w, h) = faces[0]
+    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))
     return image, face.flatten()
 
 def face_to_embedding(face_vector):
-    np.random.seed(0)
-    projection = np.random.randn(face_vector.shape[0], 128)
-    embedding = face_vector @ projection
-    embedding = embedding / np.linalg.norm(embedding)
-    return embedding
+    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
 
 # ===============================
-# VISUALIZATION HELPERS
+# VISUALS
 # ===============================
 
-def embedding_plot(embedding, title):
+def plot_embedding(embedding):
     fig = go.Figure()
     fig.add_trace(go.Scatter(
         y=embedding[:50],
         mode="lines+markers"
     ))
     fig.update_layout(
-        title=title,
-        height=300,
-        xaxis_title="Dimension",
-        yaxis_title="Value"
+        title="Face Embedding (Vector Representation)",
+        height=300
     )
     return fig
 
-def embedding_3d_plot(embeddings, labels):
+def plot_3d(enroll, live):
     pca = PCA(n_components=3)
-    reduced = pca.fit_transform(embeddings)
+    reduced = pca.fit_transform(np.vstack([enroll, live]))
 
     fig = go.Figure()
-    for i, label in enumerate(labels):
-        fig.add_trace(go.Scatter3d(
-            x=[reduced[i,0]],
-            y=[reduced[i,1]],
-            z=[reduced[i,2]],
-            mode="markers+text",
-            text=[label],
-            marker=dict(size=6)
-        ))
+    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",
-        height=450
-    )
+    fig.update_layout(title="3D Face Embedding Space")
     return fig
 
 # ===============================
-# TAB LOGIC FUNCTIONS
+# LOGIC
 # ===============================
 
-def enroll_face(image):
+def enroll(image):
     img, face = detect_face(image)
     if face is None:
-        return img, None, "❌ No face detected"
+        return img, None, "❌ No face detected", None
 
     emb = face_to_embedding(face)
-    return img, emb, "✅ Face enrolled successfully"
+    return img, emb, "✅ Face enrolled", plot_embedding(emb)
 
-def verify_face(image, stored_embedding, threshold):
+def verify(image, stored, threshold):
     img, face = detect_face(image)
-    if face is None or stored_embedding is None:
-        return img, "❌ Face / Enrollment missing", None
+    if face is None or stored is None:
+        return img, "❌ Missing face or enrollment", None, None
 
-    emb = face_to_embedding(face)
-    distance = cosine_distances([stored_embedding], [emb])[0][0]
+    live = face_to_embedding(face)
+    dist = cosine_distances([stored], [live])[0][0]
 
-    status = "🔓 UNLOCKED" if distance < threshold else "🔒 DENIED"
+    status = "🔓 UNLOCKED" if dist < threshold else "🔒 DENIED"
 
-    fig = go.Figure(go.Indicator(
+    gauge = go.Figure(go.Indicator(
         mode="gauge+number",
-        value=distance,
+        value=dist,
         gauge={
             "axis": {"range": [0,1]},
-            "threshold": {
-                "line": {"color": "red", "width": 4},
-                "value": threshold
-            }
+            "threshold": {"value": threshold}
         },
         title={"text": status}
     ))
 
-    return img, f"Distance: {distance:.3f}", fig
+    return img, f"Distance: {dist:.3f}", gauge, plot_3d(stored, live)
 
 # ===============================
-# TAB NAVIGATION
+# NAVIGATION
 # ===============================
 
-def next_tab(t): return min(t+1, 3)
+def next_tab(t): return min(t+1, 2)
 def prev_tab(t): return max(t-1, 0)
 
 # ===============================
-# GRADIO UI
+# UI
 # ===============================
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🔐 How Face Unlock Works (Visual Simulator)")
-    gr.Markdown("Understand mobile face authentication step-by-step")
-
-    current_tab = gr.State(0)
+    gr.Markdown("# 🔐 How Face Unlock Works (Visual)")
+    tab_state = gr.State(0)
 
     with gr.Row():
         back = gr.Button("⬅ Back")
         nextb = gr.Button("Next ➡")
 
-    with gr.Tabs() as tabs:
-        # ---------------- TAB 0 ----------------
-        with gr.Tab("�� Face Detection"):
-            cam1 = gr.Image(source="webcam", streaming=True)
-            out1 = gr.Image()
-            btn1 = gr.Button("Detect Face")
+    with gr.Tabs(selected=0) as tabs:
 
-            btn1.click(
-                detect_face,
-                inputs=cam1,
-                outputs=[out1, gr.State()]
+        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()])
 
-        # ---------------- TAB 1 ----------------
-        with gr.Tab("🧠 Face → Vector"):
-            cam2 = gr.Image(source="webcam")
-            img2 = gr.Image()
-            enroll_msg = gr.Markdown()
-            stored_embedding = gr.State()
-            emb_plot = gr.Plot()
+        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_face,
-                inputs=cam2,
-                outputs=[img2, stored_embedding, enroll_msg]
-            ).then(
-                lambda e: embedding_plot(e, "Face Embedding"),
-                inputs=stored_embedding,
-                outputs=emb_plot
+                enroll,
+                cam2,
+                [out2, emb_state, msg2, plot2]
             )
 
-        # ---------------- TAB 2 ----------------
-        with gr.Tab("📐 Matching & Threshold"):
-            cam3 = gr.Image(source="webcam")
-            img3 = gr.Image()
-            threshold = gr.Slider(0.1, 0.8, 0.35, label="Unlock Threshold")
-            match_msg = gr.Markdown()
-            gauge = gr.Plot()
-
-            gr.Button("Verify Face").click(
-                verify_face,
-                inputs=[cam3, stored_embedding, threshold],
-                outputs=[img3, match_msg, gauge]
+        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()
 
-        # ---------------- TAB 3 ----------------
-        with gr.Tab("🌐 3D Embedding Space"):
-            plot3d = gr.Plot()
-
-            gr.Button("Visualize").click(
-                lambda e: embedding_3d_plot(
-                    np.vstack([e, e + np.random.normal(0,0.05,e.shape)]),
-                    ["Enrolled", "Live"]
-                ),
-                inputs=stored_embedding,
-                outputs=plot3d
+            gr.Button("Verify").click(
+                verify,
+                [cam3, emb_state, threshold],
+                [out3, msg3, gauge, space3d]
             )
 
-    # ===============================
-    # NAV BUTTON LOGIC (SAFE)
-    # ===============================
-
-    back.click(
-        prev_tab,
-        current_tab,
-        current_tab
-    ).then(
-        lambda i: i,
-        current_tab,
-        tabs
+    back.click(prev_tab, tab_state, tab_state).then(
+        lambda i: i, tab_state, tabs
     )
-
-    nextb.click(
-        next_tab,
-        current_tab,
-        current_tab
-    ).then(
-        lambda i: i,
-        current_tab,
-        tabs
+    nextb.click(next_tab, tab_state, tab_state).then(
+        lambda i: i, tab_state, tabs
     )
 
 demo.launch()