AI 证件照换底与改尺寸

\theta = \arctan2(y_{le} - y_{re}, x_{le} - x_{re}) \times \frac{180}{\pi}

Y_{top\_hair} = \min \{ y \mid \sum_{x} (\alpha(x, y) > 50) > 10 \}

H_{crop} = \frac{H_{head}}{0.65}, \quad M_{top} \approx 0.104 \times H_{crop}

H_{crop} = \frac{H_{head}}{0.58}, \quad M_{top} \approx 0.110 \times H_{crop}

Y_{min} = Y_{top\_hair} - M_{top}, \quad Y_{max} = Y_{min} + H_{crop}

W_{crop} = H_{crop} \times \frac{5}{7}

X_{min} = X_{center} - \frac{W_{crop}}{2}, \quad X_{max} = X_{center} + \frac{W_{crop}}{2}

\text{RGB} = (65, 136, 218) \quad (\text{Hex: } \#4188\text{D2})

r = \min\left(1.0, \frac{\sqrt{((u - u_0) \times 1.05)^2 + ((v - v_0) \times 0.9)^2}}{0.85}\right)

S(r) = r^2 \times (3 - 2r)

\text{Color}(u, v) = \text{Color}_{center} \times (1 - S(r)) + \text{Color}_{edge} \times S(r)

C_{final}(x, y) = C_{fg}(x, y) \cdot \alpha(x, y) + C_{bg}(x, y) \cdot (1.0 - \alpha(x, y))

image.save(output_path, dpi=(300, 300), quality=96)

"""
智能证件照生成工具
功能：自动抠图、人脸五官定位、规范裁剪、纯蓝/渐变蓝渲染、300 DPI 导出
"""

import os
import cv2
import numpy as np
from PIL import Image
from rembg import remove, new_session

def create_id_photos(input_image_path, output_dir=None):
    if output_dir is None:
        output_dir = os.path.dirname(input_image_path)
    os.makedirs(output_dir, exist_ok=True)
    
    filename_base = os.path.splitext(os.path.basename(input_image_path))[0]
    print(f"[*] 正在处理: {input_image_path}")

    # 1. AI 抠图
    print("[1/5] 执行 BiRefNet 人像精细抠图...")
    session = new_session("birefnet-portrait")
    img_pil = Image.open(input_image_path).convert("RGB")
    rgba_pil = remove(img_pil, session=session)
    rgba = cv2.cvtColor(np.array(rgba_pil), cv2.COLOR_RGBA2BGRA)
    h_orig, w_orig = rgba.shape[:2]

    # 2. 定位人脸五官与头顶
    print("[2/5] 分析人脸五官与头部几何坐标...")
    # 查找头顶最高点 (Alpha > 50 的行)
    alpha = rgba[:, :, 3]
    row_occ = (alpha > 50).sum(axis=1)
    hair_top_y = np.where(row_occ > 10)[0][0]

    # 检测眼睛与下巴区域
    # 若需精准检测，可用 Yunet；此处提供基于人像蒙版的鲁棒重心与比例估算
    y_indices, x_indices = np.where(alpha > 50)
    person_center_x = int(np.median(x_indices[y_indices < (hair_top_y + 1200)]))
    
    # 估算头部高度 (根据人体工学，头顶至下巴约占上身蒙版特定比例)
    # 取颈部收窄处上方作为下巴估算
    widths = []
    for y in range(hair_top_y + 400, min(hair_top_y + 1400, h_orig)):
        xs = np.where(alpha[y, :] > 50)[0]
        if len(xs) > 0:
            widths.append((y, xs.max() - xs.min()))
    min_width_y = min(widths, key=lambda x: x[1])[0]
    chin_y = min_width_y - 20
    head_height = chin_y - hair_top_y
    if head_height < 600: # 保护性阈值
        head_height = 1000

    print(f"    - 头顶 Y: {hair_top_y}, 下巴 Y: {chin_y}, 头部高度: {head_height}px, 中心 X: {person_center_x}")

    # 3. 背景生成器
    def make_gradient_bg(h, w):
        y = np.linspace(0, 1, h)[:, None]
        x = np.linspace(0, 1, w)[None, :]
        cx, cy = 0.5, 0.35
        r = np.sqrt(((x - cx) * 1.05)**2 + ((y - cy) * 0.9)**2)
        r = np.clip(r / 0.85, 0, 1)
        smooth = r * r * (3 - 2 * r)
        bg_b = 219 * (1 - smooth) + 184 * smooth
        bg_g = 142 * (1 - smooth) + 87 * smooth
        bg_r = 67 * (1 - smooth) + 27 * smooth
        return np.stack([bg_b, bg_g, bg_r], axis=-1).astype(np.float32)

    def make_solid_bg(h, w):
        bg = np.zeros((h, w, 3), dtype=np.float32)
        bg[:, :] = [218, 136, 65] # BGR: RGB(65, 136, 218)
        return bg

    # 4. 规格定义
    specs = [
        {
            "name": "一寸",
            "head_ratio": 0.65,
            "top_margin_ratio": 0.104,
            "std_wh": (295, 413),
            "hd_wh": (590, 826),
        },
        {
            "name": "二寸",
            "head_ratio": 0.58,
            "top_margin_ratio": 0.110,
            "std_wh": (413, 579),
            "hd_wh": (826, 1158),
        }
    ]

    print("[3/5] 正在执行裁剪与底色融合...")
    for sp in specs:
        crop_h = int(head_height / sp["head_ratio"])
        top_margin = int(crop_h * sp["top_margin_ratio"])
        y1 = max(0, hair_top_y - top_margin)
        y2 = min(h_orig, y1 + crop_h)
        actual_h = y2 - y1
        
        crop_w = int(actual_h * (5.0 / 7.0))
        x1 = max(0, person_center_x - crop_w // 2)
        x2 = min(w_orig, x1 + crop_w)
        
        cropped_rgba = rgba[y1:y2, x1:x2]
        ch, cw = cropped_rgba.shape[:2]
        
        for bg_type, bg_gen in [("渐变高级蓝", make_gradient_bg), ("标准纯蓝", make_solid_bg)]:
            bg = bg_gen(ch, cw)
            alpha_crop = (cropped_rgba[:, :, 3:4] / 255.0).astype(np.float32)
            composed = (cropped_rgba[:, :, :3].astype(np.float32) * alpha_crop + bg * (1.0 - alpha_crop)).astype(np.uint8)
            
            # 导出标准版
            std_img = cv2.resize(composed, sp["std_wh"], interpolation=cv2.INTER_AREA)
            std_pil = Image.fromarray(cv2.cvtColor(std_img, cv2.COLOR_BGR2RGB))
            std_path = os.path.join(output_dir, f"{filename_base}_{sp['name']}蓝底_{bg_type}_标准版.jpg")
            std_pil.save(std_path, dpi=(300, 300), quality=96)
            
            # 导出高清版
            hd_img = cv2.resize(composed, sp["hd_wh"], interpolation=cv2.INTER_AREA)
            hd_pil = Image.fromarray(cv2.cvtColor(hd_img, cv2.COLOR_BGR2RGB))
            hd_path = os.path.join(output_dir, f"{filename_base}_{sp['name']}蓝底_{bg_type}_高清版.jpg")
            hd_pil.save(hd_path, dpi=(300, 300), quality=96)

    print(f"[✓] 处理完成！所有照片已保存至: {output_dir}")

if __name__ == "__main__":
    # 使用示例
    target_img = r"<input-photo-path>"
    create_id_photos(target_img)