Deploy Space app files

app.py

@@ -36,6 +36,14 @@ DATASET_REPO = os.environ.get("DATASET_REPO", "3DReflecNet/3DReflecNet")
 HF_TOKEN = os.environ.get("HF_TOKEN", None)
 MAX_RESULTS = 300
 BOOL_COLUMNS = ["hasGlass", "isGenerated", "transparent", "near_light"]
+TAG_TEXT_COLUMNS = [
+    "indoor_outdoor", "glossiness", "reflectivity", "texture_scale",
+    "anisotropy", "metallic_hint", "light_type", "light_intensity",
+    "key_light_direction", "shadow_hardness", "description",
+]
+TAG_NUMERIC_COLUMNS = ["roughness"]
+TAG_COLUMNS = TAG_TEXT_COLUMNS + TAG_NUMERIC_COLUMNS
+TEXT_FILTER_COLUMNS = ["main_category", "material_name", "env_name"]
 
 _GLB_CACHE_DIR = Path(tempfile.mkdtemp(prefix="glb_cache_"))
 atexit.register(shutil.rmtree, str(_GLB_CACHE_DIR), True)
@@ -53,6 +61,10 @@ def load_preview_dataframe() -> pd.DataFrame:
         "main_category", "sub_category", "model_name",
         "material_name", "env_name", "glb_path",
         "hasGlass", "isGenerated", "transparent", "near_light",
+        "indoor_outdoor", "glossiness", "roughness", "reflectivity",
+        "texture_scale", "anisotropy", "metallic_hint", "light_type",
+        "light_intensity", "key_light_direction", "shadow_hardness",
+        "description",
     ]
     ds = load_dataset(
         DATASET_REPO,
@@ -68,10 +80,13 @@ def load_preview_dataframe() -> pd.DataFrame:
         [
             "instance_id", "split", "main_category", "sub_category",
             "model_name", "material_name", "env_name", "glb_path",
+            *TAG_TEXT_COLUMNS,
         ],
         "preview parquet",
     )
     require_bool_columns(df, BOOL_COLUMNS, "preview parquet")
+    if df["roughness"].isna().any() or not pd.api.types.is_numeric_dtype(df["roughness"]):
+        raise TypeError(f"Expected numeric dtype for column 'roughness' in preview parquet, got {df['roughness'].dtype}.")
     if df["frame_id"].isna().any() or not pd.api.types.is_integer_dtype(df["frame_id"]):
         raise TypeError(f"Expected integer dtype for column 'frame_id' in preview parquet, got {df['frame_id'].dtype}.")
     for col in ["rgb", "mask", "depth_preview", "normal_preview"]:
@@ -93,7 +108,7 @@ def build_preview_instance_dataframe(preview_df: pd.DataFrame) -> pd.DataFrame:
     instance_cols = [
         "instance_id", "main_category", "sub_category", "model_name",
         "material_name", "env_name", "hasGlass", "isGenerated",
-        "transparent", "near_light", "glb_path",
+        "transparent", "near_light", "glb_path", *TAG_COLUMNS,
     ]
     require_columns(preview_df, instance_cols, "preview parquet")
 
@@ -113,10 +128,15 @@ def build_preview_instance_dataframe(preview_df: pd.DataFrame) -> pd.DataFrame:
         [
             "instance_id", "main_category", "sub_category",
             "model_name", "material_name", "env_name", "glb_path",
+            *TAG_TEXT_COLUMNS,
         ],
         "preview instance dataframe",
     )
     require_bool_columns(df, BOOL_COLUMNS, "preview instance dataframe")
+    if df["roughness"].isna().any() or not pd.api.types.is_numeric_dtype(df["roughness"]):
+        raise TypeError(
+            f"Expected numeric dtype for column 'roughness' in preview instance dataframe, got {df['roughness'].dtype}."
+        )
     if df["glb_path"].map(lambda value: not value.strip()).any():
         raise ValueError("Preview instance dataframe contains empty GLB paths.")
     return df
@@ -144,6 +164,37 @@ def instance_caption(row: dict[str, Any]) -> str:
     return f"{row['model_name']} | {row['material_name']} | {row['env_name']}"
 
 
+def build_llm_tags(row: dict[str, Any]) -> dict[str, Any]:
+    """Reconstruct the tags.json shape from preview parquet columns."""
+    return {
+        "instance_id": row["instance_id"],
+        "category": {
+            "main": row["main_category"],
+            "sub": row["sub_category"],
+        },
+        "material_properties": {
+            "glossiness": row["glossiness"],
+            "roughness": float(row["roughness"]),
+            "reflectivity": row["reflectivity"],
+            "texture_scale": row["texture_scale"],
+            "anisotropy": row["anisotropy"],
+            "metallic_hint": row["metallic_hint"],
+        },
+        "environment": {
+            "indoor_outdoor": row["indoor_outdoor"],
+            "light_type": row["light_type"],
+            "light_intensity": row["light_intensity"],
+            "key_light_direction": row["key_light_direction"],
+            "shadow_hardness": row["shadow_hardness"],
+        },
+        "description": row["description"],
+    }
+
+
+def build_instance_metadata(row: dict[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in row.items() if key not in TAG_COLUMNS}
+
+
 def build_instance_gallery_items(
     rows: list[dict[str, Any]],
     preview_df: pd.DataFrame,
@@ -218,60 +269,139 @@ def download_glb(glb_path: str) -> str:
 # ---------------------------------------------------------------------------
 
 def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
-    model_name_choices = get_distinct_text_choices(instance_df, "model_name")
+    main_category_choices = get_distinct_text_choices(instance_df, "main_category")
     material_name_choices = get_distinct_text_choices(instance_df, "material_name")
     env_name_choices = get_distinct_text_choices(instance_df, "env_name")
 
-    def filtered_instance_rows(
-        model_name: str,
-        material_name: str,
-        env_name: str,
-        has_glass: str,
-        is_generated: str,
-        transparent: str,
-        near_light: str,
-    ) -> tuple[pd.DataFrame, list[dict[str, Any]]]:
-        filtered = filter_dataframe_advanced(
+    def text_choices_for(df: pd.DataFrame, column: str) -> list[str]:
+        if df.empty:
+            return [FILTER_ALL]
+        return get_distinct_text_choices(df, column)
+
+    def filter_with_values(values: dict[str, str], skip_text_column: str | None = None) -> pd.DataFrame:
+        return filter_dataframe_advanced(
             instance_df,
-            model_name=model_name,
-            material_name=material_name,
-            env_name=env_name,
-            has_glass=has_glass,
-            is_generated=is_generated,
-            transparent=transparent,
-            near_light=near_light,
+            main_category=FILTER_ALL if skip_text_column == "main_category" else values["main_category"],
+            material_name=FILTER_ALL if skip_text_column == "material_name" else values["material_name"],
+            env_name=FILTER_ALL if skip_text_column == "env_name" else values["env_name"],
+            has_glass=values["has_glass"],
+            is_generated=values["is_generated"],
+            transparent=values["transparent"],
+            near_light=values["near_light"],
         )
+
+    def normalize_filter_values(values: dict[str, str], changed_column: str | None) -> dict[str, str]:
+        normalized = values.copy()
+        for column in TEXT_FILTER_COLUMNS:
+            value = (normalized[column] or "").strip()
+            normalized[column] = value if value else FILTER_ALL
+        for column in ["has_glass", "is_generated", "transparent", "near_light"]:
+            value = (normalized[column] or "").strip()
+            normalized[column] = value if value else FILTER_ALL
+
+        protected = {changed_column} if changed_column in TEXT_FILTER_COLUMNS else set()
+        for _ in TEXT_FILTER_COLUMNS:
+            changed = False
+            for column in TEXT_FILTER_COLUMNS:
+                if column in protected:
+                    continue
+                choices = text_choices_for(filter_with_values(normalized, skip_text_column=column), column)
+                if normalized[column] not in choices:
+                    normalized[column] = FILTER_ALL
+                    changed = True
+            if not changed:
+                break
+
+        for column in protected:
+            choices = text_choices_for(filter_with_values(normalized, skip_text_column=column), column)
+            if normalized[column] not in choices:
+                normalized[column] = FILTER_ALL
+        return normalized
+
+    def text_filter_updates(values: dict[str, str]) -> list[Any]:
+        return [
+            gr.update(
+                choices=text_choices_for(filter_with_values(values, skip_text_column=column), column),
+                value=values[column],
+            )
+            for column in TEXT_FILTER_COLUMNS
+        ]
+
+    def filtered_instance_rows(values: dict[str, str]) -> tuple[pd.DataFrame, list[dict[str, Any]]]:
+        filtered = filter_with_values(values)
         shown = filtered.head(MAX_RESULTS).copy()
         rows = shown.to_dict(orient="records")
         return filtered, rows
 
     def filter_gallery(
-        model_name: str,
+        main_category: str,
         material_name: str,
         env_name: str,
         has_glass: str,
         is_generated: str,
         transparent: str,
         near_light: str,
+        changed_column: str | None = None,
     ):
-        filtered, rows = filtered_instance_rows(
-            model_name=model_name,
-            material_name=material_name,
-            env_name=env_name,
-            has_glass=has_glass,
-            is_generated=is_generated,
-            transparent=transparent,
-            near_light=near_light,
+        values = normalize_filter_values(
+            {
+                "main_category": main_category,
+                "material_name": material_name,
+                "env_name": env_name,
+                "has_glass": has_glass,
+                "is_generated": is_generated,
+                "transparent": transparent,
+                "near_light": near_light,
+            },
+            changed_column=changed_column,
         )
+        filtered, rows = filtered_instance_rows(values)
         summary = f"Matched **{len(filtered)}** preview instances, showing **{len(rows)}**."
         gallery_items = build_instance_gallery_items(rows, preview_df)
         slider_empty = gr.update(minimum=1, maximum=1, step=1, value=1, interactive=False)
-        return summary, gallery_items, rows, {}, None, None, None, None, None, slider_empty, []
+        return [
+            *text_filter_updates(values),
+            summary,
+            gallery_items,
+            rows,
+            {},
+            {},
+            None,
+            None,
+            None,
+            None,
+            None,
+            slider_empty,
+            [],
+        ]
+
+    def make_filter_handler(changed_column: str):
+        def handler(
+            main_category: str,
+            material_name: str,
+            env_name: str,
+            has_glass: str,
+            is_generated: str,
+            transparent: str,
+            near_light: str,
+        ):
+            return filter_gallery(
+                main_category,
+                material_name,
+                env_name,
+                has_glass,
+                is_generated,
+                transparent,
+                near_light,
+                changed_column=changed_column,
+            )
+
+        return handler
 
     def on_instance_select(rows: list[dict[str, Any]], evt: gr.SelectData):
         if not rows:
             slider_empty = gr.update(minimum=1, maximum=1, step=1, value=1, interactive=False)
-            return {}, None, None, None, None, None, slider_empty, []
+            return {}, {}, None, None, None, None, None, slider_empty, []
         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}")
@@ -289,7 +419,14 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
             value=1,
             interactive=True,
         )
-        return row, download_glb(row["glb_path"]), *render_frame_images(frame_items, 1), slider_ready, frame_items
+        return (
+            build_instance_metadata(row),
+            build_llm_tags(row),
+            download_glb(row["glb_path"]),
+            *render_frame_images(frame_items, 1),
+            slider_ready,
+            frame_items,
+        )
 
     def on_frame_change(frame_idx: float, frame_items: list[dict[str, Any]]):
         return render_frame_images(frame_items, frame_idx)
@@ -305,7 +442,7 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
         )
 
         with gr.Row():
-            model_name = gr.Dropdown(label="model_name", choices=model_name_choices, value=FILTER_ALL)
+            main_category = gr.Dropdown(label="main_category", choices=main_category_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():
@@ -325,6 +462,7 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
 
         with gr.Row():
             instance_meta = gr.JSON(label="Instance Metadata")
+            llm_tags = gr.JSON(label="LLM Tags")
             model_viewer = gr.Model3D(
                 label="3D Preview (GLB)",
                 clear_color=(0.35, 0.35, 0.38, 1.0),
@@ -349,7 +487,7 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
         frame_state = gr.State([])
 
         filter_inputs = [
-            model_name,
+            main_category,
             material_name,
             env_name,
             has_glass,
@@ -358,10 +496,14 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
             near_light,
         ]
         filter_outputs = [
+            main_category,
+            material_name,
+            env_name,
             summary,
             instance_gallery,
             instance_state,
             instance_meta,
+            llm_tags,
             model_viewer,
             rgb_image,
             mask_image,
@@ -370,9 +512,17 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
             frame_slider,
             frame_state,
         ]
-        for filter_component in filter_inputs:
+        for filter_component, changed_column in [
+            (main_category, "main_category"),
+            (material_name, "material_name"),
+            (env_name, "env_name"),
+            (has_glass, "has_glass"),
+            (is_generated, "is_generated"),
+            (transparent, "transparent"),
+            (near_light, "near_light"),
+        ]:
             filter_component.change(
-                fn=filter_gallery,
+                fn=make_filter_handler(changed_column),
                 inputs=filter_inputs,
                 outputs=filter_outputs,
             )
@@ -381,6 +531,7 @@ def build_app(instance_df: pd.DataFrame, preview_df: pd.DataFrame) -> gr.Blocks:
             inputs=[instance_state],
             outputs=[
                 instance_meta,
+                llm_tags,
                 model_viewer,
                 rgb_image,
                 mask_image,

utils.py

@@ -93,7 +93,7 @@ def _apply_text_equals(df: pd.DataFrame, column: str, selected_value: str, all_l
 
 def filter_dataframe_advanced(
     df: pd.DataFrame,
-    model_name: str = FILTER_ALL,
+    main_category: str = FILTER_ALL,
     material_name: str = FILTER_ALL,
     env_name: str = FILTER_ALL,
     has_glass: str = FILTER_ALL,
@@ -101,9 +101,9 @@ def filter_dataframe_advanced(
     transparent: str = FILTER_ALL,
     near_light: str = FILTER_ALL,
 ) -> pd.DataFrame:
-    """Filter by model/material/environment exact selection and four tri-state bool fields."""
+    """Filter by category/material/environment exact selection and four tri-state bool fields."""
     selected = df
-    selected = _apply_text_equals(selected, "model_name", model_name)
+    selected = _apply_text_equals(selected, "main_category", main_category)
     selected = _apply_text_equals(selected, "material_name", material_name)
     selected = _apply_text_equals(selected, "env_name", env_name)
     selected = apply_bool_filter(selected, "hasGlass", has_glass)