Update app.py

app.py

@@ -1,187 +1,34 @@
 import gradio as gr
+import tensorflow as tf
 import cv2
 import numpy as np
-import mediapipe as mp
-from sklearn.cluster import KMeans
-import os
-
-# Train the model once at startup
-if not os.path.exists("mask_model.pkl"):
-    exec(open("train_model.py").read())
-
-
-# ADD this function near the top
-def recommend_mask_style(face_shape, skin_tone):
-    rules = {
-        ("oval", "fair"): "Floral Pastel",
-        ("oval", "medium"): "Elegant Pearl",
-        ("oval", "dark"): "Tribal Geometric",
-        ("round", "fair"): "Soft Petals",
-        ("round", "medium"): "Bold Striped",
-        ("round", "dark"): "Neon Carnival",
-        ("square", "fair"): "Royal Blue Lace",
-        ("square", "medium"): "Copper Edge",
-        ("square", "dark"): "Metallic Mask"
-    }
-    return rules.get((face_shape, skin_tone), "Mystery Style")
-
-# UPDATE overlay_mask function to add the style
-def overlay_mask(image, face_shape, skin_tone, x, y, w, h):
-    overlay = image.copy()
-    mask = np.zeros_like(image, dtype=np.uint8)
-
-    color_dict = {
-        "fair": (255, 182, 193),
-        "medium": (0, 191, 255),
-        "dark": (138, 43, 226)
-    }
-    color = color_dict.get(skin_tone, (255, 255, 255))
-
-    if face_shape == "oval":
-        center = (x + w // 2, y + h // 2)
-        axes = (w // 2, h // 2)
-        cv2.ellipse(mask, center, axes, 0, 0, 360, color, -1)
-    elif face_shape == "round":
-        radius = min(w, h) // 2
-        center = (x + w // 2, y + h // 2)
-        cv2.circle(mask, center, radius, color, -1)
-    elif face_shape == "square":
-        cv2.rectangle(mask, (x, y), (x + w, y + h), color, -1)
-    else:
-        cv2.rectangle(mask, (x, y), (x + w, y + h), color, -1)
-
-    # Get mask style
-    style = recommend_mask_style(face_shape, skin_tone)
-
-    # Blend mask overlay
-    alpha = 0.4
-    blended = cv2.addWeighted(mask, alpha, image, 1 - alpha, 0)
-
-    # Add style label
-    label_text = f"{face_shape}, {skin_tone}, {style}"
-    cv2.putText(blended, label_text, (x, y - 10),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-
-    return blended
-
-# Initialize MediaPipe modules
-mp_face_detection = mp.solutions.face_detection
-mp_face_mesh = mp.solutions.face_mesh
-
-face_detector = mp_face_detection.FaceDetection(model_selection=0, min_detection_confidence=0.6)
-face_mesh = mp_face_mesh.FaceMesh(static_image_mode=True, max_num_faces=1, refine_landmarks=True)
-
-def detect_face_shape(landmarks, image_width, image_height):
-    # Extract specific landmarks
-    jaw_left = landmarks[234]
-    jaw_right = landmarks[454]
-    chin = landmarks[152]
-    forehead = landmarks[10]
-
-    x1 = int(jaw_left.x * image_width)
-    x2 = int(jaw_right.x * image_width)
-    y1 = int(chin.y * image_height)
-    y2 = int(forehead.y * image_height)
-
-    face_width = abs(x2 - x1)
-    face_height = abs(y1 - y2)
-
-    ratio = face_width / face_height if face_height != 0 else 0
-
-    if ratio > 1.05:
-        return "round"
-    elif 0.95 < ratio <= 1.05:
-        return "square"
-    else:
-        return "oval"
-
-def detect_skin_tone(image, x, y, w, h):
-    roi = image[y:y+h, x:x+w]
-    roi_rgb = cv2.cvtColor(roi, cv2.COLOR_BGR2RGB)
-    roi_flat = roi_rgb.reshape((-1, 3))
-
-    kmeans = KMeans(n_clusters=3, n_init=10)
-    kmeans.fit(roi_flat)
-    avg_color = kmeans.cluster_centers_[0]
-    brightness = np.mean(avg_color)
-
-    if brightness > 200:
-        return "fair"
-    elif brightness > 100:
-        return "medium"
-    else:
-        return "dark"
-
-def overlay_mask(image, face_shape, skin_tone, x, y, w, h):
-    overlay = image.copy()
-    mask = np.zeros_like(image, dtype=np.uint8)
-
-    color_dict = {
-        "fair": (255, 182, 193),    # light pink
-        "medium": (0, 191, 255),    # deep sky blue
-        "dark": (138, 43, 226)      # blue violet
-    }
-    color = color_dict.get(skin_tone, (255, 255, 255))
-
-    if face_shape == "oval":
-        center = (x + w // 2, y + h // 2)
-        axes = (w // 2, h // 2)
-        cv2.ellipse(mask, center, axes, 0, 0, 360, color, -1)
-    elif face_shape == "round":
-        radius = min(w, h) // 2
-        center = (x + w // 2, y + h // 2)
-        cv2.circle(mask, center, radius, color, -1)
-    elif face_shape == "square":
-        cv2.rectangle(mask, (x, y), (x + w, y + h), color, -1)
-    else:
-        cv2.rectangle(mask, (x, y), (x + w, y + h), color, -1)
-
-    alpha = 0.4
-    blended = cv2.addWeighted(mask, alpha, image, 1 - alpha, 0)
-
-    cv2.putText(blended, f"{face_shape}, {skin_tone}", (x, y - 10),
-                cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
-
-    return blended
-
-def process_image(image):
-    image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
-    ih, iw, _ = image.shape
-
-    results = face_detector.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
-    if not results.detections:
-        return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-
-    for detection in results.detections:
-        bboxC = detection.location_data.relative_bounding_box
-        x = int(bboxC.xmin * iw)
-        y = int(bboxC.ymin * ih)
-        w = int(bboxC.width * iw)
-        h = int(bboxC.height * ih)
-        x, y = max(x, 0), max(y, 0)
-
-        # Detect mesh
-        results_mesh = face_mesh.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
-        if results_mesh.multi_face_landmarks:
-            landmarks = results_mesh.multi_face_landmarks[0].landmark
-            face_shape = detect_face_shape(landmarks, iw, ih)
-        else:
-            face_shape = "oval"
-
-        skin_tone = detect_skin_tone(image, x, y, w, h)
-        image = overlay_mask(image, face_shape, skin_tone, x, y, w, h)
-
-    return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-
-# Gradio UI
-demo = gr.Interface(
-    fn=process_image,
-    inputs=gr.Image(type="numpy", label="Upload or Snap Image"),
-    outputs=gr.Image(label="Face Shape + Skin Tone + Mask Overlay"),
-    live=True,
-    title="Face Shape & Skin Tone Analyzer",
-    description="This app detects face shape & skin tone and overlays a dynamic mask using OpenCV."
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+
+# Load trained model
+model = tf.keras.models.load_model("cnn_mask_model.h5")
+
+# Load dataset & encode mask types
+df = pd.read_excel("mask_dataset.xlsx")
+label_encoder = LabelEncoder()
+df["mask_type"] = label_encoder.fit_transform(df["mask_type"])
+
+# Define function for prediction
+def predict_mask(image):
+    img_resized = cv2.resize(image, (128, 128)).reshape(1, 128, 128, 3) / 255.0
+    mask_pred = model.predict(img_resized).argmax()
+    
+    mask_name = label_encoder.inverse_transform([mask_pred])[0]  # Convert label back
+
+    return f"Recommended Mask: {mask_name}"
+
+# Gradio interface for Hugging Face Spaces
+iface = gr.Interface(
+    fn=predict_mask,
+    inputs=gr.Image(type="numpy", label="Upload Your Face Image"),
+    outputs="text",
+    title="🎭 Party Mask Recommendation App",
+    description="Upload a face image and get the best party mask recommendation!"
 )
 
-if __name__ == "__main__":
-    demo.launch()
+iface.launch()