feat(接口2): 新增生发后图片(ComfyUI/Flux inpaint)

在发际线预览基础上，每种发际线再出一张「植发3个月」生发图：

- hairline/mask.py: headmark 5步法遮罩(额头上部区域∩SegFormer头部=ROI，
  取发际线曲线以上闭合区域)；用 hairline_texture_black 渲染黑线替代手绘检测；
  compose_comfy_rgba 合成 RGBA(alpha=255-mask, 透明=重绘区, 对齐 ComfyUI mask=1-alpha)
- hairline/comfyui.py: ComfyUI 客户端(默认8182)，/upload/image+/prompt(改节点26+随机seed)
  +轮询/history+/view 取回生发图
- hairline/render.py: 抽出 build_overlay_layer 供遮罩取曲线像素
- hairline/service.py: extract_context 一次出 landmarks/parse_map/502点；
  generate_grow_results 每种=预览+生发图(同步串行N张，单张ComfyUI失败则grown置空不拖垮整请求)
- app.py: /hair/grow 返回 results[].grown_image_base64；重活放线程池避免卡事件循环
- add_hair.json 工作流 + hairline_texture_black/ 黑贴图入库
- 测试: test_mask.py(遮罩几何) + test_api mock ComfyUI 验 grown 字段，35 全绿

实测(5090): female 5张生发图同步约18s；预览/生发图人物五官服饰背景保持、黑线已清除。

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

hairline/comfyui.py

@@ -0,0 +1,110 @@
+"""ComfyUI 客户端：用 add_hair.json 工作流跑生发图（Flux-2 inpaint）。
+
+worker 不跑 Flux，只把「划线图 + 遮罩」的 RGBA 上传到本机 ComfyUI(默认 8182)，
+替换工作流节点 26 的输入图、随机 seed，提交 /prompt，轮询 /history，取回 /view 输出。
+"""
+from __future__ import annotations
+
+import copy
+import json
+import os
+import random
+import time
+import uuid
+
+import httpx
+
+COMFYUI_URL = os.getenv("COMFYUI_URL", "http://127.0.0.1:8182").rstrip("/")
+WORKFLOW_PATH = os.getenv(
+    "ADD_HAIR_WORKFLOW",
+    os.path.join(os.path.dirname(os.path.dirname(__file__)), "add_hair.json"),
+)
+COMFY_TIMEOUT = float(os.getenv("COMFYUI_TIMEOUT", "600"))   # 单张出图最长等待(秒)
+
+_INPUT_NODE = "26"     # LoadImage：外部输入图(含 alpha 遮罩)
+_SEED_NODE = "6"       # RandomNoise
+_OUTPUT_NODE = "17"    # SaveImage
+
+_workflow = None
+
+
+def _load_workflow() -> dict:
+    global _workflow
+    if _workflow is None:
+        with open(WORKFLOW_PATH, encoding="utf-8") as f:
+            _workflow = json.load(f)
+    return _workflow
+
+
+def run(rgba_png_bytes: bytes, timeout: float = COMFY_TIMEOUT) -> bytes:
+    """提交一次生发任务，返回输出 PNG 字节。失败抛异常。"""
+    client_id = uuid.uuid4().hex
+    with httpx.Client(base_url=COMFYUI_URL, timeout=30.0) as cli:
+        # 1. 上传输入图（含 alpha 遮罩）到 ComfyUI input 目录
+        fname = f"hair_{client_id}.png"
+        r = cli.post("/upload/image", files={"image": (fname, rgba_png_bytes, "image/png")},
+                     data={"overwrite": "true", "type": "input"})
+        r.raise_for_status()
+        up = r.json()
+        name = (up.get("subfolder") + "/" if up.get("subfolder") else "") + up["name"]
+
+        # 2. 改工作流：节点26 输入图 + 随机 seed
+        wf = copy.deepcopy(_load_workflow())
+        wf[_INPUT_NODE]["inputs"]["image"] = name
+        wf[_SEED_NODE]["inputs"]["noise_seed"] = random.randint(0, 2**63 - 1)
+
+        # 3. 提交
+        r = cli.post("/prompt", json={"prompt": wf, "client_id": client_id})
+        r.raise_for_status()
+        prompt_id = r.json()["prompt_id"]
+
+        # 4. 轮询 /history
+        deadline = time.time() + timeout
+        outputs = None
+        while time.time() < deadline:
+            hr = cli.get(f"/history/{prompt_id}")
+            hr.raise_for_status()
+            hist = hr.json()
+            if prompt_id in hist:
+                entry = hist[prompt_id]
+                status = entry.get("status", {})
+                if status.get("status_str") == "error":
+                    raise RuntimeError(f"ComfyUI 执行报错: {status}")
+                outputs = entry.get("outputs")
+                if outputs and _OUTPUT_NODE in outputs:
+                    break
+            time.sleep(1.0)
+        if not outputs or _OUTPUT_NODE not in outputs:
+            raise TimeoutError(f"ComfyUI 出图超时({timeout}s) prompt_id={prompt_id}")
+
+        # 5. 取回输出图
+        imgs = outputs[_OUTPUT_NODE].get("images") or []
+        if not imgs:
+            raise RuntimeError("ComfyUI 输出无图像")
+        info = imgs[0]
+        vr = cli.get("/view", params={"filename": info["filename"],
+                                      "subfolder": info.get("subfolder", ""),
+                                      "type": info.get("type", "output")})
+        vr.raise_for_status()
+        return vr.content
+
+
+def ping() -> bool:
+    """探测 ComfyUI 是否在线（/system_stats）。"""
+    try:
+        with httpx.Client(base_url=COMFYUI_URL, timeout=3.0) as cli:
+            return cli.get("/system_stats").status_code == 200
+    except Exception:  # noqa: BLE001
+        return False
+
+
+if __name__ == "__main__":
+    import sys
+    inp = sys.argv[1] if len(sys.argv) > 1 else "tests/output/comfy_input.png"
+    print("ComfyUI:", COMFYUI_URL, "online:", ping())
+    with open(inp, "rb") as f:
+        png = run(f.read())
+    out = "tests/output/grown.png"
+    with open(out, "wb") as f:
+        f.write(png)
+    print(f"生发图已存 {out}（{len(png)} bytes）")

hairline/mask.py

@@ -0,0 +1,149 @@
+"""接口2 第二步：inpaint 遮罩 + 黑色发际线划线合成（参考 headmark 5步法）。
+
+算法（用 hairline_texture_black 渲染黑线替代 headmark 的手绘检测）：
+  ① 额头上部区域：MediaPipe 额头边界关键点连线，向上+两侧补到图像边缘填充
+  ② 头部轮廓：SegFormer 头部类（hair∪skin∪…，排除 bg/neck/cloth）
+  ③ ROI = ① ∩ ②
+  ④ 渲染黑色发际线 → 烧进照片(marked) + 得到曲线像素
+  ⑤ mask = ROI 中"发际线曲线以上"，闭运算去洞 + 最大连通域 + 轻羽化
+合成 RGBA：RGB=marked，alpha=255×(1−mask)（透明=重绘区，对齐 ComfyUI mask=1−alpha）。
+"""
+from __future__ import annotations
+
+import cv2
+import numpy as np
+from PIL import Image
+
+from .render import load_ext_mesh, load_texture_rgba, render_hairline_overlay, build_overlay_layer
+
+# headmark 额头边界关键点（MediaPipe canonical 索引，左→右沿上额）
+FOREHEAD_LANDMARKS = [21, 68, 104, 69, 108, 151, 337, 299, 333, 298, 251]
+# SegFormer 头部类（含 skin..hat；排除 bg=0 / ear_r=15 / neck_l=16 / neck=17 / cloth=18）
+_HEAD_CLASSES = list(range(1, 15))
+
+
+def forehead_upper_region(landmarks_mp: np.ndarray, w: int, h: int) -> np.ndarray:
+    """headmark step1：额头边界关键点以上的"上部区域"填充 mask（uint8 0/255）。"""
+    pts = [(int(landmarks_mp[i, 0] * w), int(landmarks_mp[i, 1] * h)) for i in FOREHEAD_LANDMARKS]
+    left_ext = (0, pts[0][1])
+    right_ext = (w - 1, pts[-1][1])
+    polygon = np.array([left_ext] + pts + [right_ext, (w - 1, 0), (0, 0)], dtype=np.int32)
+    m = np.zeros((h, w), np.uint8)
+    cv2.fillPoly(m, [polygon], 255)
+    return m
+
+
+def head_silhouette(parse_map: np.ndarray) -> np.ndarray:
+    """headmark step2：SegFormer 头部轮廓 mask（uint8 0/255）。"""
+    return (np.isin(parse_map, _HEAD_CLASSES).astype(np.uint8) * 255)
+
+
+def _curve_bottom_per_column(curve_mask: np.ndarray):
+    """每列发际线曲线的**最低**像素 y（线下沿），返回 (xs, ys) 仅含有曲线的列。"""
+    ys_idx, xs_idx = np.where(curve_mask > 0)
+    if xs_idx.size == 0:
+        return None, None
+    w = curve_mask.shape[1]
+    bottom = np.full(w, -1, np.int32)
+    np.maximum.at(bottom, xs_idx, ys_idx)
+    cols = np.where(bottom >= 0)[0]
+    return cols, bottom[cols]
+
+
+def _above_curve_region(curve_mask: np.ndarray, h: int, w: int) -> np.ndarray:
+    """由发际线曲线得到"曲线以上"区域（uint8 0/255）。
+
+    曲线 x 跨度内逐列插值出下沿 y_line(x)，两侧按端点 y 水平延伸；
+    above = 所有 y ≤ y_line(x)。曲线缺失（极端）则返回全 1（交给 ROI 兜底）。
+    """
+    cols, ybot = _curve_bottom_per_column(curve_mask)
+    if cols is None:
+        return np.full((h, w), 255, np.uint8)
+    x0, x1 = int(cols.min()), int(cols.max())
+    # 全列插值 y_line：[x0,x1] 内线性插值，两侧水平延伸
+    yline = np.interp(np.arange(w), cols, ybot,
+                      left=float(ybot[0]), right=float(ybot[-1])).astype(np.int32)
+    yy = np.arange(h)[:, None]                  # (h,1)
+    above = (yy <= yline[None, :]).astype(np.uint8) * 255   # (h,w)
+    return above
+
+
+def _clean_mask(mask: np.ndarray, w: int) -> np.ndarray:
+    """闭运算去洞 + 取最大连通域填充 + 轻羽化。"""
+    k = max(3, (int(w * 0.015) | 1))
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (k, k))
+    closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+    cnts, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    out = np.zeros_like(mask)
+    if cnts:
+        largest = max(cnts, key=cv2.contourArea)
+        cv2.drawContours(out, [largest], -1, 255, -1)
+    # 轻羽化（柔化边缘，利于扩散衔接）
+    out = cv2.GaussianBlur(out, (0, 0), sigmaX=max(1.0, w * 0.004))
+    return out
+
+
+def build_inpaint_mask(photo_bgr: np.ndarray, landmarks_mp: np.ndarray,
+                       parse_map: np.ndarray, points502: np.ndarray,
+                       black_texture_rgba: np.ndarray):
+    """返回 (marked_bgr 划线图, mask uint8 0..255 重绘区)。"""
+    h, w = photo_bgr.shape[:2]
+    uv, ext_faces = load_ext_mesh()
+
+    # ④ 渲染黑线：marked = 烧进照片；curve_mask = 曲线像素
+    marked = render_hairline_overlay(photo_bgr, points502, ext_faces, uv, black_texture_rgba)
+    overlay = build_overlay_layer(h, w, points502, ext_faces, uv, black_texture_rgba)
+    curve_mask = (overlay[:, :, 3] > 40).astype(np.uint8) * 255
+
+    # ①②③ ROI
+    upper = forehead_upper_region(landmarks_mp, w, h)
+    head = head_silhouette(parse_map)
+    roi = cv2.bitwise_and(upper, head)
+
+    # ⑤ ROI ∩ 曲线以上 → 清理
+    above = _above_curve_region(curve_mask, h, w)
+    mask = cv2.bitwise_and(roi, above)
+    mask = _clean_mask(mask, w)
+    return marked, mask
+
+
+def compose_comfy_rgba(marked_bgr: np.ndarray, mask: np.ndarray) -> Image.Image:
+    """合成 ComfyUI LoadImage 用的 RGBA：RGB=划线图，alpha=255−mask（透明=重绘区）。"""
+    rgb = cv2.cvtColor(marked_bgr, cv2.COLOR_BGR2RGB)
+    alpha = (255 - mask).astype(np.uint8)
+    rgba = np.dstack([rgb, alpha])
+    return Image.fromarray(rgba, mode="RGBA")
+
+
+if __name__ == "__main__":
+    import sys, os
+    from .service import get_landmarker, get_parser
+
+    path = sys.argv[1] if len(sys.argv) > 1 else "tests/fixtures/frontal.jpg"
+    tex_name = sys.argv[2] if len(sys.argv) > 2 else "girl_straight"
+    img = cv2.imread(path)
+    h, w = img.shape[:2]
+    rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+
+    from .hairline_2d import sample_hairline, smooth_hairline
+    from .lift_3d import lift_hairline_to_3d, build_middle_row, assemble_full
+    lm = get_landmarker().detect(rgb)
+    parse_map = get_parser().parse(rgb)
+    h2d, valid = sample_hairline(lm, parse_map); h2d = smooth_hairline(h2d, valid)
+    h3d = lift_hairline_to_3d(lm, h2d); mid = build_middle_row(lm, h3d)
+    pts = assemble_full(lm, mid, h3d)
+
+    black = load_texture_rgba(f"hairline_texture_black/{tex_name}.png")
+    marked, mask = build_inpaint_mask(img, lm, parse_map, pts, black)
+    os.makedirs("tests/output", exist_ok=True)
+    cv2.imwrite("tests/output/mask_marked.png", marked)
+    cv2.imwrite("tests/output/mask_binary.png", mask)
+    # 三联可视化：划线图 / ROI / mask 叠加
+    upper = forehead_upper_region(lm, w, h); head = head_silhouette(parse_map)
+    roi = cv2.bitwise_and(upper, head)
+    vis = marked.copy()
+    vis[roi > 0] = (vis[roi > 0] * 0.6 + np.array([0, 40, 0])).clip(0, 255).astype(np.uint8)
+    vis[mask > 128] = (vis[mask > 128] * 0.4 + np.array([0, 0, 150])).clip(0, 255).astype(np.uint8)
+    cv2.imwrite("tests/output/mask_vis.png", vis)
+    compose_comfy_rgba(marked, mask).save("tests/output/comfy_input.png")
+    print(f"saved mask_marked/mask_binary/mask_vis/comfy_input；mask 像素 {int((mask>128).sum())}")

hairline/render.py

@@ -78,19 +78,30 @@ def render_hairline_overlay(photo_bgr: np.ndarray,
     points502_norm: (502, 3) 归一化坐标（x,y ∈ [0,1]），**MP 顺序**（extract_hairline 输出）。
     """
     H, W = photo_bgr.shape[:2]
-    TH, TW = texture_rgba.shape[:2]
-    pts_obj = mp_order_to_obj_order(points502_norm)              # MP序 → OBJ序
-    img_xy = pts_obj[:, :2] * np.array([W, H], dtype=np.float32)  # (502,2)
+    overlay = build_overlay_layer(H, W, points502_norm, ext_faces, uv502, texture_rgba)
+    # alpha 合成（RGBA→BGR：贴图 RGB 顺序需反成 BGR）
+    a = overlay[:, :, 3:4] / 255.0
+    rgb = overlay[:, :, :3][..., ::-1]               # RGB→BGR
+    out = photo_bgr.astype(np.float32) * (1.0 - a) + rgb * a
+    return np.clip(out, 0, 255).astype(np.uint8)
 
-    overlay = np.zeros((H, W, 4), np.float32)        # 累积曲线层 RGBA
+
+def build_overlay_layer(H, W, points502_norm, ext_faces, uv502, texture_rgba) -> np.ndarray:
+    """渲染发际线曲线层，返回 (H, W, 4) float32 RGBA（未合成到照片）。
+
+    供渲染合成（render_hairline_overlay）与遮罩（mask.py 取 alpha=曲线像素）共用。
+    """
+    TH, TW = texture_rgba.shape[:2]
+    pts_obj = mp_order_to_obj_order(points502_norm)
+    img_xy = pts_obj[:, :2] * np.array([W, H], dtype=np.float32)
+    overlay = np.zeros((H, W, 4), np.float32)
     tex = texture_rgba.astype(np.float32)
     for (i, j, k) in ext_faces:
         dst = img_xy[[i, j, k]].astype(np.float32)
         # UV → 贴图像素；flipY：贴图 y = (1 - v_raw) * TH（与 head3d Three.js flipY=true 一致）
         src = np.array([[uv502[v][0] * TW, (1.0 - uv502[v][1]) * TH] for v in (i, j, k)],
                        dtype=np.float32)
-        # 退化三角形（投影到一条线）跳过，避免 getAffineTransform 奇异
-        if cv2.contourArea(dst.astype(np.int32)) < 1.0:
+        if cv2.contourArea(dst.astype(np.int32)) < 1.0:   # 退化三角形跳过
             continue
         M = cv2.getAffineTransform(src, dst)
         warped = cv2.warpAffine(tex, M, (W, H), flags=cv2.INTER_LINEAR,
@@ -99,9 +110,4 @@ def render_hairline_overlay(photo_bgr: np.ndarray,
         cv2.fillConvexPoly(tri_mask, dst.astype(np.int32), 255)
         sel = tri_mask > 0
         overlay[sel] = warped[sel]
-
-    # alpha 合成（RGBA→BGR：贴图 RGB 顺序需反成 BGR）
-    a = overlay[:, :, 3:4] / 255.0
-    rgb = overlay[:, :, :3][..., ::-1]               # RGB→BGR
-    out = photo_bgr.astype(np.float32) * (1.0 - a) + rgb * a
-    return np.clip(out, 0, 255).astype(np.uint8)
+    return overlay

hairline/service.py

@@ -11,13 +11,22 @@ import cv2
 import numpy as np
 
 from . import constants as C
+from . import comfyui
 from .face_landmarks import FaceLandmarker
 from .face_parsing import FaceParser
 from .hairline_2d import sample_hairline, smooth_hairline
 from .lift_3d import lift_hairline_to_3d, build_middle_row, assemble_full
 from .render import load_ext_mesh, load_texture_rgba, render_hairline_overlay
+from .mask import build_inpaint_mask, compose_comfy_rgba
 
-_TEXTURE_DIR = os.path.join(os.path.dirname(os.path.dirname(__file__)), "hairline_texture")
+import io
+import logging
+
+logger = logging.getLogger("hair.worker")
+
+_REPO = os.path.dirname(os.path.dirname(__file__))
+_TEXTURE_DIR = os.path.join(_REPO, "hairline_texture")
+_BLACK_TEXTURE_DIR = os.path.join(_REPO, "hairline_texture_black")
 
 # ⚠️ 本 worker 是 RTX 5090(sm_120)，torch 2.2.2(cu121) 只编到 sm_90，CUDA 跑算子会报
 #    "no kernel image"。SegFormer 默认走 CPU（~2.5s/张）。换 torch cu128 后可设 SEG_DEVICE=cuda。
@@ -73,40 +82,84 @@ def get_texture_map() -> dict:
 
 def extract_502(image_bgr: np.ndarray):
     """照片(BGR) → (points502 MP序, valid17)。无人脸返回 (None, None)。"""
+    ctx = extract_context(image_bgr)
+    if ctx is None:
+        return None, None
+    return ctx["points"], ctx["valid"]
+
+
+def extract_context(image_bgr: np.ndarray):
+    """照片(BGR) → {landmarks, parse_map, points, valid}。无人脸返回 None。"""
     rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
     landmarks = get_landmarker().detect(rgb)
     if landmarks is None:
-        return None, None
+        return None
     parse_map = get_parser().parse(rgb)
     hairline_2d, valid = sample_hairline(landmarks, parse_map)
     hairline_2d = smooth_hairline(hairline_2d, valid)
     hairline_3d = lift_hairline_to_3d(landmarks, hairline_2d)
     middle_3d = build_middle_row(landmarks, hairline_3d)
     points = assemble_full(landmarks, middle_3d, hairline_3d)
-    return points, valid
+    return {"landmarks": landmarks, "parse_map": parse_map, "points": points, "valid": valid}
+
+
+def _black_texture_path(white_path: str) -> str:
+    """白贴图路径 → 同名黑贴图路径（hairline_texture_black/）。"""
+    return os.path.join(_BLACK_TEXTURE_DIR, os.path.basename(white_path))
 
 
 def generate_previews(image_bgr: np.ndarray, gender: str):
-    """生成该性别全部发际线预览图。
+    """生成该性别全部发际线预览图（仅预览，不生发）。
 
-    Returns: list[dict]，每项 {"hairline_type": key, "image_bgr": ndarray, "order": 1..N}。
-    无人脸返回 None。gender 必须是 male/female。
+    Returns: list[dict] {"hairline_type", "image_bgr", "order"}；无人脸返回 None。
     """
     if gender not in ("male", "female"):
         raise ValueError(f"gender 必须是 male/female，收到 {gender!r}")
-    points, _valid = extract_502(image_bgr)
-    if points is None:
+    ctx = extract_context(image_bgr)
+    if ctx is None:
         return None
-
     uv, ext_faces = load_ext_mesh()
     results = []
     for order, (key, path) in enumerate(get_texture_map()[gender], start=1):
-        tex = load_texture_rgba(path)
-        preview = render_hairline_overlay(image_bgr, points, ext_faces, uv, tex)
+        preview = render_hairline_overlay(image_bgr, ctx["points"], ext_faces, uv,
+                                          load_texture_rgba(path))
         results.append({"hairline_type": key, "image_bgr": preview, "order": order})
     return results
 
 
+def generate_grow_results(image_bgr: np.ndarray, gender: str):
+    """该性别全部发际线：预览图(白线) + 生发图(ComfyUI)。同步、串行。
+
+    Returns: list[dict] {"hairline_type","order","image_bgr"(预览), "grown_png"(bytes 或 None)}。
+    无人脸返回 None。某张 ComfyUI 失败时该项 grown_png=None，不影响其余。
+    """
+    if gender not in ("male", "female"):
+        raise ValueError(f"gender 必须是 male/female，收到 {gender!r}")
+    ctx = extract_context(image_bgr)
+    if ctx is None:
+        return None
+    uv, ext_faces = load_ext_mesh()
+    results = []
+    for order, (key, white_path) in enumerate(get_texture_map()[gender], start=1):
+        white = load_texture_rgba(white_path)
+        preview = render_hairline_overlay(image_bgr, ctx["points"], ext_faces, uv, white)
+
+        grown_png = None
+        try:
+            black = load_texture_rgba(_black_texture_path(white_path))
+            marked, mask = build_inpaint_mask(
+                image_bgr, ctx["landmarks"], ctx["parse_map"], ctx["points"], black)
+            buf = io.BytesIO()
+            compose_comfy_rgba(marked, mask).save(buf, format="PNG")
+            grown_png = comfyui.run(buf.getvalue())
+        except Exception as e:  # noqa: BLE001  单张失败不拖垮整请求
+            logger.warning("接口2 生发图失败 type=%s：%s", key, e)
+
+        results.append({"hairline_type": key, "order": order,
+                        "image_bgr": preview, "grown_png": grown_png})
+    return results
+
+
 if __name__ == "__main__":
     import sys
     g = sys.argv[2] if len(sys.argv) > 2 else "female"