Spaces:
Running on Zero
Running on Zero
File size: 10,026 Bytes
7d46f0e 4837eb2 7d46f0e d5d4335 7d46f0e 9bd304c 7d46f0e 4837eb2 7d46f0e b94d130 7d46f0e d5d4335 7d46f0e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 | """
Make-It-Animatable for 3dvalley.com: the free lane of Auto-rig
(https://3dvalley.com/tools/fix/auto-rig). A humanoid mesh in, the same mesh
back with a Mixamo-named skeleton and skin weights, as a GLB (and the FBX it
was exported as). One API endpoint for headless callers, plus a small demo UI.
Differs from jasongzy/Make-It-Animatable-v2's Space (code at the commit
deploy.sh pins) in these ways:
- rigging only: no animation step, so no Auto-Rig Pro add-on and no Mixamo
animation files; the only Mixamo file is the skeleton template the bones
are laid out on
- one GPU reservation per run instead of three: upstream's three
@spaces.GPU calls would each reserve the 60 s default, 180 s in all, more
than an anonymous visitor's daily quota, so they are imported without
their decorators and run inside `_rig_on_gpu`
- the weights and the template are downloaded file by file, not by cloning
the model repo and the dataset
- the output keeps the input's own position and size (Restore Global
Transform) and its rest pose is reset to a T-pose
"""
import spaces # isort:skip
import os
import queue
import shutil
import sys
import tempfile
import time
import types
import gradio as gr
import trimesh
from huggingface_hub import hf_hub_download
HERE = os.path.dirname(os.path.abspath(__file__))
CODE = os.path.join(HERE, "mia")
TOKEN = os.environ.get("HF_TOKEN")
os.environ["GRADIO_TEMP_DIR"] = os.path.join(tempfile.gettempdir(), "gradio")
MAX_INPUT_FACES = 300_000
# What trimesh reads from one uploaded file: the input is loaded with it to merge duplicate vertices (below).
# FBX it cannot read, and a .gltf usually keeps its data in files of its own.
INPUT_TYPES = [".glb", ".obj", ".ply", ".stl"]
# The upstream code reads its files relative to its own folder: the three
# v2 checkpoints (Apache-2.0) and the Mixamo skeleton template (from the
# author's gated dataset; the Space's token has accepted its terms).
for name in ("bw_joints.pth", "joints_coarse.pth", "pose.pth"):
target = os.path.join(CODE, "output", "best", "v2", name)
if not os.path.isfile(target):
os.makedirs(os.path.dirname(target), exist_ok=True)
shutil.copy(hf_hub_download("jasongzy/Make-It-Animatable", f"output/best/v2/{name}", token=TOKEN), target)
# FBX2glTF turns the rig's FBX into the GLB. An upload to the Space does not
# keep a file's executable bit, so it is set again here (upstream's install.sh does the same).
_converter = os.path.join(CODE, "util", "FBX2glTF")
if os.path.isfile(_converter):
os.chmod(_converter, 0o755)
template = os.path.join(CODE, "data", "Mixamo", "bones.fbx")
if not os.path.isfile(template):
os.makedirs(os.path.dirname(template), exist_ok=True)
shutil.copy(hf_hub_download("jasongzy/Mixamo", "bones.fbx", repo_type="dataset", token=TOKEN), template)
# Upstream decorates each model call with @spaces.GPU. Imported under a
# stand-in whose GPU decorator does nothing, they become plain functions that
# `_rig_on_gpu` calls inside one reservation; the real module is put back.
_real_spaces = sys.modules["spaces"]
_stand_in = types.ModuleType("spaces")
_stand_in.GPU = lambda fn=None, **_: fn if callable(fn) else (lambda inner: inner)
sys.modules["spaces"] = _stand_in
sys.path.insert(0, CODE)
try:
import app_v2 as mia # noqa: E402
finally:
sys.modules["spaces"] = _real_spaces
# The steps return Gradio updates keyed by the upstream UI's components, which
# are built in its init_blocks(); this app has its own UI, so plain keys stand in.
for _name in (
"state",
"output_joints_coarse",
"output_normed_input",
"output_sample",
"output_joints",
"output_bw",
"output_rest_vis",
"output_rest_lbs",
"output_anim_vis",
"output_anim",
):
setattr(mia, _name, f"_{_name}")
# Models on cuda at module level: init_models() places them on the device,
# which ZeroGPU emulates here and attaches for real inside the reservation.
mia.init_models()
os.chdir(CODE)
from upsampler_theme import UPSAMPLER_CSS, UPSAMPLER_THEME, footer_html, header_html # noqa: E402
REST_POSES = {"As it stands": "No", "T-pose": "T-pose", "A-pose": "A-pose"}
def _rig_duration(model_file, rest_pose="As it stands", fingers=True):
# A warm run is a few seconds of network passes on 32,768 sampled points
# plus the blend weights of every vertex; declare a typical run, not the
# worst case (spaces/README.md, ZeroGPU rule 3).
return 20
@spaces.GPU(duration=_rig_duration)
def _rig_on_gpu(db):
"""Joint localisation, blend weights, bones and pose: the three networks, one reservation."""
mia.preprocess(db)
mia.infer(True, db)
return db
def rig(model_file, rest_pose="As it stands", fingers=True):
"""A humanoid model → the same model with a skeleton and skin weights: (GLB, FBX)."""
if not model_file:
raise gr.Error("Upload a 3D model of a humanoid character first.")
path = model_file if isinstance(model_file, str) else model_file.name
if os.path.splitext(path)[1].lower() not in INPUT_TYPES:
raise gr.Error(f"Upload a {', '.join(t[1:].upper() for t in INPUT_TYPES)} file.")
started = time.time()
# A folder of its own per run: handlers run at once, and upstream names its outputs after the input file.
work = tempfile.mkdtemp(prefix="rig-")
source = os.path.join(work, "model.glb")
# The weights are matched to Blender's mesh vertex by vertex, and Blender's glTF import merges vertices that
# are exact duplicates (same place, normal and UV). A model with such duplicates (Quaternius' Casual,
# 2026-11-08) then had more weights than vertices and failed. They are merged first, the same way; vertices
# that differ in their UV or normal stay apart, so textures and hard edges are kept.
mesh = trimesh.load(path, force="mesh")
if not isinstance(mesh, trimesh.Trimesh) or len(mesh.faces) == 0:
raise gr.Error("Upload a 3D model with a surface: this file has no faces.")
mesh.merge_vertices(merge_tex=False, merge_norm=False)
mesh.export(source)
db = mia.DB()
mia.fix_random()
mia.prepare_input(source, is_gs=False, opacity_threshold=0.0, db=db, export_temp=False)
if db.faces is not None and len(db.faces) > MAX_INPUT_FACES:
raise gr.Error(f"The model has {len(db.faces):,} faces; rigging takes up to {MAX_INPUT_FACES:,}. Reduce it first.")
db = _rig_on_gpu(db)
mia.vis(bw_fix=True, bw_vis_bone="LeftArm", no_fingers=not fingers, restore_global=True, db=db)
pose = REST_POSES.get(rest_pose, "No")
mia.vis_blender(
reset_to_rest=True,
remove_fingers=not fingers,
rest_pose_type=pose if pose != "No" else None,
ignore_pose_parts=[],
animation_file=None,
retarget=False,
inplace=False,
restore_global=True,
db=db,
)
# The GLB is the one Blender writes itself, in the rest pose (upstream's "Rest Pose" preview): FBX2glTF's
# conversion of the FBX came out mirrored, its faces inside out (2026-11-07). FBX2glTF's is the fallback.
glb = db.rest_vis_path if db.rest_vis_path and os.path.isfile(db.rest_vis_path) else db.anim_vis_path
fbx = db.anim_path
if not (glb and os.path.isfile(glb) and fbx and os.path.isfile(fbx)):
raise gr.Error("The rig could not be exported. Try a single, closed character model.")
print(f"rigged {os.path.basename(path)} in {time.time() - started:.1f} s")
return glb, fbx
with gr.Blocks(title="Make-It-Animatable - Free AI Auto Rigging for 3D Characters") as demo:
gr.HTML(header_html(
"Make-It-Animatable: Free AI Auto Rigging",
"Upload a humanoid character and get it back rigged: a Mixamo-named skeleton and skin weights, as GLB and FBX.",
))
with gr.Row():
with gr.Column():
model_in = gr.File(label="3D model (GLB, OBJ, PLY or STL)", file_types=INPUT_TYPES)
with gr.Accordion("Settings", open=False):
rest_in = gr.Radio(list(REST_POSES), value="As it stands", label="The pose it stands in")
fingers_in = gr.Checkbox(value=True, label="Finger bones")
rig_btn = gr.Button("Rig", variant="primary")
with gr.Column():
glb_out = gr.Model3D(label="Rigged model (GLB)", clear_color=[0, 0, 0, 0], height=420)
fbx_out = gr.File(label="Rigged model (FBX)")
rig_btn.click(rig, inputs=[model_in, rest_in, fingers_in], outputs=[glb_out, fbx_out], api_name="rig")
gr.HTML(footer_html(
"Make-It-Animatable rigs a humanoid 3D character in seconds: it places the joints of a Mixamo-compatible "
"skeleton, fingers included, paints the skin weights of every vertex and returns the model as a GLB and an "
"FBX ready to animate in Blender, Unity, Unreal or Godot, or with any Mixamo animation.",
"https://3dvalley.com/tools/fix/auto-rig",
"free AI auto rigging",
))
if __name__ == "__main__":
# No concurrency limit of our own: see spaces/README.md, ZeroGPU rules 1 and 2.
demo.queue().launch(
theme=UPSAMPLER_THEME,
css=UPSAMPLER_CSS,
ssr_mode=False,
show_error=True,
max_threads=200,
allowed_paths=[tempfile.gettempdir()],
prevent_thread_lock=True,
)
# Blender (bpy) runs on the main thread only: upstream's export step hands
# its work to this loop through a queue when called from a request thread.
print("Main thread entering the Blender task loop")
while True:
try:
task = mia.blender_task_queue.get()
except KeyboardInterrupt:
break
if task is None:
continue
args, event, result_box = task
try:
import app_blender
app_blender.main(args)
except Exception as error: # handed back to the request that asked
import traceback
traceback.print_exc()
result_box.append(error)
finally:
event.set()
|