Default to one-by-one, robust video decode, add 40-img/1-img examples

- Default inference mode is now One-by-one (was Joint).
- Decode videos with cv2.VideoCapture instead of imageio's extension-based plugin
pick, which only yielded the first frame of webcam recordings; now the first
MAX_FRAMES frames are used (imageio fallback kept).
- Add two click-to-run gr.Examples (cache_examples=False so the build never runs
on the GPU-less builder): a 40-image sequence and a single image, vendored under
examples/seq40/ (first 40 frames of nersemble 109 EMO-1-shout+laugh), LFS-tracked.
Verified: examples build on gradio 6.19; cv2 extracts 40 frames from a 50-frame clip.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* 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
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -197,6 +197,28 @@ def _sniff_ext(path):
         return ".png"
 
 
+def _extract_video(video_path, max_frames, out_dir):
+    """Decode the first ``max_frames`` frames of a video. Uses cv2.VideoCapture,
+    which (unlike imageio's extension-based plugin pick) robustly decodes webcam
+    recordings — those were yielding only a single frame otherwise."""
+    import cv2
+
+    os.makedirs(out_dir, exist_ok=True)
+    paths = []
+    cap = cv2.VideoCapture(video_path)
+    try:
+        while len(paths) < int(max_frames):
+            ok, frame = cap.read()
+            if not ok:
+                break
+            p = os.path.join(out_dir, f"frame_{len(paths):04d}.png")
+            cv2.imwrite(p, frame)  # BGR ndarray -> correct-RGB PNG on disk
+            paths.append(p)
+    finally:
+        cap.release()
+    return paths
+
+
 def _prepare_inputs(files, video, max_frames, workdir):
     """Normalize the upload (an image set OR a video) into an ordered list of
     frame paths.
@@ -206,14 +228,21 @@ def _prepare_inputs(files, video, max_frames, workdir):
     one): files are natural-sorted by their original name (temporal order),
     capped, then copied as ``frame_XXXX.<ext>`` with a content-sniffed extension.
     """
-    from faceanything.io_utils import load_frame_paths
-
     if video:
         vpath = video if isinstance(video, str) else _to_entry(video)[0]
         if vpath and os.path.exists(vpath):
-            paths, _ = load_frame_paths(
-                vpath, max_frames=int(max_frames), stride=1,
-                work_dir=os.path.join(workdir, "video_frames"))
+            paths = _extract_video(vpath, max_frames,
+                                   os.path.join(workdir, "video_frames"))
+            if len(paths) <= 1:  # fall back to imageio if cv2 read too few frames
+                from faceanything.io_utils import load_frame_paths
+                try:
+                    alt, _ = load_frame_paths(
+                        vpath, max_frames=int(max_frames), stride=1,
+                        work_dir=os.path.join(workdir, "video_frames_io"))
+                    if len(alt) > len(paths):
+                        paths = alt
+                except Exception:
+                    pass
             if paths:
                 return paths
 
@@ -576,10 +605,10 @@ def build_demo():
                 )
                 mode = gr.Radio(
                     choices=["Joint", "One-by-one"],
-                    value="Joint",
+                    value="One-by-one",
                     label="Inference mode",
-                    info="Joint (all-at-once): more 3D-consistent across frames. "
-                         "One-by-one: more surface detail, lower memory.",
+                    info="One-by-one: more surface detail, lower memory. "
+                         "Joint (all-at-once): more 3D-consistent across frames.",
                 )
                 remove_bg = gr.Checkbox(
                     value=True, label="Remove background",
@@ -650,6 +679,26 @@ def build_demo():
         # slider — smoother than reloading a glb on every drag tick.
         frame_slider.release(pick_frame, inputs=[frame_slider, view_state],
                              outputs=model3d)
+
+        # ---------------- examples (click to load + run) ----------------
+        ex40 = sorted(glob.glob(os.path.join(APP_DIR, "examples", "seq40", "*.png")))[:MAX_IMAGES]
+        if ex40:
+            gr.Examples(
+                examples=[
+                    [ex40, None, "One-by-one", 504, True, 0, 100, 25, 0.01, 10, MAX_IMAGES],
+                    [ex40[:1], None, "One-by-one", 504, True, 0, 100, 25, 0.01, 10, 1],
+                ],
+                example_labels=[f"{len(ex40)}-image sequence", "Single image"],
+                inputs=[files, video, mode, process_res, remove_bg,
+                        conf_percentile, n_tracks, track_k, track_threshold,
+                        fps, max_frames],
+                outputs=[model3d, canonical_vid, depth_vid, normals_vid,
+                         tracks2d_vid, tracks_zip, view_state, frame_slider, status],
+                fn=run,
+                run_on_click=True,     # click runs the pipeline
+                cache_examples=False,  # never pre-run at build (no GPU at build time)
+                label="Examples — click to load and run",
+            )
     return demo