Spaces:
Running on Zero
Running on Zero
Download app.py from alrobles/smooth_gen: direct link, hf CLI and curl.
- Browser
- Download file 29 kB
-
https://huggingface.co/spaces/alrobles/smooth_gen/resolve/main/app.py
- Command line
-
hf download hf://spaces/alrobles/smooth_gen/app.py
-
curl -L -o app.py https://huggingface.co/spaces/alrobles/smooth_gen/resolve/main/app.py
29 kB
| """ | |
| Stop-motion Studio — un solo archivo, tres capacidades: | |
| A) Fluidez: dedupe de poses -> deflicker -> RIFE (lo que ya funcionó) | |
| B) Limpieza: detecta manos (YOLO) y/o zona rectangular -> LaMa inpaint | |
| C) Transiciones: FLF2V generativo entre el final de un clip y el inicio | |
| del siguiente, encadenando N clips en una secuencia. | |
| Orden recomendado: B (limpiar) -> A (suavizar) -> C (encadenar). | |
| """ | |
| import os | |
| import shutil | |
| import subprocess | |
| import sys | |
| import tempfile | |
| import uuid | |
| from pathlib import Path | |
| import gradio as gr | |
| import numpy as np | |
| from PIL import Image | |
| from imageio_ffmpeg import get_ffmpeg_exe | |
| try: | |
| import spaces | |
| HAS_SPACES = True | |
| except Exception: | |
| HAS_SPACES = False | |
| try: | |
| import torch | |
| HAS_TORCH = True | |
| except Exception: | |
| HAS_TORCH = False | |
| try: | |
| import cv2 | |
| HAS_CV2 = True | |
| except Exception: | |
| HAS_CV2 = False | |
| FFMPEG = get_ffmpeg_exe() | |
| WORK = Path(tempfile.gettempdir()) / "smstudio" | |
| WORK.mkdir(parents=True, exist_ok=True) | |
| MAX_SIDE = 1280 | |
| THUMB = (96, 54) | |
| MAX_POSES = 400 | |
| MAX_OUT_FRAMES = 1500 | |
| MAX_SEQ_CLIPS = 6 | |
| RIFE_SPACE = "X-HighVoltage-X/RIFE-Video-Frame-Interpolation" | |
| RIFE_WEIGHTS = ("r3gm/RIFE", "RIFEv4.26_0921.zip") | |
| FLF_SPACE = "dream2589632147/Dream-wan2-2-fp8da-aoti-preview-2" | |
| HAND_MODEL = ("Bingsu/adetailer", "hand_yolov8n.pt") | |
| # ========================================================================== | |
| # Vídeo I/O | |
| # ========================================================================== | |
| def extract_frames(video_path, out_dir, max_side=MAX_SIDE, fps=None): | |
| out_dir = Path(out_dir) | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| vf = ("scale=w='if(gte(iw,ih),min({0},iw),-2)':" | |
| "h='if(gte(iw,ih),-2,min({0},ih))'").format(max_side) | |
| if fps: | |
| vf = "fps={},{}".format(fps, vf) | |
| cmd = [FFMPEG, "-y", "-i", str(video_path), "-vf", vf, | |
| "-fps_mode", "passthrough", "-pix_fmt", "rgb24", | |
| str(out_dir / "%05d.png")] | |
| p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) | |
| frames = sorted(out_dir.glob("*.png")) | |
| if p.returncode != 0 or not frames: | |
| raise gr.Error("No pude decodificar el vídeo. Recomplímelo a H.264 " | |
| "(iPhone: Atajos > Codificar multimedia > HD 1080p).\n\n" | |
| + p.stderr.decode(errors="ignore")[-400:]) | |
| return frames | |
| def encode_png_sequence(sequence_dir, fps, out_path): | |
| cmd = [FFMPEG, "-y", "-framerate", str(fps), | |
| "-i", str(Path(sequence_dir) / "%05d.png"), | |
| "-c:v", "libx264", "-preset", "fast", "-crf", "16", | |
| "-pix_fmt", "yuv420p", "-movflags", "+faststart", str(out_path)] | |
| p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) | |
| if p.returncode != 0: | |
| raise gr.Error("Fallo al montar el vídeo:\n" | |
| + p.stderr.decode(errors="ignore")[-500:]) | |
| def encode_numpy_frames(frames, fps, out_path): | |
| h, w = frames[0].shape[:2] | |
| cmd = [FFMPEG, "-y", "-f", "rawvideo", "-pix_fmt", "rgb24", | |
| "-s", "{}x{}".format(w, h), "-r", str(fps), "-i", "-", | |
| "-c:v", "libx264", "-preset", "fast", "-crf", "16", | |
| "-pix_fmt", "yuv420p", "-movflags", "+faststart", str(out_path)] | |
| p = subprocess.Popen(cmd, stdin=subprocess.PIPE, | |
| stdout=subprocess.DEVNULL, stderr=subprocess.PIPE) | |
| try: | |
| for fr in frames: | |
| p.stdin.write(fr.tobytes()) | |
| p.stdin.close() | |
| except BrokenPipeError: | |
| pass | |
| err = p.stderr.read().decode(errors="ignore")[-500:] | |
| if p.wait() != 0: | |
| raise gr.Error("Fallo al codificar:\n" + err) | |
| def read_pngs(paths): | |
| out = [] | |
| for p in paths: | |
| with Image.open(p) as im: | |
| out.append(np.asarray(im.convert("RGB"), dtype=np.uint8)) | |
| return out | |
| def write_pngs(frames, out_dir): | |
| out_dir = Path(out_dir) | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| for i, fr in enumerate(frames, start=1): | |
| Image.fromarray(fr).save(out_dir / ("%05d.png" % i)) | |
| return sorted(out_dir.glob("*.png")) | |
| def thumb(path): | |
| with Image.open(path) as im: | |
| g = im.convert("L").resize(THUMB, Image.BILINEAR) | |
| return np.asarray(g, dtype=np.float32) | |
| def dedupe_poses(frames, threshold): | |
| kept = [frames[0]] | |
| last = thumb(frames[0]) | |
| for f in frames[1:]: | |
| t = thumb(f) | |
| if float(np.abs(t - last).mean()) > threshold: | |
| kept.append(f) | |
| last = t | |
| return kept | |
| def deflicker_frames(kept, out_dir): | |
| out_dir = Path(out_dir) | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| lums = [] | |
| for p in kept: | |
| with Image.open(p) as im: | |
| lums.append(float(np.asarray(im.convert("L"), np.float32).mean())) | |
| target = float(np.median(lums)) | |
| result = [] | |
| for i, p in enumerate(kept): | |
| with Image.open(p) as im: | |
| arr = np.asarray(im.convert("RGB"), np.float32) | |
| if lums[i] > 1.0: | |
| arr = np.clip(arr * min(1.25, max(0.80, target / lums[i])), 0, 255) | |
| dst = out_dir / ("%05d.png" % (i + 1)) | |
| Image.fromarray(arr.astype(np.uint8)).save(dst) | |
| result.append(dst) | |
| return result | |
| # ========================================================================== | |
| # RIFE | |
| # ========================================================================== | |
| _NET = None | |
| def _rife_pkg_dir(): | |
| base = Path(tempfile.gettempdir()) / "rife_pkg" | |
| if (base / "train_log" / "IFNet_HDv3.py").exists(): | |
| return base | |
| from huggingface_hub import snapshot_download | |
| src = Path(snapshot_download(RIFE_SPACE, repo_type="space", | |
| allow_patterns=["model/*", "train_log/*"])) | |
| base.mkdir(parents=True, exist_ok=True) | |
| for sub in ("model", "train_log"): | |
| s = src / sub | |
| if s.exists() and not (base / sub).exists(): | |
| shutil.copytree(s, base / sub) | |
| return base | |
| def _load_net(): | |
| global _NET | |
| if _NET is not None: | |
| return _NET | |
| import zipfile | |
| from huggingface_hub import hf_hub_download | |
| base = _rife_pkg_dir() | |
| if str(base) not in sys.path: | |
| sys.path.insert(0, str(base)) | |
| from train_log.IFNet_HDv3 import IFNet | |
| zip_path = hf_hub_download(RIFE_WEIGHTS[0], RIFE_WEIGHTS[1]) | |
| wf = Path(tempfile.gettempdir()) / "rife_w" / "flownet.pkl" | |
| if not wf.exists(): | |
| wf.parent.mkdir(parents=True, exist_ok=True) | |
| with zipfile.ZipFile(zip_path) as z: | |
| for name in z.namelist(): | |
| if name.endswith("flownet.pkl"): | |
| with z.open(name) as s, open(wf, "wb") as d: | |
| shutil.copyfileobj(s, d) | |
| break | |
| state = torch.load(str(wf), map_location="cpu") | |
| if any("module." in k for k in state): | |
| state = {k.replace("module.", ""): v for k, v in state.items() | |
| if "module." in k} | |
| net = IFNet() | |
| res = net.load_state_dict(state, strict=False) | |
| if len(res.missing_keys) > 3: | |
| raise RuntimeError("Pesos RIFE incompletos") | |
| net.eval() | |
| _NET = net | |
| return net | |
| def _interp_worker(frames, mult): | |
| net = _load_net() | |
| device = "cuda" if torch.cuda.is_available() else "cpu" | |
| if device == "cpu": | |
| raise RuntimeError("Sin GPU") | |
| net = net.to(device) | |
| h, w = frames[0].shape[:2] | |
| ph, pw = ((h - 1) // 64 + 1) * 64, ((w - 1) // 64 + 1) * 64 | |
| def to_t(fr): | |
| t = torch.from_numpy(fr).to(device).permute(2, 0, 1).float().unsqueeze(0) / 255.0 | |
| return torch.nn.functional.pad(t, (0, pw - w, 0, ph - h)) | |
| out = [] | |
| with torch.inference_mode(): | |
| for i in range(len(frames) - 1): | |
| t0, t1 = to_t(frames[i]), to_t(frames[i + 1]) | |
| out.append(frames[i]) | |
| for k in range(1, mult): | |
| _, _, merged = net(torch.cat((t0, t1), 1), k / mult, [16, 8, 4, 2, 1]) | |
| fr = merged[-1][0][:, :h, :w].permute(1, 2, 0) * 255.0 | |
| out.append(fr.clamp(0, 255).byte().cpu().numpy()) | |
| del t0, t1 | |
| out.append(frames[-1]) | |
| if torch.cuda.is_available(): | |
| torch.cuda.empty_cache() | |
| return out | |
| # ========================================================================== | |
| # Limpieza: YOLO manos + LaMa | |
| # ========================================================================== | |
| _YOLO = None | |
| _LAMA = None | |
| def _get_yolo(): | |
| global _YOLO | |
| if _YOLO is None: | |
| from huggingface_hub import hf_hub_download | |
| from ultralytics import YOLO | |
| _YOLO = YOLO(hf_hub_download(HAND_MODEL[0], HAND_MODEL[1])) | |
| return _YOLO | |
| def _get_lama(): | |
| global _LAMA | |
| if _LAMA is not None: | |
| return _LAMA | |
| subprocess.run([sys.executable, "-m", "pip", "install", "--no-deps", "-q", | |
| "simple-lama-inpainting==0.1.2"], check=False) | |
| try: | |
| from simple_lama_inpainting import SimpleLama | |
| dev = "cuda" if torch.cuda.is_available() else "cpu" | |
| try: | |
| _LAMA = ("lama", SimpleLama(device=torch.device(dev))) | |
| except TypeError: | |
| m = SimpleLama() | |
| if hasattr(m, "model"): | |
| m.model.to(dev) | |
| _LAMA = ("lama", m) | |
| except Exception: | |
| _LAMA = ("cv2", None) | |
| return _LAMA | |
| def _inpaint(arr, mask, engine): | |
| kind, model = engine | |
| if kind == "lama": | |
| out = model(Image.fromarray(arr), Image.fromarray(mask)) | |
| return np.asarray(out.convert("RGB"), dtype=np.uint8) | |
| bgr = cv2.cvtColor(arr, cv2.COLOR_RGB2BGR) | |
| fixed = cv2.inpaint(bgr, mask, 3, cv2.INPAINT_TELEA) | |
| return cv2.cvtColor(fixed, cv2.COLOR_BGR2RGB) | |
| def _clean_worker(frames, use_hands, dilate_px, rect, ext_mask): | |
| if not HAS_CV2: | |
| raise RuntimeError("cv2 no disponible") | |
| yolo = _get_yolo() if use_hands else None | |
| engine = _get_lama() | |
| out, touched = [], 0 | |
| for arr in frames: | |
| mask = np.zeros(arr.shape[:2], np.uint8) | |
| if rect is not None: | |
| mask = np.maximum(mask, rect) | |
| if ext_mask is not None: | |
| if ext_mask.shape != mask.shape: | |
| ext_mask = cv2.resize(ext_mask, (mask.shape[1], mask.shape[0]), | |
| interpolation=cv2.INTER_NEAREST) | |
| mask = np.maximum(mask, ext_mask) | |
| if yolo is not None: | |
| for r in yolo.predict(arr, verbose=False, conf=0.25): | |
| if r.boxes is None: | |
| continue | |
| for b in r.boxes.xyxy.cpu().numpy().astype(int): | |
| x1, y1, x2, y2 = b | |
| mask[max(0, y1):y2, max(0, x1):x2] = 255 | |
| if dilate_px and dilate_px > 0: | |
| k = np.ones((int(dilate_px) * 2 + 1,) * 2, np.uint8) | |
| mask = cv2.dilate(mask, k) | |
| if int(mask.max()) == 0: | |
| out.append(arr) | |
| continue | |
| out.append(_inpaint(arr, mask, engine)) | |
| touched += 1 | |
| return out, touched | |
| if HAS_SPACES: | |
| _clean_gpu = spaces.GPU(duration=120)(_clean_worker) | |
| _interp_gpu = spaces.GPU(duration=120)(_interp_worker) | |
| else: | |
| _clean_gpu = _clean_worker | |
| _interp_gpu = _interp_worker | |
| # ========================================================================== | |
| # Puente generativo (FLF2V por API) | |
| # ========================================================================== | |
| def _client(space_id, token="", request=None): | |
| """Orden de búsqueda del token: | |
| 1) campo de la UI 2) sesión del navegador (x-ip-token) 3) secreto. | |
| """ | |
| from gradio_client import Client | |
| tok = (token or "").strip() | |
| if not tok and request is not None: | |
| try: | |
| tok = request.headers.get("x-ip-token", "") or "" | |
| except Exception: | |
| tok = "" | |
| if not tok: | |
| tok = os.environ.get("HF_TOKEN", "") or "" | |
| if tok: | |
| return Client(space_id.strip(), headers={"x-ip-token": tok}) | |
| return Client(space_id.strip()) | |
| def _pick_endpoint(cli): | |
| """Elige el endpoint de generación. Primero candidatos conocidos, | |
| luego heurística: un endpoint con 2 imágenes + prompt.""" | |
| try: | |
| info = cli.view_api(return_format="dict") | |
| named = info.get("named_endpoints", {}) or {} | |
| except Exception: | |
| return None | |
| for cand in ("/generate_video", "/flf2v", "/generate", "/predict"): | |
| if cand in named: | |
| return cand | |
| for name, meta in named.items(): | |
| pn = [(p.get("parameter_name") or p.get("name") or "").lower() | |
| for p in meta.get("parameters", [])] | |
| has_first = any("first" in n for n in pn) | |
| has_last = any(("last" in n) or n.endswith("_end") for n in pn) | |
| has_prompt = any("prompt" in n and "negative" not in n for n in pn) | |
| if has_first and has_last and has_prompt: | |
| return name | |
| return None | |
| def _build_args(cli, api, start_png, end_png, prompt, duration): | |
| """Construye la lista COMPLETA de argumentos posicionales según el schema | |
| del endpoint. Así funciona con endpoints de 3 o de 24 parámetros.""" | |
| from gradio_client import handle_file | |
| info = cli.view_api(return_format="dict") | |
| params = info["named_endpoints"][api].get("parameters", []) | |
| args = [] | |
| for p in params: | |
| pn = (p.get("parameter_name") or p.get("name") or "").lower() | |
| if "first" in pn: | |
| args.append(handle_file(start_png)) | |
| elif "last" in pn: | |
| args.append(handle_file(end_png)) | |
| elif "negative" in pn: | |
| args.append(p.get("parameter_default")) | |
| elif "prompt" in pn: | |
| args.append(prompt) | |
| elif "generation_mode" in pn or pn in ("mode", "task"): | |
| args.append("First + Last Frame") | |
| elif "duration" in pn: | |
| args.append(float(duration)) | |
| elif "safe_mode" in pn: | |
| args.append(True) | |
| elif p.get("parameter_has_default"): | |
| args.append(p.get("parameter_default")) | |
| else: | |
| args.append(None) | |
| return args | |
| def _find_video(obj): | |
| if isinstance(obj, str): | |
| low = obj.lower() | |
| if low.endswith((".mp4", ".webm", ".mov", ".gif")): | |
| return obj | |
| return None | |
| if isinstance(obj, dict): | |
| for v in obj.values(): | |
| r = _find_video(v) | |
| if r: | |
| return r | |
| return None | |
| if isinstance(obj, (list, tuple)): | |
| for v in obj: | |
| r = _find_video(v) | |
| if r: | |
| return r | |
| return None | |
| def call_flf2v(space_id, token, start_png, end_png, prompt, api_override, | |
| request=None, duration=3.5): | |
| cli = _client(space_id, token, request) | |
| api = (api_override or "").strip() or _pick_endpoint(cli) | |
| if not api: | |
| raise gr.Error( | |
| "No encontré un endpoint de generación en ese Space. Abre su " | |
| "pestaña 'Use via API' y pega el nombre exacto en el campo API." | |
| ) | |
| args = _build_args(cli, api, start_png, end_png, prompt, duration) | |
| res = cli.predict(*args, api_name=api) | |
| vid = _find_video(res) | |
| if not vid: | |
| raise gr.Error("El Space respondió pero no devolvió un vídeo.") | |
| return vid | |
| def _median_frame(paths): | |
| stack = np.stack([np.asarray(Image.open(p).convert("RGB"), np.float32) | |
| for p in paths]) | |
| return Image.fromarray(np.median(stack, axis=0).astype(np.uint8)) | |
| # ========================================================================== | |
| # Tarea A: fluidez | |
| # ========================================================================== | |
| def task_fluidez(video, sensitivity, pose_fps, mult, do_deflicker, do_rife, | |
| progress=gr.Progress()): | |
| if video is None: | |
| raise gr.Error("Sube un vídeo.") | |
| job = WORK / uuid.uuid4().hex[:10] | |
| frames = extract_frames(video, job / "raw") | |
| progress(0.25, desc="Detectando poses") | |
| thr = 0.5 + (100.0 - float(sensitivity)) * 0.15 | |
| kept = dedupe_poses(frames, thr) | |
| if len(kept) < 3: | |
| raise gr.Error("Solo {} poses. Sube la sensibilidad.".format(len(kept))) | |
| if len(kept) > MAX_POSES: | |
| raise gr.Error("{} poses, demasiadas. Baja la sensibilidad.".format(len(kept))) | |
| if do_deflicker: | |
| progress(0.4, desc="Igualando exposición") | |
| kept = deflicker_frames(kept, job / "poses") | |
| else: | |
| pose_dir = job / "poses" | |
| pose_dir.mkdir(parents=True, exist_ok=True) | |
| for i, p in enumerate(kept): | |
| shutil.copy(p, pose_dir / ("%05d.png" % (i + 1))) | |
| progress(0.5, desc="Montando poses") | |
| poses_video = job / "poses.mp4" | |
| encode_png_sequence(job / "poses", pose_fps, poses_video) | |
| final, done, warn = poses_video, False, "" | |
| if do_rife: | |
| paths = sorted((job / "poses").glob("*.png")) | |
| if len(paths) * int(mult) > MAX_OUT_FRAMES: | |
| warn = "Interpolación omitida: demasiados frames." | |
| else: | |
| progress(0.6, desc="Interpolando (RIFE)") | |
| try: | |
| out = _interp_gpu(read_pngs(paths), int(mult)) | |
| final = job / "final.mp4" | |
| encode_numpy_frames(out, float(pose_fps) * int(mult), final) | |
| done = True | |
| except Exception as exc: | |
| warn = "RIFE no disponible ({}). Usa el vídeo de poses.".format( | |
| type(exc).__name__) | |
| fps_txt = "{} fps".format(int(pose_fps) * int(mult)) if done else "{} fps".format(pose_fps) | |
| info = ("### Hecho\n- Frames leídos: **{}**\n- Poses: **{}**\n" | |
| "- Salida: **{}**\n- Deflicker: **{}** | RIFE x{}: **{}**\n{}" | |
| ).format(len(frames), len(kept), fps_txt, | |
| "sí" if do_deflicker else "no", mult, | |
| "sí" if done else "no", | |
| ("\n\n> ⚠️ " + warn) if warn else "") | |
| return str(final), str(poses_video), info | |
| # ========================================================================== | |
| # Tarea B: limpieza | |
| # ========================================================================== | |
| def task_limpieza(video, mode, dilate_px, x1, y1, x2, y2, mask_img, | |
| progress=gr.Progress()): | |
| if video is None: | |
| raise gr.Error("Sube un vídeo.") | |
| job = WORK / uuid.uuid4().hex[:10] | |
| frames = extract_frames(video, job / "raw") | |
| if len(frames) > 480: | |
| raise gr.Error("Demasiados frames ({}). Usa un clip más corto." | |
| .format(len(frames))) | |
| arrs = read_pngs(frames) | |
| h, w = arrs[0].shape[:2] | |
| rect = None | |
| if x2 > x1 and y2 > y1: | |
| rect = np.zeros((h, w), np.uint8) | |
| rect[int(y1 * h / 100):int(y2 * h / 100), | |
| int(x1 * w / 100):int(x2 * w / 100)] = 255 | |
| ext = None | |
| if mask_img is not None: | |
| ext = np.asarray(Image.fromarray(mask_img).convert("L"), np.uint8) | |
| _, ext = cv2.threshold(ext, 127, 255, cv2.THRESH_BINARY) | |
| use_hands = mode in ("Manos (auto)", "Manos + rectángulo") | |
| if rect is not None and mode == "Manos (auto)": | |
| rect = None | |
| if rect is not None: | |
| use_hands = mode in ("Manos (auto)", "Manos + rectángulo") | |
| progress(0.2, desc="Detectando e inpaintando") | |
| try: | |
| out, touched = _clean_gpu(arrs, use_hands, int(dilate_px), rect, ext) | |
| except Exception as exc: | |
| raise gr.Error("Falló la limpieza ({}). Prueba con menos frames o " | |
| "sin detección automática.".format(exc)) | |
| progress(0.8, desc="Codificando") | |
| paths = write_pngs(out, job / "clean") | |
| cleaned = job / "clean.mp4" | |
| encode_png_sequence(job / "clean", 30, cleaned) | |
| preview = job / "preview.png" | |
| Image.fromarray(out[len(out) // 2]).save(preview) | |
| engine = _get_lama()[0] if _LAMA else "?" | |
| info = ("### Limpieza\n- Frames: **{}**\n- Frames modificados: **{}**\n" | |
| "- Motor de inpaint: **{}**\n- Manos automáticas: **{}**\n\n" | |
| "> El vídeo se reencoda a **30 fps**; si tu clip tenía otra " | |
| "cadencia, pásalo luego por la pestaña Fluidez." | |
| ).format(len(frames), touched, engine, "sí" if use_hands else "no") | |
| return str(cleaned), str(preview), info | |
| # ========================================================================== | |
| # Tarea C: transiciones generativas + secuencia | |
| # ========================================================================== | |
| def _clip_frames(video, pose_fps, sensitivity): | |
| """Devuelve los frames PNG de un clip ya ritmados a pose_fps.""" | |
| job = WORK / uuid.uuid4().hex[:10] | |
| frames = extract_frames(video, job / "raw") | |
| thr = 0.5 + (100.0 - float(sensitivity)) * 0.15 | |
| kept = dedupe_poses(frames, thr) | |
| return kept | |
| def task_secuencia(videos, sensitivity, pose_fps, smooth, mult, space_id, token, | |
| api_override, prompt, progress=gr.Progress(), | |
| request: gr.Request = None): | |
| clips = [v for v in (videos or []) if v] | |
| if len(clips) < 2: | |
| raise gr.Error("Sube al menos 2 clips.") | |
| if len(clips) > MAX_SEQ_CLIPS: | |
| raise gr.Error("Máximo {} clips.".format(MAX_SEQ_CLIPS)) | |
| job = WORK / uuid.uuid4().hex[:10] | |
| job.mkdir(parents=True, exist_ok=True) | |
| n_joints = len(clips) - 1 | |
| log = [] | |
| segments = [] | |
| for idx, clip in enumerate(clips): | |
| progress(idx / (len(clips) * 2.0), desc="Analizando clip {}".format(idx + 1)) | |
| pose_paths = _clip_frames(clip, pose_fps, sensitivity) | |
| arrs = read_pngs(pose_paths) | |
| segments.append(arrs) | |
| log.append("clip {}: {} poses".format(idx + 1, len(pose_paths))) | |
| transitions = [] | |
| for idx in range(n_joints): | |
| progress(0.5 + idx / (n_joints * 4.0), | |
| desc="Generando transición {} -> {}".format(idx + 1, idx + 2)) | |
| pa = _clip_frames(clips[idx], pose_fps, sensitivity) | |
| pb = _clip_frames(clips[idx + 1], pose_fps, sensitivity) | |
| start_img = job / ("start_%d.png" % idx) | |
| end_img = job / ("end_%d.png" % idx) | |
| _median_frame(pa[-3:] if len(pa) >= 3 else pa).save(start_img) | |
| _median_frame(pb[:3]).save(end_img) | |
| try: | |
| gen = call_flf2v(space_id, token, str(start_img), str(end_img), | |
| prompt, api_override, request) | |
| except Exception as exc: | |
| raise gr.Error( | |
| "Falló la transición {} ({}). Revisa el Space y el token; " | |
| "el resto del pipeline sigue disponible.".format(idx + 1, exc)) | |
| gen_frames = extract_frames(gen, job / ("gen_%d" % idx), fps=pose_fps) | |
| if len(gen_frames) < 2: | |
| raise gr.Error("La transición {} salió vacía.".format(idx + 1)) | |
| transitions.append(read_pngs(gen_frames)) | |
| log.append("transición {}: {} frames a {} fps".format( | |
| idx + 1, len(gen_frames), pose_fps)) | |
| # concatenar con fundido de 3 frames en las uniones | |
| seq = [] | |
| for i, seg in enumerate(segments): | |
| if i == 0: | |
| seq.extend(seg) | |
| continue | |
| prev, tr = transitions[i - 1], None | |
| seq.extend(tr if tr else []) | |
| seg2 = list(seg) | |
| if len(seq) >= 3 and len(seg2) >= 3: | |
| n = 3 | |
| tail = seq[-n:] | |
| head = seg2[:n] | |
| blend = [] | |
| for k in range(n): | |
| a = 1.0 - (k + 1) / (n + 1.0) | |
| base = tail[k].astype(np.float32) * a + head[k].astype(np.float32) * (1 - a) | |
| blend.append(base.astype(np.uint8)) | |
| seq[-n:] = blend | |
| seq.extend(seg2) | |
| else: | |
| seq.extend(seg2) | |
| seq = segments[0] + transitions[0] if n_joints == 1 else seq | |
| if n_joints == 1: | |
| seq = list(segments[0]) + list(transitions[0]) + list(segments[1]) | |
| progress(0.9, desc="Montando secuencia") | |
| final_fps = float(pose_fps) | |
| final_frames = seq | |
| if smooth and int(mult) > 1: | |
| try: | |
| final_frames = _interp_gpu(seq, int(mult)) | |
| final_fps = float(pose_fps) * int(mult) | |
| except Exception as exc: | |
| log.append("RIFE omitido: {}".format(type(exc).__name__)) | |
| out = job / "secuencia.mp4" | |
| encode_numpy_frames(final_frames, final_fps, out) | |
| info = ("### Secuencia\n- Clips: **{}**\n- Transiciones generadas: **{}**\n" | |
| "- Fps de salida: **{}**\n\n{}\n").format( | |
| len(clips), n_joints, int(final_fps), "\n".join("- " + l for l in log)) | |
| return str(out), info | |
| # ========================================================================== | |
| # UI | |
| # ========================================================================== | |
| with gr.Blocks(title="Stop-motion Studio") as demo: | |
| gr.Markdown("# 🎬 Stop-motion Studio\n" | |
| "**Orden recomendado:** 1) Limpieza → 2) Fluidez → 3) Secuencia") | |
| with gr.Tab("1 · Limpieza (manos / objetos)"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| l_video = gr.Video(label="Vídeo") | |
| l_mode = gr.Radio(["Manos (auto)", "Manos + rectángulo", | |
| "Solo rectángulo"], | |
| value="Manos (auto)", label="Qué quitar") | |
| l_dilate = gr.Slider(0, 30, value=8, step=1, | |
| label="Expandir máscara (px)") | |
| with gr.Accordion("Zona rectangular (si aplica)", open=False): | |
| l_x1 = gr.Slider(0, 100, value=0, label="x1 %") | |
| l_y1 = gr.Slider(0, 100, value=0, label="y1 %") | |
| l_x2 = gr.Slider(0, 100, value=0, label="x2 %") | |
| l_y2 = gr.Slider(0, 100, value=0, label="y2 %") | |
| l_mask = gr.Image(label="Máscara extra (opcional, blanco = borrar)", | |
| image_mode="L") | |
| l_run = gr.Button("Limpiar", variant="primary") | |
| with gr.Column(): | |
| l_out = gr.Video(label="Vídeo limpio") | |
| l_prev = gr.Image(label="Fotograma de muestra") | |
| l_info = gr.Markdown() | |
| l_run.click(task_limpieza, | |
| [l_video, l_mode, l_dilate, l_x1, l_y1, l_x2, l_y2, l_mask], | |
| [l_out, l_prev, l_info]) | |
| with gr.Tab("2 · Fluidez"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| f_video = gr.Video(label="Vídeo") | |
| f_sens = gr.Slider(40, 99, value=85, step=1, | |
| label="Sensibilidad al cambio de pose") | |
| f_fps = gr.Dropdown([6, 8, 10, 12], value=8, | |
| label="Fps de la secuencia de poses") | |
| f_mult = gr.Radio([2, 4, 6, 8], value=6, label="Multiplicador RIFE") | |
| f_deflick = gr.Checkbox(value=True, label="Igualar exposición") | |
| f_rife = gr.Checkbox(value=True, label="Interpolar con RIFE") | |
| f_run = gr.Button("Procesar", variant="primary") | |
| with gr.Column(): | |
| f_out = gr.Video(label="Vídeo final") | |
| f_poses = gr.Video(label="Solo poses") | |
| f_info = gr.Markdown() | |
| f_run.click(task_fluidez, | |
| [f_video, f_sens, f_fps, f_mult, f_deflick, f_rife], | |
| [f_out, f_poses, f_info]) | |
| with gr.Tab("3 · Secuencia con transiciones"): | |
| gr.Markdown("Sube 2-6 clips. Entre cada par se genera un tramo con " | |
| "first+last frame y todo se encadena a la misma cadencia.") | |
| with gr.Row(): | |
| with gr.Column(): | |
| s_videos = gr.File(file_count="multiple", | |
| file_types=["video"], | |
| label="Clips (en orden)") | |
| s_sens = gr.Slider(40, 99, value=85, step=1, | |
| label="Sensibilidad al cambio de pose") | |
| s_fps = gr.Dropdown([6, 8, 10, 12], value=8, | |
| label="Fps base de la secuencia") | |
| s_smooth = gr.Checkbox(value=True, label="Suavizar secuencia con RIFE") | |
| s_mult = gr.Radio([2, 4, 6], value=4, label="Multiplicador RIFE") | |
| with gr.Accordion("Generador (API)", open=True): | |
| s_space = gr.Textbox(value=FLF_SPACE, label="Space generativo") | |
| s_token = gr.Textbox(type="password", label="HF token (tu cuenta PRO)") | |
| s_api = gr.Textbox(label="Endpoint (vacío = autodetectar)", | |
| placeholder="/generate_video") | |
| s_prompt = gr.Textbox( | |
| value=("continuación suave del movimiento, misma cámara, " | |
| "misma iluminación, mismo personaje"), | |
| label="Prompt de la transición") | |
| s_run = gr.Button("Generar secuencia", variant="primary") | |
| with gr.Column(): | |
| s_out = gr.Video(label="Secuencia final") | |
| s_info = gr.Markdown() | |
| s_run.click(task_secuencia, | |
| [s_videos, s_sens, s_fps, s_smooth, s_mult, s_space, | |
| s_token, s_api, s_prompt], | |
| [s_out, s_info]) | |
| demo.queue(max_size=8).launch() |