Super-squash branch 'main' using huggingface_hub

.gitattributes

@@ -0,0 +1,62 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text
+manifest.jsonl filter=lfs diff=lfs merge=lfs -text
+processed.log filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,38 @@
+---
+pretty_name: filtered_lowpoly_rig
+tags:
+  - 3d
+  - mesh
+  - rigging
+  - glb
+---
+
+# filtered_lowpoly_rig
+
+Filtered low-poly rigged-mesh dataset: 26,033 GLB files with skeleton rigs,
+all under 10k vertices, deduplicated (double-hash), with a normalization
+pipeline (target range [-0.5, 0.5]).
+
+## Contents
+
+- `meshes/meshes-XXX.tar` — the 26,033 rigged GLBs, uncompressed tar shards
+  of 2000 files each, sharded by sorted filename (see
+  `shards_index.json`).
+- `meshes_norm.tar` — normalized GLBs (partial bake run, 199 files).
+- `manifest.jsonl`, `stats.json`, `bake_report.jsonl`, `processed.log`,
+  `run_full.log` — pipeline metadata and logs.
+- `filter_meshes.py`, `bake_normalize.py` — the filtering / normalization
+  pipeline scripts.
+- `restore.sh` — extraction script (see below).
+
+## Download & restore
+
+```bash
+uvx --from huggingface_hub hf download udbbdh/filtered-lowpoly-rig \
+    --repo-type dataset --local-dir ./filtered_lowpoly_rig_pkg
+cd ./filtered_lowpoly_rig_pkg
+bash restore.sh /path/to/target_dir
+```
+
+This recreates `filtered_lowpoly_rig/` (with `meshes/` and `meshes_norm/`
+unpacked) under the target directory.

bake_normalize.py

@@ -0,0 +1,512 @@
+#!/usr/bin/env python
+"""Bake the wrapper-node normalization of filtered_lowpoly_rig/meshes into
+vertex data, writing self-normalized GLBs to meshes_norm/.
+
+Input files are known products of filter_meshes.py: single scene root
+"__normalized_root__" with uniform scale s + translation t (no rotation).
+We remove the wrapper and bake W = T(t)*S(s) so that spec-correct world-space
+output is EXACTLY unchanged while raw accessor data becomes normalized:
+
+  node translations *= s (old roots += t)   =>  G' = W * G * D^-1
+  skinned positions  p'' = (W*C) p, C = G_j0*IBM_j0 (any invertible C is
+    exact):  IBM' = D * IBM * C^-1 * W^-1
+  static non-skinned positions p'' = (W*G_node) p, mesh moved to an identity
+    root (skipped for meshes on joint/animated nodes: those keep p*=s so they
+    still follow their node)
+  animation translation outputs *= s (+t on old roots; CUBICSPLINE tangents
+    *= s only)
+  normals by inverse-transpose, tangents by linear part, morph deltas by
+  linear part; POSITION min/max recomputed.
+
+Per-file fallback scheme A (M = D everywhere, nothing moved) when accessors
+are shared across conflicting groups or IBMs are absent/unreadable.
+Quantized/sparse POSITION: file copied unchanged with wrapper kept.
+Every output is verified: skinning-evaluated world vertices before vs after,
+compared per (mesh, primitive).
+"""
+import json
+import os
+import struct
+import sys
+import time
+from multiprocessing import Pool
+from pathlib import Path
+
+import numpy as np
+
+SRC_DIR = Path("/root/zhaotianhao/filtered_lowpoly_rig/meshes")
+DST_DIR = Path("/root/zhaotianhao/filtered_lowpoly_rig/meshes_norm")
+REPORT = Path("/root/zhaotianhao/filtered_lowpoly_rig/bake_report.jsonl")
+JSON_CHUNK = 0x4E4F534A
+BIN_CHUNK = 0x004E4942
+FLOAT = 5126
+WRAPPER_NAMES = {"__normalized_root__", "__normalize_root__"}
+VERIFY_TOL = 5e-3
+
+
+def read_glb(path):
+    raw = open(path, "rb").read()
+    if raw[:4] != b"glTF":
+        raise ValueError("bad magic")
+    off = 12
+    gltf = None
+    chunks = []
+    while off + 8 <= len(raw):
+        cl, ct = struct.unpack_from("<II", raw, off)
+        payload = raw[off + 8: off + 8 + cl]
+        if ct == JSON_CHUNK and gltf is None:
+            gltf = json.loads(payload)
+            chunks.append([ct, None])
+        else:
+            chunks.append([ct, bytearray(payload)])
+        off += 8 + cl
+    return gltf, chunks
+
+
+def write_glb(path, gltf, chunks):
+    jb = json.dumps(gltf, separators=(",", ":")).encode()
+    jb += b" " * ((4 - len(jb) % 4) % 4)
+    body = b""
+    for ct, payload in chunks:
+        if ct == JSON_CHUNK and payload is None:
+            payload = jb
+        payload = bytes(payload)
+        if len(payload) % 4:
+            payload += (b"\x00" if ct == BIN_CHUNK else b" ") * (4 - len(payload) % 4)
+        body += struct.pack("<II", len(payload), ct) + payload
+    blob = struct.pack("<4sII", b"glTF", 2, 12 + len(body)) + body
+    tmp = str(path) + ".part"
+    with open(tmp, "wb") as f:
+        f.write(blob)
+    os.replace(tmp, path)
+
+
+NCOMP = {"SCALAR": 1, "VEC2": 2, "VEC3": 3, "VEC4": 4, "MAT4": 16}
+
+
+def acc_view(gltf, bin_ba, ai):
+    acc = gltf["accessors"][ai]
+    if acc.get("componentType") != FLOAT or "sparse" in acc or "bufferView" not in acc:
+        return None
+    n = NCOMP.get(acc.get("type"))
+    if n is None:
+        return None
+    bv = gltf["bufferViews"][acc["bufferView"]]
+    if bv.get("buffer", 0) != 0:
+        return None
+    stride = bv.get("byteStride") or 4 * n
+    off = bv.get("byteOffset", 0) + acc.get("byteOffset", 0)
+    count = acc["count"]
+    if off + (count - 1) * stride + 4 * n > len(bin_ba):
+        return None
+    return np.ndarray((count, n), dtype="<f4", buffer=memoryview(bin_ba),
+                      offset=off, strides=(stride, 4))
+
+
+def node_matrix(node):
+    if "matrix" in node:
+        return np.array(node["matrix"], dtype=np.float64).reshape(4, 4).T
+    m = np.eye(4)
+    if "rotation" in node:
+        x, y, z, w = node["rotation"]
+        nq = x * x + y * y + z * z + w * w
+        if nq > 1e-12:
+            f = 2.0 / nq
+            m[:3, :3] = np.array([
+                [1 - (y * y + z * z) * f, (x * y - w * z) * f, (x * z + w * y) * f],
+                [(x * y + w * z) * f, 1 - (x * x + z * z) * f, (y * z - w * x) * f],
+                [(x * z - w * y) * f, (y * z + w * x) * f, 1 - (x * x + y * y) * f]])
+    if "scale" in node:
+        m[:3, :3] = m[:3, :3] * np.asarray(node["scale"], dtype=np.float64)
+    if "translation" in node:
+        m[:3, 3] = node["translation"]
+    return m
+
+
+def globals_from(gltf, roots):
+    out = {}
+    stack = [(r, np.eye(4)) for r in roots]
+    while stack:
+        ni, pm = stack.pop()
+        if ni in out:
+            continue
+        g = pm @ node_matrix(gltf["nodes"][ni])
+        out[ni] = g
+        for c in gltf["nodes"][ni].get("children", []):
+            stack.append((c, g))
+    return out
+
+
+def scale_node_translation(node, s, add=None):
+    if "matrix" in node:
+        mm = list(node["matrix"])
+        for k in (12, 13, 14):
+            mm[k] = mm[k] * s
+        if add is not None:
+            mm[12] += add[0]; mm[13] += add[1]; mm[14] += add[2]
+        node["matrix"] = mm
+    else:
+        t = [v * s for v in node.get("translation", [0.0, 0.0, 0.0])]
+        if add is not None:
+            t = [t[0] + add[0], t[1] + add[1], t[2] + add[2]]
+        if any(abs(v) > 1e-12 for v in t) or "translation" in node or add is not None:
+            node["translation"] = t
+
+
+def world_verts(gltf, bin_ba, roots):
+    """Spec-correct world vertices keyed by (mesh, prim). None if unsupported."""
+    G = globals_from(gltf, roots)
+    out = {}
+    for ni in sorted(G):
+        g = G[ni]
+        nd = gltf["nodes"][ni]
+        mi = nd.get("mesh")
+        if mi is None:
+            continue
+        si = nd.get("skin")
+        for pk, prim in enumerate(gltf["meshes"][mi].get("primitives", [])):
+            key = (mi, pk)
+            if key in out:
+                continue
+            pa = prim.get("attributes", {}).get("POSITION")
+            if pa is None:
+                continue
+            P = acc_view(gltf, bin_ba, pa)
+            if P is None:
+                return None
+            P = P[:, :3].astype(np.float64)
+            if si is None:
+                out[key] = P @ g[:3, :3].T + g[:3, 3]
+                continue
+            skin = gltf["skins"][si]
+            joints = skin["joints"]
+            ibm_ai = skin.get("inverseBindMatrices")
+            if ibm_ai is None:
+                IBM = np.tile(np.eye(4), (len(joints), 1, 1))
+            else:
+                raw = acc_view(gltf, bin_ba, ibm_ai)
+                if raw is None:
+                    return None
+                IBM = raw.astype(np.float64).reshape(-1, 4, 4).transpose(0, 2, 1)
+            JM = np.stack([G.get(j, np.eye(4)) @ IBM[k]
+                           for k, j in enumerate(joints)])
+            ja = prim["attributes"].get("JOINTS_0")
+            wa = prim["attributes"].get("WEIGHTS_0")
+            if ja is None or wa is None:
+                out[key] = P @ g[:3, :3].T + g[:3, 3]
+                continue
+            jacc = gltf["accessors"][ja]
+            jbv = gltf["bufferViews"][jacc["bufferView"]]
+            dt = {5121: np.uint8, 5123: np.uint16, 5125: np.uint32}.get(
+                jacc["componentType"])
+            if dt is None:
+                return None
+            isz = np.dtype(dt).itemsize
+            stride = jbv.get("byteStride") or 4 * isz
+            off = jbv.get("byteOffset", 0) + jacc.get("byteOffset", 0)
+            J = np.ndarray((jacc["count"], 4), dtype=dt, buffer=memoryview(bin_ba),
+                           offset=off, strides=(stride, isz)).astype(np.int64)
+            Wt = acc_view(gltf, bin_ba, wa)
+            if Wt is None:
+                return None
+            Wt = Wt.astype(np.float64)
+            Wn = Wt / np.maximum(Wt.sum(1, keepdims=True), 1e-9)
+            J = np.clip(J, 0, len(joints) - 1)
+            M = (JM[J] * Wn[..., None, None]).sum(1)
+            hp = np.concatenate([P, np.ones((len(P), 1))], 1)
+            out[key] = np.einsum("nij,nj->ni", M, hp)[:, :3]
+    return out
+
+
+def bake_one(name):
+    src = SRC_DIR / name
+    dst = DST_DIR / name
+    rec = {"file": name}
+    try:
+        gltf, chunks = read_glb(src)
+        bin_ba = next((p for ct, p in chunks if ct == BIN_CHUNK), None)
+        nodes = gltf["nodes"]
+        scene = gltf["scenes"][gltf.get("scene", 0)]
+        sroots = scene.get("nodes", [])
+        if len(sroots) != 1 or nodes[sroots[0]].get("name") not in WRAPPER_NAMES:
+            rec.update(status="error", reason="no_wrapper"); return rec
+        wi = sroots[0]
+        wrap = nodes[wi]
+        s = float(wrap.get("scale", [1, 1, 1])[0])
+        t = np.array(wrap.get("translation", [0, 0, 0]), dtype=np.float64)
+        old_roots = list(wrap.get("children", []))
+        W = np.eye(4); W[:3, :3] *= s; W[:3, 3] = t
+        D = np.eye(4); D[:3, :3] *= s
+        Dinv = np.eye(4); Dinv[:3, :3] /= s
+        Winv = np.linalg.inv(W)
+
+        v_before = world_verts(gltf, bin_ba, [wi])
+        G = globals_from(gltf, old_roots)
+        accessors = gltf["accessors"]
+
+        joints_all = set()
+        for sk in gltf.get("skins", []):
+            joints_all.update(sk.get("joints", []))
+        anim_nodes = set()
+        for anim in gltf.get("animations", []):
+            for ch in anim.get("channels", []):
+                tgt = ch.get("target", {})
+                if tgt.get("path") in ("translation", "rotation", "scale"):
+                    anim_nodes.add(tgt.get("node"))
+        # nodes whose world transform can change at runtime
+        dyn = set()
+        stack = [(r, False) for r in old_roots]
+        while stack:
+            ni, flag = stack.pop()
+            flag = flag or ni in anim_nodes or ni in joints_all
+            if flag:
+                dyn.add(ni)
+            for c in nodes[ni].get("children", []):
+                stack.append((c, flag))
+
+        full_ok = bin_ba is not None
+        mesh_owner = {}   # mesh -> (node, skin, G, movable)
+        for ni in sorted(G):
+            nd = nodes[ni]
+            mi = nd.get("mesh")
+            if mi is None:
+                continue
+            movable = ni not in dyn
+            if mi in mesh_owner:
+                p_ni, p_si, p_g, p_mv = mesh_owner[mi]
+                if p_si != nd.get("skin") or not np.allclose(p_g, G[ni], atol=1e-6):
+                    full_ok = False
+                mesh_owner[mi] = (p_ni, p_si, p_g, p_mv and movable)
+            else:
+                mesh_owner[mi] = (ni, nd.get("skin"), G[ni], movable)
+
+        skin_C = {}
+        if full_ok:
+            for si, skin in enumerate(gltf.get("skins", [])):
+                ibm_ai = skin.get("inverseBindMatrices")
+                raw = acc_view(gltf, bin_ba, ibm_ai) if ibm_ai is not None else None
+                if raw is None:
+                    full_ok = False; break
+                j0 = skin["joints"][0]
+                IBM0 = raw[0].astype(np.float64).reshape(4, 4).T
+                C = G.get(j0, np.eye(4)) @ IBM0
+                if not np.all(np.isfinite(C)) or abs(np.linalg.det(C)) < 1e-12:
+                    C = np.eye(4)
+                skin_C[si] = C
+
+        def group_key(mi):
+            ni, si, g, movable = mesh_owner[mi]
+            if si is not None:
+                return ("s", si)
+            return ("n", ni) if movable else ("d",)
+
+        if full_ok:
+            acc_grp = {}
+            for mi in mesh_owner:
+                key = group_key(mi)
+                for prim in gltf["meshes"][mi].get("primitives", []):
+                    sets = [prim.get("attributes", {})] + prim.get("targets", [])
+                    for aset in sets:
+                        for an in ("POSITION", "NORMAL", "TANGENT"):
+                            ai = aset.get(an)
+                            if ai is None:
+                                continue
+                            if acc_grp.get(ai, key) != key:
+                                full_ok = False
+                            acc_grp[ai] = key
+                    pa = prim.get("attributes", {}).get("POSITION")
+                    if pa is not None and acc_view(gltf, bin_ba, pa) is None:
+                        rec.update(status="kept_wrapper",
+                                   reason="unbakeable_positions")
+                        write_glb(dst, gltf, chunks)
+                        return rec
+
+        scheme = "full" if full_ok else "A"
+
+        # ---- 1. node translations ----
+        for ni in G:
+            scale_node_translation(nodes[ni], s,
+                                   add=t.tolist() if ni in old_roots else None)
+
+        # ---- 2. vertex data ----
+        done_acc = set()
+        for mi, (ni, si, g, movable) in mesh_owner.items():
+            if scheme == "full":
+                if si is not None:
+                    M = W @ skin_C[si]
+                elif movable:
+                    M = W @ g
+                else:
+                    M = D
+            else:
+                M = D
+            L = M[:3, :3]
+            if abs(np.linalg.det(L)) < 1e-15:
+                # degenerate node transform: keep mesh in place, scale only
+                M = D
+                L = M[:3, :3]
+                mesh_owner[mi] = (ni, si, g, False)
+            Mt = M[:3, 3]
+            it = np.linalg.inv(L).T
+            for prim in gltf["meshes"][mi].get("primitives", []):
+                attrs = prim.get("attributes", {})
+                sets = [(attrs, False)] + [(tg, True) for tg in prim.get("targets", [])]
+                for aset, is_delta in sets:
+                    for an in ("POSITION", "NORMAL", "TANGENT"):
+                        ai = aset.get(an)
+                        if ai is None or ai in done_acc:
+                            continue
+                        done_acc.add(ai)
+                        V = acc_view(gltf, bin_ba, ai)
+                        if V is None:
+                            continue
+                        if an == "POSITION":
+                            X = V[:, :3].astype(np.float64) @ L.T
+                            if not is_delta:
+                                X = X + Mt
+                            V[:, :3] = X.astype(np.float32)
+                            acc = accessors[ai]
+                            acc["min"] = np.min(V[:, :3], 0).astype(float).tolist()
+                            acc["max"] = np.max(V[:, :3], 0).astype(float).tolist()
+                        elif scheme == "full":
+                            R3 = it if an == "NORMAL" else L
+                            X = V[:, :3].astype(np.float64) @ R3.T
+                            nn = np.linalg.norm(X, axis=1, keepdims=True)
+                            V[:, :3] = (X / np.maximum(nn, 1e-12)).astype(np.float32)
+
+        # ---- 3. IBMs ----
+        for si, skin in enumerate(gltf.get("skins", [])):
+            ibm_ai = skin.get("inverseBindMatrices")
+            if ibm_ai is None:
+                if scheme == "full":
+                    rec.update(status="error", reason="ibm_missing_full"); return rec
+                continue
+            raw = acc_view(gltf, bin_ba, ibm_ai)
+            if raw is None:
+                rec.update(status="error", reason="ibm_unreadable"); return rec
+            R = (np.linalg.inv(skin_C[si]) @ Winv) if scheme == "full" else Dinv
+            for k in range(len(raw)):
+                ib = raw[k].astype(np.float64).reshape(4, 4).T
+                raw[k] = (D @ ib @ R).T.reshape(16).astype(np.float32)
+
+        # ---- 4. animation translation outputs ----
+        anim_shared = False
+        out_rule = {}
+        for anim in gltf.get("animations", []):
+            samplers = anim.get("samplers", [])
+            for ch in anim.get("channels", []):
+                tgt = ch.get("target", {})
+                if tgt.get("path") != "translation":
+                    continue
+                sm = samplers[ch["sampler"]]
+                rule = (tgt.get("node") in old_roots,
+                        sm.get("interpolation") == "CUBICSPLINE")
+                oa = sm["output"]
+                if out_rule.get(oa, rule) != rule:
+                    anim_shared = True
+                out_rule[oa] = rule
+        for oa, (is_root, cubic) in out_rule.items():
+            V = acc_view(gltf, bin_ba, oa)
+            if V is None:
+                continue
+            V[:] = V[:] * s
+            if is_root:
+                if cubic:
+                    V[1::3, :3] += t.astype(np.float32)
+                else:
+                    V[:, :3] += t.astype(np.float32)
+
+        # ---- 5. restructure scene ----
+        new_roots = list(old_roots)
+        if scheme == "full":
+            parent = {}
+            for ni in G:
+                for c in nodes[ni].get("children", []):
+                    parent[c] = ni
+            newG = globals_from(gltf, old_roots)
+            for mi, (ni, si, g, movable) in mesh_owner.items():
+                if si is None and movable:
+                    for nj in G:
+                        if nodes[nj].get("mesh") == mi:
+                            nodes[nj].pop("mesh", None)
+                    nodes.append({"name": "baked_mesh_%d" % mi, "mesh": mi})
+                    new_roots.append(len(nodes) - 1)
+                elif (si is not None and not nodes[ni].get("children")
+                      and ni not in joints_all and ni not in anim_nodes):
+                    pg = newG.get(parent.get(ni), np.eye(4)) if ni in parent \
+                        else np.eye(4)
+                    try:
+                        inv = np.linalg.inv(pg)
+                    except np.linalg.LinAlgError:
+                        continue
+                    nd = nodes[ni]
+                    for k in ("matrix", "translation", "rotation", "scale"):
+                        nd.pop(k, None)
+                    if not np.allclose(inv, np.eye(4), atol=1e-9):
+                        nd["matrix"] = inv.T.reshape(16).tolist()
+
+        scene["nodes"] = new_roots
+        wrap.pop("children", None)
+        wrap.pop("scale", None)
+        wrap.pop("translation", None)
+        if wi == len(nodes) - 1:
+            nodes.pop()
+
+        # ---- verify ----
+        v_after = world_verts(gltf, bin_ba, new_roots)
+        err = None
+        if v_before is not None and v_after is not None:
+            errs = [float(np.abs(v_before[k] - v_after[k]).max())
+                    for k in v_before if k in v_after
+                    and v_before[k].shape == v_after[k].shape]
+            if len(errs) != len(v_before) or len(v_before) != len(v_after):
+                rec.update(status="error", reason="verify_key_mismatch"); return rec
+            err = max(errs) if errs else 0.0
+            if err > VERIFY_TOL:
+                rec.update(status="error", reason="verify_failed", max_err=err)
+                return rec
+        lo = hi = None
+        if v_after:
+            allv = np.concatenate(list(v_after.values()), 0)
+            lo, hi = float(allv.min()), float(allv.max())
+
+        write_glb(dst, gltf, chunks)
+        rec.update(status="ok", scheme=scheme, max_err=err,
+                   anim_shared=anim_shared, world_min=lo, world_max=hi)
+        return rec
+    except Exception as e:  # noqa: BLE001
+        rec.update(status="error", reason="exc:%s:%s" % (type(e).__name__, e))
+        return rec
+
+
+def main():
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--workers", type=int, default=16)
+    args = ap.parse_args()
+    DST_DIR.mkdir(parents=True, exist_ok=True)
+    names = sorted(os.listdir(SRC_DIR))
+    done = set(os.listdir(DST_DIR))
+    todo = [n for n in names if n not in done and n.endswith(".glb")]
+    if args.limit:
+        todo = todo[: args.limit]
+    print("[bake] %d total, %d todo" % (len(names), len(todo)), flush=True)
+    stats = {}
+    t0 = time.time()
+    with open(REPORT, "a") as rep, Pool(args.workers) as pool:
+        for i, rec in enumerate(pool.imap_unordered(bake_one, todo, chunksize=8), 1):
+            key = rec["status"] + (":" + rec.get("reason", "") if rec["status"] == "error"
+                                   else ":" + rec.get("scheme", rec.get("reason", "")))
+            stats[key] = stats.get(key, 0) + 1
+            if rec["status"] != "ok" or i % 2000 == 0:
+                rep.write(json.dumps(rec) + "\n")
+                rep.flush()
+            if i % 2000 == 0:
+                print("[bake] %d/%d (%.0f/s) %s" % (
+                    i, len(todo), i / max(time.time() - t0, 1e-9), stats), flush=True)
+    print("[bake] DONE %s" % stats, flush=True)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

bake_report.jsonl

@@ -0,0 +1 @@
+{"file": "01044a407d2c48cc8acbd762b3710c18.glb", "status": "error", "reason": "exc:LinAlgError:Singular matrix"}

filter_meshes.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Filter rigged low-poly meshes from multiple datasets.
+
+A .glb is kept only if ALL of:
+  - valid glTF 2.0 binary
+  - has skins with joints, and at least one scene-reachable node binds mesh+skin
+  - total vertex count of scene-reachable meshes < 10000
+
+Kept meshes are normalized into [-0.5, 0.5]^3 by inserting a wrapper root node
+(uniform scale + translation) into the scene graph. This preserves skeleton /
+skin / animation data exactly (a re-export through trimesh would drop them).
+
+Dedup: exact file sha256 + geometry hash over POSITION/JOINTS_0/WEIGHTS_0
+buffer bytes. Sources are opened read-only; all output goes under OUT_ROOT.
+Resumable: paths already listed in processed.log are skipped on restart.
+
+Run:  python filter_meshes.py [--limit-per-source N]
+"""
+import argparse
+import hashlib
+import itertools
+import json
+import os
+import struct
+import sys
+import time
+from collections import Counter
+from multiprocessing import Pool
+from pathlib import Path
+
+import numpy as np
+
+# highest priority first: when duplicates exist, the earlier source wins
+SOURCES = [
+    ("dataset_rig", "/root/zhaotianhao/dataset_rig"),
+    ("canoverse", "/root/youjiaZhang/topotex_data_CanoVerse/raw"),
+    ("objaverse_xl", "/root/dataset/dataset.2/objaverse-xl/hf-objaverse-v1/glbs"),
+]
+
+OUT_ROOT = Path("/root/zhaotianhao/filtered_lowpoly_rig")
+MESH_DIR = OUT_ROOT / "meshes"
+TMP_DIR = OUT_ROOT / "tmp"
+MANIFEST = OUT_ROOT / "manifest.jsonl"
+PROCESSED = OUT_ROOT / "processed.log"
+STATS = OUT_ROOT / "stats.json"
+
+MAX_VERTS = 10000          # strict: keep only n_verts < MAX_VERTS
+NORM_HALF = 0.5            # normalize longest axis into [-NORM_HALF, NORM_HALF]
+MAX_FILE_BYTES = 300 << 20 # skip pathological files
+WORKERS = 24
+MESH_EXTS = {".glb", ".gltf", ".vrm", ".fbx", ".obj", ".dae", ".ply", ".stl"}
+
+CHUNK_JSON = 0x4E4F534A
+CHUNK_BIN = 0x004E4942
+
+
+def _quat_to_mat(x, y, z, w):
+    n = x * x + y * y + z * z + w * w
+    if n < 1e-12:
+        return np.eye(3)
+    s = 2.0 / n
+    xx, yy, zz = x * x * s, y * y * s, z * z * s
+    xy, xz, yz = x * y * s, x * z * s, y * z * s
+    wx, wy, wz = w * x * s, w * y * s, w * z * s
+    return np.array([
+        [1 - (yy + zz), xy - wz, xz + wy],
+        [xy + wz, 1 - (xx + zz), yz - wx],
+        [xz - wy, yz + wx, 1 - (xx + yy)],
+    ])
+
+
+def _node_matrix(node):
+    if "matrix" in node:
+        return np.array(node["matrix"], dtype=np.float64).reshape(4, 4).T
+    m = np.eye(4)
+    if "scale" in node:
+        m[:3, :3] = np.diag(node["scale"])
+    if "rotation" in node:
+        x, y, z, w = node["rotation"]
+        m[:3, :3] = _quat_to_mat(x, y, z, w) @ m[:3, :3]
+    if "translation" in node:
+        m[:3, 3] = node["translation"]
+    return m
+
+
+def _reject(rec, reason, **extra):
+    rec.update(status="reject", reason=reason, **extra)
+    return rec
+
+
+def process_one(task):
+    tag, path = task
+    rec = {"src": path, "tag": tag}
+    try:
+        return _process_one(tag, path, rec)
+    except Exception as e:  # noqa: BLE001 - any parse failure is a data reject
+        return _reject(rec, "error:%s" % type(e).__name__)
+
+
+def _process_one(tag, path, rec):
+    ext = os.path.splitext(path)[1].lower()
+    if ext != ".glb":
+        # .obj cannot embed skin/skeleton; .fbx would need blender (unavailable)
+        return _reject(rec, "non_glb:%s" % ext.lstrip("."))
+    size = os.path.getsize(path)
+    if size > MAX_FILE_BYTES:
+        return _reject(rec, "too_large")
+
+    fhash = hashlib.sha256()
+    with open(path, "rb") as f:
+        hdr = f.read(12)
+        if len(hdr) < 12 or hdr[:4] != b"glTF":
+            return _reject(rec, "bad_magic")
+        version, _total = struct.unpack("<II", hdr[4:])
+        if version != 2:
+            return _reject(rec, "gltf_v%d" % version)
+        ch = f.read(8)
+        if len(ch) < 8:
+            return _reject(rec, "truncated")
+        clen, ctype = struct.unpack("<II", ch)
+        if ctype != CHUNK_JSON:
+            return _reject(rec, "no_json_chunk")
+        raw_json = f.read(clen)
+        try:
+            gltf = json.loads(raw_json)
+        except Exception:
+            return _reject(rec, "json_parse")
+
+        # ---------- rig filter (cheap: JSON only) ----------
+        skins = gltf.get("skins") or []
+        joints_union = set()
+        for s in skins:
+            joints_union.update(s.get("joints") or [])
+        if not joints_union:
+            return _reject(rec, "no_skeleton")
+
+        nodes = gltf.get("nodes") or []
+        meshes = gltf.get("meshes") or []
+        accessors = gltf.get("accessors") or []
+        scenes = gltf.get("scenes") or []
+        if not scenes:
+            return _reject(rec, "no_scene")
+        scene_idx = min(gltf.get("scene", 0), len(scenes) - 1)
+        roots = scenes[scene_idx].get("nodes") or []
+        if not roots:
+            return _reject(rec, "empty_scene")
+
+        mesh_nodes = []  # (node_index, world_matrix)
+        has_skinned = False
+        stack = [(r, np.eye(4)) for r in roots]
+        seen = set()
+        while stack:
+            ni, pm = stack.pop()
+            if ni in seen or not (0 <= ni < len(nodes)):
+                continue
+            seen.add(ni)
+            nd = nodes[ni]
+            wm = pm @ _node_matrix(nd)
+            if nd.get("mesh") is not None:
+                mesh_nodes.append((ni, wm))
+                if nd.get("skin") is not None:
+                    has_skinned = True
+            for c in nd.get("children") or []:
+                stack.append((c, wm))
+        if not mesh_nodes:
+            return _reject(rec, "no_mesh_in_scene")
+        if not has_skinned:
+            return _reject(rec, "no_skinned_mesh")
+
+        # ---------- vertex budget ----------
+        mesh_ids = sorted({nodes[ni]["mesh"] for ni, _ in mesh_nodes
+                           if 0 <= nodes[ni]["mesh"] < len(meshes)})
+        n_verts = 0
+        n_faces = 0
+        for mi in mesh_ids:
+            for prim in meshes[mi].get("primitives") or []:
+                pa = (prim.get("attributes") or {}).get("POSITION")
+                if pa is None or not (0 <= pa < len(accessors)):
+                    continue
+                cnt = accessors[pa].get("count", 0)
+                n_verts += cnt
+                if prim.get("mode", 4) == 4:
+                    ia = prim.get("indices")
+                    if ia is not None and 0 <= ia < len(accessors):
+                        n_faces += accessors[ia].get("count", 0) // 3
+                    else:
+                        n_faces += cnt // 3
+        if n_verts == 0:
+            return _reject(rec, "no_position")
+        if n_verts >= MAX_VERTS:
+            return _reject(rec, "too_many_verts", n_verts=n_verts)
+
+        # ---------- world bbox from accessor min/max ----------
+        mn = np.full(3, np.inf)
+        mx = np.full(3, -np.inf)
+        for ni, wm in mesh_nodes:
+            mi = nodes[ni]["mesh"]
+            if not (0 <= mi < len(meshes)):
+                continue
+            for prim in meshes[mi].get("primitives") or []:
+                pa = (prim.get("attributes") or {}).get("POSITION")
+                if pa is None or not (0 <= pa < len(accessors)):
+                    continue
+                acc = accessors[pa]
+                amn, amx = acc.get("min"), acc.get("max")
+                if not amn or not amx or len(amn) < 3 or len(amx) < 3:
+                    return _reject(rec, "missing_bounds")
+                cs = np.array(list(itertools.product(
+                    (amn[0], amx[0]), (amn[1], amx[1]), (amn[2], amx[2]))))
+                cs4 = np.hstack([cs, np.ones((8, 1))])
+                w = (wm @ cs4.T).T[:, :3]
+                mn = np.minimum(mn, w.min(axis=0))
+                mx = np.maximum(mx, w.max(axis=0))
+        extent = mx - mn
+        max_extent = float(np.max(extent))
+        if not np.isfinite(max_extent) or max_extent <= 1e-9:
+            return _reject(rec, "degenerate_bbox")
+        scale = (2.0 * NORM_HALF) / max_extent
+        center = (mn + mx) / 2.0
+
+        # ---------- read remaining chunks, hash file ----------
+        fhash.update(hdr)
+        fhash.update(ch)
+        fhash.update(raw_json)
+        rest = []
+        while True:
+            h = f.read(8)
+            if len(h) < 8:
+                break
+            fhash.update(h)
+            cl, ct = struct.unpack("<II", h)
+            payload = f.read(cl)
+            fhash.update(payload)
+            rest.append((ct, payload))
+    file_hash = fhash.hexdigest()
+
+    bin_data = None
+    for ct, payload in rest:
+        if ct == CHUNK_BIN:
+            bin_data = payload
+            break
+
+    # ---------- geometry hash (positions + skin binding bytes) ----------
+    bvs = gltf.get("bufferViews") or []
+    buffers = gltf.get("buffers") or []
+    bin_usable = bin_data is not None and buffers and "uri" not in buffers[0]
+    if bin_usable:
+        gh = hashlib.sha256()
+        gh.update(b"%d/%d/%d" % (n_verts, n_faces, len(joints_union)))
+        for mi in mesh_ids:
+            for prim in meshes[mi].get("primitives") or []:
+                attrs = prim.get("attributes") or {}
+                for name in ("POSITION", "JOINTS_0", "WEIGHTS_0"):
+                    ai = attrs.get(name)
+                    if ai is None or not (0 <= ai < len(accessors)):
+                        continue
+                    bvi = accessors[ai].get("bufferView")
+                    if bvi is None or not (0 <= bvi < len(bvs)):
+                        continue
+                    bv = bvs[bvi]
+                    if bv.get("buffer", 0) != 0:
+                        continue
+                    off = bv.get("byteOffset", 0)
+                    gh.update(bin_data[off:off + bv.get("byteLength", 0)])
+        geo_hash = gh.hexdigest()
+    else:
+        geo_hash = "file:" + file_hash
+
+    # ---------- insert normalization wrapper node ----------
+    wrapper = {
+        "name": "__normalized_root__",
+        "children": list(roots),
+        "scale": [scale, scale, scale],
+        "translation": [float(-center[0] * scale),
+                        float(-center[1] * scale),
+                        float(-center[2] * scale)],
+    }
+    gltf.setdefault("nodes", nodes).append(wrapper)
+    scenes[scene_idx]["nodes"] = [len(gltf["nodes"]) - 1]
+
+    new_json = json.dumps(gltf, separators=(",", ":")).encode("utf-8")
+    new_json += b" " * ((4 - len(new_json) % 4) % 4)
+    body = bytearray()
+    for ct, payload in rest:
+        if len(payload) % 4:
+            payload = payload + b"\x00" * (4 - len(payload) % 4)
+        body += struct.pack("<II", len(payload), ct)
+        body += payload
+    total = 12 + 8 + len(new_json) + len(body)
+    blob = (struct.pack("<4sII", b"glTF", 2, total)
+            + struct.pack("<II", len(new_json), CHUNK_JSON) + new_json + bytes(body))
+
+    tmp = TMP_DIR / ("%d_%s.glb" % (os.getpid(), hashlib.md5(path.encode()).hexdigest()[:12]))
+    tmp.write_bytes(blob)
+
+    rec.update(
+        status="accept", tmp=str(tmp), file_hash=file_hash, geo_hash=geo_hash,
+        n_verts=n_verts, n_faces=n_faces, n_joints=len(joints_union),
+        n_skins=len(skins), scale=round(scale, 6),
+        bbox_min=[round(v, 5) for v in mn.tolist()],
+        bbox_max=[round(v, 5) for v in mx.tolist()],
+    )
+    return rec
+
+
+# ---------------------------------------------------------------- main driver
+
+def iter_source_files(root):
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = sorted(d for d in dirnames if not d.startswith("."))
+        for fn in sorted(filenames):
+            if os.path.splitext(fn)[1].lower() in MESH_EXTS:
+                yield os.path.join(dirpath, fn)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--limit-per-source", type=int, default=0,
+                    help="smoke test: only process first N files of each source")
+    args = ap.parse_args()
+
+    MESH_DIR.mkdir(parents=True, exist_ok=True)
+    TMP_DIR.mkdir(parents=True, exist_ok=True)
+    for stale in TMP_DIR.glob("*.glb"):
+        stale.unlink(missing_ok=True)
+
+    processed = set()
+    if PROCESSED.exists():
+        with open(PROCESSED) as f:
+            processed = {ln.rstrip("\n") for ln in f}
+    seen_file, seen_geo, used_names = set(), set(), set()
+    if MANIFEST.exists():
+        with open(MANIFEST) as f:
+            for ln in f:
+                try:
+                    r = json.loads(ln)
+                except Exception:
+                    continue
+                seen_file.add(r["file_hash"])
+                seen_geo.add(r["geo_hash"])
+                used_names.add(r["out"])
+    print("[init] resume: %d processed, %d accepted so far"
+          % (len(processed), len(seen_file)), flush=True)
+
+    def tasks():
+        for tag, root in SOURCES:
+            it = iter_source_files(root)
+            if args.limit_per_source:
+                it = itertools.islice(it, args.limit_per_source)
+            for p in it:
+                if p not in processed:
+                    yield (tag, p)
+
+    stats = Counter()
+    t0 = time.time()
+    n_done = 0
+    man_f = open(MANIFEST, "a")
+    proc_f = open(PROCESSED, "a")
+
+    def dump_stats():
+        payload = {
+            "done_this_run": n_done,
+            "elapsed_sec": round(time.time() - t0, 1),
+            "accepted_total": len(seen_file),
+            "counts": dict(stats),
+        }
+        STATS.write_text(json.dumps(payload, indent=2))
+
+    with Pool(WORKERS, maxtasksperchild=500) as pool:
+        for rec in pool.imap(process_one, tasks(), chunksize=16):
+            n_done += 1
+            tag = rec["tag"]
+            if rec["status"] == "reject":
+                reason = rec["reason"].split(":")[0]
+                stats["%s.reject.%s" % (tag, rec["reason"])] += 1
+            else:
+                tmp = Path(rec.pop("tmp"))
+                if rec["file_hash"] in seen_file or rec["geo_hash"] in seen_geo:
+                    tmp.unlink(missing_ok=True)
+                    stats["%s.dup" % tag] += 1
+                else:
+                    seen_file.add(rec["file_hash"])
+                    seen_geo.add(rec["geo_hash"])
+                    stem = Path(rec["src"]).stem[:64]
+                    name = stem + ".glb"
+                    if name in used_names:
+                        name = "%s_%s.glb" % (stem, rec["file_hash"][:8])
+                    used_names.add(name)
+                    os.replace(tmp, MESH_DIR / name)
+                    rec["out"] = name
+                    man_f.write(json.dumps(rec) + "\n")
+                    stats["%s.accept" % tag] += 1
+            proc_f.write(rec["src"] + "\n")
+            if n_done % 200 == 0:
+                man_f.flush()
+                proc_f.flush()
+            if n_done % 5000 == 0:
+                acc = sum(v for k, v in stats.items() if k.endswith(".accept"))
+                print("[%.0fs] %d files done, %d accepted, %d dup"
+                      % (time.time() - t0, n_done, acc,
+                         sum(v for k, v in stats.items() if k.endswith(".dup"))),
+                      flush=True)
+                dump_stats()
+
+    man_f.close()
+    proc_f.close()
+    dump_stats()
+    print("[DONE] %d files in %.0fs" % (n_done, time.time() - t0), flush=True)
+    print(json.dumps(dict(stats), indent=2, sort_keys=True), flush=True)
+
+
+if __name__ == "__main__":
+    main()

manifest.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e71b59fa01076f2aa519e504f63d622a2f7c3124aaeff79ac50e65f2faa780a
+size 13502566

meshes/meshes-000.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dae16c24448bd2d604e028eee484d16af44675dd60aeecaa37fdcf8209362f05
+size 1915873280

meshes/meshes-001.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:feee80f562c2c81d5c64795f50013e69d89b18264d4319106235fd00198fe40d
+size 2033633280

meshes/meshes-002.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da79ab515125c4ef84466b594990a87c527b43aa5bbbc9e7ddeb964acdcaae09
+size 1889085440

meshes/meshes-003.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:448a4a13870a0a4da83a0a32b942ae94d06fa0d843f580a608b3b4d337b4ee69
+size 2001121280

meshes/meshes-004.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d0c443b4b438b330c4d060d065029cccc9a98f6e19f05bc269f2753d59af2df
+size 2074593280

meshes/meshes-005.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad1ee5a36f18c9b1719e0d18ca9afed58888d802a597da95e52a1ae95159c3d0
+size 2058618880

meshes/meshes-006.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:964fd3b9f09656c9c72de8e50aa65ab7bf54b7fc6229e99a478798ff0d3e80fd
+size 1934858240

meshes/meshes-007.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e23b4551d269c64df7b7dc249faee3779c4cf32691ea32520b509df0ba4a7280
+size 2009937920

meshes/meshes-008.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1650ffb10d522c67f320b469839fdaab20563abd62faced18dbce251930b2882
+size 2059827200

meshes/meshes-009.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf482c7b023460ca7bfa09303b34cfb74193e922a6fe3521b0284c30ca285ce7
+size 2012989440

meshes/meshes-010.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e248a7704abeda94e2c1d7328eae5334c11aeb8e0754b5bffd7007bdb09b0b78
+size 2259271680

meshes/meshes-011.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3606fdccae6d37de70198578193250e1eddfccc359fd9d12034a02270faa190
+size 2031206400

meshes/meshes-012.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:32d688569e8ec37f75edad8775fe7ca9563d435b9f368ac32822f489a73d0388
+size 1936394240

meshes/meshes-013.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d98d42ca2e3f9d7d4e84279a182c4fa95ecdf8d1a24aa0e1f5727a0c2ce049d6
+size 33945600

meshes_norm.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38aff6d0b9e15f8669278684e148f347be069fe80b73ebfeae6952c0a0e3ae56
+size 169338880

processed.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cd74f4b702f56f752bc8424783d09a2415bfdc7c9601f2aebcabe5f917bd6d0
+size 109528215

restore.sh

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# Usage: bash restore.sh [TARGET_DIR]
+# Run from inside the downloaded repo directory. Default target: ./restored
+set -euo pipefail
+TARGET="${1:-$PWD/restored}"
+RIG="$TARGET/filtered_lowpoly_rig"
+mkdir -p "$RIG/meshes" "$RIG/meshes_norm"
+
+echo "== Extracting meshes shards =="
+for t in meshes/meshes-*.tar; do
+  echo "  $t"
+  tar -xf "$t" -C "$RIG/meshes"
+done
+
+echo "== Extracting meshes_norm =="
+tar -xf meshes_norm.tar -C "$RIG/meshes_norm"
+
+echo "== Copying metadata / scripts =="
+find . -maxdepth 1 -type f ! -name '*.tar' ! -name restore.sh \
+  -exec cp {} "$RIG/" \;
+
+echo "Done. Restored into: $RIG"
+echo "  $(find "$RIG/meshes" -type f | wc -l) files in meshes/"
+echo "  $(find "$RIG/meshes_norm" -type f | wc -l) files in meshes_norm/"

run_full.log

@@ -0,0 +1,238 @@
+[init] resume: 1200 processed, 312 accepted so far
+[8s] 5000 files done, 3573 accepted, 470 dup
+[16s] 10000 files done, 7001 accepted, 1141 dup
+[24s] 15000 files done, 10207 accepted, 1968 dup
+[31s] 20000 files done, 11742 accepted, 2201 dup
+[43s] 25000 files done, 15120 accepted, 2632 dup
+[46s] 30000 files done, 18135 accepted, 3352 dup
+[49s] 35000 files done, 21058 accepted, 4162 dup
+[53s] 40000 files done, 23875 accepted, 5116 dup
+[54s] 45000 files done, 24965 accepted, 5511 dup
+[54s] 50000 files done, 24965 accepted, 5511 dup
+[54s] 55000 files done, 24965 accepted, 5511 dup
+[54s] 60000 files done, 24965 accepted, 5511 dup
+[54s] 65000 files done, 24965 accepted, 5511 dup
+[54s] 70000 files done, 24965 accepted, 5511 dup
+[54s] 75000 files done, 24965 accepted, 5511 dup
+[54s] 80000 files done, 24965 accepted, 5511 dup
+[54s] 85000 files done, 24965 accepted, 5511 dup
+[54s] 90000 files done, 24965 accepted, 5511 dup
+[54s] 95000 files done, 24965 accepted, 5511 dup
+[54s] 100000 files done, 24965 accepted, 5511 dup
+[54s] 105000 files done, 24965 accepted, 5511 dup
+[54s] 110000 files done, 24965 accepted, 5511 dup
+[55s] 115000 files done, 24965 accepted, 5511 dup
+[55s] 120000 files done, 24965 accepted, 5511 dup
+[56s] 125000 files done, 24965 accepted, 5511 dup
+[57s] 130000 files done, 24965 accepted, 5511 dup
+[64s] 135000 files done, 24965 accepted, 5511 dup
+[64s] 140000 files done, 24965 accepted, 5511 dup
+[64s] 145000 files done, 24965 accepted, 5511 dup
+[64s] 150000 files done, 24965 accepted, 5511 dup
+[64s] 155000 files done, 24965 accepted, 5511 dup
+[64s] 160000 files done, 24965 accepted, 5511 dup
+[64s] 165000 files done, 24965 accepted, 5511 dup
+[66s] 170000 files done, 24965 accepted, 5511 dup
+[66s] 175000 files done, 24965 accepted, 5511 dup
+[67s] 180000 files done, 24965 accepted, 5511 dup
+[68s] 185000 files done, 24965 accepted, 5511 dup
+[69s] 190000 files done, 24965 accepted, 5511 dup
+[70s] 195000 files done, 24965 accepted, 5511 dup
+[71s] 200000 files done, 24965 accepted, 5511 dup
+[72s] 205000 files done, 24965 accepted, 5511 dup
+[73s] 210000 files done, 24965 accepted, 5511 dup
+[74s] 215000 files done, 24965 accepted, 5511 dup
+[77s] 220000 files done, 24965 accepted, 5511 dup
+[77s] 225000 files done, 24965 accepted, 5511 dup
+[77s] 230000 files done, 24965 accepted, 5511 dup
+[77s] 235000 files done, 24965 accepted, 5511 dup
+[79s] 240000 files done, 24965 accepted, 5511 dup
+[80s] 245000 files done, 24965 accepted, 5511 dup
+[81s] 250000 files done, 24965 accepted, 5511 dup
+[81s] 255000 files done, 24965 accepted, 5511 dup
+[83s] 260000 files done, 24965 accepted, 5511 dup
+[84s] 265000 files done, 24965 accepted, 5511 dup
+[85s] 270000 files done, 24965 accepted, 5511 dup
+[87s] 275000 files done, 24965 accepted, 5511 dup
+[88s] 280000 files done, 24965 accepted, 5511 dup
+[88s] 285000 files done, 24965 accepted, 5511 dup
+[90s] 290000 files done, 24966 accepted, 5531 dup
+[93s] 295000 files done, 24971 accepted, 5617 dup
+[95s] 300000 files done, 24974 accepted, 5696 dup
+[97s] 305000 files done, 24978 accepted, 5764 dup
+[99s] 310000 files done, 24984 accepted, 5841 dup
+[102s] 315000 files done, 24991 accepted, 5918 dup
+[104s] 320000 files done, 24995 accepted, 6004 dup
+[110s] 325000 files done, 25000 accepted, 6091 dup
+[112s] 330000 files done, 25005 accepted, 6185 dup
+[114s] 335000 files done, 25013 accepted, 6288 dup
+[116s] 340000 files done, 25017 accepted, 6355 dup
+[118s] 345000 files done, 25020 accepted, 6444 dup
+[120s] 350000 files done, 25022 accepted, 6517 dup
+[122s] 355000 files done, 25028 accepted, 6598 dup
+[125s] 360000 files done, 25031 accepted, 6682 dup
+[127s] 365000 files done, 25040 accepted, 6769 dup
+[129s] 370000 files done, 25045 accepted, 6852 dup
+[132s] 375000 files done, 25049 accepted, 6944 dup
+[134s] 380000 files done, 25052 accepted, 7023 dup
+[137s] 385000 files done, 25058 accepted, 7116 dup
+[138s] 390000 files done, 25065 accepted, 7200 dup
+[141s] 395000 files done, 25068 accepted, 7285 dup
+[143s] 400000 files done, 25072 accepted, 7366 dup
+[146s] 405000 files done, 25079 accepted, 7462 dup
+[149s] 410000 files done, 25082 accepted, 7559 dup
+[151s] 415000 files done, 25088 accepted, 7649 dup
+[154s] 420000 files done, 25090 accepted, 7719 dup
+[156s] 425000 files done, 25093 accepted, 7805 dup
+[157s] 430000 files done, 25100 accepted, 7896 dup
+[160s] 435000 files done, 25105 accepted, 7981 dup
+[162s] 440000 files done, 25111 accepted, 8069 dup
+[164s] 445000 files done, 25115 accepted, 8159 dup
+[166s] 450000 files done, 25119 accepted, 8254 dup
+[172s] 455000 files done, 25122 accepted, 8323 dup
+[174s] 460000 files done, 25126 accepted, 8406 dup
+[175s] 465000 files done, 25131 accepted, 8487 dup
+[177s] 470000 files done, 25137 accepted, 8579 dup
+[182s] 475000 files done, 25139 accepted, 8661 dup
+[184s] 480000 files done, 25143 accepted, 8752 dup
+[186s] 485000 files done, 25146 accepted, 8837 dup
+[191s] 490000 files done, 25149 accepted, 8910 dup
+[192s] 495000 files done, 25153 accepted, 8997 dup
+[195s] 500000 files done, 25156 accepted, 9087 dup
+[197s] 505000 files done, 25163 accepted, 9173 dup
+[199s] 510000 files done, 25169 accepted, 9254 dup
+[201s] 515000 files done, 25173 accepted, 9327 dup
+[204s] 520000 files done, 25182 accepted, 9416 dup
+[207s] 525000 files done, 25185 accepted, 9509 dup
+[209s] 530000 files done, 25194 accepted, 9601 dup
+[211s] 535000 files done, 25198 accepted, 9680 dup
+[214s] 540000 files done, 25206 accepted, 9755 dup
+[218s] 545000 files done, 25211 accepted, 9862 dup
+[219s] 550000 files done, 25219 accepted, 9935 dup
+[221s] 555000 files done, 25224 accepted, 10034 dup
+[226s] 560000 files done, 25229 accepted, 10122 dup
+[227s] 565000 files done, 25237 accepted, 10207 dup
+[228s] 570000 files done, 25242 accepted, 10304 dup
+[230s] 575000 files done, 25246 accepted, 10377 dup
+[233s] 580000 files done, 25253 accepted, 10463 dup
+[235s] 585000 files done, 25258 accepted, 10551 dup
+[237s] 590000 files done, 25267 accepted, 10638 dup
+[240s] 595000 files done, 25270 accepted, 10720 dup
+[242s] 600000 files done, 25274 accepted, 10806 dup
+[244s] 605000 files done, 25278 accepted, 10890 dup
+[248s] 610000 files done, 25280 accepted, 10975 dup
+[250s] 615000 files done, 25281 accepted, 11055 dup
+[252s] 620000 files done, 25286 accepted, 11133 dup
+[254s] 625000 files done, 25292 accepted, 11211 dup
+[256s] 630000 files done, 25296 accepted, 11299 dup
+[259s] 635000 files done, 25301 accepted, 11387 dup
+[261s] 640000 files done, 25304 accepted, 11465 dup
+[263s] 645000 files done, 25310 accepted, 11555 dup
+[265s] 650000 files done, 25312 accepted, 11649 dup
+[267s] 655000 files done, 25315 accepted, 11729 dup
+[269s] 660000 files done, 25319 accepted, 11810 dup
+[272s] 665000 files done, 25322 accepted, 11910 dup
+[274s] 670000 files done, 25327 accepted, 11989 dup
+[277s] 675000 files done, 25328 accepted, 12062 dup
+[279s] 680000 files done, 25330 accepted, 12143 dup
+[282s] 685000 files done, 25333 accepted, 12209 dup
+[284s] 690000 files done, 25334 accepted, 12294 dup
+[286s] 695000 files done, 25337 accepted, 12380 dup
+[288s] 700000 files done, 25345 accepted, 12471 dup
+[291s] 705000 files done, 25353 accepted, 12554 dup
+[293s] 710000 files done, 25359 accepted, 12643 dup
+[295s] 715000 files done, 25364 accepted, 12720 dup
+[298s] 720000 files done, 25368 accepted, 12811 dup
+[300s] 725000 files done, 25374 accepted, 12891 dup
+[302s] 730000 files done, 25381 accepted, 12971 dup
+[304s] 735000 files done, 25384 accepted, 13033 dup
+[306s] 740000 files done, 25388 accepted, 13114 dup
+[309s] 745000 files done, 25392 accepted, 13204 dup
+[311s] 750000 files done, 25398 accepted, 13280 dup
+[313s] 755000 files done, 25405 accepted, 13369 dup
+[316s] 760000 files done, 25412 accepted, 13450 dup
+[318s] 765000 files done, 25420 accepted, 13531 dup
+[323s] 770000 files done, 25423 accepted, 13612 dup
+[325s] 775000 files done, 25429 accepted, 13705 dup
+[327s] 780000 files done, 25433 accepted, 13797 dup
+[329s] 785000 files done, 25434 accepted, 13871 dup
+[330s] 790000 files done, 25435 accepted, 13964 dup
+[339s] 795000 files done, 25439 accepted, 14039 dup
+[339s] 800000 files done, 25444 accepted, 14130 dup
+[339s] 805000 files done, 25449 accepted, 14210 dup
+[341s] 810000 files done, 25452 accepted, 14304 dup
+[344s] 815000 files done, 25458 accepted, 14377 dup
+[347s] 820000 files done, 25461 accepted, 14459 dup
+[350s] 825000 files done, 25463 accepted, 14539 dup
+[352s] 830000 files done, 25470 accepted, 14628 dup
+[354s] 835000 files done, 25476 accepted, 14719 dup
+[357s] 840000 files done, 25479 accepted, 14799 dup
+[359s] 845000 files done, 25482 accepted, 14895 dup
+[361s] 850000 files done, 25490 accepted, 15001 dup
+[364s] 855000 files done, 25492 accepted, 15076 dup
+[367s] 860000 files done, 25495 accepted, 15164 dup
+[370s] 865000 files done, 25496 accepted, 15254 dup
+[370s] 870000 files done, 25500 accepted, 15344 dup
+[373s] 875000 files done, 25507 accepted, 15438 dup
+[375s] 880000 files done, 25511 accepted, 15506 dup
+[377s] 885000 files done, 25516 accepted, 15590 dup
+[380s] 890000 files done, 25520 accepted, 15682 dup
+[381s] 895000 files done, 25526 accepted, 15766 dup
+[384s] 900000 files done, 25532 accepted, 15850 dup
+[387s] 905000 files done, 25534 accepted, 15928 dup
+[389s] 910000 files done, 25537 accepted, 16012 dup
+[391s] 915000 files done, 25539 accepted, 16102 dup
+[394s] 920000 files done, 25546 accepted, 16191 dup
+[396s] 925000 files done, 25550 accepted, 16274 dup
+[398s] 930000 files done, 25556 accepted, 16359 dup
+[401s] 935000 files done, 25560 accepted, 16437 dup
+[404s] 940000 files done, 25566 accepted, 16520 dup
+[405s] 945000 files done, 25572 accepted, 16597 dup
+[408s] 950000 files done, 25576 accepted, 16677 dup
+[412s] 955000 files done, 25583 accepted, 16762 dup
+[413s] 960000 files done, 25597 accepted, 16837 dup
+[416s] 965000 files done, 25600 accepted, 16925 dup
+[418s] 970000 files done, 25602 accepted, 17002 dup
+[420s] 975000 files done, 25609 accepted, 17092 dup
+[423s] 980000 files done, 25618 accepted, 17181 dup
+[425s] 985000 files done, 25625 accepted, 17275 dup
+[427s] 990000 files done, 25633 accepted, 17380 dup
+[429s] 995000 files done, 25636 accepted, 17471 dup
+[432s] 1000000 files done, 25638 accepted, 17550 dup
+[434s] 1005000 files done, 25644 accepted, 17638 dup
+[436s] 1010000 files done, 25649 accepted, 17722 dup
+[438s] 1015000 files done, 25652 accepted, 17799 dup
+[441s] 1020000 files done, 25660 accepted, 17871 dup
+[443s] 1025000 files done, 25666 accepted, 17949 dup
+[446s] 1030000 files done, 25667 accepted, 18038 dup
+[449s] 1035000 files done, 25676 accepted, 18123 dup
+[451s] 1040000 files done, 25681 accepted, 18222 dup
+[454s] 1045000 files done, 25687 accepted, 18316 dup
+[455s] 1050000 files done, 25688 accepted, 18398 dup
+[457s] 1055000 files done, 25691 accepted, 18487 dup
+[459s] 1060000 files done, 25700 accepted, 18577 dup
+[461s] 1065000 files done, 25704 accepted, 18667 dup
+[463s] 1070000 files done, 25709 accepted, 18751 dup
+[466s] 1075000 files done, 25712 accepted, 18837 dup
+[468s] 1080000 files done, 25715 accepted, 18923 dup
+[DONE] 1084436 files in 471s
+{
+  "canoverse.reject.no_skeleton": 229545,
+  "dataset_rig.accept": 24965,
+  "dataset_rig.dup": 5511,
+  "dataset_rig.reject.degenerate_bbox": 10,
+  "dataset_rig.reject.no_skeleton": 4,
+  "dataset_rig.reject.no_skinned_mesh": 34,
+  "dataset_rig.reject.non_glb:fbx": 17,
+  "dataset_rig.reject.non_glb:obj": 19997,
+  "dataset_rig.reject.non_glb:ply": 21,
+  "dataset_rig.reject.too_many_verts": 8708,
+  "objaverse_xl.accept": 756,
+  "objaverse_xl.dup": 13476,
+  "objaverse_xl.reject.bad_magic": 1,
+  "objaverse_xl.reject.degenerate_bbox": 2,
+  "objaverse_xl.reject.no_skeleton": 759940,
+  "objaverse_xl.reject.no_skinned_mesh": 3040,
+  "objaverse_xl.reject.too_large": 1128,
+  "objaverse_xl.reject.too_many_verts": 17281
+}

shards_index.json

@@ -0,0 +1,72 @@
+{
+  "meshes/meshes-000.tar": {
+    "num_files": 2000,
+    "first": "0000304b89ca43ea9d63a7c32f0398bc.glb",
+    "last": "106836a458ac4afc824c78b6b397c988.glb"
+  },
+  "meshes/meshes-001.tar": {
+    "num_files": 2000,
+    "first": "106abf2757924ce7990fe5b12e6a9a1d.glb",
+    "last": "222a3e9f7f794a80aa87fa0c8a145c8c.glb"
+  },
+  "meshes/meshes-002.tar": {
+    "num_files": 2000,
+    "first": "222b416357a04a1780815ce4fd7beaa5.glb",
+    "last": "34e512a6cb834201bc98b251dc5df951.glb"
+  },
+  "meshes/meshes-003.tar": {
+    "num_files": 2000,
+    "first": "34e5cedd240b4087bbaf491c0b31903c.glb",
+    "last": "4774f13767bd4dd5a07d76ac1f7fb3cd.glb"
+  },
+  "meshes/meshes-004.tar": {
+    "num_files": 2000,
+    "first": "4776030ed1a54274bde5491de1331f90.glb",
+    "last": "5b446752da5a468db6c357b36fe37c5c_17fe970e.glb"
+  },
+  "meshes/meshes-005.tar": {
+    "num_files": 2000,
+    "first": "5b44817772b24ceb9e08bb09f3d56fa9.glb",
+    "last": "6eccd8975a604eb4ab83bdec602ff37f.glb"
+  },
+  "meshes/meshes-006.tar": {
+    "num_files": 2000,
+    "first": "6eccd8975a604eb4ab83bdec602ff37f_027405f4.glb",
+    "last": "82e743d9fa184bb7886e570396dfda47.glb"
+  },
+  "meshes/meshes-007.tar": {
+    "num_files": 2000,
+    "first": "82e7e52b34c64a7f9421dc071ce8da4b.glb",
+    "last": "95ee5c76e08442a5ad00e2b02a8270b9.glb"
+  },
+  "meshes/meshes-008.tar": {
+    "num_files": 2000,
+    "first": "95ef7d9252a54284ba61e084c0b6b880.glb",
+    "last": "aa986e5603c249bc80c12f01220ea531_80bddf3a.glb"
+  },
+  "meshes/meshes-009.tar": {
+    "num_files": 2000,
+    "first": "aa9c0e4426924266bbd12b3dc80ed413.glb",
+    "last": "bf97adaf00f64a1486409fbaba1af2c9.glb"
+  },
+  "meshes/meshes-010.tar": {
+    "num_files": 2000,
+    "first": "bf9a0b8b4bc64868a7dcb92398bed4ac.glb",
+    "last": "d41589adebaf4fcfbba60c911fb32643.glb"
+  },
+  "meshes/meshes-011.tar": {
+    "num_files": 2000,
+    "first": "d415aa76dc614c38a54690c818e6805b.glb",
+    "last": "e9f48204bde942f78ba1fb3d56afcf1c.glb"
+  },
+  "meshes/meshes-012.tar": {
+    "num_files": 2000,
+    "first": "e9f841653056464a960ab6ee457a5dbc.glb",
+    "last": "ffab1ba7706f4db4aff10ed98f898451.glb"
+  },
+  "meshes/meshes-013.tar": {
+    "num_files": 33,
+    "first": "ffab1ba7706f4db4aff10ed98f898451_55607973.glb",
+    "last": "fff87ccd24464db1adb0995b5415b2d4_c0af9449.glb"
+  }
+}

stats.json

@@ -0,0 +1,20 @@
+{
+  "canoverse.reject.no_skeleton": 229545,
+  "dataset_rig.accept": 24965,
+  "dataset_rig.dup": 5511,
+  "dataset_rig.reject.degenerate_bbox": 10,
+  "dataset_rig.reject.no_skeleton": 4,
+  "dataset_rig.reject.no_skinned_mesh": 34,
+  "dataset_rig.reject.non_glb:fbx": 17,
+  "dataset_rig.reject.non_glb:obj": 19997,
+  "dataset_rig.reject.non_glb:ply": 21,
+  "dataset_rig.reject.too_many_verts": 8708,
+  "objaverse_xl.accept": 756,
+  "objaverse_xl.dup": 13476,
+  "objaverse_xl.reject.bad_magic": 1,
+  "objaverse_xl.reject.degenerate_bbox": 2,
+  "objaverse_xl.reject.no_skeleton": 759940,
+  "objaverse_xl.reject.no_skinned_mesh": 3040,
+  "objaverse_xl.reject.too_large": 1128,
+  "objaverse_xl.reject.too_many_verts": 17281
+}