#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Hunyuan3D Full Pipeline (aptol/genshin 메인) — Weaponless + T-Pose + 6-View STEP1: 전처리 (rembg, DINO+SAM+LaMa weapon remove, T-pose enforce via ControlNet, img2img redraw) STEP2: Space 호출 (model / optional texture) STEP3: 6-view 렌더 ZIP + Blender 오토리깅(FBX) + VRM(옵션) + 기본 BlendShapes + Unity Animator 스크립트 권장 패키지: pip install gradio gradio_client pillow numpy opencv-python pip install rembg pip install diffusers transformers accelerate torch --extra-index-url https://download.pytorch.org/whl/cu121 pip install controlnet-aux pip install groundingdino segment-anything pip install lama-cleaner pip install trimesh pyrender PyOpenGL 환경변수(옵션): HF_TOKEN=hf_xxx BLENDER_PATH=/path/to/blender DINO_CFG=./GroundingDINO_SwinT_OGC.py DINO_WEIGHTS=./groundingdino_swint_ogc.pth SAM_WEIGHTS=./sam_vit_h_4b8939.pth """ import os, io, json, time, math, random, shutil, zipfile, hashlib, tempfile, subprocess, textwrap, traceback from pathlib import Path from typing import Any, Dict, List, Optional, Tuple, Union from PIL import Image as PILImage, ImageDraw, ImageFilter import gradio as gr try: import spaces except Exception: class _Dummy: def GPU(self, *a, **k): def deco(fn): return fn return deco spaces = _Dummy() from PIL import Image, ImageDraw # ---- HF Spaces GPU decorator (호환용 더미 포함) try: import spaces except Exception: class _Dummy: def GPU(self, *a, **k): def deco(fn): return fn return deco spaces = _Dummy() # --------------------------------- # PATHS # --------------------------------- ROOT = Path(__file__).resolve().parent OUT = ROOT / "outputs" (OUT / "step1").mkdir(parents=True, exist_ok=True) (OUT / "step2").mkdir(parents=True, exist_ok=True) (OUT / "step2b").mkdir(parents=True, exist_ok=True) (OUT / "step3").mkdir(parents=True, exist_ok=True) (OUT / "exports").mkdir(parents=True, exist_ok=True) # --------------------------------- # OPTIONAL IMPORTS (lazy) # --------------------------------- def _lazy(): P = {} try: import numpy as np P["np"] = np except Exception: P["np"] = None try: import cv2 P["cv2"] = cv2 except Exception: P["cv2"] = None try: from gradio_client import Client P["Client"] = Client except Exception: P["Client"] = None try: import trimesh, pyrender P["trimesh"] = __import__("trimesh") P["pyrender"] = __import__("pyrender") except Exception: P["trimesh"] = None P["pyrender"] = None # rembg try: from rembg import remove as rembg_remove P["rembg_remove"] = rembg_remove except Exception: P["rembg_remove"] = None # diffusers (img2img) try: from diffusers import StableDiffusionImg2ImgPipeline import torch P["sd_img2img"] = StableDiffusionImg2ImgPipeline P["torch"] = torch except Exception: P["sd_img2img"] = None P["torch"] = None # ControlNet (OpenPose) for T-POSE enforce try: from diffusers import ControlNetModel, StableDiffusionControlNetImg2ImgPipeline P["ControlNetModel"] = ControlNetModel P["SD_CN_Img2Img"] = StableDiffusionControlNetImg2ImgPipeline except Exception: P["ControlNetModel"] = None P["SD_CN_Img2Img"] = None # controlnet_aux (OpenposeDetector) try: from controlnet_aux import OpenposeDetector P["OpenposeDetector"] = OpenposeDetector except Exception: P["OpenposeDetector"] = None # GroundingDINO try: from groundingdino.util.inference import load_model, predict P["g_load_model"] = load_model P["g_predict"] = predict except Exception: P["g_load_model"] = None P["g_predict"] = None # SAM try: from segment_anything import sam_model_registry, SamPredictor P["sam_model_registry"] = sam_model_registry P["SamPredictor"] = SamPredictor except Exception: P["sam_model_registry"] = None P["SamPredictor"] = None # LaMa try: from lama_cleaner.model_manager import ModelManager P["LaMaManager"] = ModelManager except Exception: P["LaMaManager"] = None return P PKG = _lazy() def _device(): try: t = PKG["torch"] if t is not None and t.cuda.is_available(): return "cuda" except Exception: pass return "cpu" # --------------------------------- # Spaces profiles (genshin 메인) # --------------------------------- SPACES: Dict[str, Dict[str, Any]] = { "genshin (main)": { "repo": "aptol/genshin", "api_model": "/run", "api_texture": "/texture", "variants_model": [ ("prompt","image","steps","guidance","seed"), ("prompt","image"), ("image","steps","guidance","seed"), ("image",), ], "variants_texture": [ ("glb","steps","guidance"), ("glb",), ], }, "fork (backend)": { "repo": "aptol/Hunyuan3D-2.1", "api_model": "/run", "api_texture": "/texture", "variants_model": [ ("prompt","image","steps","guidance","seed"), ("prompt","image"), ("image","steps","guidance","seed"), ("image",), ], "variants_texture": [ ("glb","steps","guidance"), ("glb",), ], }, "tencent (upstream)": { "repo": "tencent/Hunyuan3D-2.1", "api_model": "/run", "api_texture": "/texture", "variants_model": [ ("prompt","image","steps","guidance","seed"), ("prompt","image"), ("image","steps","guidance","seed"), ("image",), ], "variants_texture": [ ("glb","steps","guidance"), ("glb",), ], }, "": { "repo": "", "api_model": "/run", "api_texture": "/texture", "variants_model": [("prompt","image","steps","guidance","seed"),("prompt","image"),("image","steps","guidance","seed"),("image",)], "variants_texture": [("glb","steps","guidance"),("glb",)], } } # --------------------------------- # Utility # --------------------------------- def _disable_safety(pipe): """ Diffusers SafetyChecker 완전 비활성화 (0.29.x 호환). run_safety_checker가 항상 (images, [False]*BATCH) 형태를 반환하게 만든다. """ try: def _dummy_run_safety_checker(images, device=None, dtype=None): # images: torch.Tensor [B,C,H,W] 또는 list/tuple 길이 B try: if hasattr(images, "shape"): batch = int(images.shape[0]) else: batch = len(images) except Exception: batch = 1 return images, [False] * max(1, batch) # ★ 리스트 보장 pipe.run_safety_checker = _dummy_run_safety_checker # ★ 핵심 pipe.safety_checker = None # 혹시 내부에서 feature_extractor를 호출해도 터지지 않도록 '호출 가능한' 더미 제공 pipe.feature_extractor = (lambda *args, **kwargs: None) except Exception: pass return pipe def _openpose_canvas_from_image(img_rgb: Image.Image) -> Image.Image: try: if PKG.get("OpenposeDetector") is None: return Image.new("RGB", img_rgb.size, "black") det = PKG["OpenposeDetector"]() pose = det(img_rgb) return pose.convert("RGB").resize(img_rgb.size) except Exception: return Image.new("RGB", img_rgb.size, "black") def _blend_pose_canvases(orig_pose: Image.Image, tpose: Image.Image, alpha: float = 0.4) -> Image.Image: alpha = max(0.0, min(1.0, float(alpha))) if orig_pose.size != tpose.size: tpose = tpose.resize(orig_pose.size) return Image.blend(orig_pose, tpose, alpha).convert("RGB") def _mean_brightness(img: Image.Image) -> float: import numpy as np return float(np.asarray(img.convert("L"), dtype=np.uint8).mean()) def _save_png(img: Image.Image, path: Union[str,Path]) -> str: p = Path(path); p.parent.mkdir(parents=True, exist_ok=True); img.save(p); return str(p) def _cache_key(img_path: str, opt: Dict[str,Any]) -> str: b = Path(img_path).read_bytes() digest = hashlib.sha256(b + json.dumps(opt, sort_keys=True).encode()).hexdigest()[:24] return digest def _hf_client(repo: str): if PKG["Client"] is None: raise RuntimeError("gradio_client 설치 필요: pip install gradio_client") tok = os.getenv("HF_TOKEN", None) return PKG["Client"](repo, hf_token=tok) def _call_space(repo: str, api_name: str, variant: Tuple[str,...], payload: Dict[str,Any]): client = _hf_client(repo) args = [] for k in variant: args.append(payload[k]) try: return client.predict(*args, api_name=api_name) except Exception: job = client.submit(*args, api_name=api_name) return job.result() def _pick_glb(res: Any) -> Optional[str]: if isinstance(res, str) and res.lower().endswith(".glb"): return res if isinstance(res, (list,tuple)): for it in res: p = _pick_glb(it) if p: return p if isinstance(res, dict): for k in ("glb","path","file","result","data"): if k in res: p = _pick_glb(res[k]) if p: return p if hasattr(res, "name") and str(res.name).lower().endswith(".glb"): return str(res.name) return None # --------------------------------- # STEP1: BG remove / WEAPON remove / T-POSE / Redraw # --------------------------------- def _remove_bg(img: Image.Image) -> Image.Image: """ rembg를 안전하게 호출 (PNG 바이트 왕복). 결과가 완전 투명(알파 0%)이면 실패로 간주하고 원본을 반환. """ try: from rembg import remove buf = io.BytesIO() img.convert("RGBA").save(buf, format="PNG") out_bytes = remove(buf.getvalue()) # bytes in → bytes out out = Image.open(io.BytesIO(out_bytes)).convert("RGBA") # 완전 투명 체크: 알파 채널 bbox가 없으면 전부 0 alpha = out.getchannel("A") if alpha.getbbox() is None: # 전부 투명 -> 실패 처리 return img.convert("RGBA") return out except Exception: return img.convert("RGBA") def _to_preview(img: Image.Image, bg=(40, 40, 40)) -> Image.Image: """ 갤러리 미리보기용으로 RGBA 이미지를 불투명 배경에 합성. 저장물은 RGBA 그대로 두고, UI 표시만 보기 좋게. """ if img.mode != "RGBA": return img.convert("RGB") bg_img = Image.new("RGB", img.size, bg) bg_img.paste(img, mask=img.split()[-1]) return bg_img # ---- Weapon remove (DINO -> SAM -> LaMa/OpenCV) _DINO_MODEL = None def _dino_boxes(img: Image.Image, text_prompt: str) -> List[Tuple[int,int,int,int]]: global _DINO_MODEL if PKG["g_load_model"] is None or PKG["g_predict"] is None or PKG["np"] is None: return [] cfg = os.getenv("DINO_CFG", str(ROOT/"GroundingDINO_SwinT_OGC.py")) wts = os.getenv("DINO_WEIGHTS", str(ROOT/"groundingdino_swint_ogc.pth")) if not Path(cfg).exists() or not Path(wts).exists(): return [] try: if _DINO_MODEL is None: _DINO_MODEL = PKG["g_load_model"](cfg, wts) np = PKG["np"]; im = np.array(img.convert("RGB")) boxes, logits, phrases = PKG["g_predict"]( model=_DINO_MODEL, image=im, caption=text_prompt, box_threshold=0.25, text_threshold=0.25 ) out=[] for b in boxes: x1,y1,x2,y2 = [int(x) for x in b.tolist()] out.append((x1,y1,x2,y2)) return out except Exception: return [] _SAM_PRED = None def _sam_mask(img: Image.Image, boxes: List[Tuple[int,int,int,int]]) -> Optional[Image.Image]: if not boxes: return None if PKG["sam_model_registry"] is None or PKG["SamPredictor"] is None or PKG["np"] is None: return None ckpt = os.getenv("SAM_WEIGHTS", str(ROOT/"sam_vit_h_4b8939.pth")) if not Path(ckpt).exists(): return None try: global _SAM_PRED if _SAM_PRED is None: sam = PKG["sam_model_registry"]["vit_h"](checkpoint=ckpt) _SAM_PRED = PKG["SamPredictor"](sam) np = PKG["np"] arr = np.array(img.convert("RGB")) _SAM_PRED.set_image(arr) H,W = arr.shape[:2] m_all = np.zeros((H,W), dtype=np.uint8) for (x1,y1,x2,y2) in boxes: box = PKG["np"].array([x1,y1,x2,y2]) masks, scores, _ = _SAM_PRED.predict(box=box, multimask_output=True) if masks is not None and len(masks)>0: m = (masks[scores.argmax()].astype("uint8")*255) m_all = PKG["np"].maximum(m_all, m) return Image.fromarray(m_all, mode="L") except Exception: return None def _lama_inpaint(img: Image.Image, mask: Image.Image) -> Image.Image: """ 우선 simple-lama-inpainting 사용, 실패 시 OpenCV로 폴백. ZeroGPU 안전: CPU만 사용. """ if mask is None: return img # 1) simple-lama-inpainting (선택 설치) try: from simple_lama_inpainting import SimpleLama import numpy as np, cv2 model = SimpleLama() # CPU 추론 src = np.array(img.convert("RGB")) m = np.array(mask.convert("L")) # simple-lama는 마스크가 255=인페인트 영역일 때 동작 if m.max() <= 1: m = (m * 255).astype("uint8") res = model(src, m) # (H,W,3) np.uint8 반환 return Image.fromarray(res) except Exception: pass # 2) OpenCV 폴백 try: import numpy as np, cv2 src = cv2.cvtColor(np.array(img.convert("RGB")), cv2.COLOR_RGB2BGR) m = np.array(mask.convert("L")) if m.max() <= 1: m = (m * 255).astype("uint8") # feather 조금 주면 경계 부드러움 m = cv2.GaussianBlur(m, (0,0), 1.2) dst = cv2.inpaint(src, (m>127).astype("uint8")*255, 3, cv2.INPAINT_TELEA) return Image.fromarray(cv2.cvtColor(dst, cv2.COLOR_BGR2RGB)) except Exception: return img def _refine_mask_with_morph(mask_pil: Image.Image, ksize: int = 5, dilate_iter: int = 1, erode_iter: int = 1) -> Image.Image: if PKG["cv2"] is None or PKG["np"] is None: return mask_pil cv2, np = PKG["cv2"], PKG["np"] m = np.array(mask_pil.convert("L")) k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (ksize, ksize)) m = cv2.dilate(m, k, iterations=dilate_iter) m = cv2.erode(m, k, iterations=erode_iter) m = cv2.GaussianBlur(m, (0, 0), 1.5) # feather return Image.fromarray(m.clip(0, 255).astype("uint8"), "L") def _filter_weapon_boxes(boxes: List[Tuple[int,int,int,int]], img_size: Tuple[int,int]) -> List[Tuple[int,int,int,int]]: W, H = img_size out = [] for (x1, y1, x2, y2) in boxes: w, h = max(1, x2 - x1), max(1, y2 - y1) area = w * h aspect = max(w, h) / max(1, min(w, h)) if area < (W * H * 0.005): # 너무 작은 건 버림(0.5%) continue if aspect < 2.2: # 창/장병기(길쭉함) 우선 continue out.append((x1, y1, x2, y2)) return out or boxes def _weaponless_pipeline(img: Image.Image, terms: str, logs: List[str]) -> Image.Image: boxes = _dino_boxes(img, terms or "weapon, sword, spear, lance, polearm, bow, gun, axe, dagger") if not boxes: logs.append("무기 탐지 실패 또는 DINO/SAM 미설치 → 무기 제거 스킵(프롬프트 가중만)") return img boxes = _filter_weapon_boxes(boxes, img.size) mask = _sam_mask(img, boxes) if mask is None: logs.append("SAM 마스크 생성 실패 → 무기 제거 스킵") return img mask = _refine_mask_with_morph(mask, ksize=5, dilate_iter=1, erode_iter=1) out = _lama_inpaint(img, mask) logs.append(f"무기 제거 완료 (boxes={len(boxes)})") return out # ---- T-POSE enforce def _draw_tpose_openpose_canvas(size=768) -> Image.Image: """간단 T포즈 스켈레톤 가이드 이미지(흑배경 흰선). ControlNet 힌트로 사용.""" img = Image.new("RGB", (size,size), "black") d = ImageDraw.Draw(img) cx, cy = size//2, int(size*0.6) arm = int(size*0.35); leg = int(size*0.35); head = int(size*0.06) # body d.line([ (cx, cy-int(size*0.25)), (cx, cy+int(size*0.05)) ], fill="white", width=6) # spine # arms (T) d.line([ (cx-arm, cy-int(size*0.20)), (cx+arm, cy-int(size*0.20)) ], fill="white", width=6) # legs d.line([ (cx, cy+int(size*0.05)), (cx-int(leg*0.6), cy+leg) ], fill="white", width=6) d.line([ (cx, cy+int(size*0.05)), (cx+int(leg*0.6), cy+leg) ], fill="white", width=6) # head d.ellipse([ (cx-head, cy-int(size*0.35)-head), (cx+head, cy-int(size*0.35)+head) ], outline="white", width=6) return img def _tpose_controlnet(img: Image.Image, logs: List[str], strength=0.6, steps=25, guidance=7.5) -> Image.Image: """ControlNet(OpenPose)으로 T포즈 강제 (설치 시). 실패 시 프롬프트만.""" if PKG["ControlNetModel"] is None or PKG["SD_CN_Img2Img"] is None or PKG["torch"] is None: logs.append("ControlNet 미설치 → T-포즈는 프롬프트로만 유도") return img try: dev = _device() cn = PKG["ControlNetModel"].from_pretrained( "lllyasviel/control_v11p_sd15_openpose", torch_dtype=PKG["torch"].float16 if dev=="cuda" else PKG["torch"].float32 ) pipe = PKG["SD_CN_Img2Img"].from_pretrained( "runwayml/stable-diffusion-v1-5", controlnet=cn, torch_dtype=PKG["torch"].float16 if dev=="cuda" else PKG["torch"].float32 ) if dev=="cuda": pipe.to("cuda") pose_canvas = _draw_tpose_openpose_canvas(size=max(img.size)) out = pipe( prompt="T-pose, full body, clean anime lines", image=img.convert("RGB"), control_image=pose_canvas, strength=float(strength), guidance_scale=float(guidance), num_inference_steps=int(steps) ).images[0] logs.append("ControlNet(OpenPose) T-포즈 적용") return out except Exception as e: logs.append(f"T-포즈 ControlNet 실패: {e}") return img # ---- img2img redraw(클린업) def _redraw(img: Image.Image, strength=0.5, steps=25, guidance=7.0) -> Image.Image: if PKG["sd_img2img"] is None or PKG["torch"] is None: return img try: dev = _device() pipe = PKG["sd_img2img"].from_pretrained( "runwayml/stable-diffusion-v1-5", torch_dtype=PKG["torch"].float16 if dev=="cuda" else PKG["torch"].float32 ) if dev=="cuda": pipe.to("cuda") out = pipe( prompt="clean anime illustration, sharp lines, simple solid background", image=img.convert("RGB"), strength=float(strength), guidance_scale=float(guidance), num_inference_steps=int(steps) ).images[0] return out except Exception: return img def step1_preprocess(img: Image.Image, keep_rembg: bool, do_weaponless: bool, weapon_terms: str, enforce_tpose: bool, tpose_strength: float, tpose_steps: int, tpose_guidance: float, do_redraw_flag: bool, redraw_strength: float, redraw_steps: int, redraw_guidance: float) -> Tuple[List[Image.Image], str, str]: logs=[] if img is None: raise gr.Error("이미지를 업로드하세요.") base = img.convert("RGBA") if keep_rembg: base = _remove_bg(base); logs.append("rembg 배경 제거") if do_weaponless: base = _weaponless_pipeline(base, weapon_terms, logs) if enforce_tpose: base = _tpose_controlnet(base, logs, strength=tpose_strength, steps=tpose_steps, guidance=tpose_guidance) if do_redraw_flag: base = _redraw(base, redraw_strength, redraw_steps, redraw_guidance) p = _save_png(base, OUT/"step1"/"input_preprocessed.png") return [base], p, "\n".join(logs) def step1_cpu(img, keep_rembg, do_weaponless, weapon_terms): """CPU 단계: rembg + (있으면) DINO/SAM/LaMa로 무기 제거. CUDA 사용 금지""" logs = [] if img is None: raise gr.Error("이미지를 업로드하세요.") base = img.convert("RGBA") # rembg (완전 투명 방지 포함) try: base2 = _remove_bg(base) if keep_rembg else base if keep_rembg: logs.append("rembg 배경 제거") base = base2 except Exception as e: logs.append(f"rembg 실패: {e}") # DINO/SAM/LaMa 무기 제거 try: if do_weaponless: base = _weaponless_pipeline(base, weapon_terms, logs) except Exception as e: logs.append(f"무기 제거 실패: {e}") # 파일 저장 out_path = _save_png(base, OUT / "step1" / "input_preprocessed.png") # 갤러리에는 보기 좋은 미리보기(배경 합성), 디버그는 파일 경로 그대로 preview = _to_preview(base) return [preview], str(out_path), "\n".join(logs), str(out_path) # ✅ 4개 반환 def _resize_to_multiple(img: Image.Image, multiple: int = 8, max_side: int = 768) -> Image.Image: """Aspect 유지 + 8의 배수 리사이즈 (최대 변은 max_side)""" w, h = img.size # 최대 변 제한 scale = min(1.0, float(max_side) / float(max(w, h))) w = int(w * scale); h = int(h * scale) # 8 배수로 내림 w = max(multiple, (w // multiple) * multiple) h = max(multiple, (h // multiple) * multiple) if (w, h) != img.size: img = img.resize((w, h), Image.BICUBIC) return img def _make_tpose_canvas_like(img: Image.Image) -> Image.Image: """입력과 동일 해상도의 T-포즈 가이드 캔버스 생성""" from PIL import ImageDraw w, h = img.size size = min(w, h) base = Image.new("RGB", (w, h), "black") square = Image.new("RGB", (size, size), "black") d = ImageDraw.Draw(square) cx, cy = size//2, int(size*0.58) arm = int(size*0.36); leg = int(size*0.36); head = int(size*0.06) # spine d.line([(cx, cy-int(size*0.28)), (cx, cy+int(size*0.04))], fill="white", width=10) # arms (T) yA = cy-int(size*0.22) d.line([(cx-arm, yA), (cx+arm, yA)], fill="white", width=10) # legs d.line([(cx, cy+int(size*0.04)), (cx-int(leg*0.65), cy+leg)], fill="white", width=10) d.line([(cx, cy+int(size*0.04)), (cx+int(leg*0.65), cy+leg)], fill="white", width=10) # head d.ellipse([(cx-head, yA-int(size*0.18)-head), (cx+head, yA-int(size*0.18)+head)], outline="white", width=10) # joints for pt in [(cx,yA), (cx-arm,yA), (cx+arm,yA), (cx,cy), (cx,cy+int(size*0.04))]: d.ellipse([(pt[0]-8,pt[1]-8), (pt[0]+8,pt[1]+8)], fill="white") offx = (w - size)//2; offy = (h - size)//2 base.paste(square, (offx, offy)) return base @spaces.GPU(duration=120) def step1_gpu_refine( s1_path: str, enforce_tpose: bool, tpose_strength: float, tpose_steps: int, tpose_guidance: float, do_redraw_flag: bool, redraw_strength: float, redraw_steps: int, redraw_guidance: float ): """ GPU 단계: ControlNet(OpenPose)로 T-포즈 강제 → (선택) img2img 리드로우. - ZeroGPU 규칙: torch/diffusers 로드는 이 함수 내부에서만! - image/control_image 해상도 동일 + 8의 배수로 강제. """ logs = [] if not s1_path or not Path(s1_path).exists(): raise gr.Error("STEP1 이미지가 없습니다. 먼저 STEP1(CPU)을 실행하세요.") # 항상 먼저 로드 (UnboundLocal 방지) img: PILImage.Image = PILImage.open(s1_path).convert("RGBA") (OUT/"step1").mkdir(parents=True, exist_ok=True) try: img.save(OUT/"step1"/"dbg_00_loaded.png") except Exception: pass # 안전 파라미터 클램프 tpose_strength = max(0.35, min(0.65, float(tpose_strength))) tpose_steps = int(max(12, min(28, int(tpose_steps)))) tpose_guidance = max(5.5, min(9.0, float(tpose_guidance))) redraw_strength = max(0.25, min(0.5, float(redraw_strength))) redraw_steps = int(max(12, min(28, int(redraw_steps)))) redraw_guidance = max(5.0, min(9.0, float(redraw_guidance))) # 디바이스 try: import torch dev = "cuda" if torch.cuda.is_available() else "cpu" dtype = torch.float16 if dev == "cuda" else torch.float32 except Exception: dev = "cpu"; dtype = None # type: ignore if enforce_tpose: try: import math, torch from PIL import Image from diffusers import ( ControlNetModel, StableDiffusionControlNetImg2ImgPipeline, DPMSolverMultistepScheduler ) from diffusers.utils import load_image from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel dev = "cuda" if torch.cuda.is_available() else "cpu" dtype = torch.float16 if dev == "cuda" else torch.float32 # --- 입력/캔버스 준비 --- base_rgb = _resize_to_multiple(img.convert("RGB"), multiple=8, max_side=512) # 원본 포즈 캔버스 + T포즈 캔버스 → 약블렌드(원본 80% : T 20%) pose_orig = _openpose_canvas_from_image(base_rgb) pose_t = _make_tpose_canvas_like(base_rgb) pose_canvas= _blend_pose_canvases(pose_orig, pose_t, alpha=0.20).resize(base_rgb.size) # --- Dual ControlNet: OpenPose + Reference-Only --- cn_pose = ControlNetModel.from_pretrained( "lllyasviel/control_v11p_sd15_openpose", torch_dtype=dtype ) cn_ref = ControlNetModel.from_pretrained( "lllyasviel/control_v11f1e_sd15_tile", torch_dtype=dtype ) # 참고: reference-only는 tile 모델에서 ref 모드로 동작합니다. controlnet = MultiControlNetModel([cn_pose, cn_ref]) pipe = StableDiffusionControlNetImg2ImgPipeline.from_pretrained( "runwayml/stable-diffusion-v1-5", controlnet=controlnet, torch_dtype=dtype, safety_checker=None, feature_extractor=None, ) pipe = _disable_safety(pipe) try: pipe.scheduler = DPMSolverMultistepScheduler.from_config( pipe.scheduler.config, use_karras_sigmas=True ) except Exception: pass if dev == "cuda": pipe.to("cuda") try: pipe.enable_vae_slicing() except Exception: pass # --- 컨디션 이미지 2개 준비 --- control_images = [ pose_canvas, # 0: 포즈 base_rgb # 1: 레퍼런스(색/텍스처) ] # --- 프롬프트 --- POS = ( "clean anime illustration, full body, sharp lines, same outfit and colors as reference, " "T-pose tendency, white studio background, bright, high-key lighting" ) NEG = ( "glitch, collage, cutout, fragments, abstract shapes, mosaic, compression artifacts, " "extra limbs, extra fingers, deformed, melted, noisy, text, watermark, black background" ) # --- 파라미터 (안정값) --- steps = int(max(16, min(28, int(tpose_steps)))) strength = float(max(0.50, min(0.65, float(tpose_strength)))) guidance = float(max(7.0, min(9.5, float(tpose_guidance)))) # controlnet 영향: [OpenPose, Reference] cond_scales = [0.22, 0.70] # 포즈는 약하게, 레퍼런스는 강하게 start_list = [0.05, 0.00] # 포즈는 초반부터, 레퍼런스는 전 구간 end_list = [0.35, 0.80] # 포즈는 중반까지만, 레퍼런스는 오래 # --- 실행 --- out = pipe( prompt=POS, negative_prompt=NEG, image=base_rgb, control_image=control_images, num_inference_steps=steps, strength=strength, guidance_scale=guidance, controlnet_conditioning_scale=cond_scales, control_guidance_start=start_list, control_guidance_end=end_list, guess_mode=True, # reference-only 모드: tile controlnet에 적용되는 힌트 토글 # (diffusers 0.29 기준, tile은 ref-like 역할로 충분) ).images[0].convert("RGBA") # --- 어두움 가드 + 밝기 리프트 --- if _mean_brightness(out) < 16: out = _lift_brightness(out, gain=1.18, gamma=0.90) if _mean_brightness(out) < 12: logs.append("T-포즈(DualCN) 결과가 어두워 원본 유지") else: img = out try: pose_canvas.save(OUT/"step1"/"dbg_pose_blend.png") img.save(OUT/"step1"/"dbg_03_after_dualcn.png") except Exception: pass logs.append("T-포즈(Dual-ControlNet) 적용: Pose 0.22 + Reference 0.70") except Exception as e: logs.append(f"T-포즈 Dual-ControlNet 실패: {e}") # 3) 프로ンプ트 (밝고 단순한 배경 + NSFW 방지 단어) POS = ( "T-pose tendency, full body, same outfit and colors, clean anime lines, " "consistent scale, white studio background, bright, high-key lighting" ) NEG = ( "black background, low-key lighting, extra limbs, extra fingers, deformed hands, " "melted face, distorted body, nsfw, cleavage, underwear, bikini, watermark, text, noisy" ) # 4) 아주 낮은 ControlNet 영향 + 짧은 적용 구간 # cond_scale 스케줄링: 초반 0.22 -> 후반 0.18 로 살짝 감쇠 def cond_scale_by_step(step, total): start, end = 0.22, 0.18 t = step / max(1,total-1) return end + (start - end) * (1.0 - t) # 선형 감소 steps = int(max(14, min(28, int(tpose_steps)))) strength = float(max(0.45, min(0.65, float(tpose_strength)))) guidance = float(max(7.0, min(9.5, float(tpose_guidance)))) # diffusers는 per-step cond_scale 스케줄이 직접 지원되지 않으므로 # 구간을 2번 호출로 나눠서 흉내낸다: [0~0.2] 구간 강하게, [0.2~0.35] 약하게 def run_pose(_img_rgb, scale, start, end, n_steps): return pipe_pose( prompt=POS, negative_prompt=NEG, image=_img_rgb, control_image=pose_canvas, strength=strength, guidance_scale=guidance, num_inference_steps=n_steps, controlnet_conditioning_scale=scale, control_guidance_start=[start], control_guidance_end=[end], guess_mode=True ).images[0].convert("RGBA") # 1차: 초반 유도 (0.05~0.20, scale 0.22) out_a = run_pose(base_rgb, scale=0.22, start=0.05, end=0.20, n_steps=math.ceil(steps*0.55)) # 2차: 중반 마무리 (0.20~0.35, scale 0.18) — 입력은 1차 결과 inter_rgb = _resize_to_multiple(out_a.convert("RGB"), multiple=8, max_side=512) out_b = run_pose(inter_rgb, scale=0.18, start=0.20, end=0.35, n_steps=steps - math.ceil(steps*0.55)) out = out_b # 6) 너무 어두우면 밝기 리프트 + 실패 시 원본 롤백 if _mean_brightness(out) < 16: out = _lift_brightness(out, gain=1.20, gamma=0.88) if _mean_brightness(out) < 12: logs.append("T-포즈(SafeMode) 결과가 어두워 원본 유지") else: img = out img.save(OUT/"step1"/"dbg_03_after_tpose.png") pose_canvas.save(OUT/"step1"/"dbg_pose_safemode.png") logs.append("T-포즈(SafeMode) 적용: 원본80%+T포즈20%, cond_scale↓, Karras DPM, 얼굴 보호") except Exception as e: logs.append(f"T-포즈 ControlNet 실패(SafeMode): {e}") # ---- (옵션) 리드로우(img2img) if do_redraw_flag: try: from diffusers import StableDiffusionImg2ImgPipeline pr = StableDiffusionImg2ImgPipeline.from_pretrained( "runwayml/stable-diffusion-v1-5", torch_dtype=dtype, safety_checker=None, feature_extractor=None ) pr = _disable_safety(pr) if dev == "cuda": pr.to("cuda") img_for = _resize_to_multiple(img.convert("RGB"), 8, 640) img = pr( prompt="clean anime illustration, sharp lines, flat colors, plain white background", negative_prompt="glitch, mosaic, text, watermark, noisy", image=img_for, strength=float(max(0.30, min(0.45, float(redraw_strength)))), guidance_scale=float(max(6.5, min(9.0, float(redraw_guidance)))), num_inference_steps=int(max(14, min(28, int(redraw_steps)))) ).images[0].convert("RGBA") img.save(OUT/"step1"/"dbg_05_after_redraw.png") logs.append("img2img 리드로우 적용") except Exception as e: logs.append(f"img2img 리드로우 실패: {e}") # ---- 저장 & 프리뷰 out_path = _save_png(img, OUT / "step1" / "input_preprocessed.png") try: preview = _to_preview(img) except Exception: preview = img.convert("RGB") # ✅ 반환: 갤러리(미리보기), 경로, 로그, 디버그(원본 경로 그대로 노출) return [preview], str(out_path), "\n".join(logs), str(out_path) # ====== (옵션) img2img 리드로우 ====== if do_redraw_flag: try: from diffusers import StableDiffusionImg2ImgPipeline pipe_redraw = StableDiffusionImg2ImgPipeline.from_pretrained( "runwayml/stable-diffusion-v1-5", torch_dtype=(torch.float16 if dev == "cuda" else torch.float32) ) if dev == "cuda": pipe_redraw.to("cuda") img_for_redraw = _resize_to_multiple(img.convert("RGB"), multiple=8, max_side=768) out = pipe_redraw( prompt="clean anime illustration, sharp lines, simple solid background", image=img_for_redraw, strength=float(redraw_strength), guidance_scale=float(redraw_guidance), num_inference_steps=int(redraw_steps), ).images[0] img = out.convert("RGBA") logs.append("img2img 리드로우 적용") except Exception as e: logs.append(f"img2img 리드로우 실패: {e}") # ====== 저장 & 갤러리 미리보기 ====== out_path = _save_png(img, OUT / "step1" / "input_preprocessed.png") try: preview = _to_preview(img) # 있으면 사용 except Exception: preview = img.convert("RGB") return [preview], str(out_path), "\n".join(logs) # --------------------------------- # STEP2: Spaces call (model + texture) # --------------------------------- def _compose_prompt(gender: str, weaponless: bool, extra: str, enforce_tpose: bool) -> str: seg = [] if gender and gender!="auto": seg.append(gender) if weaponless: seg += ["weaponless","no weapons"] if enforce_tpose: seg.append("T-pose") seg += ["anime character","clean lines","consistent style"] if extra: seg.append(extra) return ", ".join(seg) @spaces.GPU(duration=120) # 요청 시 GPU 확보 def step2_generate(space_key: str, custom_repo: str, steps: int, guidance: float, seed: int, s1_path: str, gender: str, weaponless: bool, enforce_tpose: bool, do_texture: bool, prompt_extra: str) -> Tuple[str, str, str]: if not s1_path or not Path(s1_path).exists(): raise gr.Error("STEP1 결과가 없습니다.") profile = SPACES[space_key] repo = profile["repo"] or custom_repo.strip() if not repo: raise gr.Error("커스텀 Space를 선택한 경우 레포를 입력하세요. 예) username/space") prompt = _compose_prompt(gender, weaponless, prompt_extra, enforce_tpose) # 캐시 경로 ck = _cache_key(s1_path, dict(steps=steps,guidance=guidance,seed=seed,space=repo,gender=gender,weaponless=weaponless,enforce_tpose=enforce_tpose,extra=prompt_extra)) glb_cache = OUT/"step2"/f"{ck}.glb" glb_tex_cache = OUT/"step2b"/f"{ck}.glb" if glb_cache.exists() and (not do_texture or glb_tex_cache.exists()): return str(glb_cache), (str(glb_tex_cache) if glb_tex_cache.exists() else ""), "cache hit" payload = {"prompt":prompt,"image":s1_path,"steps":int(steps),"guidance":float(guidance),"seed":int(seed),"glb":str(glb_cache)} last_err=None; glb=None for variant in profile["variants_model"]: try: res = _call_space(repo, profile["api_model"], variant, payload) glb = _pick_glb(res) if glb: break except Exception as e: last_err=e; continue if not glb: raise gr.Error(f"모델 생성 실패: {last_err}") try: if Path(glb).exists(): shutil.copy2(glb, glb_cache) except Exception: pass tex_log="" if do_texture and profile.get("api_texture"): payload2={"glb":str(glb_cache),"steps":int(steps),"guidance":float(guidance)} last2=None; glb2=None for var in profile["variants_texture"]: try: res = _call_space(repo, profile["api_texture"], var, payload2) glb2=_pick_glb(res) if glb2: break except Exception as e: last2=e; continue if glb2 and Path(glb2).exists(): shutil.copy2(glb2, glb_tex_cache); tex_log="texture ok" else: tex_log=f"texture skip/failed: {last2}" return str(glb_cache), (str(glb_tex_cache) if glb_tex_cache.exists() else ""), tex_log # --------------------------------- # STEP3: 6-view render + Blender autorig + FBX/VRM + Animator script # --------------------------------- def _normalize_mesh(mesh: "trimesh.Trimesh") -> "trimesh.Trimesh": # type: ignore m=mesh.copy(); b=m.bounds; size=(b[1]-b[0]).max() if size>0: m.apply_scale(1.0/float(size)); m.apply_translation(-m.centroid) return m def six_view_render(glb_path: str) -> Tuple[List[str], str, str]: if not Path(glb_path).exists(): raise gr.Error("GLB가 없습니다.") if PKG["trimesh"] is None or PKG["pyrender"] is None: info = OUT/"step3"/"RENDER_INFO.txt"; info.write_text("pip install trimesh pyrender PyOpenGL\n") return [], "", "trimesh/pyrender 미설치" import trimesh, pyrender, numpy as np scene = pyrender.Scene(bg_color=[0,0,0,0]); outs=[] try: mesh = trimesh.load(glb_path) if isinstance(mesh, trimesh.Scene): mesh = trimesh.util.concatenate(mesh.dump()) mesh = _normalize_mesh(mesh) node = scene.add(pyrender.Mesh.from_trimesh(mesh, smooth=True)) scene.add(pyrender.DirectionalLight(intensity=3.0)) rnd = pyrender.OffscreenRenderer(768,768) views=[(0,0),(0,180),(0,90),(0,-90),(45,0),(-45,0)] for i,(elev,az) in enumerate(views): cam = pyrender.PerspectiveCamera(yfov=60*math.pi/180); cn = scene.add(cam) r=2.2; phi=math.radians(90-elev); th=math.radians(az) x=r*math.sin(phi)*math.cos(th); y=r*math.cos(phi); z=r*math.sin(phi)*math.sin(th) pose = trimesh.transformations.look_at(eye=[x,y,z], target=[0,0,0], up=[0,1,0]) scene.set_pose(cn, pose); color,_ = rnd.render(scene) p = OUT/"step3"/f"view_{i+1}.png"; Image.fromarray(color).save(p); outs.append(str(p)); scene.remove_node(cn) rnd.delete(); scene.remove_node(node) z = OUT/"step3"/"six_views.zip" with zipfile.ZipFile(z,"w") as zf: for p in outs: zf.write(p, Path(p).name) return outs, str(z), "ok" except Exception as e: err = OUT/"step3"/"RENDER_ERROR.txt"; err.write_text(f"{e}\n{traceback.format_exc()}"); return [], "", f"render err: {e}" def _write_blender_script(tmp_py: Path, src_glb: str, out_fbx: str, out_vrm: Optional[str], add_bs: bool): tmp_py.write_text(textwrap.dedent(f""" import bpy, os src=r'''{src_glb}'''; outfbx=r'''{out_fbx}'''; outvrm=r'''{out_vrm or ""}'''; add={str(bool(add_bs))} bpy.ops.wm.read_homefile(use_empty=True) bpy.ops.import_scene.gltf(filepath=src) meshes=[o for o in bpy.context.scene.objects if o.type=='MESH'] if not meshes: raise RuntimeError("no mesh") obj=meshes[0] bpy.ops.object.armature_add(enter_editmode=False, location=(0,0,0)) arm=bpy.context.active_object bpy.ops.object.select_all(action='DESELECT'); obj.select_set(True); arm.select_set(True); bpy.context.view_layer.objects.active=arm bpy.ops.object.parent_set(type='ARMATURE_AUTO') if add and obj.type=='MESH': if not obj.data.shape_keys: obj.shape_key_add(name='Basis') s=obj.shape_key_add(name='Smile'); a=obj.shape_key_add(name='Angry'); u=obj.shape_key_add(name='Surprised') for v in obj.data.vertices: s.data[v.index].co.y+=0.01; a.data[v.index].co.x-=0.01; u.data[v.index].co.z+=0.01 bpy.ops.export_scene.fbx(filepath=outfbx, use_active_collection=False, apply_unit_scale=True, bake_space_transform=True, object_types={{'ARMATURE','MESH'}}, add_leaf_bones=False, path_mode='AUTO') if outvrm: try: bpy.ops.export_scene.vrm(filepath=outvrm) except Exception as e: print("VRM export failed:", e) """)) def _run_blender(glb: str, add_bs: bool, do_vrm: bool) -> Tuple[str,str,str]: blender = os.getenv("BLENDER_PATH","blender") outfbx = OUT/"exports"/"character_unity.fbx" outvrm = OUT/"exports"/"character.vrm" if do_vrm else None script = Path(tempfile.gettempdir())/f"rig_{int(time.time())}.py" _write_blender_script(script, glb, str(outfbx), (str(outvrm) if outvrm else ""), add_bs) try: subprocess.run([blender,"--background","--python",str(script)], check=True) return str(outfbx), (str(outvrm) if outvrm and Path(outvrm).exists() else ""), "ok" except Exception as e: return "", "", f"blender err: {e}" finally: try: script.unlink(missing_ok=True) except Exception: pass def _write_unity_animator_cs() -> str: cs = OUT/"exports"/"CreateCharacterAnimator.cs" cs.write_text(textwrap.dedent(r''' using UnityEditor; using UnityEngine; using UnityEditor.Animations; public class CreateCharacterAnimator : MonoBehaviour { [MenuItem("Tools/Generate Character Animator")] static void Generate() { var ctrl = AnimatorController.CreateAnimatorControllerAtPath("Assets/character_controller.controller"); var root = ctrl.layers[0].stateMachine; var idle = ctrl.AddMotion(new AnimationClip()); idle.name="Idle"; var s=root.AddState("Idle"); s.motion=idle; var sm = ctrl.AddMotion(new AnimationClip()); sm.name="Smile"; var stS=root.AddState("Smile"); stS.motion=sm; var ag = ctrl.AddMotion(new AnimationClip()); ag.name="Angry"; var stA=root.AddState("Angry"); stA.motion=ag; var su = ctrl.AddMotion(new AnimationClip()); su.name="Surprised"; var stU=root.AddState("Surprised"); stU.motion=su; ctrl.AddParameter("Smile", AnimatorControllerParameterType.Trigger); ctrl.AddParameter("Angry", AnimatorControllerParameterType.Trigger); ctrl.AddParameter("Surprised", AnimatorControllerParameterType.Trigger); var t1 = s.AddTransition(stS); t1.AddCondition(AnimatorConditionMode.If,0,"Smile"); t1.hasExitTime=false; var t2 = s.AddTransition(stA); t2.AddCondition(AnimatorConditionMode.If,0,"Angry"); t2.hasExitTime=false; var t3 = s.AddTransition(stU); t3.AddCondition(AnimatorConditionMode.If,0,"Surprised"); t3.hasExitTime=false; Debug.Log("Animator created at Assets/character_controller.controller"); } }'''), encoding="utf-8") return str(cs) def step3_all(glb_model: str, glb_tex: str, add_bs: bool, do_vrm: bool) -> Tuple[List[Tuple[str,str]], str, str, str, str]: glb = glb_tex if glb_tex and Path(glb_tex).exists() else glb_model if not glb or not Path(glb).exists(): raise gr.Error("GLB가 없습니다. STEP2를 먼저 실행하세요.") views, zip_path, rlog = six_view_render(glb) fbx, vrm, blog = _run_blender(glb, add_bs, do_vrm) cs = _write_unity_animator_cs() gallery=[(p, Path(p).name) for p in views] log = "\n".join(filter(None, [rlog, blog])) return gallery, (zip_path if zip_path else ""), (fbx if fbx else ""), (vrm if vrm else ""), cs # --------------------------------- # Gradio UI # --------------------------------- with gr.Blocks() as demo: gr.Markdown("## Pixel→(rembg / **Weaponless** / **T-Pose** / Redraw)→Hunyuan3D(genshin)→**6-View**→AutoRig(FBX/VRM)+BlendShapes→Unity Animator") with gr.Row(): space_sel = gr.Dropdown(choices=list(SPACES.keys()), value="genshin (main)", label="Space 선택") custom_repo = gr.Textbox(label="커스텀 Space (선택, 일 때)", placeholder="username/space-name") steps = gr.Slider(5, 100, value=28, step=1, label="steps") guidance = gr.Slider(1.0, 20.0, value=7.5, step=0.5, label="guidance") seed = gr.Number(value=0, precision=0, label="seed (0=랜덤)") with gr.Tab("STEP 1 — 전처리"): with gr.Row(): s1_img = gr.Image(type="pil", label="입력 이미지") s1_gallery = gr.Gallery(label="전처리 미리보기", columns=3, height=220) with gr.Row(): keep_rembg = gr.Checkbox(value=True, label="배경 제거(rembg)") do_weaponless = gr.Checkbox(value=True, label="무기 제거 (DINO+SAM+LaMa)") weapon_terms = gr.Textbox(value="weapon, sword, spear, lance, polearm, bow, gun, axe, dagger", label="무기 키워드") enforce_tpose = gr.Checkbox(value=True, label="T-포즈 강제 (ControlNet/OpenPose)") with gr.Row(): tpose_strength = gr.Slider(0.1, 0.9, value=0.6, step=0.05, label="T-포즈 강도") tpose_steps = gr.Slider(5, 50, value=25, step=1, label="T-포즈 steps") tpose_guidance = gr.Slider(1.0, 15.0, value=7.5, step=0.5, label="T-포즈 guidance") with gr.Row(): do_redraw_flag = gr.Checkbox(value=False, label="리드로우(img2img)") redraw_strength = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="리드로우 강도") redraw_steps = gr.Slider(5, 50, value=25, step=1, label="리드로우 steps") redraw_guidance = gr.Slider(1.0, 15.0, value=7.0, step=0.5, label="리드로우 guidance") with gr.Row(): gender = gr.Dropdown(choices=["auto","female","male","androgynous"], value="auto", label="성별") extra = gr.Textbox(value="", label="프롬프트 추가(선택)") s1_btn = gr.Button("STEP1 실행", variant="primary") s1_path = gr.Textbox(label="STEP1 결과 경로", interactive=False) s1_log = gr.Textbox(label="STEP1 로그", interactive=False) dbg_pre = gr.Image(label="전처리 이미지 확인(파일 그대로)", type="filepath") # ✅ 새로 추가 # CPU → (then) GPU 체인. 반환 4개: [미리보기], 경로, 로그, 디버그 파일경로 s1_btn.click( step1_cpu, inputs=[s1_img, keep_rembg, do_weaponless, weapon_terms], outputs=[s1_gallery, s1_path, s1_log, dbg_pre] ).then( step1_gpu_refine, inputs=[s1_path, enforce_tpose, tpose_strength, tpose_steps, tpose_guidance, do_redraw_flag, redraw_strength, redraw_steps, redraw_guidance], outputs=[s1_gallery, s1_path, s1_log, dbg_pre] ) with gr.Tab("STEP 2 — 3D 생성 (모델/텍스처)"): do_texture = gr.Checkbox(value=True, label="텍스처 단계 실행(지원 시)") s2_btn = gr.Button("STEP2 실행") glb_out = gr.Textbox(label="GLB(모델)", interactive=False) glb_tex_out = gr.Textbox(label="GLB(텍스처)", interactive=False) s2_log = gr.Textbox(label="STEP2 로그", interactive=False) s2_btn.click(step2_generate, inputs=[space_sel, custom_repo, steps, guidance, seed, s1_path, gender, do_weaponless, enforce_tpose, do_texture, extra], outputs=[glb_out, glb_tex_out, s2_log]) with gr.Tab("STEP 3 — 6뷰/오토리깅/Unity"): add_bs = gr.Checkbox(value=True, label="기본 BlendShapes(Smile/Angry/Surprised)") do_vrm = gr.Checkbox(value=False, label="VRM 내보내기(애드온 필요)") s3_btn = gr.Button("STEP3 실행") s3_gallery = gr.Gallery(label="6-View Render", columns=3, height=220) s3_zip = gr.File(label="6뷰 ZIP") s3_fbx = gr.File(label="Unity FBX") s3_vrm = gr.File(label="VRM(옵션)") s3_cs = gr.File(label="Unity Animator C#") s3_btn.click(step3_all, inputs=[glb_out, glb_tex_out, add_bs, do_vrm], outputs=[s3_gallery, s3_zip, s3_fbx, s3_vrm, s3_cs]) # ---- SSR 끄기 & queue 인자 호환 if __name__ == "__main__": # 옵션: 캐시 경로 명시 (Transformers 이주 로그 억제) os.environ.setdefault("HF_HOME", str((ROOT/".hf").resolve())) os.environ.setdefault("TRANSFORMERS_CACHE", str((ROOT/".hf"/"transformers").resolve())) demo.queue() # no concurrency_count (버전 호환) demo.launch(server_name="0.0.0.0", server_port=int(os.environ.get("PORT","7860")), ssr_mode=False, share=False)