Upload 3 files

README.md

@@ -1,12 +1,14 @@
 ---
-title: Era3D MV Demo
-emoji: 🐠
-colorFrom: purple
-colorTo: pink
+title: LLaMA Mesh
+emoji: 👀
+colorFrom: red
+colorTo: green
 sdk: gradio
-sdk_version: 4.31.5
+sdk_version: 5.6.0
 app_file: app.py
 pinned: false
+license: llama3.1
+short_description: Create 3D mesh by chatting.
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,411 +1,240 @@
-import os
-import torch
-import fire
 import gradio as gr
-from PIL import Image
-from functools import partial
-import spaces 
-import cv2
-import time
-import numpy as np
-from rembg import remove
-from segment_anything import sam_model_registry, SamPredictor
-
 import os
-import torch
-
-from PIL import Image
-from typing import Dict, Optional,  List
-from dataclasses import dataclass
-from mvdiffusion.data.single_image_dataset import SingleImageDataset 
-from mvdiffusion.pipelines.pipeline_mvdiffusion_unclip import StableUnCLIPImg2ImgPipeline
-from einops import rearrange
-import numpy as np
-import subprocess
-from datetime import datetime
-from icecream import ic
-def save_image(tensor):
-    ndarr = tensor.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to("cpu", torch.uint8).numpy()
-    # pdb.set_trace()
-    im = Image.fromarray(ndarr)
-    return ndarr
-
+import spaces
+from transformers import GemmaTokenizer, AutoModelForCausalLM
+from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
+from threading import Thread
 
-def save_image_to_disk(tensor, fp):
-    ndarr = tensor.mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).to("cpu", torch.uint8).numpy()
-    # pdb.set_trace()
-    im = Image.fromarray(ndarr)
-    im.save(fp)
-    return ndarr
+# Set an environment variable
+HF_TOKEN = os.environ.get("HF_TOKEN", None)
 
 
-def save_image_numpy(ndarr, fp):
-    im = Image.fromarray(ndarr)
-    im.save(fp)
-
-
-weight_dtype = torch.float16
-
-_TITLE = '''Era3D: High-Resolution Multiview Diffusion using Efficient Row-wise Attention'''
-_DESCRIPTION = '''
+DESCRIPTION = '''
 <div>
-Generate consistent high-resolution multi-view normals maps and color images.
-</div>
+<h1 style="text-align: center;">LLaMA-Mesh</h1>
 <div>
-The demo does not include the mesh reconstruction part, please visit <a href="https://github.com/pengHTYX/Era3D"><img src='https://img.shields.io/github/stars/pengHTYX/Era3D?style=social' style="display: inline-block; vertical-align: middle;"/></a> to get a textured mesh.
+<a style="display:inline-block" href="https://research.nvidia.com/labs/toronto-ai/LLaMA-Mesh/"><img src='https://img.shields.io/badge/public_website-8A2BE2'></a>
+<a style="display:inline-block; margin-left: .5em" href="https://github.com/nv-tlabs/LLaMA-Mesh"><img src='https://img.shields.io/github/stars/nv-tlabs/LLaMA-Mesh?style=social'/></a>
+</div>
+<p>LLaMA-Mesh: Unifying 3D Mesh Generation with Language Models.<a style="display:inline-block" href="https://research.nvidia.com/labs/toronto-ai/LLaMA-Mesh/">[Project Page]</a> <a style="display:inline-block" href="https://github.com/nv-tlabs/LLaMA-Mesh">[Code]</a></p>
+<p> Notice: (1) This demo supports up to 4096 tokens due to computational limits, while our full model supports 8k tokens. This limitation may result in incomplete generated meshes. To experience the full 8k token context, please run our model locally.</p>
+<p>(2) We only support generating a single mesh per dialog round. To generate another mesh, click the "clear" button and start a new dialog.</p>
+<p>(3) If the LLM refuses to generate a 3D mesh, try adding more explicit instructions to the prompt, such as "create a 3D model of a table <strong>in OBJ format</strong>." A more effective approach is to request the mesh generation at the start of the dialog.</p>
 </div>
 '''
-_GPU_ID = 0
-
-
-if not hasattr(Image, 'Resampling'):
-    Image.Resampling = Image
-
-
-def sam_init():
-    sam_checkpoint = os.path.join(os.path.dirname(__file__), "sam_pt", "sam_vit_h_4b8939.pth")
-    model_type = "vit_h"
-
-    sam = sam_model_registry[model_type](checkpoint=sam_checkpoint).to(device=f"cuda:{_GPU_ID}")
-    predictor = SamPredictor(sam)
-    return predictor
-
-@spaces.GPU
-def sam_segment(predictor, input_image, *bbox_coords):
-    bbox = np.array(bbox_coords)
-    image = np.asarray(input_image)
-
-    start_time = time.time()
-    predictor.set_image(image)
-
-    masks_bbox, scores_bbox, logits_bbox = predictor.predict(box=bbox, multimask_output=True)
-
-    print(f"SAM Time: {time.time() - start_time:.3f}s")
-    out_image = np.zeros((image.shape[0], image.shape[1], 4), dtype=np.uint8)
-    out_image[:, :, :3] = image
-    out_image_bbox = out_image.copy()
-    out_image_bbox[:, :, 3] = masks_bbox[-1].astype(np.uint8) * 255
-    torch.cuda.empty_cache()
-    return Image.fromarray(out_image_bbox, mode='RGBA')
-
 
-def expand2square(pil_img, background_color):
-    width, height = pil_img.size
-    if width == height:
-        return pil_img
-    elif width > height:
-        result = Image.new(pil_img.mode, (width, width), background_color)
-        result.paste(pil_img, (0, (width - height) // 2))
-        return result
-    else:
-        result = Image.new(pil_img.mode, (height, height), background_color)
-        result.paste(pil_img, ((height - width) // 2, 0))
-        return result
+LICENSE = """
+<p/>
 
+---
+Built with Meta Llama 3.1 8B
+"""
 
-def preprocess(predictor, input_image, chk_group=None, segment=True, rescale=False):
-    RES = 1024
-    input_image.thumbnail([RES, RES], Image.Resampling.LANCZOS)
-    if chk_group is not None:
-        segment = "Background Removal" in chk_group
-        rescale = "Rescale" in chk_group
-    if segment:
-        image_rem = input_image.convert('RGBA')
-        image_nobg = remove(image_rem, alpha_matting=True)
-        arr = np.asarray(image_nobg)[:, :, -1]
-        x_nonzero = np.nonzero(arr.sum(axis=0))
-        y_nonzero = np.nonzero(arr.sum(axis=1))
-        x_min = int(x_nonzero[0].min())
-        y_min = int(y_nonzero[0].min())
-        x_max = int(x_nonzero[0].max())
-        y_max = int(y_nonzero[0].max())
-        input_image = sam_segment(predictor, input_image.convert('RGB'), x_min, y_min, x_max, y_max)
-    # Rescale and recenter
-    if rescale:
-        image_arr = np.array(input_image)
-        in_w, in_h = image_arr.shape[:2]
-        out_res = min(RES, max(in_w, in_h))
-        ret, mask = cv2.threshold(np.array(input_image.split()[-1]), 0, 255, cv2.THRESH_BINARY)
-        x, y, w, h = cv2.boundingRect(mask)
-        max_size = max(w, h)
-        ratio = 0.75
-        side_len = int(max_size / ratio)
-        padded_image = np.zeros((side_len, side_len, 4), dtype=np.uint8)
-        center = side_len // 2
-        padded_image[center - h // 2 : center - h // 2 + h, center - w // 2 : center - w // 2 + w] = image_arr[y : y + h, x : x + w]
-        rgba = Image.fromarray(padded_image).resize((out_res, out_res), Image.LANCZOS)
-
-        rgba_arr = np.array(rgba) / 255.0
-        rgb = rgba_arr[..., :3] * rgba_arr[..., -1:] + (1 - rgba_arr[..., -1:])
-        input_image = Image.fromarray((rgb * 255).astype(np.uint8))
-    else:
-        input_image = expand2square(input_image, (127, 127, 127, 0))
-    return input_image, input_image.resize((320, 320), Image.Resampling.LANCZOS)
-
-def load_era3d_pipeline(cfg):
-    # Load scheduler, tokenizer and models.
-    
-    pipeline = StableUnCLIPImg2ImgPipeline.from_pretrained(
-        cfg.pretrained_model_name_or_path,
-        torch_dtype=weight_dtype
-    )
-    # sys.main_lock = threading.Lock()
-    return pipeline
-
-
-from mvdiffusion.data.single_image_dataset import SingleImageDataset
-
-
-def prepare_data(single_image, crop_size, cfg):
-    dataset = SingleImageDataset(root_dir='', num_views=6, img_wh=[512, 512], bg_color='white', 
-        crop_size=crop_size, single_image=single_image, prompt_embeds_path=cfg.validation_dataset.prompt_embeds_path)
-    return dataset[0]
-
-scene = 'scene'
-def run_pipeline(pipeline, cfg, single_image, guidance_scale, steps, seed, crop_size, chk_group=None):
-    pipeline.to(device=f'cuda:{_GPU_ID}')
-    pipeline.unet.enable_xformers_memory_efficient_attention()
-    
-    global scene
-    # pdb.set_trace()
-
-    if chk_group is not None:
-        write_image = "Write Results" in chk_group
-
-    batch = prepare_data(single_image, crop_size, cfg)
-
-    pipeline.set_progress_bar_config(disable=True)
-    seed = int(seed)
-    generator = torch.Generator(device=pipeline.unet.device).manual_seed(seed)
-
-
-    imgs_in = torch.cat([batch['imgs_in']]*2, dim=0)
-    num_views = imgs_in.shape[1]
-    imgs_in = rearrange(imgs_in, "B Nv C H W -> (B Nv) C H W")# (B*Nv, 3, H, W)
-    
-    normal_prompt_embeddings, clr_prompt_embeddings = batch['normal_prompt_embeddings'], batch['color_prompt_embeddings'] 
-    prompt_embeddings = torch.cat([normal_prompt_embeddings, clr_prompt_embeddings], dim=0)
-    prompt_embeddings = rearrange(prompt_embeddings, "B Nv N C -> (B Nv) N C")
-    
+PLACEHOLDER = """
+<div style="padding: 30px; text-align: center; display: flex; flex-direction: column; align-items: center;">
+   <h1 style="font-size: 28px; margin-bottom: 2px; opacity: 0.55;">LLaMA-Mesh</h1>
+   <p style="font-size: 18px; margin-bottom: 2px; opacity: 0.65;">Create 3D meshes by chatting.</p>
+</div>
+"""
+
+
+css = """
+h1 {
+  text-align: center;
+  display: block;
+}
+
+#duplicate-button {
+  margin: auto;
+  color: white;
+  background: #1565c0;
+  border-radius: 100vh;
+}
+"""
+# Load the tokenizer and model
+model_path = "Zhengyi/LLaMA-Mesh"
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+model = AutoModelForCausalLM.from_pretrained(model_path, device_map="auto")
+terminators = [
+    tokenizer.eos_token_id,
+    tokenizer.convert_tokens_to_ids("<|eot_id|>")
+]
+
+
+from trimesh.exchange.gltf import export_glb
+import gradio as gr
+import trimesh
+import numpy as np
+import tempfile
+def apply_gradient_color(mesh_text):
+    """
+    Apply a gradient color to the mesh vertices based on the Y-axis and save as GLB.
+    Args:
+        mesh_text (str): The input mesh in OBJ format as a string.
+    Returns:
+        str: Path to the GLB file with gradient colors applied.
+    """
+    # Load the mesh
+    temp_file =  tempfile.NamedTemporaryFile(suffix=f"", delete=False).name#"temp_mesh.obj"
+    with open(temp_file+".obj", "w") as f:
+        f.write(mesh_text)
+    # return temp_file
+    mesh = trimesh.load_mesh(temp_file+".obj", file_type='obj')
+
+    # Get vertex coordinates
+    vertices = mesh.vertices
+    y_values = vertices[:, 1]  # Y-axis values
+
+    # Normalize Y values to range [0, 1] for color mapping
+    y_normalized = (y_values - y_values.min()) / (y_values.max() - y_values.min())
+
+    # Generate colors: Map normalized Y values to RGB gradient (e.g., blue to red)
+    colors = np.zeros((len(vertices), 4))  # RGBA
+    colors[:, 0] = y_normalized  # Red channel
+    colors[:, 2] = 1 - y_normalized  # Blue channel
+    colors[:, 3] = 1.0  # Alpha channel (fully opaque)
+
+    # Attach colors to mesh vertices
+    mesh.visual.vertex_colors = colors
+
+    # Export to GLB format
+    glb_path = temp_file+".glb"
+    with open(glb_path, "wb") as f:
+        f.write(export_glb(mesh))
     
-    imgs_in = imgs_in.to(device=f'cuda:{_GPU_ID}', dtype=weight_dtype)
-    prompt_embeddings = prompt_embeddings.to(device=f'cuda:{_GPU_ID}', dtype=weight_dtype)
+    return glb_path
+
+def visualize_mesh(mesh_text):
+    """
+    Convert the provided 3D mesh text into a visualizable format.
+    This function assumes the input is in OBJ format.
+    """
+    temp_file = "temp_mesh.obj"
+    with open(temp_file, "w") as f:
+        f.write(mesh_text)
+    return temp_file
+
+@spaces.GPU(duration=120)
+def chat_llama3_8b(message: str, 
+              history: list, 
+              temperature: float, 
+              max_new_tokens: int
+             ) -> str:
+    """
+    Generate a streaming response using the llama3-8b model.
+    Args:
+        message (str): The input message.
+        history (list): The conversation history used by ChatInterface.
+        temperature (float): The temperature for generating the response.
+        max_new_tokens (int): The maximum number of new tokens to generate.
+    Returns:
+        str: The generated response.
+    """
+    conversation = []
+    for user, assistant in history:
+        conversation.extend([{"role": "user", "content": user}, {"role": "assistant", "content": assistant}])
+    conversation.append({"role": "user", "content": message})
+
+    input_ids = tokenizer.apply_chat_template(conversation, return_tensors="pt").to(model.device)
     
-    out = pipeline(
-        imgs_in, 
-        None, 
-        prompt_embeds=prompt_embeddings,
-        generator=generator, 
-        guidance_scale=guidance_scale, 
-        output_type='pt', 
-        num_images_per_prompt=1, 
-        # return_elevation_focal=cfg.log_elevation_focal_length,
-        **cfg.pipe_validation_kwargs
-    ).images
-
-    bsz = out.shape[0] // 2
-    normals_pred = out[:bsz]
-    images_pred = out[bsz:]
-    num_views = 6
-    if write_image:
-        VIEWS = ['front', 'front_right', 'right', 'back', 'left', 'front_left']
-        cur_dir = os.path.join(cfg.save_dir, f"cropsize-{int(crop_size)}-cfg{guidance_scale:.1f}")
-        
-        scene = 'scene'+datetime.now().strftime('@%Y%m%d-%H%M%S')
-        scene_dir = os.path.join(cur_dir, scene)
-        os.makedirs(scene_dir, exist_ok=True)
-
-        for j in range(num_views):
-            view = VIEWS[j]
-            normal = normals_pred[j]
-            color = images_pred[j]
-
-            normal_filename = f"normals_{view}_masked.png"
-            color_filename = f"color_{view}_masked.png"
-            normal = save_image_to_disk(normal, os.path.join(scene_dir, normal_filename))
-            color = save_image_to_disk(color, os.path.join(scene_dir, color_filename))
-
-
-    normals_pred = [save_image(normals_pred[i]) for i in range(bsz)]
-    images_pred = [save_image(images_pred[i]) for i in range(bsz)]
-    
-    out = images_pred + normals_pred
-    return images_pred, normals_pred
-
-
-def process_3d(mode, data_dir, guidance_scale, crop_size):
-    dir = None
-    global scene
-
-    cur_dir = os.path.dirname(os.path.abspath(__file__))
-
-    subprocess.run(
-        f'cd instant-nsr-pl && bash run.sh 0 {scene} exp_demo && cd ..',
-        shell=True,
+    streamer = TextIteratorStreamer(tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True)
+    # print(max_new_tokens)
+    max_new_tokens=4096
+    temperature=0.9
+    generate_kwargs = dict(
+        input_ids= input_ids,
+        streamer=streamer,
+        max_new_tokens=max_new_tokens,
+        do_sample=True,
+        temperature=temperature,
+        eos_token_id=terminators,
     )
-    import glob
-
-    obj_files = glob.glob(f'{cur_dir}/instant-nsr-pl/exp_demo/{scene}/*/save/*.obj', recursive=True)
-    print(obj_files)
-    if obj_files:
-        dir = obj_files[0]
-    return dir
-
-
-@dataclass
-class TestConfig:
-    pretrained_model_name_or_path: str
-    pretrained_unet_path:Optional[str]
-    revision: Optional[str]
-    validation_dataset: Dict
-    save_dir: str
-    seed: Optional[int]
-    validation_batch_size: int
-    dataloader_num_workers: int
-    # save_single_views: bool
-    save_mode: str
-    local_rank: int
-
-    pipe_kwargs: Dict
-    pipe_validation_kwargs: Dict
-    unet_from_pretrained_kwargs: Dict
-    validation_guidance_scales: List[float]
-    validation_grid_nrow: int
-    camera_embedding_lr_mult: float
-
-    num_views: int
-    camera_embedding_type: str
-
-    pred_type: str  # joint, or ablation
-    regress_elevation: bool
-    enable_xformers_memory_efficient_attention: bool
-
-    cond_on_normals: bool
-    cond_on_colors: bool
-    
-    regress_elevation: bool
-    regress_focal_length: bool
-    
-
-
-def run_demo():
-    from utils.misc import load_config
-    from omegaconf import OmegaConf
-
-    # parse YAML config to OmegaConf
-    cfg = load_config("./configs/test_unclip-512-6view.yaml")
-    # print(cfg)
-    schema = OmegaConf.structured(TestConfig)
-    cfg = OmegaConf.merge(schema, cfg)
-
-    pipeline = load_era3d_pipeline(cfg)
-    torch.set_grad_enabled(False)
-
-    
-    predictor = sam_init()
-
+    # This will enforce greedy generation (do_sample=False) when the temperature is passed 0, avoiding the crash.             
+    if temperature == 0:
+        generate_kwargs['do_sample'] = False
+        
+    t = Thread(target=model.generate, kwargs=generate_kwargs)
+    t.start()
+
+    outputs = []
+    for text in streamer:
+        outputs.append(text)
+        #print(outputs)
+        yield "".join(outputs)
+        
 
-    custom_theme = gr.themes.Soft(primary_hue="blue").set(
-        button_secondary_background_fill="*neutral_100", button_secondary_background_fill_hover="*neutral_200"
-    )
-    custom_css = '''#disp_image {
-        text-align: center; /* Horizontally center the content */
-    }'''
-    
+# Gradio block
+chatbot=gr.Chatbot(height=450, placeholder=PLACEHOLDER, label='Gradio ChatInterface')
 
-    with gr.Blocks(title=_TITLE, theme=custom_theme, css=custom_css) as demo:
+with gr.Blocks(fill_height=True, css=css) as demo:
+    with gr.Column(): 
+        gr.Markdown(DESCRIPTION)
+        # gr.DuplicateButton(value="Duplicate Space for private use", elem_id="duplicate-button")
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown('# ' + _TITLE)
-        gr.Markdown(_DESCRIPTION)
-        with gr.Row(variant='panel'):
-            with gr.Column(scale=1):
-                input_image = gr.Image(type='pil', image_mode='RGBA', height=320, label='Input image')
-
-            with gr.Column(scale=1):
-                processed_image_highres = gr.Image(type='pil', image_mode='RGBA', visible=False)
-               
-                processed_image = gr.Image(
-                    type='pil',
-                    label="Processed Image",
-                    interactive=False,
-                    # height=320,
-                    image_mode='RGBA',
-                    elem_id="disp_image",
-                    visible=True,
+            with gr.Column(scale=3):    
+                gr.ChatInterface(
+                    fn=chat_llama3_8b,
+                    chatbot=chatbot,
+                    fill_height=True,
+                    additional_inputs_accordion=gr.Accordion(label="⚙️ Parameters", open=False, render=False),
+                    additional_inputs=[
+                        gr.Slider(minimum=0,
+                                maximum=1, 
+                                step=0.1,
+                                value=0.9, 
+                                label="Temperature", 
+                                interactive = False,
+                                render=False),
+                        gr.Slider(minimum=128, 
+                                maximum=4096,
+                                step=1,
+                                value=4096, 
+                                label="Max new tokens", 
+                                interactive = False,
+                                render=False),
+                        ],
+                    examples=[
+                        ['Create a 3D model of a wooden hammer'],
+                        ['Create a 3D model of a pyramid in obj format'],
+                        ['Create a 3D model of a cabinet.'],
+                        ['Create a low poly 3D model of a coffe cup'],
+                        ['Create a 3D model of a table.'],
+                        ["Create a low poly 3D model of a tree."],
+                        ['Write a python code for sorting.'],
+                        ['How to setup a human base on Mars? Give short answer.'],
+                        ['Explain theory of relativity to me like I’m 8 years old.'],
+                        ['What is 9,000 * 9,000?'],
+                        ['Create a 3D model of a soda can.'],
+                        ['Create a 3D model of a sword.'],
+                        ['Create a 3D model of a wooden barrel'],
+                        ['Create a 3D model of a chair.']
+                        ],
+                    cache_examples=False,
+                                )
+                gr.Markdown(LICENSE)
+        
+            with gr.Column(scale=2): 
+                output_model = gr.Model3D(
+                            label="3D Mesh Visualization",
+                            interactive=False,
+                        )
+                gr.Markdown("You can copy the generated 3d objects in the left and paste in the textbox below. Put the button and you will see the visualization of the 3D mesh.")
+                
+                # Add the text box for 3D mesh input and button
+                mesh_input = gr.Textbox(
+                    label="3D Mesh Input",
+                    placeholder="Paste your 3D mesh in OBJ format here...",
+                    lines=5,
                 )
-            # with gr.Column(scale=1):
-            #     ## add 3D Model
-            #     obj_3d = gr.Model3D(
-            #                         # clear_color=[0.0, 0.0, 0.0, 0.0], 
-            #                         label="3D Model", height=320, 
-            #                         # camera_position=[0,0,2.0]
-            #                         )
+                visualize_button = gr.Button("Visualize 3D Mesh")
                 
-        with gr.Row(variant='panel'):
-            with gr.Column(scale=1):
-                example_folder = os.path.join(os.path.dirname(__file__), "./examples")
-                example_fns = [os.path.join(example_folder, example) for example in os.listdir(example_folder)]
-                gr.Examples(
-                    examples=example_fns,
-                    inputs=[input_image],
-                    outputs=[input_image],
-                    cache_examples=False,
-                    label='Examples (click one of the images below to start)',
-                    examples_per_page=30,
+                # Link the button to the visualization function
+                visualize_button.click(
+                    fn=apply_gradient_color,
+                    inputs=[mesh_input],
+                    outputs=[output_model]
                 )
-            with gr.Column(scale=1):
-                with gr.Row():
-                    with gr.Column():
-                        with gr.Accordion('Advanced options', open=True):
-                            input_processing = gr.CheckboxGroup(
-                                ['Background Removal'],
-                                label='Input Image Preprocessing',
-                                value=['Background Removal'],
-                                info='untick this, if masked image with alpha channel',
-                            )
-                    with gr.Column():
-                        with gr.Accordion('Advanced options', open=False):
-                            output_processing = gr.CheckboxGroup(
-                                ['Write Results'], label='write the results in mv_res folder', value=['Write Results']
-                            )
-                    with gr.Row():
-                        with gr.Column():
-                            scale_slider = gr.Slider(1, 5, value=3, step=1, label='Classifier Free Guidance Scale')
-                        with gr.Column():
-                            steps_slider = gr.Slider(15, 100, value=40, step=1, label='Number of Diffusion Inference Steps')
-                    with gr.Row():
-                        with gr.Column():
-                            seed = gr.Number(600, label='Seed', info='100 for digital portraits')
-                        with gr.Column():
-                            crop_size = gr.Number(420, label='Crop size', info='380 for digital portraits')
-
-                        mode = gr.Textbox('train', visible=False)
-                        data_dir = gr.Textbox('outputs', visible=False)
-                    # with gr.Row():
-                    #     method = gr.Radio(choices=['instant-nsr-pl', 'NeuS'], label='Method (Default: instant-nsr-pl)', value='instant-nsr-pl')
-                run_btn = gr.Button('Generate Normals and Colors', variant='primary', interactive=True)
-                # recon_btn = gr.Button('Reconstruct 3D model', variant='primary', interactive=True)
-                # gr.Markdown("<span style='color:red'>First click Generate button, then click Reconstruct button. Reconstruction may cost several minutes.</span>")
-        
-        with gr.Row():
-            view_gallery = gr.Gallery(label='Multiview Images')
-            normal_gallery = gr.Gallery(label='Multiview Normals')
-            
-        print('Launching...')
-        run_btn.click(
-            fn=partial(preprocess, predictor), inputs=[input_image, input_processing], outputs=[processed_image_highres, processed_image], queue=True
-        ).success(
-            fn=partial(run_pipeline, pipeline, cfg),
-            inputs=[processed_image_highres, scale_slider, steps_slider, seed, crop_size, output_processing],
-            outputs=[view_gallery, normal_gallery],
-        )
-        # recon_btn.click(
-        #     process_3d, inputs=[mode, data_dir, scale_slider, crop_size], outputs=[obj_3d]
-        # )
-
-        demo.queue().launch(share=True, max_threads=80)
-        
-
-if __name__ == '__main__':
-    fire.Fire(run_demo)
+          
+if __name__ == "__main__":
+    demo.launch()
+    

requirements.txt

@@ -1,29 +1,4 @@
---extra-index-url https://download.pytorch.org/whl/cu118 --extra-index-url https://download.pytorch.org/whl/cu118
-diffusers[torch]
-transformers
-decord
-pytorch-lightning
-omegaconf
-nerfacc
-trimesh
-pyhocon
-icecream
-PyMCubes
-accelerate
-modelcards
-einops
-ftfy
-piq
-matplotlib
-opencv-python
-imageio
-imageio-ffmpeg
-scipy
-pyransac3d
-torch_efficient_distloss
-tensorboard
-rembg
-segment_anything
-gradio==4.31.5
-kornia
-fire
+accelerate
+transformers
+trimesh
+numpy