Update app.py

- New Version with Up- and Download Fotoset

app.py

@@ -10,13 +10,25 @@ import uuid
 import subprocess
 from glob import glob
 from huggingface_hub import snapshot_download
+import zipfile
+import json
+from pathlib import Path
+
+# ============================================================
+# Model download
+# ============================================================
 
-# Download models
 os.makedirs("ckpts", exist_ok=True)
-snapshot_download(repo_id="pengHTYX/PSHuman_Unclip_768_6views", local_dir="./ckpts")
+snapshot_download(
+    repo_id="pengHTYX/PSHuman_Unclip_768_6views",
+    local_dir="./ckpts"
+)
 
 os.makedirs("smpl_related", exist_ok=True)
-snapshot_download(repo_id="fffiloni/PSHuman-SMPL-related", local_dir="./smpl_related")
+snapshot_download(
+    repo_id="fffiloni/PSHuman-SMPL-related",
+    local_dir="./smpl_related"
+)
 
 examples_folder = "examples"
 images_examples = [
@@ -25,39 +37,17 @@ images_examples = [
     if os.path.isfile(os.path.join(examples_folder, file))
 ]
 
-
-def find_primary_input_image(temp_dir: str) -> str:
-    candidates = sorted(glob(os.path.join(temp_dir, "output_image_rmbg_*.png")))
-    if candidates:
-        return candidates[0]
-    candidates = sorted(glob(os.path.join(temp_dir, "input_image_*.png")))
-    if candidates:
-        return candidates[0]
-    raise gr.Error(f"Kein Eingabebild im Session-Ordner gefunden: {temp_dir}")
-
-
-
-def get_scene_name_from_temp_dir(temp_dir: str) -> str:
-    image_path = find_primary_input_image(temp_dir)
-    return os.path.splitext(os.path.basename(image_path))[0]
-
-
-
-def get_multiview_gallery_paths(temp_dir: str):
-    scene = get_scene_name_from_temp_dir(temp_dir)
-    edit_dir = os.path.join(temp_dir, "multiview", scene, "edit")
-    raw_dir = os.path.join(temp_dir, "multiview", scene, "raw")
-    source_dir = edit_dir if os.path.isdir(edit_dir) else raw_dir
-    if not os.path.isdir(source_dir):
-        return []
-    return sorted(glob(os.path.join(source_dir, "*.png")))
+ALLOWED_IMAGE_EXTENSIONS = {".png", ".jpg", ".jpeg", ".webp"}
 
 
+# ============================================================
+# Helper: session + image prep
+# ============================================================
 
 def remove_background(input_pil, remove_bg):
     temp_dir = tempfile.mkdtemp(prefix="pshuman_session_")
     unique_id = str(uuid.uuid4())
-    image_path = os.path.join(temp_dir, f'input_image_{unique_id}.png')
+    image_path = os.path.join(temp_dir, f"input_image_{unique_id}.png")
 
     try:
         if isinstance(input_pil, Image.Image):
@@ -65,14 +55,15 @@ def remove_background(input_pil, remove_bg):
         else:
             image = Image.open(input_pil)
 
+        # Keep original PSHuman behavior
         image = image.transpose(Image.FLIP_LEFT_RIGHT)
         image.save(image_path)
     except Exception as e:
         shutil.rmtree(temp_dir, ignore_errors=True)
-        raise gr.Error(f"Fehler beim Laden oder Speichern des Bildes: {str(e)}")
+        raise gr.Error(f"Fehler beim Laden/Speichern des Bildes: {str(e)}")
 
-    if remove_bg:
-        removed_bg_path = os.path.join(temp_dir, f'output_image_rmbg_{unique_id}.png')
+    if remove_bg is True:
+        removed_bg_path = os.path.join(temp_dir, f"output_image_rmbg_{unique_id}.png")
         try:
             img = Image.open(image_path)
             result = remove(img)
@@ -81,20 +72,260 @@ def remove_background(input_pil, remove_bg):
         except Exception as e:
             shutil.rmtree(temp_dir, ignore_errors=True)
             raise gr.Error(f"Fehler bei der Hintergrundentfernung: {str(e)}")
+
         return removed_bg_path, temp_dir
+    else:
+        return image_path, temp_dir
+
+
+# ============================================================
+# Helper: multiview paths
+# ============================================================
+
+def get_multiview_root(session_dir: str) -> Path:
+    return Path(session_dir) / "multiview"
+
+
+def find_single_scene_dir(session_dir: str) -> Path:
+    mv_root = get_multiview_root(session_dir)
+    if not mv_root.exists():
+        raise gr.Error(f"Kein multiview-Ordner gefunden: {mv_root}")
+
+    scene_dirs = [p for p in mv_root.iterdir() if p.is_dir()]
+    if not scene_dirs:
+        raise gr.Error(f"Keine Szene im multiview-Ordner gefunden: {mv_root}")
+    if len(scene_dirs) > 1:
+        raise gr.Error("Mehrere Szenen gefunden. Diese App erwartet aktuell genau eine Szene pro Session.")
+
+    return scene_dirs[0]
+
+
+def get_edit_dir(session_dir: str) -> Path:
+    return find_single_scene_dir(session_dir) / "edit"
+
+
+def get_raw_dir(session_dir: str) -> Path:
+    return find_single_scene_dir(session_dir) / "raw"
+
+
+def list_gallery_images(session_dir: str):
+    if not session_dir or not Path(session_dir).exists():
+        return []
+
+    mv_root = get_multiview_root(session_dir)
+    if not mv_root.exists():
+        return []
+
+    try:
+        scene_dir = find_single_scene_dir(session_dir)
+        edit_dir = scene_dir / "edit"
+        if not edit_dir.exists():
+            return []
+        return sorted(str(p) for p in edit_dir.glob("color_*") if p.is_file())
+    except Exception:
+        return []
+
+
+# ============================================================
+# ZIP helpers
+# ============================================================
+
+def create_edit_zip(session_dir: str) -> str:
+    scene_dir = find_single_scene_dir(session_dir)
+    edit_dir = scene_dir / "edit"
+    meta_path = scene_dir / "meta.json"
+
+    if not edit_dir.exists():
+        raise gr.Error(f"Kein edit-Ordner gefunden: {edit_dir}")
+
+    zip_path = Path(session_dir) / f"{scene_dir.name}_multiview_edit.zip"
+
+    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for file_path in sorted(edit_dir.iterdir()):
+            if file_path.is_file():
+                zf.write(file_path, arcname=file_path.name)
+
+        if meta_path.exists():
+            zf.write(meta_path, arcname="meta.json")
+
+    return str(zip_path)
+
+
+def inspect_edit_set(edit_dir: Path) -> dict:
+    existing_files = {p.name for p in edit_dir.iterdir() if p.is_file()}
+
+    color_files = sorted([
+        f for f in existing_files
+        if f.startswith("color_") and Path(f).suffix.lower() in ALLOWED_IMAGE_EXTENSIONS
+    ])
+    normal_files = sorted([
+        f for f in existing_files
+        if f.startswith("normal_") and Path(f).suffix.lower() in ALLOWED_IMAGE_EXTENSIONS
+    ])
+
+    if color_files:
+        expected_indices = sorted([f.split("_")[1].split(".")[0] for f in color_files])
+    elif normal_files:
+        expected_indices = sorted([f.split("_")[1].split(".")[0] for f in normal_files])
+    else:
+        expected_indices = []
+
+    expected_color_names = {f"color_{idx}.png" for idx in expected_indices}
+    expected_normal_names = {f"normal_{idx}.png" for idx in expected_indices}
+
+    found_colors = {f for f in existing_files if f.startswith("color_")}
+    found_normals = {f for f in existing_files if f.startswith("normal_")}
+
+    missing_colors = sorted(expected_color_names - found_colors) if expected_indices else []
+    missing_normals = sorted(expected_normal_names - found_normals) if expected_indices else []
+
+    has_full_colors = bool(expected_indices) and len(missing_colors) == 0
+    has_full_normals = bool(expected_indices) and len(missing_normals) == 0
+
+    if has_full_colors and has_full_normals:
+        state = "READY"
+    elif has_full_colors and not has_full_normals:
+        state = "NEEDS_NORMALS"
+    else:
+        state = "INVALID"
+
+    return {
+        "state": state,
+        "expected_indices": expected_indices,
+        "found_colors": sorted(found_colors),
+        "found_normals": sorted(found_normals),
+        "missing_colors": missing_colors,
+        "missing_normals": missing_normals,
+        "has_full_colors": has_full_colors,
+        "has_full_normals": has_full_normals,
+    }
+
+
+def validate_uploaded_zip_structure(zf: zipfile.ZipFile) -> list[str]:
+    file_names = []
+
+    for member in zf.infolist():
+        if member.is_dir():
+            continue
+
+        member_name = member.filename.replace("\\", "/")
+
+        if "/" in member_name:
+            raise gr.Error(f"ZIP darf keine Unterordner enthalten: {member_name}")
+
+        suffix = Path(member_name).suffix.lower()
+        stem = Path(member_name).stem
+
+        if member_name == "meta.json":
+            file_names.append(member_name)
+            continue
+
+        if suffix not in ALLOWED_IMAGE_EXTENSIONS:
+            raise gr.Error(f"Nicht erlaubter Dateityp im ZIP: {member_name}")
+
+        if not (stem.startswith("color_") or stem.startswith("normal_")):
+            raise gr.Error(f"Ungültiger Dateiname im ZIP: {member_name}")
+
+        file_names.append(member_name)
+
+    return file_names
+
+
+def overwrite_edit_set_from_zip(zip_file_path: str, session_dir: str) -> tuple[str, list[str]]:
+    scene_dir = find_single_scene_dir(session_dir)
+    edit_dir = scene_dir / "edit"
+    edit_dir.mkdir(parents=True, exist_ok=True)
+
+    with zipfile.ZipFile(zip_file_path, "r") as zf:
+        uploaded_names = validate_uploaded_zip_structure(zf)
+
+        has_uploaded_colors = any(name.startswith("color_") for name in uploaded_names)
+        has_uploaded_normals = any(name.startswith("normal_") for name in uploaded_names)
+
+        tmp_extract_dir = Path(session_dir) / "_upload_tmp"
+        if tmp_extract_dir.exists():
+            shutil.rmtree(tmp_extract_dir)
+        tmp_extract_dir.mkdir(parents=True, exist_ok=True)
+
+        try:
+            zf.extractall(tmp_extract_dir)
+
+            # If only new colors are uploaded, invalidate old normals.
+            if has_uploaded_colors and not has_uploaded_normals:
+                for p in edit_dir.glob("normal_*"):
+                    if p.is_file():
+                        p.unlink()
+
+            for name in uploaded_names:
+                if name == "meta.json":
+                    continue
+                src = tmp_extract_dir / name
+                dst = edit_dir / name
+                shutil.copy2(src, dst)
+
+        finally:
+            if tmp_extract_dir.exists():
+                shutil.rmtree(tmp_extract_dir)
+
+    report = inspect_edit_set(edit_dir)
 
-    return image_path, temp_dir
+    if report["state"] == "READY":
+        status = (
+            "Upload erfolgreich.\n"
+            "Komplettes Fotoset erkannt:\n"
+            f"- Colors: {len(report['found_colors'])}\n"
+            f"- Normalmaps: {len(report['found_normals'])}\n"
+            "Rekonstruktion kann direkt fortgesetzt werden."
+        )
+    elif report["state"] == "NEEDS_NORMALS":
+        status = (
+            "Upload erfolgreich.\n"
+            "Nur vollständige Color-Ansichten erkannt, aber keine vollständigen Normalmaps.\n"
+            "Alte Normalmaps wurden verworfen bzw. als ungültig behandelt.\n"
+            "Normalmaps müssen vor der Rekonstruktion neu berechnet werden."
+        )
+    else:
+        status = (
+            "Upload unvollständig oder ungültig.\n"
+            f"Fehlende Colors: {report['missing_colors']}\n"
+            f"Fehlende Normalmaps: {report['missing_normals']}\n"
+            "Bitte ein vollständiges Fotoset hochladen."
+        )
+
+    preview_paths = sorted(str(p) for p in edit_dir.glob("color_*"))
+    return status, preview_paths
+
+
+def ensure_ready_for_reconstruction(session_dir: str) -> str:
+    scene_dir = find_single_scene_dir(session_dir)
+    edit_dir = scene_dir / "edit"
+    report = inspect_edit_set(edit_dir)
 
+    if report["state"] == "READY":
+        return "READY"
 
+    if report["state"] == "NEEDS_NORMALS":
+        raise gr.Error("Es sind nur Color-Bilder vorhanden. Bitte zuerst die Normalmaps neu berechnen.")
 
-def run_pshuman(temp_dir: str, run_mode: str):
+    raise gr.Error(
+        "Das Fotoset ist unvollständig. "
+        f"Fehlende Colors: {report['missing_colors']} | "
+        f"Fehlende Normalmaps: {report['missing_normals']}"
+    )
+
+
+# ============================================================
+# Inference stage calls
+# ============================================================
+
+def run_generate_multiview(session_dir: str):
     inference_config = "configs/inference-768-6view.yaml"
     pretrained_model = "./ckpts"
     crop_size = 740
     seed = 600
     num_views = 7
     save_mode = "rgb"
-    multiview_dir = os.path.join(temp_dir, "multiview")
+    multiview_dir = str(get_multiview_root(session_dir))
 
     subprocess.run(
         [
@@ -103,72 +334,142 @@ def run_pshuman(temp_dir: str, run_mode: str):
             f"pretrained_model_name_or_path={pretrained_model}",
             f"validation_dataset.crop_size={crop_size}",
             "with_smpl=false",
-            f"validation_dataset.root_dir={temp_dir}",
+            f"validation_dataset.root_dir={session_dir}",
             f"seed={seed}",
             f"num_views={num_views}",
             f"save_mode={save_mode}",
-            f"run_mode={run_mode}",
+            "run_mode=generate",
             f"multiview_tmp_dir={multiview_dir}",
             "prefer_edited_views=true",
         ],
-        check=True,
+        check=True
     )
 
 
+def run_reconstruct_from_session(session_dir: str):
+    inference_config = "configs/inference-768-6view.yaml"
+    pretrained_model = "./ckpts"
+    crop_size = 740
+    seed = 600
+    num_views = 7
+    save_mode = "rgb"
+    multiview_dir = str(get_multiview_root(session_dir))
+
+    subprocess.run(
+        [
+            "python", "inference.py",
+            "--config", inference_config,
+            f"pretrained_model_name_or_path={pretrained_model}",
+            f"validation_dataset.crop_size={crop_size}",
+            "with_smpl=false",
+            f"validation_dataset.root_dir={session_dir}",
+            f"seed={seed}",
+            f"num_views={num_views}",
+            f"save_mode={save_mode}",
+            "run_mode=reconstruct",
+            f"multiview_tmp_dir={multiview_dir}",
+            "prefer_edited_views=true",
+        ],
+        check=True
+    )
+
 
-def get_outputs_for_session(temp_dir: str):
-    scene = get_scene_name_from_temp_dir(temp_dir)
-    output_video = glob(os.path.join("out", scene, "*.mp4"))
-    output_objects = glob(os.path.join("out", scene, "*.obj"))
-    if len(output_video) < 1 or len(output_objects) < 2:
-        raise gr.Error(f"Ausgabedateien für Szene '{scene}' wurden nicht vollständig gefunden.")
-    return output_video, output_objects
+def collect_outputs_from_session(session_dir: str):
+    scene_dir = find_single_scene_dir(session_dir)
+    scene_name = scene_dir.name
 
+    output_video = glob(os.path.join("out", scene_name, "*.mp4"))
+    output_objects = glob(os.path.join("out", scene_name, "*.obj"))
+
+    video = output_video[0] if output_video else None
+    mesh = output_objects[0] if len(output_objects) > 0 else None
+    mesh_color = output_objects[1] if len(output_objects) > 1 else None
+
+    return video, mesh, mesh_color
+
+
+# ============================================================
+# UI callbacks
+# ============================================================
 
 @spaces.GPU(duration=140)
-def generate_views(input_pil, remove_bg, progress=gr.Progress(track_tqdm=True)):
+def process_generate(input_pil, remove_bg):
     torch.cuda.empty_cache()
 
-    removed_bg_path, temp_dir = remove_background(input_pil, remove_bg)
+    removed_bg_path, session_dir = remove_background(input_pil, remove_bg)
 
     try:
-        run_pshuman(temp_dir, run_mode="generate")
-        gallery_paths = get_multiview_gallery_paths(temp_dir)
-        if not gallery_paths:
-            raise gr.Error("Es wurden keine Multiview-Bilder erzeugt.")
+        run_generate_multiview(session_dir)
+        gallery = list_gallery_images(session_dir)
+
         status = (
-            "Stufe 1 abgeschlossen. Die Multiview-Bilder wurden erzeugt und im Session-Ordner gespeichert. "
-            "Du kannst die Dateien jetzt im Ordner bearbeiten und danach Stufe 2 starten.\n\n"
-            f"Session-Ordner: {temp_dir}"
+            "Stufe 1 abgeschlossen.\n"
+            "Multiview-Bilder wurden erzeugt und im Session-Ordner gespeichert.\n"
+            "Du kannst jetzt das Fotoset herunterladen, extern bearbeiten und wieder hochladen.\n"
+            "Session: " + session_dir
         )
-        return gallery_paths, temp_dir, status
+
+        return session_dir, status, gallery
     except subprocess.CalledProcessError as e:
-        shutil.rmtree(temp_dir, ignore_errors=True)
+        shutil.rmtree(session_dir, ignore_errors=True)
         raise gr.Error(f"Fehler während der Multiview-Erzeugung: {str(e)}")
+    finally:
+        torch.cuda.empty_cache()
+
+
+def process_download_set(session_dir):
+    if not session_dir or not Path(session_dir).exists():
+        raise gr.Error("Kein gültiger Session-Ordner vorhanden.")
+    zip_path = create_edit_zip(session_dir)
+    status = f"Fotoset als ZIP erstellt: {zip_path}"
+    return zip_path, status
+
+
+def process_upload_set(upload_zip, session_dir):
+    if upload_zip is None:
+        raise gr.Error("Bitte zuerst eine ZIP-Datei auswählen.")
+    if not session_dir or not Path(session_dir).exists():
+        raise gr.Error("Kein gültiger Session-Ordner vorhanden.")
+
+    status, gallery = overwrite_edit_set_from_zip(upload_zip.name, session_dir)
+    return status, gallery
 
 
 @spaces.GPU(duration=140)
-def continue_reconstruction(session_dir, keep_session_files=False, progress=gr.Progress(track_tqdm=True)):
-    torch.cuda.empty_cache()
+def process_reconstruct(session_dir, keep_session):
+    if not session_dir or not Path(session_dir).exists():
+        raise gr.Error("Kein gültiger Session-Ordner vorhanden.")
 
-    if not session_dir or not os.path.isdir(session_dir):
-        raise gr.Error("Es wurde kein gültiger Session-Ordner übergeben.")
+    torch.cuda.empty_cache()
 
     try:
-        run_pshuman(session_dir, run_mode="reconstruct")
-        output_video, output_objects = get_outputs_for_session(session_dir)
-        status = f"Stufe 2 abgeschlossen. Rekonstruktion für Session '{session_dir}' wurde erzeugt."
+        ensure_ready_for_reconstruction(session_dir)
+        run_reconstruct_from_session(session_dir)
+        video, mesh, mesh_color = collect_outputs_from_session(session_dir)
 
-        if not keep_session_files:
+        status = "Stufe 2 abgeschlossen. Rekonstruktion erfolgreich."
+
+        if not keep_session:
             shutil.rmtree(session_dir, ignore_errors=True)
-            status += " Session-Ordner wurde danach gelöscht."
+            session_dir = ""
 
-        torch.cuda.empty_cache()
-        return output_video[0], output_objects[0], output_objects[1], status
+        return status, video, mesh, mesh_color, session_dir
     except subprocess.CalledProcessError as e:
         raise gr.Error(f"Fehler während der Rekonstruktion: {str(e)}")
+    finally:
+        torch.cuda.empty_cache()
+
+
+def process_clear_session(session_dir):
+    if session_dir and Path(session_dir).exists():
+        shutil.rmtree(session_dir, ignore_errors=True)
+    return "", "Session gelöscht.", [], None, None, None, None
 
 
+# ============================================================
+# UI
+# ============================================================
+
 css = """
 div#col-container{
     margin: 0 auto;
@@ -179,15 +480,25 @@ div#video-out-elm{
 }
 """
 
-
 def gradio_interface():
     with gr.Blocks(css=css) as app:
         with gr.Column(elem_id="col-container"):
-            gr.Markdown("# PSHuman – Zweistufige Pipeline mit editierbaren Multiview-Bildern")
-            gr.Markdown(
-                "**Stufe 1:** Eingabebild vorbereiten und Multiview-Bilder erzeugen.  \n"
-                "**Stufe 2:** Die gespeicherten Multiview-Bilder aus dem Session-Ordner wieder einlesen und die Rekonstruktion fortsetzen."
-            )
+            gr.Markdown("# PSHuman 2.0 – Zwei-Stufen-Pipeline mit Multiview-Export/Import")
+            gr.HTML("""
+            <div style="display:flex;column-gap:4px;flex-wrap:wrap;">
+                <a href="https://github.com/pengHTYX/PSHuman">
+                    <img src='https://img.shields.io/badge/GitHub-Repo-blue'>
+                </a>
+                <a href="https://penghtyx.github.io/PSHuman/">
+                    <img src='https://img.shields.io/badge/Project-Page-green'>
+                </a>
+                <a href="https://arxiv.org/pdf/2409.10141">
+                    <img src='https://img.shields.io/badge/ArXiv-Paper-red'>
+                </a>
+            </div>
+            """)
+
+            session_dir_box = gr.Textbox(label="Session-Ordner", interactive=False)
 
             with gr.Group():
                 with gr.Row():
@@ -196,17 +507,22 @@ def gradio_interface():
                             label="Image input",
                             type="pil",
                             image_mode="RGBA",
-                            height=480,
+                            height=480
                         )
-                        remove_bg = gr.Checkbox(label="Need to remove BG ?", value=False)
-                        generate_button = gr.Button("1) Multiview erzeugen")
-                        continue_button = gr.Button("2) Rekonstruktion fortsetzen")
-                        keep_session_files = gr.Checkbox(label="Session-Ordner nach Stufe 2 behalten", value=False)
-                        session_dir = gr.Textbox(label="Session-Ordner", interactive=True)
-                        status_box = gr.Textbox(label="Status", lines=6, interactive=False)
+                        remove_bg = gr.Checkbox(label="Need to remove BG?", value=False)
+                        keep_session = gr.Checkbox(label="Session nach Stufe 2 behalten", value=True)
+
+                        btn_generate = gr.Button("1) Multiview erzeugen")
+                        btn_download = gr.Button("2) Fotoset herunterladen")
+                        upload_zip = gr.File(label="3) Bearbeitetes Fotoset hochladen", file_types=[".zip"])
+                        btn_upload = gr.Button("4) Upload prüfen und Bilder überschreiben")
+                        btn_reconstruct = gr.Button("5) Rekonstruktion fortsetzen")
+                        btn_clear = gr.Button("Session löschen")
 
                     with gr.Column(scale=4):
-                        multiview_gallery = gr.Gallery(label="Multiview-Bilder", columns=4, height=420)
+                        status_box = gr.Textbox(label="Status", lines=8)
+                        multiview_gallery = gr.Gallery(label="Multiview Edit Set", columns=3, rows=2, height=420)
+                        download_file = gr.File(label="Download ZIP")
                         output_video = gr.Video(label="Output Video", elem_id="video-out-elm")
                         with gr.Row():
                             output_object_mesh = gr.Model3D(label=".OBJ Mesh", height=240)
@@ -215,20 +531,38 @@ def gradio_interface():
             gr.Examples(
                 examples=examples_folder,
                 inputs=[input_image],
-                examples_per_page=11,
+                examples_per_page=11
             )
 
-        generate_button.click(
-            generate_views,
-            inputs=[input_image, remove_bg],
-            outputs=[multiview_gallery, session_dir, status_box],
-        )
+            btn_generate.click(
+                process_generate,
+                inputs=[input_image, remove_bg],
+                outputs=[session_dir_box, status_box, multiview_gallery]
+            )
 
-        continue_button.click(
-            continue_reconstruction,
-            inputs=[session_dir, keep_session_files],
-            outputs=[output_video, output_object_mesh, output_object_color, status_box],
-        )
+            btn_download.click(
+                process_download_set,
+                inputs=[session_dir_box],
+                outputs=[download_file, status_box]
+            )
+
+            btn_upload.click(
+                process_upload_set,
+                inputs=[upload_zip, session_dir_box],
+                outputs=[status_box, multiview_gallery]
+            )
+
+            btn_reconstruct.click(
+                process_reconstruct,
+                inputs=[session_dir_box, keep_session],
+                outputs=[status_box, output_video, output_object_mesh, output_object_color, session_dir_box]
+            )
+
+            btn_clear.click(
+                process_clear_session,
+                inputs=[session_dir_box],
+                outputs=[session_dir_box, status_box, multiview_gallery, download_file, output_video, output_object_mesh, output_object_color]
+            )
 
     return app