zzhang2816/new_share_long_live_100

/home/tione/notebook/home/eckertzhang/Codes/LiveWorld/ckpts/

LiveWorld_comp

Drop-in inference wrapper that runs the LiveWorld video diffusion model with a user-supplied complete point cloud in place of LiveWorld's Stream3R-based geometry pipeline. Designed for comparison experiments: same diffusion backbone, same keyframe / overlap logic, different geometry source.

LiveWorld_comp/
├── run_liveworld.py          # entry point
├── configs/default.yaml      # paths to backbone / lora / state_adapter ckpts
├── core/
│   ├── inputs.py             # load user PC + first frame + poses + fg mask + proj mp4s
│   ├── precomputed.py        # read bg/fg_projection.mp4 → VAE latent (mp4 mode)
│   ├── color.py              # first-frame coloring (+ optional progressive; PC mode)
│   ├── projection.py         # scene_proj rendering (colored subset; PC mode)
│   ├── fg.py                 # P1 fg_proj latent encoding
│   ├── overlap.py            # P1 / P9 preceding builders
│   ├── reference.py          # re-export retrieve_reference_frames
│   ├── model_loader.py       # build UnifiedBackbonePipeline (no SAM3/Qwen/Stream3R)
│   └── pipeline.py           # main iter loop
└── inputs/<case>/            # one folder per test case

Converting mine_blender voxels → inputs

python scripts/convert_mine_blender.py \
    --meta /home/arenzhang/remote_copy/mine_blender/meta_long_updated.json \
    --output-root inputs/mine_blender \
    --num-frames 65

TL;DR data processing pipeline

The converter takes the fast path that mirrors what the model actually consumes, instead of a "physically pure" per-frame depth-sensor sim. Because coloring is keyed to first_frame.png only (progressive coloring is disabled by default in the inference pipeline), anything that can't be coloured from camera 0 gets dropped anyway — so we never bother generating it.

1. Static → cam-0 raycast (once). Build a triangle mesh from static voxel cubes + frame-0 dyn voxel cubes (the latter as occluder). Open3D- raycast every pixel of camera 0 only. Keep first-hit static points. static_pts = exactly the static surface visible at frame 0 with the character cut out. ~60× cheaper than the legacy 65-frame union and gives identical results downstream.
2. Per-voxel frame-0 color table. Project each dyn voxel's frame-0 centre to camera 0 and sample first_frame.png only if the pixel falls inside fg_mask. Voxels whose centre misses the mask are flagged "un-coloured" and dropped from every downstream step.
3. Persistent dyn-voxel identity. mine_blender stores each dyn object as (K, 3) per frame with stable row order: row i in any frame is the same physical voxel. The color table from step 2 is indexed by row, so each voxel keeps its colour as it moves through time — for free, with no per-frame search.
4. Dyn → surface samples (no raycast). For each frame t, transform a SHARED unit-cube surface template (default 96 samples per voxel) by the per-voxel (size_t, center_t). Each sample inherits its voxel's persistent frame-0 colour. Z-buffer splat at render time handles silhouette and inter-voxel occlusion correctly. No raycasting per frame. This is the biggest single speedup.
5. PC for the model = static cam-0 hits ∪ dyn samples from the first --num-frames frames, voxel-downsampled at 1 cm, saved as pointcloud.npz. Camera trajectory → geometry.npz. First frame + fg_mask_first.png + prompt complete the case folder.
6. bg visualization (bg_projection.mp4): each static point projects to camera 0 and samples first_frame.png RGB. Points outside cam 0 OR inside fg_mask are dropped entirely (rendered black, not gray) so every visible pixel is a real sample. Z-buffer splat through each --viz-num-frames camera.
7. fg visualization (fg_projection.mp4): the per-frame dyn samples from step 4 are splatted directly — colour follows the voxel rigidly. Uncoloured voxels are pre-filtered out, so leftover regions stay pure black.

Speed: the full mine_blender boxing case (84 dyn voxels × 420 frames, target 480×832) takes ~30 s end-to-end, ~30× faster than the legacy per-frame raycast path.

The bg/fg_projection.mp4 files are sanity checks for the converter; the model only consumes pointcloud.npz, geometry.npz, first_frame.png, fg_mask_first.png, prompt.txt.

Depth-derived PC details

The default --visibility depth mode produces a depth-derived PC that is fair-comparable to LiveWorld's STream3R input, but takes a shortcut that's only valid because the inference pipeline colours everything from first_frame.png only (progressive coloring is disabled by default):

• Static side: build axis-aligned cube meshes for static voxels and ONE Open3D RaycastingScene containing static + frame-0 dyn cubes (the latter as occluder). Raycast camera 0 only. First-hit 3D points are kept.
• Dyn side: no raycasting at all. For every coloured dyn voxel, evaluate a SHARED unit-cube surface template (default 96 samples) at the per-frame (size_t, center_t). Each sample carries the voxel's persistent frame-0 colour. Z-buffer at splat time handles silhouette.
• Both layers are voxel-downsampled at 1 cm and concatenated for pointcloud.npz.

Result: only surfaces that are (a) reachable from camera 0 and (b) coloured by first_frame.png survive — exactly the set the pipeline would use anyway, computed ~30× faster than the legacy per-frame raycast sim.

Blender camera → OpenCV camera: cam-local Y/Z columns are negated, so poses_c2w is directly usable by LiveWorld's projection helpers.

Flags worth knowing:

• --num-frames N number of frames the model will iteratively generate (default: all in metadata). Saved as geometry.npz's poses_c2w and determines which dyn samples land in pointcloud.npz.
• --viz-num-frames N length of the bg/fg projection mp4s (default: same as --num-frames). Set larger than --num-frames only when you want to preview the full trajectory beyond what the model will render.
• --dyn-samples-per-voxel 96 (depth mode) surface samples per coloured dyn voxel for the no-raycast fast path. Default 96 ≈ 16/face — denser = smoother fg viz / scene_proj input, slower z-buffer splat.
• --visibility {depth,backface,none} default depth. backface / none use surface sampling instead of the new fast path; debug only.
• --final-voxel-downsample 0.01 PC dedupe voxel size in metres (default 0.01 m for depth mode; off otherwise)
• --points-per-voxel 48 surface samples per voxel (only used by non-depth modes — ignored when --visibility depth)
• --voxel-size-scale 1.0 shrink/grow every cube edge
• --fg-dilate 5 pixel dilation for the foreground mask
• --names … only convert these specific entries
• --limit N process only the first N matched entries (smoke test)
• --overwrite redo cases whose outputs already exist
• --no-projection-videos skip writing the bg/fg projection videos
• --viz-fps 16 fps of the projection mp4s (default 16)
• --viz-colormap … retained for backward compat — currently ignored since the viz is RGB-sampled from first_frame.png, not a depth colormap

Per case the converter writes two extra MP4s next to pointcloud.npz. Both use LiveWorld's z-buffer point splat (each 3-D point → 1 pixel, keep the closest one) with RGB colors sampled from first_frame.png, mirroring spmem_comp's full_tracking.mp4 recipe. Any holes / sparsity here are real artifacts in the State Adapter condition, not viz quirks.

How the videos are built:

1. bg (bg_projection.mp4) — static cam-0 PC voxel-downsampled to 1 cm. Each point projects to camera 0 and samples first_frame.png. Points that project outside cam 0 OR onto a pixel inside fg_mask_first.png are dropped entirely (rendered as the pure-black background); only points with a real color are splatted. You see a clean colored scene with a pure-black character-shaped hole and pure-black uncovered regions.
2. fg (fg_projection.mp4) — per-frame dyn surface samples are splatted directly. Each sample carries its source voxel's persistent frame-0 colour (the voxel-identity table is built once and shared across all frames). The character keeps the same realistic colours as it moves; uncoloured voxels are pre-filtered out so leftover regions stay pure black.
3. Both videos are z-buffer splatted at the target resolution and encoded as H.264 / yuv420p / +faststart via imageio_ffmpeg's bundled ffmpeg.

Per-case sanity check:

python -c "
import numpy as np
g = np.load('inputs/mine_blender/<case>/geometry.npz')
print('poses', g['poses_c2w'].shape, 'K', g['K'].shape, 'size', g['intrinsics_size'])
print('points', np.load('inputs/mine_blender/<case>/pointcloud.npz')['points'].shape)
"

Inputs

Each inputs/<case>/ folder must contain:

file	type	shape / meaning
first_frame.png	RGB image	resized to target_hw (default 480×832)
prompt.txt	text	scene description (and optional fg description appended)
geometry.npz	npz	required keys: poses_c2w (N, 4, 4) float32, K (3, 3) float32. Optional: intrinsics_size (2,) — H, W of K's reference resolution; defaults to first_frame's
pointcloud.npz	npz	required key: points (M, 3) float32 in the same world coords as poses_c2w
fg_mask_first.png	optional grayscale	foreground mask of the first frame (>0 = fg). Used for P1 preceding fg_proj. Set use_fg_proj=false in config to disable

All geometry must share one world coordinate system. We do not estimate any alignment transform — the pipeline assumes points, poses_c2w, and first_frame's camera (poses_c2w[0]) are all consistent.

Run

Two selection modes (the meta+indices form mirrors the converter):

cd LiveWorld_comp

# A) by meta + indices (batch; case folders resolved by entry name)
python run_liveworld.py \
    --meta         /path/meta_long_updated.json \
    --inputs-root  inputs/mine_blender \
    --output-root  outputs \
    --indices      0 \
    --config       configs/default.yaml

# B) a single explicit case folder
python run_liveworld.py \
    --input-dir   inputs/mine_blender/<case> \
    --output-dir  outputs/<case> \
    --config      configs/default.yaml

Conditioning source (run.condition_source)

• mp4 (default) — scene/fg conditioning is read straight from the converter's bg_projection.mp4 (→ scene_proj) and fg_projection.mp4 (→ fg_proj), then VAE-encoded. The per-iter point-cloud projection and the whole coloring step are skipped (the MP4s already are the projection). The point cloud is still loaded, but only for 3D-IoU reference-frame retrieval. Requires the case folder to contain both MP4s, and they must cover at least num_frames frames aligned to poses_c2w (the converter guarantees this when --viz-num-frames >= --num-frames, which is the default).
• pointcloud — legacy LiveWorld path: render scene_proj from the coloured PC each iter via render_projection, keeping the coloring logic (see "How coloring works"). fg_proj for target frames stays zero.

Output layout:

outputs/case_xxx/
├── final_video.mp4
├── videos/
│   ├── iteration_01_generated_frames0-64.mp4
│   ├── iteration_01_scene_projection_input.mp4
│   ├── iteration_01_concat_frames0-64.mp4
│   └── reference_iter_02.{mp4,json}  (iter >= 2)
└── pointclouds/
    ├── iteration_00_initial_pointcloud.ply
    └── iteration_NN_pointcloud.ply

How coloring works

Only relevant when condition_source=pointcloud. In the default mp4 mode the scene/fg conditioning comes from the precomputed projection videos, so there is no coloring step at all — colours were baked into the MP4s by the converter (static from first_frame, dynamic from the per-voxel frame-0 table). The text below describes the legacy PC path.

Legacy PC path: first-frame-only coloring. Progressive coloring is disabled. The rationale: it was complex, introduced inter-iter colour drift, and the converter already drops every point that couldn't be coloured from first_frame — so iter-N "newly colourable" points basically don't exist anyway.

• Before iter 0: every point visible from poses_c2w[0] is coloured from first_frame.png. Per-voxel dyn colours come from a frame-0 voxel-id table (see converter step 2).
• End of iter N: nothing — the colour table is frozen. Every iter re-renders scene_proj against the same colours; only camera poses and target_frame_indices change between iters.
• Uncoloured points are skipped at scene-projection time so they don't paint bogus black pixels into the State Adapter condition.

Full geometry is always used for keyframe retrieval (3D IoU) — coloring only affects rendering, not selection.

Legacy progressive coloring is still available via RunOptions.progressive_coloring=True. It re-colours newly visible points after every iter using that iter's generated frames; useful only if you ever extend the converter to keep static / dyn surfaces beyond what's visible from frame 0.

How long videos are generated

LiveWorld iterates internally. The total video length comes from len(geometry.npz['poses_c2w']) (= the converter's --num-frames).

total = len(geometry.npz['poses_c2w'])       # e.g. 65 or 420
frames_per_iter ≈ 17 or 33                   # from RunOptions
iters ≈ ceil(total / frames_per_iter)

Per iter the pipeline builds:

• Preceding frames (P): the last few frames of the previous iter (P1 = the immediately preceding generated frame, P9 = 8 more recent generated frames or first-frame fallback).
• Reference frames (R): retrieved from the full pool by 3D-IoU overlap with the new iter's target poses, ensuring the diffusion sees visually-related past frames even when they're temporally distant.
• Target frames (T): the new chunk of poses (frames_per_iter of them) to be generated this iter.

In mp4 mode, scene_proj / fg_proj for each iter are obtained by slicing the precomputed videos at the iter's target_frame_indices (and the preceding poses) and VAE-encoding — no projection compute. In pointcloud mode, scene_proj is rendered fresh per iter for the target cameras from a point cloud whose colours are updated at each chunk boundary using the previous chunk's tail frame. The default pointcloud_scene_mp4_fg mode uses that point-cloud scene projection while still slicing fg_projection.mp4 for foreground conditioning. There's no separate "short-test" vs "production" mode — only the value of --num-frames differs.

Reuse vs. removed

Reused from LiveWorld (unchanged):

• UnifiedBackbonePipeline.run_single_iteration[_few_step]
• retrieve_reference_frames (3D IoU keyframe selection)
• _update_frame_visibility
• generate_scene_projection_from_pointcloud
• compute_iteration_plan, set_seed, save_video_h264, save_point_cloud_ply
• P1 / P9 preceding semantics + accumulated_anchor_global_indices overlap tracking

Removed:

• Stream3R first-frame reconstruction + incremental updates
• Qwen3-VL entity detection
• SAM3 dynamic/sky segmentation
• EventPool / monitor-centric foreground evolution
• DINOv3 entity matching

Comparison-fair settings

For a clean comparison against LiveWorld's STream3R PC:

1. Voxel-downsample your PC at the same resolution as LiveWorld's scene_voxel_size (default 0.01).
2. Keep all max_reference_frames, voxel_size_iou, sp_context_scale, denoising_step_list identical to the system YAML.
3. Run both methods with the same seed.
4. Use the same first_frame, prompt, poses_c2w, and fg_mask_first — only the PC geometry differs.