Add dataset card, copyright notice, indexes and tooling

scripts/glb_probe.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Extract structural metadata from a .glb by parsing only its JSON chunk.
+
+GLB layout: 12-byte header ('glTF', version, length) then chunks
+(uint32 length, uint32 type, data). Chunk 0 is JSON, so we never touch the
+binary payload — probing 23 GB of assets costs only a few hundred MB of reads.
+"""
+import json, os, struct, sys
+
+def read_gltf_json(path, max_json=64 << 20):
+    with open(path, "rb") as f:
+        head = f.read(12)
+        if len(head) < 12 or head[:4] != b"glTF":
+            raise ValueError("not a GLB")
+        ver, total = struct.unpack("<II", head[4:12])
+        ch = f.read(8)
+        if len(ch) < 8:
+            raise ValueError("truncated")
+        clen, ctype = struct.unpack("<II", ch)
+        if ctype != 0x4E4F534A:            # 'JSON'
+            raise ValueError("first chunk not JSON")
+        if clen > max_json:
+            raise ValueError("json chunk too large: %d" % clen)
+        raw = f.read(clen)
+        if len(raw) < clen:
+            raise ValueError("truncated json chunk")
+    return ver, json.loads(raw.decode("utf-8", "replace"))
+
+
+def probe(path):
+    ver, g = read_gltf_json(path)
+    nodes = g.get("nodes", []) or []
+    skins = g.get("skins", []) or []
+    anims = g.get("animations", []) or []
+    accs  = g.get("accessors", []) or []
+    meshes= g.get("meshes", []) or []
+
+    # parent map from node children
+    parent = {}
+    for i, n in enumerate(nodes):
+        for c in (n.get("children") or []):
+            parent[c] = i
+
+    joints = set()
+    per_skin = []
+    for s in skins:
+        js = s.get("joints") or []
+        per_skin.append(len(js))
+        joints.update(js)
+
+    # kinematic-tree roots among joints: a joint whose parent is not a joint
+    roots = [j for j in joints if parent.get(j) not in joints]
+
+    # animation stats: max time from each sampler's input accessor max
+    dur = 0.0
+    channels = 0
+    keyframes = 0
+    anim_names = []
+    for a in anims:
+        anim_names.append(a.get("name") or "")
+        channels += len(a.get("channels") or [])
+        for smp in (a.get("samplers") or []):
+            ai = smp.get("input")
+            if ai is None or ai >= len(accs):
+                continue
+            acc = accs[ai]
+            keyframes = max(keyframes, acc.get("count", 0) or 0)
+            mx = acc.get("max")
+            if isinstance(mx, list) and mx:
+                try: dur = max(dur, float(mx[0]))
+                except (TypeError, ValueError): pass
+
+    # does any animation actually drive a joint?
+    animated_nodes = set()
+    for a in anims:
+        for c in (a.get("channels") or []):
+            t = (c.get("target") or {}).get("node")
+            if t is not None: animated_nodes.add(t)
+    animated_joints = len(animated_nodes & joints)
+
+    verts = 0
+    for m in meshes:
+        for p in (m.get("primitives") or []):
+            ai = (p.get("attributes") or {}).get("POSITION")
+            if ai is not None and ai < len(accs):
+                verts += accs[ai].get("count", 0) or 0
+
+    gen = (g.get("asset") or {}).get("generator", "")
+    return {
+        "gltf_version": ver,
+        "generator": gen[:80],
+        "num_nodes": len(nodes),
+        "num_meshes": len(meshes),
+        "num_vertices": verts,
+        "num_skins": len(skins),
+        "num_joints": len(joints),
+        "max_skin_joints": max(per_skin) if per_skin else 0,
+        "num_skeleton_roots": len(roots),
+        "num_animations": len(anims),
+        "num_anim_channels": channels,
+        "animated_joints": animated_joints,
+        "max_keyframes": keyframes,
+        "duration_sec": round(dur, 4),
+        "anim_names": "|".join(n for n in anim_names if n)[:200],
+    }
+
+if __name__ == "__main__":
+    for p in sys.argv[1:]:
+        try: print(os.path.basename(p), json.dumps(probe(p)))
+        except Exception as e: print(os.path.basename(p), "ERROR", e)