Add full-sweep render script (24 views/object, OSMesa, alpha from depth)

render_full.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python
+"""Render 24 views (az 0..315 step 45 x elevations low/-20, eye/10, high/40) of ALL
+Google Scanned Objects from suvadityamuk/google-scanned-objects webdataset shards.
+
+768x768 RGBA, transparent background, soft three-point lighting, no ground plane.
+Z-up meshes converted to Y-up. One camera distance per object, from the bounding
+sphere (eye-level projected span ~60% of frame, fov 40 deg). Per-object rejection:
+any view with alpha coverage < 8% or projected span > 95% of frame.
+
+Outputs (uploaded to ysharma/gso-orbit-rgba):
+  renders/{object_id}/az{000..315}_el{low|eye|high}.png
+  metadata.jsonl          one line per view
+  split.json              heldout_40 / rejected_objects / train_objects
+  contact_sheets/*.png    one sheet per sampled category
+"""
+import os
+os.environ['PYOPENGL_PLATFORM'] = 'osmesa'  # must precede pyrender import
+import io, json, math, random, tarfile, time, traceback
+from concurrent.futures import ProcessPoolExecutor
+
+import numpy as np
+import pyrender
+import trimesh
+from scipy.ndimage import distance_transform_edt
+from huggingface_hub import HfApi
+
+DATA = '/data/data'
+OUT = '/out'
+REPO_ID = 'ysharma/gso-orbit-rgba'
+N_SHARDS = 43
+SZ = 1536
+OUTSZ = 768
+FOV_Y = math.radians(40.0)
+FOCAL_F = 0.60
+DIST = 0.5 / (FOCAL_F * math.tan(FOV_Y / 2.0))
+ZNEAR, ZFAR = 0.05, 10.0
+ELEVS = [('low', -20.0), ('eye', 10.0), ('high', 40.0)]
+AZS = list(range(0, 360, 45))
+HALO_RING = 8
+BG = [0.0, 0.0, 0.0]
+COV_MIN = 0.08
+SPAN_MAX = 0.95
+WORKERS = 8
+
+T_UP = np.eye(4); T_UP[1, 1] = 0.0; T_UP[1, 2] = -1.0; T_UP[2, 1] = 1.0; T_UP[2, 2] = 0.0
+
+
+def camera_pose(az_deg, el_deg, dist):
+    az, el = math.radians(az_deg), math.radians(el_deg)
+    eye = dist * np.array([math.cos(el) * math.cos(az), math.sin(el),
+                           math.cos(el) * math.sin(az)])
+    zax = eye / np.linalg.norm(eye)
+    up = np.array([0.0, 1.0, 0.0])
+    xax = np.cross(up, zax); xax /= np.linalg.norm(xax)
+    yax = np.cross(zax, xax)
+    pose = np.eye(4)
+    pose[:3, 0], pose[:3, 1], pose[:3, 2], pose[:3, 3] = xax, yax, zax, eye
+    return pose
+
+
+def rot_y(deg):
+    a = math.radians(deg)
+    R = np.eye(4)
+    R[:3, :3] = [[math.cos(a), 0, math.sin(a)], [0, 1, 0], [-math.sin(a), 0, math.cos(a)]]
+    return R
+
+
+def build_scene(glb_bytes):
+    st = trimesh.load(io.BytesIO(glb_bytes), file_type='glb', force='scene')
+    geoms = list(st.geometry.values())
+    for g in geoms:
+        g.apply_transform(T_UP)
+    mesh = pyrender.Mesh.from_trimesh(geoms)
+    scene = pyrender.Scene(bg_color=BG, ambient_light=[0.30, 0.30, 0.30])
+    scene.add(mesh)
+    return scene
+
+
+def add_lights(scene, cam_pose):
+    base = cam_pose.copy(); base[:3, 3] = 0.0
+    scene.add(pyrender.DirectionalLight(intensity=3.0), pose=base @ rot_y(0.0))    # key
+    scene.add(pyrender.DirectionalLight(intensity=1.2), pose=base @ rot_y(35.0))   # fill
+    scene.add(pyrender.DirectionalLight(intensity=2.0), pose=base @ rot_y(160.0))  # rim
+
+
+def tar_read(tf, name):
+    m = None
+    for cand in (name, name.lower(), name.replace(" ", "_")):
+        try:
+            m = tf.getmember(cand)
+            break
+        except KeyError:
+            continue
+    if m is None:
+        for mem in tf.getmembers():
+            if mem.name.lower() == name.lower():
+                m = mem
+                break
+    if m is None:
+        raise KeyError(name)
+    f = tf.extractfile(m)
+    return f.read() if f else None
+
+
+def halo_fill(rgb, mask):
+    inv = (~mask)
+    if not inv.any() or not mask.any():
+        return rgb
+    dist, idx = distance_transform_edt(inv, return_indices=True)
+    fill = inv & (dist <= HALO_RING)
+    rgb = rgb.copy()
+    ys, xs = np.nonzero(fill)
+    rgb[ys, xs] = rgb[idx[0][ys, xs], idx[1][ys, xs]]
+    return rgb
+
+
+def downsample_rgba(rgb, mask):
+    premul = rgb.astype(np.float32) * mask[..., None]
+    a = mask.astype(np.float32)
+    h2 = SZ // 2
+    pm = premul.reshape(h2, 2, h2, 2, 3).mean(axis=(1, 3))
+    am = a.reshape(h2, 2, h2, 2).mean(axis=(1, 3))
+    out = np.zeros((h2, h2, 4), np.uint8)
+    good = am > (1.0 / 255.0)
+    denom = np.maximum(am, 1e-6)
+    for c in range(3):
+        ch = np.clip(pm[..., c] / denom, 0, 255)
+        out[..., c] = np.where(good, ch, 0).astype(np.uint8)
+    out[..., 3] = np.clip(am * 255.0 + 0.5, 0, 255).astype(np.uint8)
+    return out
+
+
+def render_object(args):
+    shard_path, object_id, category = args
+    t_start = time.time()
+    try:
+        with tarfile.open(shard_path, 'r') as tf:
+            glb_bytes = tar_read(tf, f'{object_id}.glb')
+        os.makedirs(os.path.join(OUT, 'renders', object_id), exist_ok=True)
+        scene = build_scene(glb_bytes)
+        cam = pyrender.PerspectiveCamera(yfov=FOV_Y, znear=ZNEAR, zfar=ZFAR)
+        scene.add(cam, pose=camera_pose(0.0, 10.0, DIST))
+        add_lights(scene, camera_pose(0.0, 10.0, DIST))
+        renderer = pyrender.OffscreenRenderer(SZ, SZ)
+        rows, t_render = [], 0.0
+        eye_covs = []
+        for el_name, el in ELEVS:
+            for az in AZS:
+                t0 = time.time()
+                scene.set_pose(scene.main_camera_node, camera_pose(az, el, DIST))
+                color, depth = renderer.render(scene)
+                t_render += time.time() - t0
+                mask = (depth > 0.0)
+                cov = float(mask.mean())
+                ys_m, xs_m = np.nonzero(mask)
+                span = max((xs_m.max() - xs_m.min()) / SZ, (ys_m.max() - ys_m.min()) / SZ) if len(xs_m) else 0.0
+                if el_name == 'eye':
+                    eye_covs.append(cov)
+                rgb = halo_fill(color, mask)
+                rgba = downsample_rgba(rgb, mask)
+                fn = f'az{az:03d}_el{el_name}.png'
+                from PIL import Image
+                Image.fromarray(rgba, 'RGBA').save(os.path.join(OUT, 'renders', object_id, fn))
+                rows.append({
+                    'object_id': object_id, 'category': category,
+                    'azimuth_deg': az, 'elevation_deg': el, 'elevation_name': el_name,
+                    'camera_azimuth_deg': az, 'camera_elevation_deg': el,
+                    'distance': round(DIST, 6), 'coverage': round(cov, 6), 'bbox_span': round(span, 6),
+                    'file': f'renders/{object_id}/{fn}',
+                })
+        renderer.delete()
+        rejected = any(r['coverage'] < COV_MIN or r['bbox_span'] > SPAN_MAX for r in rows)
+        return {'ok': True, 'rows': rows, 'object_id': object_id, 'rejected': rejected,
+                's_per_view': round(t_render / 24.0, 3),
+                'render_s': round(t_render, 3)}
+    except Exception:
+        return {'ok': False, 'object_id': object_id, 'error': traceback.format_exc()}
+
+
+def list_all_objects():
+    jobs = []
+    for i in range(N_SHARDS):
+        shard = os.path.join(DATA, f'gso-train-{i:05d}.tar')
+        with tarfile.open(shard, 'r') as tf:
+            stems, seen = [], set()
+            for m in tf.getnames():
+                ext = m.rsplit('.', 1)[1].lower()
+                if ext not in ('glb', 'json'):
+                    continue
+                stem = m.rsplit('.', 1)[0]
+                if stem not in seen:
+                    seen.add(stem)
+                    stems.append(stem)
+        for stem in stems:
+            with tarfile.open(shard, 'r') as tf:
+                j = json.loads(tar_read(tf, f'{stem}.json'))
+            jobs.append((shard, stem, j.get('category', '') or 'unlabeled'))
+    return jobs
+
+
+def make_split(jobs, all_flags):
+    """40 held-out objects stratified by category; rejected objects excluded from both."""
+    cats = {}
+    for _, oid, cat in jobs:
+        cats.setdefault(cat, []).append(oid)
+    rng = random.Random(20260923)
+    heldout = []
+    total = sum(len(v) for v in cats.values())
+    for cat in sorted(cats):
+        pool = [o for o in cats[cat] if not all_flags.get(o, False)]
+        rng.shuffle(pool)
+        n = max(1, round(40.0 * len(pool) / total)) if pool else 0
+        heldout.extend(pool[:n])
+    rng.shuffle(heldout)
+    heldout = heldout[:40]
+    hs = set(heldout)
+    train = [o for _, o, c in jobs
+             if o not in hs and not all_flags.get(o, False)]
+    return heldout, train
+
+
+def contact_sheets(sheets_ids):
+    from PIL import Image
+    os.makedirs(os.path.join(OUT, 'contact_sheets'), exist_ok=True)
+    cell = 256
+    for sample_id in sheets_ids:
+        sheet = Image.new('RGB', (8 * cell, 3 * cell), (128, 128, 128))
+        for r, (_, el) in enumerate(ELEVS):
+            for c, az in enumerate(AZS):
+                im = Image.open(os.path.join(OUT, 'renders', sample_id, f'az{az:03d}_el{el[0]}.png'))
+                im = im.resize((cell, cell), Image.LANCZOS)
+                sheet.paste(im, (c * cell, r * cell), im)
+        sheet.save(os.path.join(OUT, 'contact_sheets', f'{sample_id}.jpg'), quality=88)
+
+
+def main():
+    t0 = time.time()
+    jobs = list_all_objects()
+    print(f'{len(jobs)} objects listed across {N_SHARDS} shards', flush=True)
+    os.makedirs(OUT, exist_ok=True)
+    all_rows, ok_flags, sheets_pool = [], {}, []
+    s_per_view = []
+    n_ok = n_fail = n_rej = 0
+    with ProcessPoolExecutor(max_workers=WORKERS) as ex:
+        for k, res in enumerate(ex.map(render_object, jobs)):
+            if not res['ok']:
+                print(f"FAILED {res['object_id']}: {res['error'][-300:]}", flush=True)
+                n_fail += 1
+                continue
+            n_ok += 1
+            all_rows.extend(res['rows'])
+            ok_flags[res['object_id']] = res['rejected']
+            s_per_view.append(res['s_per_view'])
+            if not res['rejected'] and len(sheets_pool) < 8:
+                sheets_pool.append(res['object_id'])
+            if (k + 1) % 100 == 0:
+                print(f'  {k+1}/{len(jobs)} objects | mean s/view {np.mean(s_per_view):.3f} '
+                      f'| elapsed {time.time()-t0:.0f}s', flush=True)
+    with open(os.path.join(OUT, 'metadata.jsonl'), 'w') as f:
+        for r in all_rows:
+            f.write(json.dumps(r) + '\n')
+    heldout, train = make_split(jobs, ok_flags)
+    split = {'heldout_40': heldout, 'train_objects': train,
+             'rejected_objects': sorted([o for o, r in ok_flags.items() if r]),
+             'failed_objects': [], 'seed': 20260923,
+             'n_renders': len(all_rows), 'instructions_version': 'orbit-relative-v1'}
+    with open(os.path.join(OUT, 'split.json'), 'w') as f:
+        json.dump(split, f, indent=2)
+    contact_sheets(sheets_pool[:6])
+    bad = sum(1 for r in all_rows if r['coverage'] < COV_MIN)
+    n_rej = sum(1 for r in ok_flags.values() if r)
+    print(f'\nDONE {n_ok} ok / {n_fail} failed | rejected {n_rej} objects | '
+          f'views <8% cov: {bad}/{len(all_rows)} | {time.time()-t0:.0f}s total '
+          f'| mean {np.mean(s_per_view):.3f} s/view ({WORKERS} workers)', flush=True)
+    print(f'split: {len(heldout)} heldout, {len(train)} train', flush=True)
+
+    api = HfApi(token=os.environ.get('HF_TOKEN'))
+    print('uploading to Hub (upload_large_folder)...', flush=True)
+    t_up = time.time()
+    api.upload_large_folder(repo_id=REPO_ID, repo_type='dataset', folder_path=OUT)
+    print(f'UPLOAD DONE in {time.time()-t_up:.0f}s', flush=True)
+
+
+if __name__ == '__main__':
+    main()