Deploy Space app files

app.py

@@ -23,13 +23,9 @@ from PIL import Image
 from utils import (
     BOOL_FILTER_CHOICES,
     FILTER_ALL,
-    aggregate_by_model,
     filter_dataframe_advanced,
-    format_instance_choice,
-    format_model_choice,
     get_distinct_text_choices,
     logger,
-    parse_choice_index,
     require_bool_columns,
     require_columns,
     require_text_columns,
@@ -85,6 +81,13 @@ def load_preview_dataframe() -> pd.DataFrame:
     return df
 
 
+def decode_image_bytes(img_bytes: bytes | bytearray, context: str) -> Image.Image:
+    if not isinstance(img_bytes, (bytes, bytearray)) or not img_bytes:
+        raise TypeError(f"Expected non-empty image bytes for {context}.")
+    with Image.open(io.BytesIO(img_bytes)) as img:
+        return img.copy()
+
+
 def build_preview_instance_dataframe(preview_df: pd.DataFrame) -> pd.DataFrame:
     """Derive one row per preview instance from preview frame rows."""
     instance_cols = [
@@ -119,34 +122,49 @@ def build_preview_instance_dataframe(preview_df: pd.DataFrame) -> pd.DataFrame:
     return df
 
 
-def load_instance_frames(
-    preview_df: pd.DataFrame, instance_id: str, split: str = "train", max_frames: int = 50,
-) -> list[dict[str, Any]]:
-    """Load preview image payloads for one instance from preview Parquet."""
+def train_frame_rows(preview_df: pd.DataFrame, instance_id: str, max_frames: int | None = None) -> list[dict[str, Any]]:
     selected = preview_df[
         (preview_df["instance_id"].astype(str) == str(instance_id))
-        & (preview_df["split"].astype(str) == split)
+        & (preview_df["split"].astype(str) == "train")
     ].copy()
-    selected = selected.sort_values("frame_id").head(max_frames)
+    if selected.empty:
+        raise ValueError(f"Preview instance {instance_id!r} has no train split rows.")
+    selected = selected.sort_values("frame_id")
+    if max_frames is not None:
+        selected = selected.head(max_frames)
+    return selected.to_dict(orient="records")
+
+
+def get_instance_thumbnail(preview_df: pd.DataFrame, instance_id: str) -> Image.Image:
+    row = train_frame_rows(preview_df, instance_id, max_frames=1)[0]
+    return decode_image_bytes(row["rgb"], f"{instance_id} thumbnail RGB")
+
+
+def instance_caption(row: dict[str, Any]) -> str:
+    return f"{row['model_name']} | {row['material_name']} | {row['env_name']}"
+
+
+def build_instance_gallery_items(
+    rows: list[dict[str, Any]],
+    preview_df: pd.DataFrame,
+) -> list[tuple[Image.Image, str]]:
+    return [
+        (get_instance_thumbnail(preview_df, row["instance_id"]), instance_caption(row))
+        for row in rows
+    ]
 
-    rows = selected.to_dict(orient="records")
-    if not rows and split == "train":
-        selected = preview_df[
-            preview_df["instance_id"].astype(str) == str(instance_id)
-        ].copy()
-        selected = selected.sort_values(["split", "frame_id"]).head(max_frames)
-        rows = selected.to_dict(orient="records")
 
+def load_instance_frames(
+    preview_df: pd.DataFrame, instance_id: str, max_frames: int = 50,
+) -> list[dict[str, Any]]:
+    """Load train preview image payloads for one instance from preview Parquet."""
+    rows = train_frame_rows(preview_df, instance_id, max_frames=max_frames)
     frames: list[dict[str, Any]] = []
     for example in rows:
         frame_id = int(example["frame_id"])
         frame_item: dict[str, Any] = {"frame_id": frame_id}
         for key in ("rgb", "mask", "depth_preview", "normal_preview"):
-            img_bytes = example[key]
-            if not isinstance(img_bytes, (bytes, bytearray)) or not img_bytes:
-                raise TypeError(f"Expected non-empty image bytes for {key} frame {frame_id}.")
-            with Image.open(io.BytesIO(img_bytes)) as img:
-                frame_item[key] = img.copy()
+            frame_item[key] = decode_image_bytes(example[key], f"{key} frame {frame_id}")
         frames.append(frame_item)
     return frames
 
@@ -220,42 +238,9 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
     model_name_choices = get_distinct_text_choices(instance_df, "model_name")
     material_name_choices = get_distinct_text_choices(instance_df, "material_name")
     env_name_choices = get_distinct_text_choices(instance_df, "env_name")
-
-    model_display_cols = [
-        "instance_id",
-        "model_name",
-        "material_name",
-        "env_name",
-        "hasGlass",
-        "isGenerated",
-        "transparent",
-        "near_light",
-    ]
-    instance_display_cols = [
-        "instance_id",
-        "model_name",
-        "material_name",
-        "env_name",
-        "hasGlass",
-        "isGenerated",
-        "transparent",
-        "near_light",
-    ]
-    model_extra_cols = [
-        "material_name",
-        "env_name",
-        "hasGlass",
-        "isGenerated",
-        "transparent",
-        "near_light",
-        "glb_path",
-    ]
-
     stats_md = build_stats_markdown(instance_df, preview_df)
 
-    # ---- 3D Viewer callbacks ----
-
-    def search_models(
+    def filtered_instance_rows(
         model_name: str,
         material_name: str,
         env_name: str,
@@ -263,7 +248,7 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
         is_generated: str,
         transparent: str,
         near_light: str,
-    ):
+    ) -> tuple[pd.DataFrame, list[dict[str, Any]]]:
         filtered = filter_dataframe_advanced(
             instance_df,
             model_name=model_name,
@@ -274,42 +259,11 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
             transparent=transparent,
             near_light=near_light,
         )
-        aggregated = aggregate_by_model(filtered, extra_columns=model_extra_cols)
-        shown = aggregated.head(MAX_RESULTS).copy()
+        shown = filtered.head(MAX_RESULTS).copy()
         rows = shown.to_dict(orient="records")
-        choices = [format_model_choice(i, r) for i, r in enumerate(rows)]
-        selected = choices[0] if choices else None
-        summary = (
-            f"Matched **{len(aggregated)}** models, showing **{len(rows)}**. "
-            f"Preview instances: **{len(filtered)}**."
-        )
-        table = shown[model_display_cols] if not shown.empty else pd.DataFrame(columns=model_display_cols)
-        meta = rows[0] if rows else {}
-        return summary, table, gr.update(choices=choices, value=selected), rows, meta
-
-    def on_model_select(choice: str, rows: list[dict[str, Any]]):
-        if not choice or not rows:
-            return {}
-        idx = parse_choice_index(choice, len(rows))
-        if idx is None:
-            return {}
-        return rows[idx]
-
-    def on_load_3d(rows: list[dict[str, Any]], choice: str):
-        if not choice or not rows:
-            return None
-        idx = parse_choice_index(choice, len(rows))
-        if idx is None:
-            return None
-        glb = rows[idx]["glb_path"]
-        logger.info("on_load_3d: glb_path=%r", glb)
-        if not isinstance(glb, str) or not glb.strip():
-            raise ValueError(f"Selected model row does not contain a GLB path: {rows[idx]!r}")
-        return download_glb(glb)
-
-    # ---- Image Viewer callbacks ----
-
-    def search_instances(
+        return filtered, rows
+
+    def filter_gallery(
         model_name: str,
         material_name: str,
         env_name: str,
@@ -318,8 +272,7 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
         transparent: str,
         near_light: str,
     ):
-        filtered = filter_dataframe_advanced(
-            instance_df,
+        filtered, rows = filtered_instance_rows(
             model_name=model_name,
             material_name=material_name,
             env_name=env_name,
@@ -328,28 +281,24 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
             transparent=transparent,
             near_light=near_light,
         )
-        shown = filtered.head(MAX_RESULTS).copy()
-        rows = shown[instance_display_cols].to_dict(orient="records")
-        choices = [format_instance_choice(i, r) for i, r in enumerate(rows)]
-        selected = choices[0] if choices else None
         summary = f"Matched **{len(filtered)}** preview instances, showing **{len(rows)}**."
-        table = shown[instance_display_cols] if not shown.empty else pd.DataFrame(columns=instance_display_cols)
-        return summary, table, gr.update(choices=choices, value=selected), rows
-
-    def on_load_images(rows: list[dict[str, Any]], choice: str):
+        gallery_items = build_instance_gallery_items(rows, preview_df)
         slider_empty = gr.update(minimum=1, maximum=1, step=1, value=1, interactive=False)
-        if not choice or not rows:
-            return [], slider_empty, []
-        idx = parse_choice_index(choice, len(rows))
-        if idx is None:
-            return [], slider_empty, []
-        instance_id = rows[idx]["instance_id"]
+        return summary, gallery_items, rows, {}, None, [], slider_empty, []
+
+    def on_instance_select(rows: list[dict[str, Any]], evt: gr.SelectData):
+        if not rows:
+            return {}, None, [], gr.update(minimum=1, maximum=1, step=1, value=1, interactive=False), []
+        idx = evt.index[0] if isinstance(evt.index, tuple) else evt.index
+        if not isinstance(idx, int) or idx < 0 or idx >= len(rows):
+            raise IndexError(f"Selected gallery index is out of range: {evt.index!r}")
+
+        row = rows[idx]
+        instance_id = row["instance_id"]
         if not isinstance(instance_id, str) or not instance_id.strip():
             raise ValueError(f"Selected instance row has invalid instance_id: {rows[idx]!r}")
         logger.info("Loading images for instance: %s", instance_id)
-        frame_items = load_instance_frames(preview_df, instance_id, split="train", max_frames=50)
-        if not frame_items:
-            return [], slider_empty, []
+        frame_items = load_instance_frames(preview_df, instance_id, max_frames=50)
         slider_ready = gr.update(
             minimum=1,
             maximum=len(frame_items),
@@ -357,126 +306,95 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
             value=1,
             interactive=True,
         )
-        return render_frame_gallery(frame_items, 1), slider_ready, frame_items
+        return row, download_glb(row["glb_path"]), render_frame_gallery(frame_items, 1), slider_ready, frame_items
 
     def on_frame_change(frame_idx: float, frame_items: list[dict[str, Any]]):
         return render_frame_gallery(frame_items, frame_idx)
 
-    # ---- UI ----
+    initial_rows = instance_df.head(MAX_RESULTS).to_dict(orient="records")
+    initial_gallery = build_instance_gallery_items(initial_rows, preview_df)
+    initial_summary = f"Matched **{len(instance_df)}** preview instances, showing **{len(initial_rows)}**."
 
     with gr.Blocks(title="3DReflecNet Dataset Explorer") as demo:
         gr.Markdown("# 3DReflecNet Dataset Explorer")
         gr.Markdown(
-            "Filter the configured preview subset by model/material/environment dropdowns and boolean scene tags."
+            "Browse the configured preview subset. Select an RGB thumbnail to inspect the instance."
         )
         gr.Markdown(stats_md)
 
-        with gr.Tabs():
-            # === Tab 1: 3D Viewer ===
-            with gr.TabItem("3D Viewer"):
-                with gr.Row():
-                    m3d_model_name = gr.Dropdown(label="model_name", choices=model_name_choices, value=FILTER_ALL)
-                    m3d_material_name = gr.Dropdown(label="material_name", choices=material_name_choices, value=FILTER_ALL)
-                    m3d_env_name = gr.Dropdown(label="env_name", choices=env_name_choices, value=FILTER_ALL)
-                with gr.Row():
-                    m3d_has_glass = gr.Dropdown(label="hasGlass", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    m3d_is_generated = gr.Dropdown(label="isGenerated", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    m3d_transparent = gr.Dropdown(label="transparent", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    m3d_near_light = gr.Dropdown(label="near_light", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    m3d_btn = gr.Button("Search", variant="primary")
-
-                m3d_summary = gr.Markdown("Click **Search** to browse models.")
-                m3d_table = gr.Dataframe(headers=model_display_cols, interactive=False, wrap=True)
-                m3d_select = gr.Dropdown(label="Select model", choices=[], value=None)
-                m3d_meta = gr.JSON(label="Model Metadata")
-
-                m3d_load_btn = gr.Button("Load 3D Preview", variant="primary")
-                m3d_viewer = gr.Model3D(
-                    label="3D Preview (GLB)",
-                    clear_color=(0.35, 0.35, 0.38, 1.0),
-                    camera_position=(35, 70, 3.5),
-                )
-
-                m3d_state = gr.State([])
-
-                m3d_btn.click(
-                    fn=search_models,
-                    inputs=[
-                        m3d_model_name,
-                        m3d_material_name,
-                        m3d_env_name,
-                        m3d_has_glass,
-                        m3d_is_generated,
-                        m3d_transparent,
-                        m3d_near_light,
-                    ],
-                    outputs=[m3d_summary, m3d_table, m3d_select, m3d_state, m3d_meta],
-                )
-                m3d_select.change(
-                    fn=on_model_select,
-                    inputs=[m3d_select, m3d_state],
-                    outputs=[m3d_meta],
-                )
-                m3d_load_btn.click(
-                    fn=on_load_3d,
-                    inputs=[m3d_state, m3d_select],
-                    outputs=[m3d_viewer],
-                )
-
-            # === Tab 2: Image Viewer ===
-            with gr.TabItem("Image Viewer"):
-                with gr.Row():
-                    img_model_name = gr.Dropdown(label="model_name", choices=model_name_choices, value=FILTER_ALL)
-                    img_material_name = gr.Dropdown(label="material_name", choices=material_name_choices, value=FILTER_ALL)
-                    img_env_name = gr.Dropdown(label="env_name", choices=env_name_choices, value=FILTER_ALL)
-                with gr.Row():
-                    img_has_glass = gr.Dropdown(label="hasGlass", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    img_is_generated = gr.Dropdown(label="isGenerated", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    img_transparent = gr.Dropdown(label="transparent", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    img_near_light = gr.Dropdown(label="near_light", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
-                    img_btn = gr.Button("Search", variant="primary")
-
-                img_summary = gr.Markdown("Click **Search** to browse instances.")
-                img_table = gr.Dataframe(headers=instance_display_cols, interactive=False, wrap=True)
-                img_select = gr.Dropdown(label="Select instance", choices=[], value=None)
-
-                img_load_btn = gr.Button("Load Instance Frames", variant="primary")
-                img_gallery = gr.Gallery(label="Frame Images", columns=4, rows=1, object_fit="contain", height="auto")
-                img_frame_slider = gr.Slider(
-                    label="Frame",
-                    minimum=1,
-                    maximum=1,
-                    step=1,
-                    value=1,
-                    interactive=False,
-                )
-
-                img_state = gr.State([])
-                img_frame_state = gr.State([])
-
-                img_btn.click(
-                    fn=search_instances,
-                    inputs=[
-                        img_model_name,
-                        img_material_name,
-                        img_env_name,
-                        img_has_glass,
-                        img_is_generated,
-                        img_transparent,
-                        img_near_light,
-                    ],
-                    outputs=[img_summary, img_table, img_select, img_state],
-                )
-                img_load_btn.click(
-                    fn=on_load_images,
-                    inputs=[img_state, img_select],
-                    outputs=[img_gallery, img_frame_slider, img_frame_state],
-                )
-                img_frame_slider.change(
-                    fn=on_frame_change,
-                    inputs=[img_frame_slider, img_frame_state],
-                    outputs=[img_gallery],
-                )
+        with gr.Row():
+            model_name = gr.Dropdown(label="model_name", choices=model_name_choices, value=FILTER_ALL)
+            material_name = gr.Dropdown(label="material_name", choices=material_name_choices, value=FILTER_ALL)
+            env_name = gr.Dropdown(label="env_name", choices=env_name_choices, value=FILTER_ALL)
+        with gr.Row():
+            has_glass = gr.Dropdown(label="hasGlass", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
+            is_generated = gr.Dropdown(label="isGenerated", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
+            transparent = gr.Dropdown(label="transparent", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
+            near_light = gr.Dropdown(label="near_light", choices=BOOL_FILTER_CHOICES, value=FILTER_ALL)
+            filter_btn = gr.Button("Apply Filters", variant="primary")
+
+        summary = gr.Markdown(initial_summary)
+        instance_gallery = gr.Gallery(
+            label="Preview Instances",
+            value=initial_gallery,
+            columns=5,
+            object_fit="contain",
+            height="auto",
+        )
+
+        with gr.Row():
+            instance_meta = gr.JSON(label="Instance Metadata")
+            model_viewer = gr.Model3D(
+                label="3D Preview (GLB)",
+                clear_color=(0.35, 0.35, 0.38, 1.0),
+                camera_position=(35, 70, 3.5),
+            )
+
+        frame_gallery = gr.Gallery(label="RGB / Mask / Depth / Normal", columns=4, rows=1, object_fit="contain", height="auto")
+        frame_slider = gr.Slider(
+            label="Frame",
+            minimum=1,
+            maximum=1,
+            step=1,
+            value=1,
+            interactive=False,
+        )
+
+        instance_state = gr.State(initial_rows)
+        frame_state = gr.State([])
+
+        filter_btn.click(
+            fn=filter_gallery,
+            inputs=[
+                model_name,
+                material_name,
+                env_name,
+                has_glass,
+                is_generated,
+                transparent,
+                near_light,
+            ],
+            outputs=[
+                summary,
+                instance_gallery,
+                instance_state,
+                instance_meta,
+                model_viewer,
+                frame_gallery,
+                frame_slider,
+                frame_state,
+            ],
+        )
+        instance_gallery.select(
+            fn=on_instance_select,
+            inputs=[instance_state],
+            outputs=[instance_meta, model_viewer, frame_gallery, frame_slider, frame_state],
+        )
+        frame_slider.change(
+            fn=on_frame_change,
+            inputs=[frame_slider, frame_state],
+            outputs=[frame_gallery],
+        )
 
     return demo