Upload 3 files

app.py

@@ -1,278 +1,276 @@
-import spaces
-import subprocess
-# Install flash attention, skipping CUDA build if necessary
-subprocess.run(
-    "pip install flash-attn --no-build-isolation",
-    env={"FLASH_ATTENTION_SKIP_CUDA_BUILD": "TRUE"},
-    shell=True,
-)
-import os
-import torch
-import trimesh
-from accelerate.utils import set_seed
-from accelerate import Accelerator
-import numpy as np
-import gradio as gr
-from main import get_args, load_model
-from mesh_to_pc import process_mesh_to_pc
-import time
-import matplotlib.pyplot as plt
-from mpl_toolkits.mplot3d.art3d import Poly3DCollection
-from PIL import Image
-import io
-
-args = get_args()
-model = load_model(args)
-
-device = torch.device('cuda')
-accelerator = Accelerator(
-    mixed_precision="fp16",
-)
-model = accelerator.prepare(model)
-model.eval()
-print("Model loaded to device")
-
-def wireframe_render(mesh):
-    views = [
-        (90, 20), (270, 20)
-    ]
-    mesh.vertices = mesh.vertices[:, [0, 2, 1]]
-
-    bounding_box = mesh.bounds
-    center = mesh.centroid
-    scale = np.ptp(bounding_box, axis=0).max()
-
-    fig = plt.figure(figsize=(10, 10))
-
-    # Function to render and return each view as an image
-    def render_view(mesh, azimuth, elevation):
-        ax = fig.add_subplot(111, projection='3d')
-        ax.set_axis_off()
-
-        # Extract vertices and faces for plotting
-        vertices = mesh.vertices
-        faces = mesh.faces
-
-        # Plot faces
-        ax.add_collection3d(Poly3DCollection(
-            vertices[faces],
-            facecolors=(0.8, 0.5, 0.2, 1.0),  # Brownish yellow
-            edgecolors='k',
-            linewidths=0.5,
-        ))
-
-        # Set limits and center the view on the object
-        ax.set_xlim(center[0] - scale / 2, center[0] + scale / 2)
-        ax.set_ylim(center[1] - scale / 2, center[1] + scale / 2)
-        ax.set_zlim(center[2] - scale / 2, center[2] + scale / 2)
-
-        # Set view angle
-        ax.view_init(elev=elevation, azim=azimuth)
-
-        # Save the figure to a buffer
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0, dpi=300)
-        plt.clf()
-        buf.seek(0)
-
-        return Image.open(buf)
-
-    # Render each view and store in a list
-    images = [render_view(mesh, az, el) for az, el in views]
-
-    # Combine images horizontally
-    widths, heights = zip(*(i.size for i in images))
-    total_width = sum(widths)
-    max_height = max(heights)
-
-    combined_image = Image.new('RGBA', (total_width, max_height))
-
-    x_offset = 0
-    for img in images:
-        combined_image.paste(img, (x_offset, 0))
-        x_offset += img.width
-
-    # Save the combined image
-    save_path = f"combined_mesh_view_{int(time.time())}.png"
-    combined_image.save(save_path)
-
-    plt.close(fig)
-    return save_path
-
-@spaces.GPU(duration=300)
-def do_inference(input_3d, sample_seed=0, do_sampling=False, do_marching_cubes=False):
-    set_seed(sample_seed)
-    print("Seed value:", sample_seed)
-
-    input_mesh = trimesh.load(input_3d)
-    pc_list, mesh_list = process_mesh_to_pc([input_mesh], marching_cubes = do_marching_cubes)
-    pc_normal = pc_list[0] # 4096, 6
-    mesh = mesh_list[0]
-    vertices = mesh.vertices
-
-    pc_coor = pc_normal[:, :3]
-    normals = pc_normal[:, 3:]
-
-    bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
-    # scale mesh and pc
-    vertices = vertices - (bounds[0] + bounds[1])[None, :] / 2
-    vertices = vertices / (bounds[1] - bounds[0]).max()
-    mesh.vertices = vertices
-    pc_coor = pc_coor - (bounds[0] + bounds[1])[None, :] / 2
-    pc_coor = pc_coor / (bounds[1] - bounds[0]).max()
-
-    mesh.merge_vertices()
-    mesh.update_faces(mesh.unique_faces())
-    mesh.fix_normals()
-    if mesh.visual.vertex_colors is not None:
-        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
-
-        mesh.visual.vertex_colors = np.tile(orange_color, (mesh.vertices.shape[0], 1))
-    else:
-        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
-        mesh.visual.vertex_colors = np.tile(orange_color, (mesh.vertices.shape[0], 1))
-    input_save_name = f"processed_input_{int(time.time())}.obj"
-    mesh.export(input_save_name)
-    input_render_res = wireframe_render(mesh)
-
-    pc_coor = pc_coor / np.abs(pc_coor).max() * 0.9995 # input should be from -1 to 1
-    assert (np.linalg.norm(normals, axis=-1) > 0.99).all(), "normals should be unit vectors, something wrong"
-    normalized_pc_normal = np.concatenate([pc_coor, normals], axis=-1, dtype=np.float16)
-
-    input = torch.tensor(normalized_pc_normal, dtype=torch.float16, device=device)[None]
-    print("Data loaded")
-
-    # with accelerator.autocast():
-    with accelerator.autocast():
-        outputs = model(input, do_sampling)
-    print("Model inference done")
-    recon_mesh = outputs[0]
-
-    recon_mesh = recon_mesh[~torch.isnan(recon_mesh[:, 0, 0])]  # nvalid_face x 3 x 3
-    vertices = recon_mesh.reshape(-1, 3).cpu()
-    vertices_index = np.arange(len(vertices))  # 0, 1, ..., 3 x face
-    triangles = vertices_index.reshape(-1, 3)
-
-    artist_mesh = trimesh.Trimesh(vertices=vertices, faces=triangles, force="mesh",
-                                 merge_primitives=True)
-    artist_mesh.merge_vertices()
-    artist_mesh.update_faces(artist_mesh.unique_faces())
-    artist_mesh.fix_normals()
-
-    if artist_mesh.visual.vertex_colors is not None:
-        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
-
-        artist_mesh.visual.vertex_colors = np.tile(orange_color, (artist_mesh.vertices.shape[0], 1))
-    else:
-        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
-        artist_mesh.visual.vertex_colors = np.tile(orange_color, (artist_mesh.vertices.shape[0], 1))
-
-    num_faces = len(artist_mesh.faces)
-
-    brown_color = np.array([165, 42, 42, 255], dtype=np.uint8)
-    face_colors = np.tile(brown_color, (num_faces, 1))
-
-    artist_mesh.visual.face_colors = face_colors
-    # add time stamp to avoid cache
-    save_name = f"output_{int(time.time())}.obj"
-    artist_mesh.export(save_name)
-    output_render = wireframe_render(artist_mesh)
-    return input_save_name, input_render_res, save_name, output_render
-
-
-_HEADER_ = '''
-<h2><b>Official 🤗 Gradio Demo</b></h2><h2><a href='https://github.com/buaacyw/MeshAnything' target='_blank'><b>MeshAnything: Artist-Created Mesh Generation with Autoregressive Transformers</b></a></h2>
-
-**MeshAnything** converts any 3D representation into meshes created by human artists, i.e., Artist-Created Meshes (AMs).
-
-Code: <a href='https://github.com/buaacyw/MeshAnything' target='_blank'>GitHub</a>. Arxiv Paper: <a href='https://arxiv.org/abs/2406.10163' target='_blank'>ArXiv</a>.
-
-❗️❗️❗️**Important Notes:**
-- Gradio doesn't support interactive wireframe rendering currently. For interactive mesh visualization, please use download the obj file and open it with MeshLab or https://3dviewer.net/.
-- The input mesh will be normalized to a unit bounding box. The up vector of the input mesh should be +Y for better results. Click **Preprocess with Marching Cubes** if the input mesh is a manually created mesh.
-- Limited by computational resources, MeshAnything is trained on meshes with fewer than 800 faces and cannot generate meshes with more than 800 faces. The shape of the input mesh should be sharp enough; otherwise, it will be challenging to represent it with only 800 faces. Thus, feed-forward image-to-3D methods may often produce bad results due to insufficient shape quality.
-- For point cloud input, please refer to our github repo <a href='https://github.com/buaacyw/MeshAnything' target='_blank'>GitHub</a>.
-'''
-
-
-_CITE_ = r"""
-If MeshAnything is helpful, please help to ⭐ the <a href='https://github.com/buaacyw/MeshAnything' target='_blank'>Github Repo</a>. Thanks!
----
-📋 **License**
-
-S-Lab-1.0 LICENSE. Please refer to the [LICENSE file](https://github.com/buaacyw/GaussianEditor/blob/master/LICENSE.txt) for details.
-
-📧 **Contact**
-
-If you have any questions, feel free to open a discussion or contact us at <b>yiwen002@e.ntu.edu.sg</b>.
-
-"""
-output_model_obj = gr.Model3D(
-    label="Generated Mesh (OBJ Format)",
-    clear_color=[1, 1, 1, 1],
-)
-preprocess_model_obj = gr.Model3D(
-    label="Processed Input Mesh (OBJ Format)",
-    clear_color=[1, 1, 1, 1],
-)
-input_image_render = gr.Image(
-    label="Wireframe Render of Processed Input Mesh",
-)
-output_image_render = gr.Image(
-    label="Wireframe Render of Generated Mesh",
-)
-with (gr.Blocks() as demo):
-    gr.Markdown(_HEADER_)
-    with gr.Row(variant="panel"):
-        with gr.Column():
-            with gr.Row():
-                input_3d = gr.Model3D(
-                    label="Input Mesh",
-                    clear_color=[1,1,1,1],
-                )
-
-            with gr.Row():
-                with gr.Group():
-                    do_marching_cubes = gr.Checkbox(label="Preprocess with Marching Cubes", value=False)
-                    do_sampling = gr.Checkbox(label="Random Sampling", value=False)
-                    sample_seed = gr.Number(value=0, label="Seed Value", precision=0)
-
-            with gr.Row():
-                submit = gr.Button("Generate", elem_id="generate", variant="primary")
-
-            with gr.Row(variant="panel"):
-                mesh_examples = gr.Examples(
-                    examples=[
-                        os.path.join("examples", img_name) for img_name in sorted(os.listdir("examples"))
-                    ],
-                    inputs=input_3d,
-                    outputs=[preprocess_model_obj, input_image_render, output_model_obj, output_image_render],
-                    fn=do_inference,
-                    cache_examples = "lazy",
-                    examples_per_page=10
-                )
-        with gr.Column():
-            with gr.Row():
-                input_image_render.render()
-            with gr.Row():
-                with gr.Tab("OBJ"):
-                    preprocess_model_obj.render()
-            with gr.Row():
-                output_image_render.render()
-            with gr.Row():
-                with gr.Tab("OBJ"):
-                    output_model_obj.render()
-            with gr.Row():
-                gr.Markdown('''Try click random sampling and different <b>Seed Value</b> if the result is unsatisfying''')
-
-    gr.Markdown(_CITE_)
-
-    mv_images = gr.State()
-
-    submit.click(
-        fn=do_inference,
-        inputs=[input_3d, sample_seed, do_sampling, do_marching_cubes],
-        outputs=[preprocess_model_obj, input_image_render, output_model_obj, output_image_render],
-    )
-
+import os
+import torch
+import trimesh
+from accelerate.utils import set_seed
+from accelerate import Accelerator
+import numpy as np
+import gradio as gr
+from main import load_v2
+from mesh_to_pc import process_mesh_to_pc
+import time
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+from PIL import Image
+import io
+
+model = load_v2()
+
+device = torch.device('cuda')
+accelerator = Accelerator(
+    mixed_precision="fp16",
+)
+model = accelerator.prepare(model)
+model.eval()
+print("Model loaded to device")
+
+def wireframe_render(mesh):
+    views = [
+        (90, 20), (270, 20)
+    ]
+    mesh.vertices = mesh.vertices[:, [0, 2, 1]]
+
+    bounding_box = mesh.bounds
+    center = mesh.centroid
+    scale = np.ptp(bounding_box, axis=0).max()
+
+    fig = plt.figure(figsize=(10, 10))
+
+    # Function to render and return each view as an image
+    def render_view(mesh, azimuth, elevation):
+        ax = fig.add_subplot(111, projection='3d')
+        ax.set_axis_off()
+
+        # Extract vertices and faces for plotting
+        vertices = mesh.vertices
+        faces = mesh.faces
+
+        # Plot faces
+        ax.add_collection3d(Poly3DCollection(
+            vertices[faces],
+            facecolors=(0.8, 0.5, 0.2, 1.0),  # Brownish yellow
+            edgecolors='k',
+            linewidths=0.5,
+        ))
+
+        # Set limits and center the view on the object
+        ax.set_xlim(center[0] - scale / 2, center[0] + scale / 2)
+        ax.set_ylim(center[1] - scale / 2, center[1] + scale / 2)
+        ax.set_zlim(center[2] - scale / 2, center[2] + scale / 2)
+
+        # Set view angle
+        ax.view_init(elev=elevation, azim=azimuth)
+
+        # Save the figure to a buffer
+        buf = io.BytesIO()
+        plt.savefig(buf, format='png', bbox_inches='tight', pad_inches=0, dpi=300)
+        plt.clf()
+        buf.seek(0)
+
+        return Image.open(buf)
+
+    # Render each view and store in a list
+    images = [render_view(mesh, az, el) for az, el in views]
+
+    # Combine images horizontally
+    widths, heights = zip(*(i.size for i in images))
+    total_width = sum(widths)
+    max_height = max(heights)
+
+    combined_image = Image.new('RGBA', (total_width, max_height))
+
+    x_offset = 0
+    for img in images:
+        combined_image.paste(img, (x_offset, 0))
+        x_offset += img.width
+
+    # Save the combined image
+    save_path = f"combined_mesh_view_{int(time.time())}.png"
+    combined_image.save(save_path)
+
+    plt.close(fig)
+    return save_path
+
+@torch.no_grad()
+def do_inference(input_3d, sample_seed=0, do_sampling=False, do_marching_cubes=False):
+    set_seed(sample_seed)
+    print("Seed value:", sample_seed)
+
+    input_mesh = trimesh.load(input_3d)
+    pc_list, mesh_list = process_mesh_to_pc([input_mesh], marching_cubes = do_marching_cubes)
+    pc_normal = pc_list[0] # 4096, 6
+    mesh = mesh_list[0]
+    vertices = mesh.vertices
+
+    pc_coor = pc_normal[:, :3]
+    normals = pc_normal[:, 3:]
+
+    bounds = np.array([vertices.min(axis=0), vertices.max(axis=0)])
+    # scale mesh and pc
+    vertices = vertices - (bounds[0] + bounds[1])[None, :] / 2
+    vertices = vertices / (bounds[1] - bounds[0]).max()
+    mesh.vertices = vertices
+    pc_coor = pc_coor - (bounds[0] + bounds[1])[None, :] / 2
+    pc_coor = pc_coor / (bounds[1] - bounds[0]).max()
+
+    mesh.merge_vertices()
+    mesh.update_faces(mesh.nondegenerate_faces())
+    mesh.update_faces(mesh.unique_faces())
+    mesh.remove_unreferenced_vertices()
+    mesh.fix_normals()
+    if mesh.visual.vertex_colors is not None:
+        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
+
+        mesh.visual.vertex_colors = np.tile(orange_color, (mesh.vertices.shape[0], 1))
+    else:
+        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
+        mesh.visual.vertex_colors = np.tile(orange_color, (mesh.vertices.shape[0], 1))
+    input_save_name = f"processed_input_{int(time.time())}.obj"
+    mesh.export(input_save_name)
+    input_render_res = wireframe_render(mesh)
+
+    pc_coor = pc_coor / np.abs(pc_coor).max() * 0.99 # input should be from -1 to 1
+
+    assert (np.linalg.norm(normals, axis=-1) > 0.99).all(), "normals should be unit vectors, something wrong"
+    normalized_pc_normal = np.concatenate([pc_coor, normals], axis=-1, dtype=np.float16)
+
+    input = torch.tensor(normalized_pc_normal, dtype=torch.float16, device=device)[None]
+    print("Data loaded")
+
+    # with accelerator.autocast():
+    with accelerator.autocast():
+        outputs = model(input, do_sampling)
+    print("Model inference done")
+    recon_mesh = outputs[0]
+
+    valid_mask = torch.all(~torch.isnan(recon_mesh.reshape((-1, 9))), dim=1)
+    recon_mesh = recon_mesh[valid_mask]  # nvalid_face x 3 x 3
+    vertices = recon_mesh.reshape(-1, 3).cpu()
+    vertices_index = np.arange(len(vertices))  # 0, 1, ..., 3 x face
+    triangles = vertices_index.reshape(-1, 3)
+
+    artist_mesh = trimesh.Trimesh(vertices=vertices, faces=triangles, force="mesh",
+                                 merge_primitives=True)
+
+    artist_mesh.merge_vertices()
+    artist_mesh.update_faces(artist_mesh.nondegenerate_faces())
+    artist_mesh.update_faces(artist_mesh.unique_faces())
+    artist_mesh.remove_unreferenced_vertices()
+    artist_mesh.fix_normals()
+
+    if artist_mesh.visual.vertex_colors is not None:
+        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
+
+        artist_mesh.visual.vertex_colors = np.tile(orange_color, (artist_mesh.vertices.shape[0], 1))
+    else:
+        orange_color = np.array([255, 165, 0, 255], dtype=np.uint8)
+        artist_mesh.visual.vertex_colors = np.tile(orange_color, (artist_mesh.vertices.shape[0], 1))
+
+    num_faces = len(artist_mesh.faces)
+
+    brown_color = np.array([165, 42, 42, 255], dtype=np.uint8)
+    face_colors = np.tile(brown_color, (num_faces, 1))
+
+    artist_mesh.visual.face_colors = face_colors
+    # add time stamp to avoid cache
+    save_name = f"output_{int(time.time())}.obj"
+    artist_mesh.export(save_name)
+    output_render = wireframe_render(artist_mesh)
+    return input_save_name, input_render_res, save_name, output_render
+
+
+_HEADER_ = '''
+<h2><b>Official ? Gradio Demo</b></h2><h2><a href='https://github.com/buaacyw/MeshAnything' target='_blank'><b>MeshAnything V2: Artist-Created Mesh Generation With Adjacent Mesh Tokenization</b></a></h2>
+
+**MeshAnything** converts any 3D representation into meshes created by human artists, i.e., Artist-Created Meshes (AMs).
+
+Code: <a href='https://github.com/buaacyw/MeshAnything' target='_blank'>GitHub</a>. Arxiv Paper: <a href='https://arxiv.org/abs/2406.10163' target='_blank'>ArXiv</a>.
+
+??????**Important Notes:**
+- Gradio doesn't support interactive wireframe rendering currently. For interactive mesh visualization, please use download the obj file and open it with MeshLab or https://3dviewer.net/.
+- The input mesh will be normalized to a unit bounding box. The up vector of the input mesh should be +Y for better results. Click **Preprocess with Marching Cubes** if the input mesh is a manually created mesh.
+- Limited by computational resources, MeshAnything is trained on meshes with fewer than 800 faces and cannot generate meshes with more than 800 faces. The shape of the input mesh should be sharp enough; otherwise, it will be challenging to represent it with only 800 faces. Thus, feed-forward image-to-3D methods may often produce bad results due to insufficient shape quality.
+- For point cloud input, please refer to our github repo <a href='https://github.com/buaacyw/MeshAnything' target='_blank'>GitHub</a>.
+'''
+
+
+_CITE_ = r"""
+If MeshAnything is helpful, please help to ? the <a href='https://github.com/buaacyw/MeshAnything' target='_blank'>Github Repo</a>. Thanks!
+---
+? **License**
+
+S-Lab-1.0 LICENSE. Please refer to the [LICENSE file](https://github.com/buaacyw/GaussianEditor/blob/master/LICENSE.txt) for details.
+
+? **Contact**
+
+If you have any questions, feel free to open a discussion or contact us at <b>yiwen002@e.ntu.edu.sg</b>.
+
+"""
+output_model_obj = gr.Model3D(
+    label="Generated Mesh (OBJ Format)",
+    clear_color=[1, 1, 1, 1],
+)
+preprocess_model_obj = gr.Model3D(
+    label="Processed Input Mesh (OBJ Format)",
+    clear_color=[1, 1, 1, 1],
+)
+input_image_render = gr.Image(
+    label="Wireframe Render of Processed Input Mesh",
+)
+output_image_render = gr.Image(
+    label="Wireframe Render of Generated Mesh",
+)
+with (gr.Blocks() as demo):
+    gr.Markdown(_HEADER_)
+    with gr.Row(variant="panel"):
+        with gr.Column():
+            with gr.Row():
+                input_3d = gr.Model3D(
+                    label="Input Mesh",
+                    clear_color=[1,1,1,1],
+                )
+
+            with gr.Row():
+                with gr.Group():
+                    do_marching_cubes = gr.Checkbox(label="Preprocess with Marching Cubes", value=False)
+                    do_sampling = gr.Checkbox(label="Random Sampling", value=False)
+                    sample_seed = gr.Number(value=0, label="Seed Value", precision=0)
+
+            with gr.Row():
+                submit = gr.Button("Generate", elem_id="generate", variant="primary")
+
+            with gr.Row(variant="panel"):
+                mesh_examples = gr.Examples(
+                    examples=[
+                        os.path.join("examples", img_name) for img_name in sorted(os.listdir("examples"))
+                    ],
+                    inputs=input_3d,
+                    outputs=[preprocess_model_obj, input_image_render, output_model_obj, output_image_render],
+                    fn=do_inference,
+                    cache_examples = False,
+                    examples_per_page=10
+                )
+        with gr.Column():
+            with gr.Row():
+                input_image_render.render()
+            with gr.Row():
+                with gr.Tab("OBJ"):
+                    preprocess_model_obj.render()
+            with gr.Row():
+                output_image_render.render()
+            with gr.Row():
+                with gr.Tab("OBJ"):
+                    output_model_obj.render()
+            with gr.Row():
+                gr.Markdown('''Try click random sampling and different <b>Seed Value</b> if the result is unsatisfying''')
+
+    gr.Markdown(_CITE_)
+
+    mv_images = gr.State()
+
+    submit.click(
+        fn=do_inference,
+        inputs=[input_3d, sample_seed, do_sampling, do_marching_cubes],
+        outputs=[preprocess_model_obj, input_image_render, output_model_obj, output_image_render],
+    )
+
 demo.launch(share=True)

main.py

@@ -3,12 +3,13 @@ import torch
 import time
 import trimesh
 import numpy as np
-from MeshAnything.models.meshanything import MeshAnything
+from MeshAnything.models.meshanything_v2 import MeshAnythingV2
 import datetime
 from accelerate import Accelerator
 from accelerate.utils import set_seed
 from accelerate.utils import DistributedDataParallelKwargs
-from safetensors import safe_open
+from safetensors.torch import load_model
+
 from mesh_to_pc import process_mesh_to_pc
 from huggingface_hub import hf_hub_download
 
@@ -21,8 +22,8 @@ class Dataset:
                 # load npy
                 cur_data = np.load(input_path)
                 # sample 4096
-                assert cur_data.shape[0] >= 4096, "input pc_normal should have at least 4096 points"
-                idx = np.random.choice(cur_data.shape[0], 4096, replace=False)
+                assert cur_data.shape[0] >= 8192, "input pc_normal should have at least 4096 points"
+                idx = np.random.choice(cur_data.shape[0], 8192, replace=False)
                 cur_data = cur_data[idx]
                 self.data.append({'pc_normal': cur_data, 'uid': input_path.split('/')[-1].split('.')[0]})
 
@@ -60,12 +61,10 @@ class Dataset:
 def get_args():
     parser = argparse.ArgumentParser("MeshAnything", add_help=False)
 
-    parser.add_argument('--llm', default="facebook/opt-350m", type=str)
     parser.add_argument('--input_dir', default=None, type=str)
     parser.add_argument('--input_path', default=None, type=str)
 
     parser.add_argument('--out_dir', default="inference_out", type=str)
-    parser.add_argument('--pretrained_weights', default="MeshAnything_350m.pth", type=str)
 
     parser.add_argument(
         '--input_type',
@@ -74,11 +73,6 @@ def get_args():
         help="Type of the asset to process (default: pc)"
     )
 
-    parser.add_argument("--codebook_size", default=8192, type=int)
-    parser.add_argument("--codebook_dim", default=1024, type=int)
-
-    parser.add_argument("--n_max_triangles", default=800, type=int)
-
     parser.add_argument("--batchsize_per_gpu", default=1, type=int)
     parser.add_argument("--seed", default=0, type=int)
 
@@ -88,20 +82,17 @@ def get_args():
     args = parser.parse_args()
     return args
 
-def load_model(args):
-    model = MeshAnything(args)
+def load_v2():
+    model = MeshAnythingV2()
     print("load model over!!!")
 
     ckpt_path = hf_hub_download(
-        repo_id="Yiwen-ntu/MeshAnything",
-        filename="MeshAnything_350m.pth",
+        repo_id="Yiwen-ntu/MeshAnythingV2",
+        filename="350m.pth",
     )
-    tensors = {}
-    with safe_open(ckpt_path, framework="pt", device=0) as f:
-        for k in f.keys():
-            tensors[k] = f.get_tensor(k)
 
-    model.load_state_dict(tensors, strict=True)
+    load_model(model, ckpt_path)
+
     print("load weights over!!!")
     return model
 if __name__ == "__main__":
@@ -117,7 +108,7 @@ if __name__ == "__main__":
         kwargs_handlers=[kwargs]
     )
 
-    model = load_model(args)
+    model = load_v2()
     # create dataset
     if args.input_dir is not None:
         input_list = sorted(os.listdir(args.input_dir))
@@ -155,7 +146,9 @@ if __name__ == "__main__":
 
             for batch_id in range(batch_size):
                 recon_mesh = outputs[batch_id]
-                recon_mesh = recon_mesh[~torch.isnan(recon_mesh[:, 0, 0])]  # nvalid_face x 3 x 3
+                valid_mask = torch.all(~torch.isnan(recon_mesh.reshape((-1, 9))), dim=1)
+                recon_mesh = recon_mesh[valid_mask]  # nvalid_face x 3 x 3
+
                 vertices = recon_mesh.reshape(-1, 3).cpu()
                 vertices_index = np.arange(len(vertices))  # 0, 1, ..., 3 x face
                 triangles = vertices_index.reshape(-1, 3)
@@ -163,7 +156,9 @@ if __name__ == "__main__":
                 scene_mesh = trimesh.Trimesh(vertices=vertices, faces=triangles, force="mesh",
                                              merge_primitives=True)
                 scene_mesh.merge_vertices()
+                scene_mesh.update_faces(scene_mesh.nondegenerate_faces())
                 scene_mesh.update_faces(scene_mesh.unique_faces())
+                scene_mesh.remove_unreferenced_vertices()
                 scene_mesh.fix_normals()
                 save_path = os.path.join(checkpoint_dir, f'{batch_data_label["uid"][batch_id]}_gen.obj')
                 num_faces = len(scene_mesh.faces)

mesh_to_pc.py

@@ -3,7 +3,7 @@ import numpy as np
 import skimage.measure
 import trimesh
 
-def normalize_vertices(vertices, scale=0.9):
+def normalize_vertices(vertices, scale=0.95):
     bbmin, bbmax = vertices.min(0), vertices.max(0)
     center = (bbmin + bbmax) * 0.5
     scale = 2.0 * scale / (bbmax - bbmin).max()
@@ -39,7 +39,7 @@ def export_to_watertight(normalized_mesh, octree_depth: int = 7):
 
     return mesh
 
-def process_mesh_to_pc(mesh_list, marching_cubes = False, sample_num = 4096):
+def process_mesh_to_pc(mesh_list, marching_cubes = False, sample_num = 8192):
     # mesh_list : list of trimesh
     pc_normal_list = []
     return_mesh_list = []