Download app.py from Mahir1426/face2: direct link, hf CLI and curl.
- Browser
- Download file 16.5 kB
-
https://huggingface.co/spaces/Mahir1426/face2/resolve/main/app.py
- Command line
-
hf download hf://spaces/Mahir1426/face2/app.py
-
curl -L -o app.py https://huggingface.co/spaces/Mahir1426/face2/resolve/main/app.py
16.5 kB
| from flask import Flask, request, render_template, Response, jsonify, url_for, send_from_directory | |
| import cv2 | |
| import numpy as np | |
| import joblib | |
| import os | |
| import warnings | |
| from werkzeug.utils import secure_filename | |
| import mediapipe as mp | |
| from mediapipe.tasks import python | |
| from mediapipe.tasks.python import vision | |
| from mediapipe.framework.formats import landmark_pb2 | |
| from flask_cors import CORS | |
| from dotenv import load_dotenv | |
| # Import database functions | |
| from database import upload_image_to_cloudinary, save_analysis_to_db | |
| # Load environment variables | |
| load_dotenv() | |
| # Suppress specific deprecation warnings from protobuf | |
| warnings.filterwarnings("ignore", category=UserWarning, module='google.protobuf') | |
| app = Flask(__name__, template_folder='templates') | |
| CORS(app) # Enable CORS for all routes | |
| # Initialize MediaPipe Face Landmarker (only once) | |
| base_options = python.BaseOptions(model_asset_path='face_landmarker_v2_with_blendshapes.task') | |
| options = vision.FaceLandmarkerOptions(base_options=base_options, | |
| output_face_blendshapes=True, | |
| output_facial_transformation_matrixes=True, | |
| num_faces=1) | |
| face_landmarker = vision.FaceLandmarker.create_from_options(options) | |
| # Initialize MediaPipe drawing utilities | |
| mp_drawing = mp.solutions.drawing_utils | |
| mp_drawing_styles = mp.solutions.drawing_styles | |
| # Load the ultra-optimized model and scaler | |
| print("Loading ultra-optimized model...") | |
| face_shape_model = joblib.load('Ultra_Optimized_RandomForest.joblib') | |
| scaler = joblib.load('ultra_optimized_scaler.joblib') | |
| print("✅ Ultra-optimized model loaded successfully!") | |
| def distance_3d(p1, p2): | |
| """Calculate 3D Euclidean distance between two points.""" | |
| return np.linalg.norm(np.array(p1) - np.array(p2)) | |
| def smart_preprocess_image(image): | |
| """ | |
| Smart image preprocessing to get the best face region. | |
| This addresses the issue of users not providing perfect images. | |
| """ | |
| h, w = image.shape[:2] | |
| # First, try to detect face and get bounding box | |
| rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) | |
| mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image) | |
| detection_result = face_landmarker.detect(mp_image) | |
| if detection_result.face_landmarks: | |
| # Get face landmarks | |
| face_landmarks = detection_result.face_landmarks[0] | |
| # Calculate face bounding box with padding | |
| x_coords = [landmark.x for landmark in face_landmarks] | |
| y_coords = [landmark.y for landmark in face_landmarks] | |
| # Convert normalized coordinates to pixel coordinates | |
| x_min = int(min(x_coords) * w) | |
| x_max = int(max(x_coords) * w) | |
| y_min = int(min(y_coords) * h) | |
| y_max = int(max(y_coords) * h) | |
| # Add generous padding around face (40% padding for better context) | |
| face_width = x_max - x_min | |
| face_height = y_max - y_min | |
| pad_x = int(face_width * 0.4) # 40% padding | |
| pad_y = int(face_height * 0.4) | |
| # Calculate crop coordinates | |
| x1 = max(0, x_min - pad_x) | |
| x2 = min(w, x_max + pad_x) | |
| y1 = max(0, y_min - pad_y) | |
| y2 = min(h, y_max + pad_y) | |
| # Crop the face region | |
| face_crop = image[y1:y2, x1:x2] | |
| # Resize to standard size while maintaining aspect ratio | |
| target_size = 224 | |
| crop_h, crop_w = face_crop.shape[:2] | |
| # Calculate scale to fit in target size | |
| scale = min(target_size / crop_w, target_size / crop_h) | |
| new_w = int(crop_w * scale) | |
| new_h = int(crop_h * scale) | |
| # Resize maintaining aspect ratio | |
| resized = cv2.resize(face_crop, (new_w, new_h)) | |
| # Create final image with padding to exact target size | |
| final_image = np.zeros((target_size, target_size, 3), dtype=np.uint8) | |
| # Center the resized image | |
| start_y = (target_size - new_h) // 2 | |
| start_x = (target_size - new_w) // 2 | |
| final_image[start_y:start_y + new_h, start_x:start_x + new_w] = resized | |
| return final_image | |
| else: | |
| # If no face detected, just resize to standard size | |
| return cv2.resize(image, (224, 224)) | |
| def extract_optimized_features(coords): | |
| """ | |
| Extract optimized features for face shape detection. | |
| Uses only the most important landmarks for efficiency. | |
| """ | |
| # Key landmarks for face shape analysis | |
| landmark_indices = { | |
| 'forehead_top': 10, | |
| 'forehead_left': 21, | |
| 'forehead_right': 251, | |
| 'cheek_left': 234, | |
| 'cheek_right': 454, | |
| 'jaw_left': 172, | |
| 'jaw_right': 397, | |
| 'chin': 152, | |
| } | |
| # Extract chosen points | |
| lm = {name: coords[idx] for name, idx in landmark_indices.items()} | |
| # Calculate key measurements | |
| face_height = distance_3d(lm['forehead_top'], lm['chin']) | |
| face_width = distance_3d(lm['cheek_left'], lm['cheek_right']) | |
| jaw_width = distance_3d(lm['jaw_left'], lm['jaw_right']) | |
| forehead_width = distance_3d(lm['forehead_left'], lm['forehead_right']) | |
| # Calculate ratios (scale-invariant features) | |
| width_to_height = face_width / face_height | |
| jaw_to_forehead = jaw_width / forehead_width | |
| jaw_to_face = jaw_width / face_width | |
| forehead_to_face = forehead_width / face_width | |
| # Additional shape features | |
| face_area = face_width * face_height | |
| jaw_angle = np.arctan2(lm['jaw_right'][1] - lm['jaw_left'][1], | |
| lm['jaw_right'][0] - lm['jaw_left'][0]) | |
| # Return optimized feature vector | |
| features = np.array([ | |
| width_to_height, | |
| jaw_to_forehead, | |
| jaw_to_face, | |
| forehead_to_face, | |
| face_area, | |
| jaw_angle | |
| ]) | |
| return features | |
| def get_face_shape_label(label): | |
| shapes = ["Heart", "Oval", "Round", "Square", "Oblong"] | |
| return shapes[label] | |
| def draw_landmarks_on_image(rgb_image, detection_result): | |
| face_landmarks_list = detection_result.face_landmarks | |
| annotated_image = np.copy(rgb_image) | |
| for idx in range(len(face_landmarks_list)): | |
| face_landmarks = face_landmarks_list[idx] | |
| # Create landmark proto | |
| face_landmarks_proto = landmark_pb2.NormalizedLandmarkList() | |
| face_landmarks_proto.landmark.extend([ | |
| landmark_pb2.NormalizedLandmark(x=landmark.x, y=landmark.y, z=landmark.z) for landmark in face_landmarks | |
| ]) | |
| # Draw face landmarks | |
| mp_drawing.draw_landmarks( | |
| image=annotated_image, | |
| landmark_list=face_landmarks_proto, | |
| connections=mp.solutions.face_mesh.FACEMESH_TESSELATION, | |
| landmark_drawing_spec=None, | |
| connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_tesselation_style()) | |
| mp_drawing.draw_landmarks( | |
| image=annotated_image, | |
| landmark_list=face_landmarks_proto, | |
| connections=mp.solutions.face_mesh.FACEMESH_CONTOURS, | |
| landmark_drawing_spec=None, | |
| connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_contours_style()) | |
| mp_drawing.draw_landmarks( | |
| image=annotated_image, | |
| landmark_list=face_landmarks_proto, | |
| connections=mp.solutions.face_mesh.FACEMESH_IRISES, | |
| landmark_drawing_spec=None, | |
| connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_iris_connections_style()) | |
| return annotated_image | |
| def allowed_file(filename): | |
| return '.' in filename and filename.rsplit('.', 1)[1].lower() in app.config['ALLOWED_EXTENSIONS'] | |
| def generate_frames(): | |
| cap = cv2.VideoCapture(0) | |
| while True: | |
| ret, frame = cap.read() | |
| if not ret: | |
| break | |
| rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) | |
| image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_frame) | |
| detection_result = face_landmarker.detect(image) | |
| if detection_result.face_landmarks: | |
| for face_landmarks in detection_result.face_landmarks: | |
| landmarks = [[lm.x, lm.y, lm.z] for lm in face_landmarks] | |
| landmarks = np.array(landmarks) | |
| face_features = extract_optimized_features(landmarks) | |
| # Normalize features using the scaler | |
| face_features_scaled = scaler.transform(face_features.reshape(1, -1)) | |
| face_shape_label = face_shape_model.predict(face_features_scaled)[0] | |
| face_shape = get_face_shape_label(face_shape_label) | |
| annotated_image = draw_landmarks_on_image(rgb_frame, detection_result) | |
| cv2.putText(annotated_image, f"Face Shape: {face_shape}", (50, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) | |
| else: | |
| annotated_image = rgb_frame | |
| ret, buffer = cv2.imencode('.jpg', annotated_image) | |
| frame = buffer.tobytes() | |
| yield (b'--frame\r\n' | |
| b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n') | |
| def index(): | |
| return render_template('index.html') | |
| def analyze_face(): | |
| if 'file' not in request.files: | |
| return jsonify({"error": "No file part"}), 400 | |
| file = request.files['file'] | |
| if file.filename == '': | |
| return jsonify({"error": "No selected file"}), 400 | |
| try: | |
| # --- 1. Read image and smart preprocessing --- | |
| img_bytes = file.read() | |
| nparr = np.frombuffer(img_bytes, np.uint8) | |
| img = cv2.imdecode(nparr, cv2.IMREAD_COLOR) | |
| # Smart preprocessing: detect face and crop optimally | |
| processed_img = smart_preprocess_image(img) | |
| # Convert to RGB for MediaPipe | |
| rgb_image = cv2.cvtColor(processed_img, cv2.COLOR_BGR2RGB) | |
| mp_image = mp.Image(image_format=mp.ImageFormat.SRGB, data=rgb_image) | |
| detection_result = face_landmarker.detect(mp_image) | |
| if not detection_result.face_landmarks: | |
| return jsonify({"error": "No face detected"}), 400 | |
| # --- 2. Get data, calculate features, and predict shape --- | |
| face_landmarks = detection_result.face_landmarks[0] | |
| # First, calculate the optimized features | |
| landmarks_normalized = np.array([[lm.x, lm.y, lm.z] for lm in face_landmarks]) | |
| face_features = extract_optimized_features(landmarks_normalized) | |
| # Normalize features using the scaler | |
| face_features_scaled = scaler.transform(face_features.reshape(1, -1)) | |
| # Then, predict the shape using calibrated features | |
| face_shape_label = face_shape_model.predict(face_features_scaled)[0] | |
| face_shape = get_face_shape_label(face_shape_label) | |
| # Get confidence scores | |
| confidence_scores = face_shape_model.predict_proba(face_features_scaled)[0] | |
| confidence = confidence_scores[face_shape_label] | |
| # --- 3. Draw landmarks on the image --- | |
| annotated_image_rgb = draw_landmarks_on_image(rgb_image, detection_result) | |
| # cv2.putText(annotated_image_rgb, f"Face Shape: {face_shape}", (20, 50), | |
| # cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) | |
| # cv2.putText(annotated_image_rgb, f"Confidence: {confidence:.3f}", (20, 90), | |
| # cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2) | |
| # --- 4. Upload the PROCESSED image to Cloudinary --- | |
| annotated_image_bgr = cv2.cvtColor(annotated_image_rgb, cv2.COLOR_RGB2BGR) | |
| _, buffer = cv2.imencode('.jpg', annotated_image_bgr) | |
| processed_image_url = upload_image_to_cloudinary(buffer.tobytes()) | |
| if not processed_image_url: | |
| return jsonify({"error": "Failed to upload processed image"}), 500 | |
| # --- 5. Calculate Measurements using CALIBRATED values --- | |
| landmarks_normalized = np.array([[lm.x, lm.y, lm.z] for lm in face_landmarks]) | |
| # Define more accurate landmark points for measurements | |
| p_iris_l = landmarks_normalized[473] # Left Iris | |
| p_iris_r = landmarks_normalized[468] # Right Iris | |
| p_forehead_top = landmarks_normalized[10] # Top of forehead hairline | |
| p_chin_tip = landmarks_normalized[152] # Bottom of chin | |
| p_cheek_l = landmarks_normalized[234] # Left cheekbone edge | |
| p_cheek_r = landmarks_normalized[454] # Right cheekbone edge | |
| p_jaw_l = landmarks_normalized[172] # Left jaw point | |
| p_jaw_r = landmarks_normalized[397] # Right jaw point | |
| p_forehead_l = landmarks_normalized[63] # Left forehead edge | |
| p_forehead_r = landmarks_normalized[293] # Right forehead edge | |
| # IPD-based calibration | |
| AVG_IPD_CM = 6.3 | |
| dist_iris = distance_3d(p_iris_l, p_iris_r) | |
| cm_per_unit = AVG_IPD_CM / dist_iris if dist_iris != 0 else 0 | |
| # Calculate all distances | |
| dist_face_length = distance_3d(p_forehead_top, p_chin_tip) | |
| dist_cheek_width = distance_3d(p_cheek_l, p_cheek_r) | |
| dist_jaw_width = distance_3d(p_jaw_l, p_jaw_r) | |
| dist_forehead_width = distance_3d(p_forehead_l, p_forehead_r) | |
| # Convert to cm and apply calibration adjustments | |
| face_length_cm = (dist_face_length * cm_per_unit) + 5.0 # +4cm calibration (increased from +2cm) | |
| cheekbone_width_cm = (dist_cheek_width * cm_per_unit) + 4.0 # +3cm calibration (increased from +2cm) | |
| jaw_width_cm = (dist_jaw_width * cm_per_unit) +0.5 # No calibration (already accurate) | |
| forehead_width_cm = (dist_forehead_width * cm_per_unit) + 6.0 # +5cm calibration (increased from +3.5cm) | |
| # Jaw curve ratio is a relative measure, so it doesn't need cm conversion | |
| jaw_curve_ratio = dist_face_length / dist_cheek_width if dist_cheek_width != 0 else 0 | |
| measurements = { | |
| "face_length_cm": float(face_length_cm), | |
| "cheekbone_width_cm": float(cheekbone_width_cm), | |
| "jaw_width_cm": float(jaw_width_cm), | |
| "forehead_width_cm": float(forehead_width_cm), | |
| "jaw_curve_ratio": float(jaw_curve_ratio) | |
| } | |
| # --- 6. Save analysis to MongoDB and return --- | |
| analysis_id = save_analysis_to_db(processed_image_url, face_shape, measurements) | |
| if not analysis_id: | |
| return jsonify({"error": "Failed to save analysis"}), 500 | |
| # --- 7. Return the complete result --- | |
| return jsonify({ | |
| "message": "Analysis successful", | |
| "analysis_id": analysis_id, | |
| "image_url": processed_image_url, | |
| "face_shape": face_shape, | |
| "confidence": float(confidence), | |
| "all_probabilities": { | |
| "Heart": float(confidence_scores[0]), | |
| "Oval": float(confidence_scores[1]), | |
| "Round": float(confidence_scores[2]), | |
| "Square": float(confidence_scores[3]), | |
| "Oblong": float(confidence_scores[4]) | |
| }, | |
| "measurements": measurements, | |
| "calibration_applied": { | |
| "face_length_adjustment": "+4.0cm (increased from +2.0cm)", | |
| "forehead_width_adjustment": "+5.0cm (increased from +3.5cm)", | |
| "cheekbone_width_adjustment": "+3.0cm (increased from +2.0cm)", | |
| "jaw_width_adjustment": "none (already accurate)", | |
| "note": "Calibration adjustments increased based on user feedback" | |
| } | |
| }) | |
| except Exception as e: | |
| print(f"An error occurred: {e}") | |
| return jsonify({"error": f"An error occurred: {str(e)}"}), 500 | |
| def video_feed(): | |
| return Response(generate_frames(), mimetype='multipart/x-mixed-replace; boundary=frame') | |
| def real_time(): | |
| return render_template('real_time.html') | |
| if __name__ == '__main__': | |
| app.run(debug=True, port=5000) | |