Hugging Face's logo

Spaces:
danicor
/
ppw2
Sleeping

App Files Community
ppw2 / app.py
danicor's picture
danicor
Rename app-stop.py to app.py
8e4650e verified
Raw History Blame Contribute Delete
111 kB
from flask import Flask, request, jsonify
import cv2
import mediapipe as mp
import numpy as np
from PIL import Image
import math
import io
import base64
import requests
import os
import threading
import time
from datetime import datetime
import traceback
try:
from transformers import pipeline
TRANSFORMERS_AVAILABLE = True
print("[AI] ✓ Transformers available")
except ImportError:
TRANSFORMERS_AVAILABLE = False
print("[AI] ✗ Transformers not available")
FACE_PARSER = None
FACE_PARSING_AVAILABLE = False
FACE_PARSING_LABELS = {
0: 'background',
1: 'skin',
2: 'nose', # ← اصلاح شد
3: 'eye_g', # ← eyeglasses
4: 'l_eye',
5: 'r_eye',
6: 'l_brow', # ← اصلاح شد
7: 'r_brow', # ← اصلاح شد
8: 'l_ear', # ← اصلاح شد
9: 'r_ear', # ← اصلاح شد
10: 'mouth', # ← اصلاح شد
11: 'u_lip', # ← اصلاح شد
12: 'l_lip', # ← اصلاح شد
13: 'hair', # ← اصلاح شد
14: 'hat', # ← اصلاح شد
15: 'ear_r', # ← earring - اصلاح شد
16: 'neck_l', # ← necklace - اصلاح شد
17: 'neck', # ← اصلاح شد
18: 'cloth' # ← اصلاح شد
}
LABEL_COLORS = {
0: (0, 0, 0), # background - مشکی
1: (204, 0, 0), # skin - قرمز تیره
2: (76, 153, 0), # nose - سبز تیره 🟢
3: (255, 0, 0), # eye_g (eyeglasses) - قرمز 🔴
4: (51, 51, 255), # l_eye - آبی
5: (0, 255, 255), # r_eye - فیروزه‌ای
6: (255, 255, 0), # l_brow - زرد
7: (204, 102, 0), # r_brow - قهوه‌ای مایل به نارنجی 🟤
8: (153, 0, 76), # l_ear - بنفش تیره
9: (255, 102, 153), # r_ear - صورتی مایل به نارنجی 🌸
10: (102, 255, 153), # mouth - سبز روشن
11: (255, 0, 255), # u_lip - صورتی
12: (204, 0, 153), # l_lip - بنفش صورتی 💜
13: (0, 204, 204), # hair - فیروزه‌ای تیره
14: (0, 255, 0), # hat - سبز روشن 🟢
15: (255, 204, 0), # ear_r (earring) - نارنجی روشن
16: (204, 0, 204), # neck_l (necklace) - صورتی تیره
17: (255, 153, 51), # neck - نارنجی
18: (102, 102, 156) # cloth - آبی خاکستری
}
def init_face_parser():
global FACE_PARSER, FACE_PARSING_AVAILABLE
if FACE_PARSING_AVAILABLE:
return True
try:
print("[FaceParsing] Loading face-parsing model...")
from transformers import AutoImageProcessor, AutoModelForSemanticSegmentation
model_name = "jonathandinu/face-parsing"
print(f"[FaceParsing] Loading from {model_name}...")
processor = AutoImageProcessor.from_pretrained(model_name)
model = AutoModelForSemanticSegmentation.from_pretrained(model_name)
FACE_PARSER = {
'processor': processor,
'model': model
}
FACE_PARSING_AVAILABLE = True
print("[FaceParsing] ✓ Model loaded successfully!")
return True
except Exception as e1:
print(f"[FaceParsing] Method 1 failed: {e1}")
try:
print("[FaceParsing] Trying ONNX version...")
import onnxruntime as ort
model_path = "face_parsing.onnx"
if os.path.exists(model_path):
session = ort.InferenceSession(model_path)
FACE_PARSER = {'session': session, 'type': 'onnx'}
FACE_PARSING_AVAILABLE = True
print("[FaceParsing] ✓ ONNX model loaded!")
return True
else:
print("[FaceParsing] ONNX file not found")
except Exception as e2:
print(f"[FaceParsing] Method 2 failed: {e2}")
print("[FaceParsing] ⚠ Will use CV2 fallback methods")
return False
def predict_face_parsing(image_pil):
global FACE_PARSER
if not FACE_PARSING_AVAILABLE or FACE_PARSER is None:
return None
try:
import torch
if 'processor' in FACE_PARSER:
processor = FACE_PARSER['processor']
model = FACE_PARSER['model']
inputs = processor(images=image_pil, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs)
logits = outputs.logits
h, w = image_pil.size[1], image_pil.size[0]
upsampled_logits = torch.nn.functional.interpolate(
logits,
size=(h, w),
mode="bilinear",
align_corners=False
)
parsing_mask = upsampled_logits.argmax(dim=1)[0].cpu().numpy()
return parsing_mask.astype(np.uint8)
elif 'session' in FACE_PARSER:
session = FACE_PARSER['session']
img_array = np.array(image_pil.resize((512, 512)))
img_array = img_array.transpose(2, 0, 1) # HWC -> CHW
img_array = img_array.astype(np.float32) / 255.0
img_array = np.expand_dims(img_array, 0) # Add batch dim
outputs = session.run(None, {'input': img_array})
parsing_mask = outputs[0].argmax(axis=1)[0]
h, w = image_pil.size[1], image_pil.size[0]
parsing_mask = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
return parsing_mask
return None
except Exception as e:
print(f"[FaceParsing] Prediction error: {e}")
import traceback
traceback.print_exc()
return None
def predict_face_parsing_xenova(image_pil):
global FACE_PARSER
if not FACE_PARSING_AVAILABLE or FACE_PARSER is None:
return None
try:
output = FACE_PARSER(image_pil)
h, w = image_pil.size[1], image_pil.size[0]
parsing_mask = np.zeros((h, w), dtype=np.uint8)
for item in output:
label_name = item['label']
mask_pil = item['mask']
mask_np = np.array(mask_pil)
if len(mask_np.shape) == 3:
mask_np = cv2.cvtColor(mask_np, cv2.COLOR_RGB2GRAY)
if mask_np.shape != (h, w):
mask_np = cv2.resize(mask_np, (w, h), interpolation=cv2.INTER_NEAREST)
label_id = XENOVA_LABELS.get(label_name, 0)
parsing_mask[mask_np > 127] = label_id
return parsing_mask
except Exception as e:
print(f"[FaceParsing] Error: {e}")
return None
def create_colored_mask(parsing_mask):
h, w = parsing_mask.shape
colored = np.zeros((h, w, 3), dtype=np.uint8)
for label_id, color in LABEL_COLORS.items():
colored[parsing_mask == label_id] = color
return colored
def create_transparent_overlay(original_pil, parsing_mask, alpha=0.5):
h, w = parsing_mask.shape
original_resized = original_pil.resize((w, h))
original_np = np.array(original_resized)
colored = create_colored_mask(parsing_mask)
return (original_np * (1 - alpha) + colored * alpha).astype(np.uint8)
def add_legend_to_image(image, active_labels):
img = image.copy()
h, w = img.shape[:2]
important_labels = {
1: {'name': 'Skin', 'color': LABEL_COLORS[1]},
2: {'name': 'Nose', 'color': LABEL_COLORS[2]},
3: {'name': 'Eyeglasses', 'color': LABEL_COLORS[3]},
4: {'name': 'L Eye', 'color': LABEL_COLORS[4]},
5: {'name': 'R Eye', 'color': LABEL_COLORS[5]},
6: {'name': 'L Brow', 'color': LABEL_COLORS[6]},
7: {'name': 'R Brow', 'color': LABEL_COLORS[7]},
8: {'name': 'L Ear', 'color': LABEL_COLORS[8]},
9: {'name': 'R Ear', 'color': LABEL_COLORS[9]},
10: {'name': 'Mouth', 'color': LABEL_COLORS[10]},
11: {'name': 'U Lip', 'color': LABEL_COLORS[11]},
12: {'name': 'L Lip', 'color': LABEL_COLORS[12]},
13: {'name': 'Hair', 'color': LABEL_COLORS[13]},
14: {'name': 'Hat', 'color': LABEL_COLORS[14]},
15: {'name': 'Earring', 'color': LABEL_COLORS[15]},
16: {'name': 'Necklace', 'color': LABEL_COLORS[16]},
17: {'name': 'Neck', 'color': LABEL_COLORS[17]},
18: {'name': 'Cloth', 'color': LABEL_COLORS[18]}
}
legend_items = []
for label_id in active_labels:
if label_id in important_labels and label_id != 0:
legend_items.append({
'id': label_id,
'name': important_labels[label_id]['name'],
'color': important_labels[label_id]['color']
})
if not legend_items:
return img
priority_order = [3, 14, 15, 16, 13, 4, 5, 2, 10, 18, 1, 17, 8, 9, 6, 7, 11, 12]
legend_items.sort(key=lambda x: priority_order.index(x['id']) if x['id'] in priority_order else 999)
base_size = min(w, h)
if base_size < 400:
font_scale = 0.25
thickness = 1
line_height = 15
box_size = 10
padding = 4
title_scale = 0.25
title_line_height = 12
title_bottom_margin = 10 # ✅ فضای خالی اضافه زیر تایتل
elif base_size < 600:
font_scale = 0.3
thickness = 1
line_height = 18
box_size = 12
padding = 5
title_scale = 0.3
title_line_height = 14
title_bottom_margin = 12 # ✅ فضای خالی اضافه زیر تایتل
elif base_size < 800:
font_scale = 0.4
thickness = 1
line_height = 20
box_size = 14
padding = 6
title_scale = 0.4
title_line_height = 16
title_bottom_margin = 14 # ✅ فضای خالی اضافه زیر تایتل
else:
font_scale = 0.5
thickness = 1
line_height = 22
box_size = 16
padding = 7
title_scale = 0.5
title_line_height = 18
title_bottom_margin = 16 # ✅ فضای خالی اضافه زیر تایتل
num_items = len(legend_items)
mid_point = (num_items + 1) // 2
left_column_items = legend_items[:mid_point] # ستون چپ
right_column_items = legend_items[mid_point:] # ستون راست
def draw_legend_column(items, side='A'):
"""
side: 'A' or 'B'
"""
if not items:
return
max_text_width = 0
for item in items:
(text_w, text_h), _ = cv2.getTextSize(item['name'], cv2.FONT_HERSHEY_SIMPLEX,
font_scale, thickness)
max_text_width = max(max_text_width, text_w)
title_line1 = "Detected"
title_line2 = f"({side}):"
(title1_w, title1_h), _ = cv2.getTextSize(title_line1, cv2.FONT_HERSHEY_SIMPLEX,
title_scale, thickness )
(title2_w, title2_h), _ = cv2.getTextSize(title_line2, cv2.FONT_HERSHEY_SIMPLEX,
title_scale, thickness )
max_title_width = max(title1_w, title2_w)
column_w = max(box_size + padding * 3 + max_text_width, max_title_width + padding * 2)
column_w = min(column_w, int(w * 0.25)) # حداکثر 25% عرض تصویر
column_h = (padding * 2 +
title_line_height * 2 + # دو خط عنوان
title_bottom_margin + # ✅ فضای خالی اضافه زیر تایتل
len(items) * line_height +
padding)
if side == 'A':
column_x = padding * 2
else: # 'B'
column_x = w - column_w - padding * 2
column_y = padding * 2
if column_x + column_w > w:
column_x = w - column_w - padding
if column_y + column_h > h:
column_y = h - column_h - padding
overlay = img.copy()
cv2.rectangle(overlay,
(column_x, column_y),
(column_x + column_w, column_y + column_h),
(0, 0, 0), -1)
cv2.addWeighted(overlay, 0.75, img, 0.25, 0, img)
cv2.rectangle(img,
(column_x, column_y),
(column_x + column_w, column_y + column_h),
(255, 255, 255), 1)
title_start_y = column_y + padding + title_line_height
title1_x = column_x + (column_w - title1_w) // 2
cv2.putText(img, title_line1,
(title1_x, title_start_y),
cv2.FONT_HERSHEY_SIMPLEX, title_scale, (255, 255, 255), thickness )
title2_x = column_x + (column_w - title2_w) // 2
cv2.putText(img, title_line2,
(title2_x, title_start_y + title_line_height),
cv2.FONT_HERSHEY_SIMPLEX, title_scale, (255, 255, 255), thickness )
start_y = title_start_y + title_line_height + title_bottom_margin
for idx, item in enumerate(items):
y_pos = start_y + idx * line_height
if y_pos + line_height > column_y + column_h - padding:
break
box_y = y_pos - box_size // 2
cv2.rectangle(img,
(column_x + padding, box_y),
(column_x + padding + box_size, box_y + box_size),
item['color'], -1)
cv2.rectangle(img,
(column_x + padding, box_y),
(column_x + padding + box_size, box_y + box_size),
(255, 255, 255), 1)
text_x = column_x + padding * 2 + box_size
cv2.putText(img, item['name'],
(text_x, y_pos),
cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255), thickness)
draw_legend_column(left_column_items, side='A')
draw_legend_column(right_column_items, side='B')
return img
class PassportPhotoProcessor:
def __init__(self):
self.mp_face_mesh = mp.solutions.face_mesh
self.mp_pose = mp.solutions.pose
self.face_mesh = self.mp_face_mesh.FaceMesh(
static_image_mode=True,
max_num_faces=1,
refine_landmarks=True,
min_detection_confidence=0.5
)
self.pose = self.mp_pose.Pose(
static_image_mode=True,
model_complexity=2,
min_detection_confidence=0.5
)
def detect_landmarks(self, image):
rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
face_results = self.face_mesh.process(rgb_image)
pose_results = self.pose.process(rgb_image)
if not face_results.multi_face_landmarks:
raise ValueError("No face detected in the image")
return face_results.multi_face_landmarks[0], pose_results
def get_eye_centers(self, landmarks, img_width, img_height):
left_eye_indices = [33, 133, 160, 159, 158, 157, 173]
right_eye_indices = [362, 263, 387, 386, 385, 384, 398]
left_eye_x = np.mean([landmarks.landmark[i].x for i in left_eye_indices]) * img_width
left_eye_y = np.mean([landmarks.landmark[i].y for i in left_eye_indices]) * img_height
right_eye_x = np.mean([landmarks.landmark[i].x for i in right_eye_indices]) * img_width
right_eye_y = np.mean([landmarks.landmark[i].y for i in right_eye_indices]) * img_height
return (left_eye_x, left_eye_y), (right_eye_x, right_eye_y)
def get_nose_tip(self, landmarks, img_width, img_height):
nose_tip = landmarks.landmark[4]
return nose_tip.x * img_width, nose_tip.y * img_height
def get_chin(self, landmarks, img_width, img_height):
chin = landmarks.landmark[152]
return chin.x * img_width, chin.y * img_height
def get_forehead_top(self, landmarks, img_width, img_height):
forehead_indices = [10, 338, 297, 332, 284, 251, 389, 356, 454, 323, 361, 288,
397, 365, 379, 378, 400, 377, 152, 148, 176, 149, 150, 136,
172, 58, 132, 93, 234, 127, 162, 21, 54, 103, 67, 109]
min_y = min([landmarks.landmark[i].y for i in forehead_indices]) * img_height
avg_x = np.mean([landmarks.landmark[i].x for i in forehead_indices]) * img_width
chin_y = landmarks.landmark[152].y * img_height
eye_indices = [33, 133, 362, 263]
eye_y = np.mean([landmarks.landmark[i].y for i in eye_indices]) * img_height
face_height = chin_y - eye_y
hair_extension = face_height * 0.65
estimated_hair_top = max(0, min_y - hair_extension)
return avg_x, estimated_hair_top
def get_shoulders(self, pose_results, img_width, img_height):
if not pose_results.pose_landmarks:
return None
left_shoulder = pose_results.pose_landmarks.landmark[11]
right_shoulder = pose_results.pose_landmarks.landmark[12]
return {
'left': (left_shoulder.x * img_width, left_shoulder.y * img_height),
'right': (right_shoulder.x * img_width, right_shoulder.y * img_height)
}
def calculate_rotation_angle(self, left_eye, right_eye):
dx = right_eye[0] - left_eye[0]
dy = right_eye[1] - left_eye[1]
angle = math.degrees(math.atan2(dy, dx))
return angle
def rotate_image(self, image, angle, center):
h, w = image.shape[:2]
matrix = cv2.getRotationMatrix2D(center, angle, 1.0)
rotated = cv2.warpAffine(image, matrix, (w, h),
flags=cv2.INTER_CUBIC,
borderMode=cv2.BORDER_REPLICATE)
return rotated, matrix
def rotate_point(self, point, matrix):
px, py = point
new_x = matrix[0,0]*px + matrix[0,1]*py + matrix[0,2]
new_y = matrix[1,0]*px + matrix[1,1]*py + matrix[1,2]
return (new_x, new_y)
def calculate_crop_box(self, image, eye_line_y, chin_y, top_hair_y,
nose_x, shoulders, body_bottom_y):
h, w = image.shape[:2]
EYE_TO_BOTTOM_MIN = 0.56
EYE_TO_BOTTOM_MAX = 0.69
FACE_HEIGHT_MIN = 0.50
FACE_HEIGHT_MAX = 0.69
face_height = chin_y - top_hair_y
best_crop = None
best_score = float('inf')
eye_to_bottom = body_bottom_y - eye_line_y
min_crop_from_eye = eye_to_bottom / EYE_TO_BOTTOM_MAX
max_crop_from_eye = eye_to_bottom / EYE_TO_BOTTOM_MIN
min_crop_from_face = face_height / FACE_HEIGHT_MAX
max_crop_from_face = face_height / FACE_HEIGHT_MIN
min_crop_size = max(min_crop_from_face, min_crop_from_eye, 600)
max_crop_size = min(max_crop_from_face, max_crop_from_eye, h, w)
print(f"[CropBox] Eye to bottom: {eye_to_bottom:.0f}px")
print(f"[CropBox] Face height: {face_height:.0f}px")
print(f"[CropBox] Min from eye: {min_crop_from_eye:.0f}, Max: {max_crop_from_eye:.0f}")
print(f"[CropBox] Min from face: {min_crop_from_face:.0f}, Max: {max_crop_from_face:.0f}")
print(f"[CropBox] Final range: {min_crop_size:.0f} - {max_crop_size:.0f}")
if max_crop_size < 600:
raise ValueError("Image too small to create passport photo")
if min_crop_size > max_crop_size:
print(f"[CropBox] Constraint conflict detected. Using flexible approach...")
target_size = (min_crop_from_eye + max_crop_from_eye) / 2
target_size = max(600, min(1200, target_size, h, w))
min_crop_size = max(600, target_size * 0.85)
max_crop_size = min(1200, target_size * 1.15, h, w)
print(f"[CropBox] Adjusted range: {min_crop_size:.0f} - {max_crop_size:.0f}")
if max_crop_size < 600:
raise ValueError("Image too small to create passport photo")
if min_crop_size > max_crop_size:
min_crop_size = max_crop_size = target_size
print(f"[CropBox] Using fixed size: {target_size:.0f}")
search_steps = max(50, int((max_crop_size - min_crop_size) / 10))
for size in np.linspace(max_crop_size, min_crop_size, search_steps):
size = int(size)
target_eye_ratio = (EYE_TO_BOTTOM_MIN + EYE_TO_BOTTOM_MAX) / 2
top = eye_line_y - (size * (1 - target_eye_ratio))
if top > top_hair_y - (size * 0.05):
top = top_hair_y - (size * 0.05)
if top + size < chin_y + (size * 0.05):
top = chin_y + (size * 0.05) - size
left = nose_x - size / 2
right = left + size
bottom = top + size
if left < 0:
left = 0
right = size
if right > w:
right = w
left = w - size
if top < 0:
top = 0
bottom = size
if bottom > h:
bottom = h
top = h - size
if shoulders:
shoulder_width = abs(shoulders['right'][0] - shoulders['left'][0])
if shoulder_width > size * 0.95:
continue
shoulder_left = min(shoulders['left'][0], shoulders['right'][0])
shoulder_right = max(shoulders['left'][0], shoulders['right'][0])
if shoulder_left < left + (size * 0.025) or shoulder_right > right - (size * 0.025):
shoulder_center = (shoulder_left + shoulder_right) / 2
left = shoulder_center - size / 2
right = left + size
if left < 0 or right > w:
continue
eye_to_bottom_ratio = (bottom - eye_line_y) / size
face_height_ratio = (chin_y - top_hair_y) / size
eye_ok = EYE_TO_BOTTOM_MIN <= eye_to_bottom_ratio <= EYE_TO_BOTTOM_MAX
face_ok = FACE_HEIGHT_MIN <= face_height_ratio <= FACE_HEIGHT_MAX
score = 0
eye_deviation = abs(eye_to_bottom_ratio - target_eye_ratio)
if not eye_ok:
score += eye_deviation * 800
else:
score += eye_deviation * 100
target_face_ratio = (FACE_HEIGHT_MIN + FACE_HEIGHT_MAX) / 2
face_deviation = abs(face_height_ratio - target_face_ratio)
if not face_ok:
score += face_deviation * 400
else:
score += face_deviation * 50
score += (1200 - size) * 0.5
if score < best_score:
best_score = score
best_crop = {
'left': int(left),
'top': int(top),
'right': int(right),
'bottom': int(bottom),
'size': size,
'eye_to_bottom_ratio': eye_to_bottom_ratio * 100,
'face_height_ratio': face_height_ratio * 100,
'score': score
}
if eye_ok and (face_ok or face_deviation < 0.05):
print(f"[CropBox] Found good solution at size {size:.0f}")
break
if not best_crop:
raise ValueError("Could not create suitable crop. Please ensure photo shows full head and shoulders.")
print(f"[CropBox] Best crop: {best_crop['size']:.0f}px, " +
f"eye={best_crop['eye_to_bottom_ratio']:.1f}%, " +
f"face={best_crop['face_height_ratio']:.1f}%, " +
f"score={best_crop['score']:.1f}")
return best_crop
def compress_to_size(self, image, max_kb=240):
h, w = image.shape[:2]
if h < 600 or w < 600:
raise ValueError("Image size too small (minimum 600x600px)")
if h > 1200 or w > 1200:
print(f"[Compress] Original size: {w}x{h}, resizing to max 1200px")
scale = 1200 / max(h, w)
new_w = int(w * scale)
new_h = int(h * scale)
image = cv2.resize(image, (new_w, new_h), interpolation=cv2.INTER_AREA)
h, w = new_h, new_w
print(f"[Compress] Resized to: {w}x{h}")
original_image = image.copy()
original_h, original_w = h, w
pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
buffer = io.BytesIO()
pil_image.save(buffer, format='JPEG', quality=100, optimize=True)
size_kb = buffer.tell() / 1024
print(f"[Compress] Initial size at quality 100: {size_kb:.2f} KB")
if size_kb <= max_kb:
print(f"[Compress] ✓ Already under {max_kb}KB")
return buffer.getvalue(), size_kb, 100, (w, h)
current_size = w
best_quality = 100
print(f"[Compress] Starting FAST reduction (step: 100px)")
while current_size > 600 and size_kb > max_kb * 1.5:
current_size -= 100
current_size = max(600, current_size)
new_size = (current_size, current_size)
resized = cv2.resize(original_image, new_size, interpolation=cv2.INTER_AREA)
pil_image = Image.fromarray(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
buffer = io.BytesIO()
pil_image.save(buffer, format='JPEG', quality=best_quality, optimize=True)
size_kb = buffer.tell() / 1024
print(f"[Compress] FAST - Size {current_size}px, quality {best_quality}: {size_kb:.2f} KB")
if size_kb <= max_kb:
print(f"[Compress] ✓ Target reached at {current_size}px")
return buffer.getvalue(), size_kb, best_quality, (current_size, current_size)
print(f"[Compress] Starting SLOW reduction (step: 10px)")
while current_size > 600 and size_kb > max_kb:
current_size -= 10
current_size = max(600, current_size)
new_size = (current_size, current_size)
resized = cv2.resize(original_image, new_size, interpolation=cv2.INTER_AREA)
pil_image = Image.fromarray(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
buffer = io.BytesIO()
pil_image.save(buffer, format='JPEG', quality=best_quality, optimize=True)
size_kb = buffer.tell() / 1024
print(f"[Compress] SLOW - Size {current_size}px, quality {best_quality}: {size_kb:.2f} KB")
if size_kb <= max_kb:
print(f"[Compress] ✓ Target reached at {current_size}px")
return buffer.getvalue(), size_kb, best_quality, (current_size, current_size)
print(f"[Compress] Starting QUALITY reduction (step: 1)")
current_quality = 100
best_size = current_size
while current_quality >= 50 and size_kb > max_kb:
new_size = (current_size, current_size)
resized = cv2.resize(original_image, new_size, interpolation=cv2.INTER_AREA)
pil_image = Image.fromarray(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
buffer = io.BytesIO()
pil_image.save(buffer, format='JPEG', quality=current_quality, optimize=True)
size_kb = buffer.tell() / 1024
print(f"[Compress] QUALITY - Size {current_size}px, quality {current_quality}: {size_kb:.2f} KB")
if size_kb <= max_kb:
best_quality = current_quality
best_size = current_size
print(f"[Compress] ✓ Found acceptable quality {best_quality} at size {best_size}")
break
current_quality -= 1
if size_kb <= max_kb:
print(f"[Compress] Starting SIZE OPTIMIZATION (step: +5px)")
optimized_size = best_size
optimized_buffer = buffer
while optimized_size < original_w and optimized_size < 1200:
test_size = optimized_size + 5
new_size = (test_size, test_size)
resized = cv2.resize(original_image, new_size, interpolation=cv2.INTER_AREA)
pil_image = Image.fromarray(cv2.cvtColor(resized, cv2.COLOR_BGR2RGB))
test_buffer = io.BytesIO()
pil_image.save(test_buffer, format='JPEG', quality=best_quality, optimize=True)
test_size_kb = test_buffer.tell() / 1024
if test_size_kb <= max_kb:
optimized_size = test_size
optimized_buffer = test_buffer
size_kb = test_size_kb
print(f"[Compress] OPTIMIZE - Size {optimized_size}px, quality {best_quality}: {size_kb:.2f} KB")
else:
print(f"[Compress] OPTIMIZE - Size {test_size}px exceeds limit: {test_size_kb:.2f} KB")
break
print(f"[Compress] ✓ Optimized to size {optimized_size}px with quality {best_quality}")
return optimized_buffer.getvalue(), size_kb, best_quality, (optimized_size, optimized_size)
print(f"[Compress] ⚠️ Could not reach {max_kb}KB, returning at {size_kb:.2f}KB")
return buffer.getvalue(), size_kb, current_quality, (current_size, current_size)
def create_analysis_image(self, image, eye_line_y, chin_y, top_hair_y, nose_x,
eye_to_bottom_ratio, face_height_ratio):
analysis_img = image.copy()
h, w = analysis_img.shape[:2]
GREEN = (0, 255, 0) # Eye line
BLUE = (255, 0, 0) # Top of hair
RED = (0, 0, 255) # Chin
YELLOW = (0, 255, 255) # Nose center
CYAN = (255, 255, 0) # Eye to Bottom (cyan)
MAGENTA = (255, 0, 255) # Face Height (magenta)
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
cv2.line(analysis_img, (0, int(top_hair_y)), (w, int(top_hair_y)), BLUE, 2)
cv2.line(analysis_img, (0, int(eye_line_y)), (w, int(eye_line_y)), GREEN, 2)
cv2.line(analysis_img, (0, int(chin_y)), (w, int(chin_y)), RED, 2)
cv2.line(analysis_img, (int(nose_x), 0), (int(nose_x), h), YELLOW, 2)
eye_bottom_x = int(w * 0.15)
cv2.line(analysis_img,
(eye_bottom_x, int(eye_line_y)),
(eye_bottom_x, h),
CYAN, 3)
arrow_size = 15
cv2.arrowedLine(analysis_img,
(eye_bottom_x, int(eye_line_y) + 30),
(eye_bottom_x, int(eye_line_y)),
CYAN, 2, tipLength=0.3)
cv2.arrowedLine(analysis_img,
(eye_bottom_x, h - 30),
(eye_bottom_x, h - 1),
CYAN, 2, tipLength=0.3)
text = f"Eye to Bottom: {eye_to_bottom_ratio:.1f}%"
text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
text_x = eye_bottom_x - text_size[0] // 2
text_y = int((eye_line_y + h) / 2)
cv2.rectangle(analysis_img,
(text_x - 5, text_y - text_size[1] - 5),
(text_x + text_size[0] + 5, text_y + 5),
BLACK, -1)
cv2.putText(analysis_img, text, (text_x, text_y),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, CYAN, 2)
face_height_x = int(w * 0.85)
cv2.line(analysis_img,
(face_height_x, int(top_hair_y)),
(face_height_x, int(chin_y)),
MAGENTA, 3)
cv2.arrowedLine(analysis_img,
(face_height_x, int(top_hair_y) + 30),
(face_height_x, int(top_hair_y)),
MAGENTA, 2, tipLength=0.3)
cv2.arrowedLine(analysis_img,
(face_height_x, int(chin_y) - 30),
(face_height_x, int(chin_y)),
MAGENTA, 2, tipLength=0.3)
text = f"Face Height: {face_height_ratio:.1f}%"
text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.6, 2)[0]
text_x = face_height_x - text_size[0] // 2
text_y = int((top_hair_y + chin_y) / 2)
cv2.rectangle(analysis_img,
(text_x - 5, text_y - text_size[1] - 5),
(text_x + text_size[0] + 5, text_y + 5),
BLACK, -1)
cv2.putText(analysis_img, text, (text_x, text_y),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, MAGENTA, 2)
legend_x = w - 250
legend_y = 30
line_height = 25
overlay = analysis_img.copy()
cv2.rectangle(overlay, (legend_x - 10, legend_y - 10),
(w - 10, legend_y + line_height * 5 + 10),
BLACK, -1)
cv2.addWeighted(overlay, 0.7, analysis_img, 0.3, 0, analysis_img)
legends = [
("Top Hair", BLUE),
("Eye Line", GREEN),
("Chin", RED),
("Nose Center", YELLOW),
("Eye-Bottom", CYAN),
("Face Height", MAGENTA)
]
for idx, (label, color) in enumerate(legends):
y_pos = legend_y + idx * line_height
cv2.line(analysis_img, (legend_x, y_pos),
(legend_x + 30, y_pos), color, 2)
cv2.putText(analysis_img, label, (legend_x + 40, y_pos + 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, WHITE, 1)
return analysis_img
def process_image_from_base64(self, image_base64):
try:
image_bytes = base64.b64decode(image_base64)
nparr = np.frombuffer(image_bytes, np.uint8)
image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
if image is None:
raise ValueError("Failed to decode image")
h, w = image.shape[:2]
face_landmarks, pose_results = self.detect_landmarks(image)
left_eye, right_eye = self.get_eye_centers(face_landmarks, w, h)
angle = self.calculate_rotation_angle(left_eye, right_eye)
center = ((left_eye[0] + right_eye[0]) / 2, (left_eye[1] + right_eye[1]) / 2)
rotated_image, rotation_matrix = self.rotate_image(image, angle, center)
left_eye = self.rotate_point(left_eye, rotation_matrix)
right_eye = self.rotate_point(right_eye, rotation_matrix)
eye_line_y = (left_eye[1] + right_eye[1]) / 2
face_landmarks, pose_results = self.detect_landmarks(rotated_image)
nose_x, nose_y = self.get_nose_tip(face_landmarks, w, h)
chin_x, chin_y = self.get_chin(face_landmarks, w, h)
hair_x, top_hair_y = self.get_forehead_top(face_landmarks, w, h)
shoulders = self.get_shoulders(pose_results, w, h)
body_bottom_y = h
if shoulders:
body_bottom_y = max(shoulders['left'][1], shoulders['right'][1])
crop_box = self.calculate_crop_box(
rotated_image, eye_line_y, chin_y, top_hair_y,
nose_x, shoulders, body_bottom_y
)
cropped = rotated_image[
crop_box['top']:crop_box['bottom'],
crop_box['left']:crop_box['right']
]
analysis_image = self.create_analysis_image(
cropped,
eye_line_y - crop_box['top'],
chin_y - crop_box['top'],
top_hair_y - crop_box['top'],
nose_x - crop_box['left'],
crop_box['eye_to_bottom_ratio'], # اضافه شده
crop_box['face_height_ratio'] # اضافه شده
)
final_bytes, file_size, quality, final_size = self.compress_to_size(cropped, max_kb=240)
final_image_b64 = base64.b64encode(final_bytes).decode('utf-8')
_, analysis_buffer = cv2.imencode('.jpg', analysis_image, [cv2.IMWRITE_JPEG_QUALITY, 95])
analysis_image_b64 = base64.b64encode(analysis_buffer).decode('utf-8')
return {
'service_type': 'processing',
'final_image': final_image_b64,
'analysis_image': analysis_image_b64,
'info': {
'size': f"{final_size[0]}x{final_size[1]}",
'file_size': f"{file_size:.2f} KB",
'quality': quality,
'eye_to_bottom': f"{crop_box['eye_to_bottom_ratio']:.1f}%",
'face_height': f"{crop_box['face_height_ratio']:.1f}%"
}
}
except Exception as e:
raise Exception(f"Processing error: {str(e)}")
class PhotoRequirementsChecker:
def __init__(self):
self.mp_face_mesh = mp.solutions.face_mesh
self.mp_face_detection = mp.solutions.face_detection
self.face_mesh = self.mp_face_mesh.FaceMesh(
static_image_mode=True, max_num_faces=2,
refine_landmarks=True, min_detection_confidence=0.5)
self.face_detection = self.mp_face_detection.FaceDetection(
min_detection_confidence=0.5)
self.results = []
self._bg_remover = None
print("[Checker] Initializing with AI Face Parsing...")
init_face_parser()
print("[Checker] Ready with AI model")
def _load_background_remover(self):
if self._bg_remover is None:
try:
print("[AI] Loading background removal model...")
try:
from transformers import pipeline
print("[AI] Trying U2Net model...")
self._bg_remover = pipeline(
"image-segmentation",
model="briaai/RMBG-2.0", # مدل جدیدتر
device=-1 # CPU
)
print("[AI] ✓ Background model loaded (RMBG-2.0)")
return self._bg_remover
except Exception as e1:
print(f"[AI] RMBG-2.0 failed: {e1}")
try:
print("[AI] Trying DeepLabV3...")
from transformers import AutoImageProcessor, AutoModelForSemanticSegmentation
import torch
processor = AutoImageProcessor.from_pretrained(
"nvidia/segformer-b0-finetuned-ade-512-512"
)
model = AutoModelForSemanticSegmentation.from_pretrained(
"nvidia/segformer-b0-finetuned-ade-512-512"
)
self._bg_remover = {
'processor': processor,
'model': model,
'type': 'segformer'
}
print("[AI] ✓ Background model loaded (SegFormer)")
return self._bg_remover
except Exception as e2:
print(f"[AI] SegFormer failed: {e2}")
print("[AI] ⚠ Using CV2 fallback for background")
self._bg_remover = False
except Exception as e:
print(f"[AI] Background model initialization failed: {e}")
self._bg_remover = False
return self._bg_remover
def add_result(self, category, requirement, status, message, details=""):
self.results.append({
'category': category,
'requirement': requirement,
'status': status,
'message': message,
'details': details
})
def _get_background_mask(self, image, landmarks, img_width, img_height):
bg_remover = self._load_background_remover()
if bg_remover and bg_remover is not False:
try:
pil_image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
if callable(bg_remover):
result = bg_remover(pil_image)
if isinstance(result, list) and len(result) > 0:
for item in result:
if 'label' in item and ('person' in item['label'].lower() or
'human' in item['label'].lower()):
mask_pil = item['mask']
mask = np.array(mask_pil)
if len(mask.shape) == 3:
mask = cv2.cvtColor(mask, cv2.COLOR_RGB2GRAY)
_, binary_mask = cv2.threshold(mask, 127, 255, cv2.THRESH_BINARY)
if binary_mask.shape[:2] != (img_height, img_width):
binary_mask = cv2.resize(binary_mask, (img_width, img_height))
bg_mask = cv2.bitwise_not(binary_mask)
print("[AI] ✓ Background mask extracted")
return bg_mask
elif isinstance(bg_remover, dict) and bg_remover.get('type') == 'segformer':
import torch
processor = bg_remover['processor']
model = bg_remover['model']
inputs = processor(images=pil_image, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs)
logits = outputs.logits
upsampled = torch.nn.functional.interpolate(
logits,
size=(img_height, img_width),
mode="bilinear",
align_corners=False
)
seg_mask = upsampled.argmax(dim=1)[0].cpu().numpy()
person_mask = (seg_mask == 12).astype(np.uint8) * 255
bg_mask = cv2.bitwise_not(person_mask)
print("[AI] ✓ Background mask extracted (SegFormer)")
return bg_mask
except Exception as e:
print(f"[AI] Background segmentation failed: {e}")
import traceback
traceback.print_exc()
print("[AI] Using CV2 fallback for background mask")
return self._get_background_mask_cv(image, landmarks, img_width, img_height)
def _get_background_mask_cv(self, image, landmarks, img_width, img_height):
h, w = image.shape[:2]
face_outline = [10, 338, 297, 332, 284, 251, 389, 356, 454, 323,
361, 288, 397, 365, 379, 378, 400, 377, 152, 148,
176, 149, 150, 136, 172, 58, 132, 93, 234, 127, 162]
face_points = []
for idx in face_outline:
x = int(landmarks.landmark[idx].x * img_width)
y = int(landmarks.landmark[idx].y * img_height)
face_points.append([x, y])
face_mask = np.zeros((h, w), dtype=np.uint8)
cv2.fillPoly(face_mask, [np.array(face_points)], 255)
kernel = np.ones((50, 50), np.uint8)
face_mask = cv2.dilate(face_mask, kernel, iterations=1)
return cv2.bitwise_not(face_mask)
def check_eyeglasses_parsing(self, parsing_mask, image):
try:
h, w = image.shape[:2]
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
glasses_pixels = np.sum(mask_resized == 3) # ← تغییر از 6 به 3
glasses_ratio = glasses_pixels / (h * w)
if glasses_ratio > 0.005:
self.add_result("Facial Features", "Eyeglasses", "fail",
f"Eyeglasses detected (AI: {min(glasses_ratio*100, 100):.1f}%)",
"Eyeglasses not allowed. Exception: Medical reasons with doctor's statement.")
elif glasses_ratio > 0.002:
self.add_result("Facial Features", "Eyeglasses", "warning",
"Possible eyeglasses detected", "If wearing glasses, remove and retake.")
else:
self.add_result("Facial Features", "Eyeglasses", "pass",
"No eyeglasses detected (AI)", "Meets requirement")
except Exception as e:
print(f"[Parsing] Eyeglasses error: {e}")
self.check_eyeglasses_cv_fallback(image, None, w, h)
def check_headwear_parsing(self, parsing_mask, image):
try:
h, w = image.shape[:2]
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
hat_pixels = np.sum(mask_resized == 14) # ← تغییر از 18 به 14
hat_ratio = hat_pixels / (h * w)
if hat_pixels > 0:
hat_y_coords, hat_x_coords = np.where(mask_resized == 14)
if len(hat_y_coords) > 0:
avg_hat_y = np.mean(hat_y_coords)
if avg_hat_y > h * 0.3:
print(f"[DEBUG] Hat pixels in wrong location (y={avg_hat_y:.0f}/{h}), ignoring")
hat_pixels = 0
hat_ratio = 0
print(f"[DEBUG] Hat: {hat_pixels} pixels ({hat_ratio*100:.4f}%), location check passed")
MIN_HAT_PIXELS = 2000
FAIL_RATIO = 0.035
WARN_RATIO = 0.018
if hat_pixels < MIN_HAT_PIXELS:
self.add_result("Head Covering", "Headwear/Hat", "pass",
f"No headwear (AI: {hat_pixels} pixels - likely noise)", "Meets requirement")
elif hat_ratio > FAIL_RATIO:
head_region = mask_resized[:int(h*0.3), :]
hat_in_head = np.sum(head_region == 14)
coverage = (hat_in_head / head_region.size) * 100
self.add_result("Head Covering", "Headwear/Hat", "fail",
f"Headwear detected (AI: {hat_pixels} pixels, {coverage:.1f}% head coverage)",
"Do not wear hats. Exception: Religious covering worn daily.")
elif hat_ratio > WARN_RATIO:
self.add_result("Head Covering", "Headwear/Hat", "warning",
f"Possible headwear/large hair accessory (AI: {hat_pixels} pixels)",
"If wearing hat/large accessory, remove. If hair/hijab, proceed.")
else:
self.add_result("Head Covering", "Headwear/Hat", "pass",
f"No significant headwear (AI: {hat_pixels} pixels)", "Meets requirement")
except Exception as e:
print(f"[Parsing] Headwear error: {e}")
import traceback
traceback.print_exc()
self.check_headwear_cv_fallback(image, None, w, h)
def check_eyes_open_parsing(self, parsing_mask, landmarks, img_width, img_height, image):
try:
h, w = image.shape[:2]
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
left_eye_pixels = np.sum(mask_resized == 4)
right_eye_pixels = np.sum(mask_resized == 5)
total_eye_pixels = left_eye_pixels + right_eye_pixels
eye_ratio = total_eye_pixels / (h * w)
print(f"[DEBUG] Eyes: L={left_eye_pixels}, R={right_eye_pixels}, ratio={eye_ratio*100:.4f}%")
if eye_ratio > 0.0005:
self.add_result("Facial Expression", "Eyes Open", "pass",
f"Both eyes clearly open (AI: {total_eye_pixels} pixels)", "Neutral expression met")
elif eye_ratio > 0.0008:
self.add_result("Facial Expression", "Eyes Open", "warning",
f"Eyes may be partially closed (AI: {total_eye_pixels} pixels)",
"Both eyes must be fully open")
else:
glasses_pixels = np.sum(mask_resized == 6)
if glasses_pixels > total_eye_pixels * 5:
self.add_result("Facial Expression", "Eyes Open", "warning",
"Eyes obscured by eyeglasses", "Eyes must be visible")
else:
self.add_result("Facial Expression", "Eyes Open", "fail",
f"Eyes appear closed (AI: {total_eye_pixels} pixels)",
"Both eyes must be fully open")
except Exception as e:
print(f"[Parsing] Eyes error: {e}")
self.check_eyes_open_cv(landmarks, img_height)
def check_jewelry_parsing(self, parsing_mask, image):
try:
h, w = image.shape[:2]
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
earring_ratio = np.sum(mask_resized == 15) / (h * w) # ← تغییر از 9 به 15
necklace_ratio = np.sum(mask_resized == 16) / (h * w) # ← تغییر از 15 به 16
jewelry_detected = []
if earring_ratio > 0.001:
jewelry_detected.append("earrings")
if necklace_ratio > 0.002:
jewelry_detected.append("necklace")
if jewelry_detected:
jewelry_str = " and ".join(jewelry_detected)
confidence = max(earring_ratio, necklace_ratio) * 100
self.add_result("Accessories", "Jewelry", "warning",
f"{jewelry_str.capitalize()} detected (AI: {confidence:.1f}%)",
"Visible jewelry should be minimal.")
else:
self.add_result("Accessories", "Jewelry", "pass",
"No prominent jewelry detected (AI)", "Meets requirement")
except Exception as e:
print(f"[Parsing] Jewelry error: {e}")
self.add_result("Accessories", "Jewelry", "pass",
"Unable to verify", "Manual review recommended")
def check_face_covering_parsing(self, parsing_mask, landmarks, img_width, img_height, image):
try:
h, w = image.shape[:2]
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
face_indices = [234, 127, 162, 21, 54, 103, 67, 109, 10, 338, 297, 332, 284,
251, 389, 356, 454, 152, 148, 176, 149, 150, 136, 172, 58, 132, 93]
face_points = [[int(landmarks.landmark[i].x * img_width),
int(landmarks.landmark[i].y * img_height)] for i in face_indices]
face_mask = np.zeros((h, w), dtype=np.uint8)
cv2.fillPoly(face_mask, [np.array(face_points)], 255)
face_region = mask_resized[face_mask > 0]
if len(face_region) == 0:
return
skin_ratio = np.sum(face_region == 1) / len(face_region)
hair_ratio = np.sum(face_region == 13) / len(face_region) # ← تغییر از 17 به 13
print(f"[DEBUG] Face Covering: skin={skin_ratio*100:.1f}%, hair={hair_ratio*100:.1f}%")
if skin_ratio < 0.30:
self.add_result("Head Covering", "Face Covering", "fail",
f"Face significantly covered (AI: {skin_ratio*100:.0f}% visible)",
"Full face must be visible")
elif hair_ratio > 0.25:
self.add_result("Head Covering", "Face Covering", "warning",
f"Hair may be covering face ({hair_ratio*100:.0f}%)",
"Ensure hair pulled back")
else:
self.add_result("Head Covering", "Face Covering", "pass",
f"Face fully visible (AI: {skin_ratio*100:.0f}% skin)", "No obstruction")
except Exception as e:
print(f"[Parsing] Face covering error: {e}")
self.add_result("Head Covering", "Face Covering", "pass",
"Unable to verify", "Manual review recommended")
def check_eyes_open_cv(self, landmarks, img_height):
left_top = landmarks.landmark[159].y
left_bottom = landmarks.landmark[145].y
left_opening = abs(left_top - left_bottom) * img_height
right_top = landmarks.landmark[386].y
right_bottom = landmarks.landmark[374].y
right_opening = abs(right_top - right_bottom) * img_height
avg_opening = (left_opening + right_opening) / 2
if avg_opening > img_height * 0.012:
self.add_result("Facial Expression", "Eyes Open", "pass",
"Both eyes open (CV)", "Meets requirement")
elif avg_opening > img_height * 0.008:
self.add_result("Facial Expression", "Eyes Open", "warning",
"Eyes may be partially closed", "Both eyes must be fully open")
else:
self.add_result("Facial Expression", "Eyes Open", "fail",
"Eyes appear closed", "Both eyes must be fully open")
def check_eyeglasses_cv_fallback(self, image, landmarks, img_width, img_height):
self.add_result("Facial Features", "Eyeglasses", "pass",
"Unable to verify with AI", "Manual review recommended")
def check_headwear_cv_fallback(self, image, landmarks, img_width, img_height):
self.add_result("Head Covering", "Headwear/Hat", "pass",
"Unable to verify with AI", "Manual review recommended")
def check_dimensions(self, image):
h, w = image.shape[:2]
if h == w and 600 <= w <= 1200:
self.add_result("Dimensions", "Image Size", "pass",
f"{w}×{h} pixels", "Meets requirements")
else:
self.add_result("Dimensions", "Image Size", "fail",
f"{w}×{h} pixels", "Must be square (600-1200px)")
def check_color_depth(self, image):
if len(image.shape) == 3 and image.shape[2] == 3:
b, g, r = cv2.split(image)
avg_diff = (np.abs(b.astype(float) - g.astype(float)).mean() +
np.abs(b.astype(float) - r.astype(float)).mean() +
np.abs(g.astype(float) - r.astype(float)).mean()) / 3
if avg_diff < 5:
self.add_result("Technical", "Color Depth", "warning",
"Image appears grayscale", "Must be in color")
return False
else:
self.add_result("Technical", "Color Depth", "pass",
"Image in color (24-bit RGB)", "Meets requirement")
return True
else:
self.add_result("Technical", "Color Depth", "fail",
"Image is grayscale", "Must be in color")
return False
def check_face_detection(self, image):
rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
face_results = self.face_mesh.process(rgb_image)
if face_results.multi_face_landmarks:
num_faces = len(face_results.multi_face_landmarks)
if num_faces == 1:
self.add_result("Composition", "Number of People", "pass",
"Exactly one face detected", "Meets requirement")
return face_results.multi_face_landmarks[0]
else:
self.add_result("Composition", "Number of People", "fail",
f"{num_faces} faces detected", "Only one person allowed")
else:
self.add_result("Composition", "Face Detection", "fail",
"No face detected", "Face must be visible")
return None
def check_face_angle(self, landmarks, img_width, img_height):
nose_x = landmarks.landmark[4].x * img_width
left_face = landmarks.landmark[234].x * img_width
right_face = landmarks.landmark[454].x * img_width
face_center = (left_face + right_face) / 2
deviation_percent = abs(nose_x - face_center) / img_width * 100
if deviation_percent < 2:
self.add_result("Head Position", "Face Direction", "pass",
"Face directly facing camera", "Full-face view met")
elif deviation_percent < 4:
self.add_result("Head Position", "Face Direction", "warning",
"Face slightly turned", "Must be in full-face view")
else:
self.add_result("Head Position", "Face Direction", "fail",
"Face significantly turned", "Must be in full-face view")
def check_red_eye(self, image, landmarks, img_width, img_height):
def check_eye_redness(eye_indices):
eye_points = [[int(landmarks.landmark[i].x * img_width),
int(landmarks.landmark[i].y * img_height)] for i in eye_indices]
mask = np.zeros((img_height, img_width), dtype=np.uint8)
cv2.fillPoly(mask, [np.array(eye_points)], 255)
pixels = image[mask > 0]
if len(pixels) > 0:
b, g, r = cv2.split(image)
red_mean = r[mask > 0].mean()
green_mean = g[mask > 0].mean()
blue_mean = b[mask > 0].mean()
if red_mean > green_mean * 1.4 and red_mean > blue_mean * 1.4 and red_mean > 100:
return True
return False
left_eye_indices = [33, 133, 160, 159, 158, 157, 173]
right_eye_indices = [362, 263, 387, 386, 385, 384, 398]
if check_eye_redness(left_eye_indices) or check_eye_redness(right_eye_indices):
self.add_result("Photo Quality", "Red Eye Effect", "fail",
"Red eye effect detected", "Photo must not have red eye")
else:
self.add_result("Photo Quality", "Red Eye Effect", "pass",
"No red eye effect detected", "Meets requirement")
def check_image_quality(self, image):
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
if laplacian_var > 150:
self.add_result("Photo Quality", "Sharpness", "pass",
"Image sharp and in focus", "Meets requirement")
elif laplacian_var > 80:
self.add_result("Photo Quality", "Sharpness", "warning",
"Image slightly soft", "Should be sharp")
else:
self.add_result("Photo Quality", "Sharpness", "fail",
"Image is blurry", "Must be sharp")
blur = cv2.GaussianBlur(gray, (5, 5), 0)
noise = cv2.subtract(gray, blur)
noise_level = np.std(noise)
if noise_level < 8:
self.add_result("Photo Quality", "Grain/Noise", "pass",
"Minimal grain/noise", "Meets requirement")
elif noise_level < 15:
self.add_result("Photo Quality", "Grain/Noise", "warning",
"Noticeable grain/noise", "Use better camera")
else:
self.add_result("Photo Quality", "Grain/Noise", "fail",
"Image is grainy/noisy", "Use better camera")
def check_head_proportions(self, landmarks, img_height, img_width):
h, w = img_height, img_width
eye_indices = [33, 133, 362, 263]
eye_y = np.mean([landmarks.landmark[i].y for i in eye_indices]) * h
eye_from_bottom = 100 - (eye_y / h) * 100
if hasattr(self, '_current_parsing_mask') and self._current_parsing_mask is not None:
parsing_mask = self._current_parsing_mask
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
hair_pixels = np.sum(mask_resized == 13)
hat_pixels = np.sum(mask_resized == 14)
total_head_coverage = hair_pixels + hat_pixels
head_region = mask_resized[:int(h*0.4), :] # 40% بالایی تصویر
head_coverage_ratio = total_head_coverage / (head_region.size)
is_head_covered = hair_pixels < 3000 or head_coverage_ratio < 0.15
print(f"[DEBUG] Head Coverage Analysis:")
print(f" Hair pixels: {hair_pixels}")
print(f" Hat/covering pixels: {hat_pixels}")
print(f" Coverage ratio: {head_coverage_ratio*100:.2f}%")
print(f" Is head covered: {is_head_covered}")
top_of_head = h # مقدار اولیه
if is_head_covered:
print("[HEAD] Covered head detected - using hybrid method")
if hat_pixels > 1000:
hat_y_coords, _ = np.where(mask_resized == 14)
if len(hat_y_coords) > 0:
top_of_head = np.min(hat_y_coords)
print(f"[HEAD] Using hat/covering top: {top_of_head}")
elif hair_pixels > 500:
hair_y_coords, _ = np.where(mask_resized == 13)
if len(hair_y_coords) > 0:
top_of_head = np.min(hair_y_coords)
print(f"[HEAD] Using minimal hair top: {top_of_head}")
else:
head_skin_region = mask_resized[:int(h*0.3), :]
skin_y_coords, _ = np.where(head_skin_region == 1)
if len(skin_y_coords) > 0:
top_of_head = np.min(skin_y_coords)
print(f"[HEAD] Using head skin top: {top_of_head}")
if top_of_head >= h * 0.5: # اگر خیلی پایین بود
print("[HEAD] Segmentation insufficient, using geometric estimation")
forehead_indices = [10, 338, 297, 332, 284, 251, 389, 356, 454]
min_forehead_y = min([landmarks.landmark[i].y for i in forehead_indices]) * h
eye_to_forehead = min_forehead_y - eye_y
if hat_pixels > 1000:
hair_extension = eye_to_forehead * 0.85
else:
hair_extension = eye_to_forehead * 0.70
top_of_head = max(0, min_forehead_y - hair_extension)
print(f"[HEAD] Estimated top using forehead + {hair_extension:.0f}px extension: {top_of_head}")
else:
print("[HEAD] Open head detected - using standard method")
hair_y_coords, _ = np.where(mask_resized == 13)
if len(hair_y_coords) > 0:
top_of_head = np.min(hair_y_coords)
print(f"[HEAD] Using hair top: {top_of_head}")
else:
head_region = mask_resized[:int(h*0.3), :]
skin_y_coords, _ = np.where(head_region == 1)
if len(skin_y_coords) > 0:
top_of_head = np.min(skin_y_coords)
print(f"[HEAD] Using head skin: {top_of_head}")
else:
forehead_indices = [10, 338, 297, 332, 284, 251, 389, 356, 454]
min_forehead_y = min([landmarks.landmark[i].y for i in forehead_indices]) * h
eye_to_forehead = min_forehead_y - eye_y
hair_extension = eye_to_forehead * 0.65
top_of_head = max(0, min_forehead_y - hair_extension)
print(f"[HEAD] Fallback to landmarks: {top_of_head}")
chin_y = 0
lower_face_region = mask_resized[int(h*0.5):, :]
skin_y_coords, _ = np.where(lower_face_region == 1)
if len(skin_y_coords) > 0:
chin_y = np.max(skin_y_coords) + int(h*0.5)
else:
chin_y = landmarks.landmark[152].y * h
face_height_pixels = chin_y - top_of_head
face_height_ratio = (face_height_pixels / h) * 100
if face_height_ratio < 35 or face_height_ratio > 85:
print(f"[HEAD] WARNING: Unrealistic face height {face_height_ratio:.1f}%, using fallback")
chin_y = landmarks.landmark[152].y * h
forehead_indices = [10, 338, 297, 332, 284, 251, 389, 356, 454]
min_forehead_y = min([landmarks.landmark[i].y for i in forehead_indices]) * h
eye_to_forehead = min_forehead_y - eye_y
hair_extension = eye_to_forehead * (0.85 if is_head_covered else 0.65)
top_of_head = max(0, min_forehead_y - hair_extension)
face_height_pixels = chin_y - top_of_head
face_height_ratio = (face_height_pixels / h) * 100
print(f"[HEAD] Corrected face height: {face_height_ratio:.1f}%")
if not hasattr(self, '_debug_data'):
self._debug_data = {}
self._debug_data.update({
'top_of_head': top_of_head,
'chin_y': chin_y,
'eye_y': eye_y,
'face_height_pixels': face_height_pixels,
'face_height_ratio': face_height_ratio,
'is_head_covered': is_head_covered,
'hair_pixels': hair_pixels,
'hat_pixels': hat_pixels,
'method': 'AI_Segmentation_Enhanced'
})
else:
chin_y = landmarks.landmark[152].y * h
forehead_indices = [10, 338, 297, 332, 284, 251, 389, 356, 454]
min_forehead_y = min([landmarks.landmark[i].y for i in forehead_indices]) * h
eye_to_forehead = min_forehead_y - eye_y
hair_extension = eye_to_forehead * 0.75 # مقدار متوسط
top_of_head = max(0, min_forehead_y - hair_extension)
face_height_pixels = chin_y - top_of_head
face_height_ratio = (face_height_pixels / h) * 100
if not hasattr(self, '_debug_data'):
self._debug_data = {}
self._debug_data.update({
'method': 'MediaPipe_Fallback'
})
if 56 <= eye_from_bottom <= 69:
self.add_result("Head Position", "Eye Height", "pass",
f"Eye height: {eye_from_bottom:.1f}% from bottom",
"Meets requirement (56-69%)")
else:
issue = "Eyes too low" if eye_from_bottom < 56 else "Eyes too high"
suggestion = "Move camera down" if eye_from_bottom < 56 else "Move camera up"
self.add_result("Head Position", "Eye Height", "fail",
f"Eye height: {eye_from_bottom:.1f}%. {issue}",
f"Eyes must be 56-69% from bottom. {suggestion}")
if 50 <= face_height_ratio <= 69:
self.add_result("Head Position", "Face Height", "pass",
f"Face height: {face_height_ratio:.1f}% (top to chin)",
"Meets requirement (50-69%)")
else:
issue = "Head too small" if face_height_ratio < 50 else "Head too large"
suggestion = "Move closer" if face_height_ratio < 50 else "Move further"
self.add_result("Head Position", "Face Height", "fail",
f"Face height: {face_height_ratio:.1f}%. {issue}",
f"Head must be 50-69% of image. {suggestion}")
def check_background_ai(self, image, landmarks, bg_mask, img_width, img_height):
try:
h, w = image.shape[:2]
if hasattr(self, '_current_parsing_mask') and self._current_parsing_mask is not None:
parsing_mask = self._current_parsing_mask
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
bg_mask_from_parsing = (mask_resized == 0).astype(np.uint8) * 255
if np.sum(bg_mask_from_parsing > 0) > (h * w * 0.1):
print("[BG] Using parsing mask for background detection")
bg_mask = bg_mask_from_parsing
else:
print("[BG] Parsing mask insufficient, using CV fallback")
bg_pixels = image[bg_mask > 0]
if len(bg_pixels) == 0:
self.add_result("Background", "Color", "fail",
"Cannot analyze background", "Background not detected")
return
bg_mean = np.mean(bg_pixels.reshape(-1, 3), axis=0)
brightness = np.mean(bg_mean)
color_variance = np.std(bg_mean)
is_neutral = color_variance < 15
if brightness > 200 and is_neutral:
self.add_result("Background", "Color", "pass",
f"Background white/off-white (brightness: {brightness:.0f})",
"Plain white requirement met")
elif brightness > 180 and is_neutral:
self.add_result("Background", "Color", "warning",
f"Background light (brightness: {brightness:.0f})",
"Should be plain white")
else:
self.add_result("Background", "Color", "fail",
f"Background not white (brightness: {brightness:.0f})",
"Must be plain white or off-white")
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
bg_gray = cv2.bitwise_and(gray, gray, mask=bg_mask)
bg_gray_pixels = bg_gray[bg_mask > 0]
bg_std = np.std(bg_gray_pixels)
print(f"[BG-Uniformity] STD: {bg_std:.2f}, Brightness: {brightness:.1f}")
edges = cv2.Canny(bg_gray, 30, 100)
edge_pixels = np.sum(edges > 0)
edge_ratio = edge_pixels / np.sum(bg_mask > 0)
if brightness > 200:
std_threshold_high = 12
std_threshold_low = 8
edge_threshold_high = 0.02
edge_threshold_low = 0.01
elif brightness > 180:
std_threshold_high = 15
std_threshold_low = 10
edge_threshold_high = 0.025
edge_threshold_low = 0.015
else:
std_threshold_high = 20
std_threshold_low = 12
edge_threshold_high = 0.03
edge_threshold_low = 0.02
has_texture = False
texture_level = "none"
if bg_std > std_threshold_high or edge_ratio > edge_threshold_high:
has_texture = True
texture_level = "high"
elif bg_std > std_threshold_low or edge_ratio > edge_threshold_low:
has_texture = True
texture_level = "slight"
print(f"[BG-Uniformity] Edge ratio: {edge_ratio:.4f}, Texture: {texture_level}")
if not has_texture:
self.add_result("Background", "Uniformity", "pass",
"Background plain and uniform", "No patterns detected")
elif texture_level == "slight":
if brightness > 190 and bg_std < std_threshold_low * 1.5:
self.add_result("Background", "Uniformity", "pass",
"Background uniform with minimal natural variation",
"Slight natural shadow acceptable")
else:
self.add_result("Background", "Uniformity", "warning",
"Background has slight texture", "Should be completely plain")
else:
self.add_result("Background", "Uniformity", "fail",
"Background has visible patterns", "Must be plain")
except Exception as e:
print(f"[AI] Background check error: {e}")
import traceback
traceback.print_exc()
self.add_result("Background", "Analysis", "pass",
"Unable to verify", "Manual review recommended")
def detect_shadow_mask(self, image, parsing_mask=None):
try:
h, w = image.shape[:2]
if parsing_mask is not None:
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
bg_mask = (mask_resized == 0).astype(np.uint8) * 255
print("[Shadow] Using parsing mask for background")
else:
print("[Shadow] Parsing mask not available")
return None, None
if np.sum(bg_mask > 0) < (h * w * 0.05):
print("[Shadow] Background area too small")
return None, None
lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
l_channel = lab[:, :, 0]
bg_l = cv2.bitwise_and(l_channel, l_channel, mask=bg_mask)
bg_pixels = l_channel[bg_mask > 0]
if len(bg_pixels) == 0:
return None, None
bg_mean = np.mean(bg_pixels)
bg_std = np.std(bg_pixels)
bg_median = np.median(bg_pixels)
print(f"[Shadow] BG Stats - Mean: {bg_mean:.1f}, Median: {bg_median:.1f}, STD: {bg_std:.1f}")
shadow_threshold_1 = bg_mean - bg_std * 1.2
shadow_threshold_2 = bg_median - bg_std * 1.0
shadow_threshold = min(shadow_threshold_1, shadow_threshold_2)
if bg_mean > 200:
shadow_threshold = bg_mean - max(bg_std * 1.5, 25)
print(f"[Shadow] Threshold: {shadow_threshold:.1f}")
shadow_mask_raw = np.zeros((h, w), dtype=np.uint8)
shadow_mask_raw[bg_mask > 0] = ((l_channel[bg_mask > 0] < shadow_threshold) * 255).astype(np.uint8)
kernel_small = np.ones((3, 3), np.uint8)
kernel_medium = np.ones((5, 5), np.uint8)
shadow_mask_clean = cv2.morphologyEx(shadow_mask_raw, cv2.MORPH_OPEN, kernel_small)
shadow_mask_clean = cv2.morphologyEx(shadow_mask_clean, cv2.MORPH_CLOSE, kernel_medium)
shadow_mask_clean = cv2.GaussianBlur(shadow_mask_clean, (5, 5), 0)
_, shadow_mask_clean = cv2.threshold(shadow_mask_clean, 127, 255, cv2.THRESH_BINARY)
shadow_pixels = np.sum(shadow_mask_clean > 0)
bg_pixels_count = np.sum(bg_mask > 0)
shadow_ratio = shadow_pixels / bg_pixels_count if bg_pixels_count > 0 else 0
if shadow_pixels > 0:
shadow_values = l_channel[shadow_mask_clean > 0]
shadow_mean = np.mean(shadow_values)
contrast = bg_mean - shadow_mean
else:
shadow_mean = 0
contrast = 0
shadow_info = {
'shadow_ratio': shadow_ratio,
'shadow_pixels': shadow_pixels,
'bg_mean': bg_mean,
'shadow_mean': shadow_mean,
'contrast': contrast,
'bg_std': bg_std
}
print(f"[Shadow] Detected: {shadow_ratio*100:.1f}% of background, Contrast: {contrast:.1f}")
return shadow_mask_clean, shadow_info
except Exception as e:
print(f"[Shadow] Detection error: {e}")
import traceback
traceback.print_exc()
return None, None
def create_shadow_visualization(self, image, shadow_mask, parsing_mask=None):
try:
h, w = image.shape[:2]
overlay = image.copy()
shadow_color = np.array([0, 0, 255], dtype=np.uint8)
overlay[shadow_mask > 0] = cv2.addWeighted(
overlay[shadow_mask > 0], 0.4,
np.full_like(overlay[shadow_mask > 0], shadow_color), 0.6,
0
)
contours, _ = cv2.findContours(shadow_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(overlay, contours, -1, (0, 0, 255), 2)
legend_x = 20
legend_y = h - 60
overlay_bg = overlay.copy()
cv2.rectangle(overlay_bg, (legend_x - 10, legend_y - 10),
(legend_x + 200, legend_y + 35), (0, 0, 0), -1)
cv2.addWeighted(overlay_bg, 0.7, overlay, 0.3, 0, overlay)
cv2.putText(overlay, "Shadow Area", (legend_x + 35, legend_y + 10),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
cv2.rectangle(overlay, (legend_x, legend_y - 5),
(legend_x + 25, legend_y + 15), (0, 0, 255), -1)
cv2.rectangle(overlay, (legend_x, legend_y - 5),
(legend_x + 25, legend_y + 15), (255, 255, 255), 1)
shadow_ratio = np.sum(shadow_mask > 0) / (h * w)
text = f"Shadow: {shadow_ratio*100:.1f}%"
cv2.putText(overlay, text, (legend_x, legend_y - 25),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 0, 255), 2)
return overlay
except Exception as e:
print(f"[Shadow] Visualization error: {e}")
return image
def check_shadows_ai(self, image, landmarks, bg_mask, img_width, img_height):
try:
h, w = image.shape[:2]
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
face_indices = [234, 127, 162, 21, 54, 103, 67, 109, 10, 338, 297, 332]
face_points = [[int(landmarks.landmark[i].x * img_width),
int(landmarks.landmark[i].y * img_height)] for i in face_indices]
face_mask = np.zeros((h, w), dtype=np.uint8)
cv2.fillPoly(face_mask, [np.array(face_points)], 255)
face_pixels = gray[face_mask > 0]
if len(face_pixels) > 0:
face_mean = np.mean(face_pixels)
face_std = np.std(face_pixels)
dark_ratio = np.sum(face_pixels < face_mean - face_std * 1.5) / len(face_pixels)
if dark_ratio < 0.15:
self.add_result("Lighting", "Face Shadows", "pass",
"No significant shadows on face", "Even lighting met")
elif dark_ratio < 0.25:
self.add_result("Lighting", "Face Shadows", "warning",
"Slight shadows on face", "Lighting should be even")
else:
self.add_result("Lighting", "Face Shadows", "fail",
"Shadows detected on face", "Must have even lighting")
parsing_mask = None
if hasattr(self, '_current_parsing_mask'):
parsing_mask = self._current_parsing_mask
shadow_mask, shadow_info = self.detect_shadow_mask(image, parsing_mask)
if shadow_mask is not None and shadow_info is not None:
self._shadow_mask = shadow_mask
self._shadow_info = shadow_info
shadow_ratio = shadow_info['shadow_ratio']
contrast = shadow_info['contrast']
if shadow_ratio < 0.05:
self.add_result("Lighting", "Background Shadows", "pass",
f"Minimal background shadow ({shadow_ratio*100:.1f}%, contrast: {contrast:.0f})",
"Natural shadow acceptable")
elif shadow_ratio < 0.15:
if contrast < 40:
self.add_result("Lighting", "Background Shadows", "pass",
f"Slight shadow with low contrast ({shadow_ratio*100:.1f}%, contrast: {contrast:.0f})",
"Acceptable shadow level")
else:
self.add_result("Lighting", "Background Shadows", "warning",
f"Moderate shadow detected ({shadow_ratio*100:.1f}%, contrast: {contrast:.0f})",
"Consider repositioning lighting or moving away from wall")
else:
self.add_result("Lighting", "Background Shadows", "fail",
f"Strong shadow cast on background ({shadow_ratio*100:.1f}%, contrast: {contrast:.0f})",
"Move away from background or improve lighting setup")
else:
print("[Shadow] Using fallback method")
bg_gray_pixels = gray[bg_mask > 0]
if len(bg_gray_pixels) > 0:
bg_mean = np.mean(bg_gray_pixels)
bg_std = np.std(bg_gray_pixels)
if bg_std < 15:
self.add_result("Lighting", "Background Shadows", "pass",
f"Background uniform (STD: {bg_std:.1f})", "No significant shadows")
elif bg_std < 25:
self.add_result("Lighting", "Background Shadows", "warning",
"Slight variation in background", "May indicate shadow")
else:
self.add_result("Lighting", "Background Shadows", "fail",
"Non-uniform background detected", "Check for shadows")
except Exception as e:
print(f"[AI] Shadow check error: {e}")
import traceback
traceback.print_exc()
self.add_result("Lighting", "Shadows", "pass",
"Unable to verify", "Manual review recommended")
def check_image_from_base64(self, image_base64):
try:
self.results = []
self._current_parsing_mask = None
self._debug_data = {}
image_bytes = base64.b64decode(image_base64)
nparr = np.frombuffer(image_bytes, np.uint8)
image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
if image is None:
raise ValueError("Failed to decode")
h, w = image.shape[:2]
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image_pil = Image.fromarray(image_rgb)
parsing_mask = predict_face_parsing(image_pil)
if parsing_mask is not None:
self._current_parsing_mask = parsing_mask
print(f"[Checker] ✓ Parsing mask saved")
self.check_dimensions(image)
self.check_color_depth(image)
face_landmarks = self.check_face_detection(image)
if face_landmarks:
bg_mask = self._get_background_mask(image, face_landmarks, w, h)
self.check_head_proportions(face_landmarks, h, w)
self.check_face_angle(face_landmarks, w, h)
if parsing_mask is not None:
self.check_eyeglasses_parsing(parsing_mask, image)
self.check_headwear_parsing(parsing_mask, image)
self.check_eyes_open_parsing(parsing_mask, face_landmarks, w, h, image)
self.check_jewelry_parsing(parsing_mask, image)
self.check_face_covering_parsing(parsing_mask, face_landmarks, w, h, image)
else:
print("[Checker] Parsing unavailable, using fallback")
self.check_eyes_open_cv(face_landmarks, h)
self.check_eyeglasses_cv_fallback(image, face_landmarks, w, h)
self.check_headwear_cv_fallback(image, face_landmarks, w, h)
self.check_background_ai(image, face_landmarks, bg_mask, w, h)
self.check_shadows_ai(image, face_landmarks, bg_mask, w, h)
self.check_red_eye(image, face_landmarks, w, h)
self.check_image_quality(image)
html_report = self.generate_html_report()
parsing_colored_b64 = None
parsing_overlay_b64 = None
debug_face_height_b64 = None
shadow_viz_b64 = None
if parsing_mask is not None:
unique_labels = np.unique(parsing_mask).tolist()
colored = create_colored_mask(parsing_mask)
colored_legend = add_legend_to_image(colored, unique_labels)
_, buf1 = cv2.imencode('.jpg', cv2.cvtColor(colored_legend, cv2.COLOR_RGB2BGR))
parsing_colored_b64 = base64.b64encode(buf1).decode('utf-8')
overlay = create_transparent_overlay(image_pil, parsing_mask, alpha=0.4)
overlay_legend = add_legend_to_image(overlay, unique_labels)
_, buf2 = cv2.imencode('.jpg', cv2.cvtColor(overlay_legend, cv2.COLOR_RGB2BGR))
parsing_overlay_b64 = base64.b64encode(buf2).decode('utf-8')
print("[Checker] ✓ Visualizations created")
if face_landmarks and hasattr(self, '_debug_data') and self._debug_data:
try:
eye_indices = [33, 133, 362, 263]
eye_y = np.mean([face_landmarks.landmark[i].y for i in eye_indices]) * h
mask_resized = cv2.resize(parsing_mask.astype(np.uint8), (w, h),
interpolation=cv2.INTER_NEAREST)
chin_region = mask_resized[int(h*0.4):, :]
skin_pixels_y, _ = np.where(chin_region == 1)
chin_y = (np.max(skin_pixels_y) + int(h*0.4)) if len(skin_pixels_y) > 0 else face_landmarks.landmark[152].y * h
hair_pixels = np.sum(mask_resized == 13)
if hair_pixels > 500:
hair_y_coords, _ = np.where(mask_resized == 13)
top_of_head = np.min(hair_y_coords) if len(hair_y_coords) > 0 else eye_y - 200
else:
head_region = mask_resized[:int(h*0.5), :]
skin_head_y, _ = np.where(head_region == 1)
if len(skin_head_y) > 0:
top_of_head = np.min(skin_head_y)
else:
forehead_indices = [10, 338, 297, 332, 284, 251, 389, 356, 454]
min_forehead_y = min([face_landmarks.landmark[i].y for i in forehead_indices]) * h
top_of_head = max(0, min_forehead_y - (min_forehead_y - eye_y) * 0.65)
debug_img = self._create_face_height_debug_image(
image, parsing_mask, top_of_head, chin_y, eye_y, h, w
)
_, buf_debug = cv2.imencode('.jpg', debug_img, [cv2.IMWRITE_JPEG_QUALITY, 95])
debug_face_height_b64 = base64.b64encode(buf_debug).decode('utf-8')
print("[Checker] ✓ Debug image created")
except Exception as e:
print(f"[Checker] Debug image failed: {e}")
if hasattr(self, '_shadow_mask') and self._shadow_mask is not None:
try:
shadow_viz = self.create_shadow_visualization(
image, self._shadow_mask, parsing_mask
)
_, buf_shadow = cv2.imencode('.jpg', shadow_viz, [cv2.IMWRITE_JPEG_QUALITY, 95])
shadow_viz_b64 = base64.b64encode(buf_shadow).decode('utf-8')
print("[Checker] ✓ Shadow visualization created")
except Exception as e:
print(f"[Checker] Shadow visualization failed: {e}")
self._current_parsing_mask = None
self._debug_data = {}
if hasattr(self, '_shadow_mask'):
delattr(self, '_shadow_mask')
if hasattr(self, '_shadow_info'):
delattr(self, '_shadow_info')
return {
'service_type': 'checking',
'html_report': html_report,
'results': self.results,
'parsing_colored_mask': parsing_colored_b64,
'parsing_transparent_overlay': parsing_overlay_b64,
'debug_face_height': debug_face_height_b64,
'shadow_visualization': shadow_viz_b64 # ✅ اضافه کردن این خط
}
except Exception as e:
import traceback
traceback.print_exc()
raise Exception(f"Checking error: {str(e)}")
def _create_face_height_debug_image(self, image, parsing_mask, top_of_head, chin_y, eye_y, img_h, img_w):
h, w = img_h, img_w
debug_img = image.copy()
RED, GREEN, BLUE = (0,0,255), (0,255,0), (255,0,0)
YELLOW, WHITE, BLACK = (0,255,255), (255,255,255), (0,0,0)
top_of_head, chin_y, eye_y = int(top_of_head), int(chin_y), int(eye_y)
cv2.line(debug_img, (0, top_of_head), (w, top_of_head), RED, 3)
cv2.line(debug_img, (0, chin_y), (w, chin_y), GREEN, 3)
cv2.line(debug_img, (0, eye_y), (w, eye_y), BLUE, 2)
measurement_x = int(w * 0.1)
cv2.line(debug_img, (measurement_x, top_of_head), (measurement_x, chin_y), YELLOW, 4)
cv2.arrowedLine(debug_img, (measurement_x, top_of_head+20),
(measurement_x, top_of_head), YELLOW, 3, tipLength=0.3)
cv2.arrowedLine(debug_img, (measurement_x, chin_y-20),
(measurement_x, chin_y), YELLOW, 3, tipLength=0.3)
face_height_pixels = chin_y - top_of_head
face_height_ratio = (face_height_pixels / h) * 100
eye_from_bottom = 100 - (eye_y / h) * 100
face_status = "PASS ✓" if 50 <= face_height_ratio <= 69 else "FAIL ✗"
eye_status = "PASS ✓" if 56 <= eye_from_bottom <= 69 else "FAIL ✗"
annotations = [
(f"IMAGE: {h}px", 30, WHITE, 1.5),
(f"TOP: {top_of_head}px", 60, RED, 1.5),
(f"CHIN: {chin_y}px", 85, GREEN, 1.5),
(f"EYE: {eye_y}px", 110, BLUE, 1.5),
(f"", 130, WHITE, 0.5),
(f"FACE: {face_height_pixels}px", 150, YELLOW, 1.5),
(f"FACE %: {face_height_ratio:.1f}% {face_status}", 180, YELLOW, 2),
(f"Required: 50-69%", 205, YELLOW, 1.5),
(f"", 225, WHITE, 0.5),
(f"EYE: {eye_from_bottom:.1f}% {eye_status}", 245, BLUE, 2),
(f"Required: 56-69%", 270, BLUE, 1.5),
]
overlay = debug_img.copy()
cv2.rectangle(overlay, (10, 10), (350, 290), BLACK, -1)
cv2.addWeighted(overlay, 0.75, debug_img, 0.25, 0, debug_img)
for text, y_pos, color, thickness in annotations:
if text:
cv2.putText(debug_img, text, (20, y_pos),
cv2.FONT_HERSHEY_SIMPLEX, 0.55, color, int(thickness))
legend_x, legend_y = w - 220, 30
overlay = debug_img.copy()
cv2.rectangle(overlay, (legend_x-10, legend_y-10), (w-10, legend_y+120), BLACK, -1)
cv2.addWeighted(overlay, 0.75, debug_img, 0.25, 0, debug_img)
cv2.putText(debug_img, "Legend:", (legend_x, legend_y+20),
cv2.FONT_HERSHEY_SIMPLEX, 0.6, WHITE, 2)
legends = [("Top", RED, 45), ("Chin", GREEN, 70), ("Eye", BLUE, 95), ("Height", YELLOW, 120)]
for label, color, y_offset in legends:
y_pos = legend_y + y_offset
cv2.line(debug_img, (legend_x, y_pos), (legend_x+30, y_pos), color, 3)
cv2.putText(debug_img, label, (legend_x+40, y_pos+5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, WHITE, 1)
overall_status = "PASS" if (50 <= face_height_ratio <= 69 and 56 <= eye_from_bottom <= 69) else "REVIEW"
status_color = GREEN if overall_status == "PASS" else RED
overlay = debug_img.copy()
cv2.rectangle(overlay, (w//2-150, h-60), (w//2+150, h-10), BLACK, -1)
cv2.addWeighted(overlay, 0.75, debug_img, 0.25, 0, debug_img)
cv2.putText(debug_img, f"Status: {overall_status}",
(w//2-130, h-25), cv2.FONT_HERSHEY_SIMPLEX, 0.9, status_color, 2)
return debug_img
def generate_html_report(self):
passed = sum(1 for r in self.results if r['status'] == 'pass')
failed = sum(1 for r in self.results if r['status'] == 'fail')
warnings = sum(1 for r in self.results if r['status'] == 'warning')
if failed == 0 and warnings == 0:
overall, color, subtitle = "✓ ALL CHECKS PASSED", "#28a745", "Your photo meets all requirements"
elif failed == 0:
overall, color, subtitle = "⚠ MINOR ISSUES", "#ffc107", "Photo acceptable but could be improved"
else:
overall, color, subtitle = "✗ REQUIREMENTS NOT MET", "#dc3545", "Please review issues and consider retaking"
html = f'''
<div style="font-family: Arial, sans-serif; max-width: 900px; margin: 0 auto;">
<div style="padding: 25px; background: {color}; color: white; border-radius: 10px; margin-bottom: 25px; text-align: center;">
<h2 style="margin: 0; font-size: 28px;">{overall}</h2>
<p style="margin: 10px 0 0; font-size: 16px;">{subtitle}</p>
<p style="margin: 10px 0 0;">
<strong>Passed:</strong> {passed} | <strong>Warnings:</strong> {warnings} | <strong>Failed:</strong> {failed}
</p>
<p style="margin: 10px 0 0; font-size: 13px; opacity: 0.9;">
✨ AI-Enhanced (Face Detection + Smart Background)
</p>
</div>
'''
categories = {}
for result in self.results:
cat = result['category']
if cat not in categories:
categories[cat] = []
categories[cat].append(result)
for category, results in categories.items():
html += f'<div style="margin-bottom: 30px;">'
html += f'<h3 style="border-bottom: 3px solid #0073aa; padding-bottom: 10px; color: #0073aa;">{category}</h3>'
for result in results:
if result['status'] == 'pass':
icon, bg, border, text_color = "✓", "#d4edda", "#28a745", "#155724"
elif result['status'] == 'warning':
icon, bg, border, text_color = "⚠", "#fff3cd", "#ffc107", "#856404"
else:
icon, bg, border, text_color = "✗", "#f8d7da", "#dc3545", "#721c24"
html += f'''
<div style="background: {bg}; padding: 18px; margin: 12px 0; border-radius: 8px; border-left: 5px solid {border};">
<h4 style="margin: 0 0 8px 0; color: {text_color}; font-size: 18px;">
{icon} {result["requirement"]}
</h4>
<p style="margin: 5px 0; color: {text_color}; font-size: 15px;">
<strong>{result["message"]}</strong>
</p>
<p style="margin: 8px 0 0 0; color: {text_color}; font-size: 14px;">
{result["details"]}
</p>
</div>
'''
html += '</div>'
# html += '''
# <div style="background: #e7f3ff; padding: 20px; border-radius: 8px; border-left: 5px solid #0073aa; margin-top: 30px;">
# <h3 style="margin: 0 0 15px 0; color: #0073aa;">📋 U.S. Visa Photo Requirements</h3>
# <ul style="margin: 10px 0; padding-left: 25px; line-height: 1.8;">
# <li><strong>Color:</strong> Must be in color (24-bit)</li>
# <li><strong>Size:</strong> Head 50-69% of image height</li>
# <li><strong>Recent:</strong> Taken within last 6 months</li>
# <li><strong>Background:</strong> Plain white or off-white</li>
# <li><strong>Position:</strong> Full-face view facing camera</li>
# <li><strong>Expression:</strong> Neutral with both eyes open</li>
# <li><strong>Head Covering:</strong> No hats unless religious</li>
# <li><strong>Eyeglasses:</strong> Not allowed (except medical)</li>
# <li><strong>Quality:</strong> Sharp focus, proper lighting</li>
# </ul>
# </div>
# </div>'''
# Add official requirements reference
html += '''
<div style="background: #e7f3ff; padding: 20px; border-radius: 8px; border-left: 5px solid #0073aa; margin-top: 30px;">
<h3 style="margin: 0 0 15px 0; color: #0073aa;">📋 Official U.S. Visa Photo Requirements</h3>
<ul style="margin: 10px 0; padding-left: 25px; line-height: 1.8;">
<li><strong>Color:</strong> Must be in color (24-bit)</li>
<li><strong>Size:</strong> Head must be 50-69% of image height (1 to 1 3/8 inches or 22-35mm from chin to top of head)</li>
<li><strong>Recent:</strong> Taken within last 6 months to reflect current appearance</li>
<li><strong>Background:</strong> Plain white or off-white background with no shadows</li>
<li><strong>Position:</strong> Full-face view directly facing camera</li>
<li><strong>Expression:</strong> Neutral facial expression with both eyes open</li>
<li><strong>Clothing:</strong> Everyday clothing (no uniforms except religious clothing worn daily)</li>
<li><strong>Head Covering:</strong> No hats unless religious head covering worn daily. Full face must be visible, no shadows on face</li>
<li><strong>Eyeglasses:</strong> Not allowed (policy updated). Exception only for medical reasons with doctor's statement</li>
<li><strong>Devices:</strong> No headphones, wireless devices, or similar items</li>
<li><strong>Quality:</strong> Sharp focus, proper lighting, no red-eye, not grainy</li>
</ul>
<p style="margin: 15px 0 5px 0; font-size: 14px;">
<strong>📸 Tips for Best Results:</strong><br>
• Use a white blanket or sheet as background if wall is not white<br>
• Ensure even lighting with no shadows on face or background<br>
• Stand 4-5 feet away from background to avoid shadows<br>
• Use natural light or diffused indoor lighting<br>
• Avoid grainy photos - use good quality printer if printing<br>
• Do not use photos from driver's licenses or copied from other documents<br>
• No selfies or full-length photos
</p>
<p style="margin: 15px 0 0 0; font-size: 13px; color: #666;">
For complete requirements and photo examples, visit:<br>
<a href="https://travel.state.gov/content/travel/en/us-visas/visa-information-resources/photos.html"
target="_blank"
style="
display: inline-block;
margin-top: 10px;
background: linear-gradient(135deg, #0073aa, #005f8d);
color: white;
text-decoration: none;
padding: 10px 18px;
border-radius: 8px;
font-weight: 500;
box-shadow: 0 4px 10px rgba(0,0,0,0.15);
transition: all 0.25s ease;
"
onmouseover="this.style.transform='translateY(-3px)'; this.style.boxShadow='0 8px 15px rgba(0,0,0,0.25)';"
onmouseout="this.style.transform='translateY(0)'; this.style.boxShadow='0 4px 10px rgba(0,0,0,0.15)';">
U.S. Department of State – Photo Requirements
</a>
</p>
</div>
'''
html += '</div>'
return html
app = Flask(__name__)
WORKER_ID = os.getenv('WORKER_ID', 'worker-1')
ORCHESTRATOR_URL = os.getenv('ORCHESTRATOR_URL', '')
WORKER_URL = os.getenv('WORKER_URL', '')
current_status = 'idle'
current_job = None
total_processed = 0
status_lock = threading.Lock()
print("\n" + "="*60)
print("PASSPORT PHOTO WORKER - XENOVA VERSION")
print("="*60)
print("[Init] PassportPhotoProcessor...")
processor = PassportPhotoProcessor()
print("[Init] ✓ Processor ready")
print("[Init] PhotoRequirementsChecker...")
checker = PhotoRequirementsChecker()
print("[Init] ✓ Checker ready")
print("[Init] Initializing Xenova Face Parsing...")
try:
if init_face_parser():
print("[Init] ✓ Xenova model loaded!")
else:
print("[Init] ⚠ Will initialize on first use")
except Exception as e:
print(f"[Init] ⚠ Error: {e}")
print("="*60)
print("WORKER READY")
print("="*60 + "\n")
@app.route('/ai_status', methods=['GET'])
def ai_status():
return jsonify({
'face_parsing': {
'available': FACE_PARSING_AVAILABLE,
'model': 'Xenova/face-parsing' if FACE_PARSING_AVAILABLE else 'N/A'
},
'transformers_available': TRANSFORMERS_AVAILABLE,
'worker_id': WORKER_ID,
'status': current_status
})
@app.route('/health', methods=['GET'])
def health_check():
with status_lock:
return jsonify({
'status': current_status,
'worker_id': WORKER_ID,
'total_processed': total_processed,
'current_job': current_job,
'timestamp': datetime.now().isoformat()
})
@app.route('/process', methods=['POST'])
def process_job():
global current_status, current_job
with status_lock:
if current_status == 'busy':
return jsonify({'error': 'Worker busy'}), 503
data = request.json
if not data or 'unique_id' not in data:
return jsonify({'error': 'Missing unique_id'}), 400
unique_id = data['unique_id']
service_type = data.get('service_type', 'processing')
image_data = data.get('image_data')
if not image_data:
return jsonify({'error': 'Missing image_data'}), 400
with status_lock:
current_status = 'busy'
current_job = unique_id
thread = threading.Thread(target=process_job_async, args=(unique_id, service_type, image_data))
thread.daemon = True
thread.start()
return jsonify({'message': 'Job accepted', 'worker_id': WORKER_ID}), 200
def process_job_async(unique_id, service_type, image_data):
global current_status, current_job, total_processed
try:
print(f"[{WORKER_ID}] Processing job {unique_id} - Type: {service_type}")
if service_type == 'processing':
result = processor.process_image_from_base64(image_data)
else:
result = checker.check_image_from_base64(image_data)
print(f"[{WORKER_ID}] Job {unique_id} completed")
send_result_to_orchestrator(unique_id, 'completed', result)
with status_lock:
total_processed += 1
except ValueError as ve:
error_msg = str(ve)
print(f"[{WORKER_ID}] Job {unique_id} failed (ValueError): {error_msg}")
send_result_to_orchestrator(unique_id, 'failed', {
'error': error_msg,
'error_type': 'validation_error'
})
except Exception as e:
error_msg = str(e)
if not error_msg or error_msg == '':
error_msg = "Processing failed due to an unknown error"
print(f"[{WORKER_ID}] Job {unique_id} failed: {error_msg}")
print(traceback.format_exc())
send_result_to_orchestrator(unique_id, 'failed', {
'error': error_msg,
'error_type': 'processing_error'
})
finally:
with status_lock:
current_status = 'idle'
current_job = None
send_heartbeat()
def send_result_to_orchestrator(unique_id, status, result):
if not ORCHESTRATOR_URL:
print(f"[{WORKER_ID}] No orchestrator URL")
return
try:
payload = {
'unique_id': unique_id,
'worker_id': WORKER_ID,
'status': status,
'result': result
}
if status == 'failed':
if isinstance(result, dict) and 'error' not in result:
payload['result'] = {'error': 'Processing failed'}
elif isinstance(result, str):
payload['result'] = {'error': result}
print(f"[{WORKER_ID}] Sending result for {unique_id} - Status: {status}")
if status == 'failed':
print(f"[{WORKER_ID}] Error message: {payload['result'].get('error', 'Unknown')}")
response = requests.post(
f"{ORCHESTRATOR_URL}/worker/result",
json=payload,
timeout=30
)
if response.status_code == 200:
print(f"[{WORKER_ID}] Result sent for {unique_id}")
else:
print(f"[{WORKER_ID}] Result send failed: {response.status_code}")
print(f"[{WORKER_ID}] Response: {response.text}")
except Exception as e:
print(f"[{WORKER_ID}] Result send error: {e}")
import traceback
traceback.print_exc()
def send_heartbeat():
if not ORCHESTRATOR_URL:
return
try:
with status_lock:
heartbeat_data = {
'worker_id': WORKER_ID,
'status': current_status,
'url': WORKER_URL,
'total_processed': total_processed,
'current_job': current_job
}
response = requests.post(
f"{ORCHESTRATOR_URL}/worker/heartbeat",
json=heartbeat_data,
timeout=10
)
if response.status_code == 200:
print(f"[{WORKER_ID}] Heartbeat sent - Status: {heartbeat_data['status']}")
else:
print(f"[{WORKER_ID}] Heartbeat failed: {response.status_code}")
except Exception as e:
print(f"[{WORKER_ID}] Heartbeat error: {e}")
def periodic_heartbeat():
while True:
try:
time.sleep(30)
send_heartbeat()
except Exception as e:
print(f"[{WORKER_ID}] Periodic heartbeat error: {e}")
time.sleep(30)
print(f"[{WORKER_ID}] Starting heartbeat thread...")
heartbeat_thread = threading.Thread(target=periodic_heartbeat, daemon=True)
heartbeat_thread.start()
if __name__ == '__main__':
print(f"=" * 60)
print(f"Worker: {WORKER_ID}")
print(f"Orchestrator: {ORCHESTRATOR_URL if ORCHESTRATOR_URL else 'Not configured'}")
print(f"Worker URL: {WORKER_URL if WORKER_URL else 'Not configured'}")
print(f"=" * 60)
if ORCHESTRATOR_URL:
print(f"[{WORKER_ID}] Sending initial heartbeat...")
send_heartbeat()
else:
print(f"[{WORKER_ID}] ⚠ Standalone mode")
port = int(os.getenv('PORT', 7860))
print(f"[{WORKER_ID}] Starting Flask on port {port}...")
app.run(host='0.0.0.0', port=port, threaded=True)