Update app.py

update the end file_path

app.py

@@ -17,8 +17,10 @@ from trellis.utils import render_utils, postprocessing_utils
 
 
 MAX_SEED = np.iinfo(np.int32).max
-TMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'tmp')
-os.makedirs(TMP_DIR, exist_ok=True)
+# Custom save directory for GLB files
+CUSTOM_SAVE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'outputs')
+os.makedirs(CUSTOM_SAVE_DIR, exist_ok=True)
+
 
 
 def start_session(req: gr.Request):
@@ -128,6 +130,7 @@ def get_seed(randomize_seed: bool, seed: int) -> int:
 def generate_and_extract_glb(
     image: Image.Image,
     multiimages: List[Tuple[Image.Image, str]],
+    is_multiimage: bool,
     seed: int,
     ss_guidance_strength: float,
     ss_sampling_steps: int,
@@ -137,33 +140,25 @@ def generate_and_extract_glb(
     mesh_simplify: float,
     texture_size: int,
     req: gr.Request,
-) -> Tuple[dict, str, str, str]:
+) -> str:
+    """
+    Generate the 3D model and save only the GLB file to a custom folder.
+    The GLB filename matches the input image filename (or first image if multi-image).
     """
-    Convert an image to a 3D model and extract GLB file.
+    # Derive base filename from the first image in the batch
+    if not is_multiimage:
+        base_filename = getattr(image, "filename", None) or "generated_model"
+    else:
+        # Use the first uploaded image filename if available
+        base_filename = getattr(multiimages[0][0], "filename", None) or "generated_model"
 
-    Args:
-        image (Image.Image): The input image.
-        multiimages (List[Tuple[Image.Image, str]]): The input images in multi-image mode.
-        is_multiimage (bool): Whether is in multi-image mode.
-        seed (int): The random seed.
-        ss_guidance_strength (float): The guidance strength for sparse structure generation.
-        ss_sampling_steps (int): The number of sampling steps for sparse structure generation.
-        slat_guidance_strength (float): The guidance strength for structured latent generation.
-        slat_sampling_steps (int): The number of sampling steps for structured latent generation.
-        multiimage_algo (Literal["multidiffusion", "stochastic"]): The algorithm for multi-image generation.
-        mesh_simplify (float): The mesh simplification factor.
-        texture_size (int): The texture resolution.
+    # Strip directories and extension to get a clean name
+    base_name = os.path.splitext(os.path.basename(base_filename))[0]
+    glb_filename = f"{base_name}.glb"
+    glb_path = os.path.join(CUSTOM_SAVE_DIR, glb_filename)
 
-    Returns:
-        dict: The information of the generated 3D model.
-        str: The path to the video of the 3D model.
-        str: The path to the extracted GLB file.
-        str: The path to the extracted GLB file (for download).
-    """
-    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
-    
     # Generate 3D model
-    if image:
+    if not is_multiimage:
         outputs = pipeline.run(
             image,
             seed=seed,
@@ -180,7 +175,7 @@ def generate_and_extract_glb(
         )
     else:
         outputs = pipeline.run_multi_image(
-            [image[0] for image in multiimages],
+            [img[0] for img in multiimages],
             seed=seed,
             formats=["gaussian", "mesh"],
             preprocess_image=False,
@@ -194,26 +189,23 @@ def generate_and_extract_glb(
             },
             mode=multiimage_algo,
         )
-    
-    # Render video
-    video = render_utils.render_video(outputs['gaussian'][0], num_frames=120)['color']
-    video_geo = render_utils.render_video(outputs['mesh'][0], num_frames=120)['normal']
-    video = [np.concatenate([video[i], video_geo[i]], axis=1) for i in range(len(video))]
-    video_path = os.path.join(user_dir, 'sample.mp4')
-    imageio.mimsave(video_path, video, fps=15)
-    
-    # Extract GLB
+
+    # Export GLB file to custom folder
     gs = outputs['gaussian'][0]
     mesh = outputs['mesh'][0]
-    glb = postprocessing_utils.to_glb(gs, mesh, simplify=mesh_simplify, texture_size=texture_size, verbose=False)
-    glb_path = os.path.join(user_dir, 'sample.glb')
+    glb = postprocessing_utils.to_glb(
+        gs,
+        mesh,
+        simplify=mesh_simplify,
+        texture_size=texture_size,
+        verbose=False
+    )
     glb.export(glb_path)
-    
-    # Pack state for optional Gaussian extraction
-    state = pack_state(gs, mesh)
-    
+
     torch.cuda.empty_cache()
-    return state, video_path, glb_path, glb_path
+    print(f"[Saved GLB] {glb_path}")
+    return glb_path
+
 
 
 @spaces.GPU
@@ -390,7 +382,7 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
     ).then(
         generate_and_extract_glb,
         inputs=[image_prompt, multiimage_prompt, seed, ss_guidance_strength, ss_sampling_steps, slat_guidance_strength, slat_sampling_steps, multiimage_algo, mesh_simplify, texture_size],
-        outputs=[output_buf, video_output, model_output, download_glb],
+        outputs=[download_glb],
     ).then(
         lambda: tuple([gr.Button(interactive=True), gr.Button(interactive=True)]),
         outputs=[extract_gs_btn, download_glb],