live preview

nvdiffmodeling/src/material.py

@@ -22,14 +22,25 @@ def load_mtl(fn, clear_ks=True):
     import re
     mtl_path = os.path.dirname(fn)
 
+    # Check if file exists
+    if not os.path.exists(fn):
+        print(f"Warning: Material file {fn} does not exist, returning empty material list")
+        return []
+
     # Read file
-    with open(fn) as f:
-        lines = f.readlines()
+    try:
+        with open(fn) as f:
+            lines = f.readlines()
+    except Exception as e:
+        print(f"Warning: Could not read material file {fn}: {e}, returning empty material list")
+        return []
 
     # Parse materials
     materials = []
     for line in lines:
         split_line = re.split(' +|\t+|\n+', line.strip())
+        if len(split_line) == 0:
+            continue
         prefix = split_line[0].lower()
         data = split_line[1:]
         if 'newmtl' in prefix:
@@ -39,33 +50,64 @@ def load_mtl(fn, clear_ks=True):
             if 'bsdf' in prefix or 'map_kd' in prefix or 'map_ks' in prefix or 'bump' in prefix:
                 material[prefix] = data[0]
             else:
-                material[prefix] = torch.tensor(tuple(float(d) for d in data), dtype=torch.float32, device='cuda')
+                try:
+                    material[prefix] = torch.tensor(tuple(float(d) for d in data), dtype=torch.float32, device='cuda')
+                except (ValueError, IndexError) as e:
+                    print(f"Warning: Could not parse material property {prefix} with data {data}: {e}")
+                    continue
 
     # Convert everything to textures. Our code expects 'kd' and 'ks' to be texture maps. So replace constants with 1x1 maps
     for mat in materials:
         if not 'bsdf' in mat:
             mat['bsdf'] = 'pbr'
 
+        # Handle kd (diffuse color)
         if 'map_kd' in mat:
-            mat['kd'] = texture.load_texture2D(os.path.join(mtl_path, mat['map_kd']))
-        else:
+            try:
+                mat['kd'] = texture.load_texture2D(os.path.join(mtl_path, mat['map_kd']))
+            except Exception as e:
+                print(f"Warning: Could not load kd texture {mat['map_kd']}: {e}, using default")
+                mat['kd'] = texture.Texture2D(torch.tensor([0.5, 0.5, 0.5], dtype=torch.float32, device='cuda'))
+        elif 'kd' in mat:
             mat['kd'] = texture.Texture2D(mat['kd'])
+        else:
+            # Default diffuse color
+            mat['kd'] = texture.Texture2D(torch.tensor([0.5, 0.5, 0.5], dtype=torch.float32, device='cuda'))
         
+        # Handle ks (specular color)
         if 'map_ks' in mat:
-            mat['ks'] = texture.load_texture2D(os.path.join(mtl_path, mat['map_ks']), channels=3)
-        else:
+            try:
+                mat['ks'] = texture.load_texture2D(os.path.join(mtl_path, mat['map_ks']), channels=3)
+            except Exception as e:
+                print(f"Warning: Could not load ks texture {mat['map_ks']}: {e}, using default")
+                mat['ks'] = texture.Texture2D(torch.tensor([0.0, 0.0, 0.0], dtype=torch.float32, device='cuda'))
+        elif 'ks' in mat:
             mat['ks'] = texture.Texture2D(mat['ks'])
+        else:
+            # Default specular color
+            mat['ks'] = texture.Texture2D(torch.tensor([0.0, 0.0, 0.0], dtype=torch.float32, device='cuda'))
 
+        # Handle normal map
         if 'bump' in mat:
-            mat['normal'] = texture.load_texture2D(os.path.join(mtl_path, mat['bump']), lambda_fn=lambda x: x * 2 - 1, channels=3)
+            try:
+                mat['normal'] = texture.load_texture2D(os.path.join(mtl_path, mat['bump']), lambda_fn=lambda x: x * 2 - 1, channels=3)
+            except Exception as e:
+                print(f"Warning: Could not load normal texture {mat['bump']}: {e}, using default")
+                mat['normal'] = texture.Texture2D(torch.tensor([0.0, 0.0, 1.0], dtype=torch.float32, device='cuda'))
 
         # Convert Kd from sRGB to linear RGB
-        mat['kd'] = texture.srgb_to_rgb(mat['kd'])
+        try:
+            mat['kd'] = texture.srgb_to_rgb(mat['kd'])
+        except Exception as e:
+            print(f"Warning: Could not convert kd to linear RGB: {e}")
 
         if clear_ks:
             # Override ORM occlusion (red) channel by zeros. We hijack this channel
-            for mip in mat['ks'].getMips():
-                mip[..., 0] = 0.0 
+            try:
+                for mip in mat['ks'].getMips():
+                    mip[..., 0] = 0.0
+            except Exception as e:
+                print(f"Warning: Could not clear ks occlusion channel: {e}")
 
     return materials
 

nvdiffmodeling/src/obj.py

@@ -41,6 +41,8 @@ def _find_mat(materials, name):
 
 def load_obj(filename, clear_ks=True, mtl_override=None):
     obj_path = os.path.dirname(filename)
+    print(f"Loading OBJ from: {filename}")
+    print(f"OBJ path: {obj_path}")
 
     # Read entire file
     with open(filename) as f:
@@ -60,9 +62,27 @@ def load_obj(filename, clear_ks=True, mtl_override=None):
             if len(line.split()) == 0:
                 continue
             if line.split()[0] == 'mtllib':
-                all_materials += material.load_mtl(obj_path + os.path.join(line.split()[1]), clear_ks) # Read in entire material library #obj_path
+                try:
+                    mtl_filename = line.split()[1].strip()
+                    # Handle both relative and absolute paths
+                    if os.path.isabs(mtl_filename):
+                        mtl_path = mtl_filename
+                    else:
+                        mtl_path = os.path.join(obj_path, mtl_filename)
+                    
+                    print(f"Looking for material file: {mtl_path}")
+                    if os.path.exists(mtl_path):
+                        print(f"Found material file: {mtl_path}")
+                        all_materials += material.load_mtl(mtl_path, clear_ks)
+                    else:
+                        print(f"Warning: Material file {mtl_path} not found, using default materials")
+                except Exception as e:
+                    print(f"Warning: Could not load material file {line.split()[1]}: {e}, using default materials")
     else:
-        all_materials += material.load_mtl(mtl_override)
+        try:
+            all_materials += material.load_mtl(mtl_override)
+        except Exception as e:
+            print(f"Warning: Could not load material override {mtl_override}: {e}, using default materials")
 
     # load vertices
     vertices, texcoords, normals  = [], [], []

utils.py

@@ -11,36 +11,50 @@ normal_map = texture.create_trainable(np.array([0, 0, 1]), [512] * 2, True)
 specular_map = texture.create_trainable(np.array([0, 0, 0]), [512] * 2, True)
 
 def get_mesh(mesh_path, output_path, triangulate_flag, bsdf_flag, mesh_name='mesh.obj'):
-    ms = pymeshlab.MeshSet()
-    ms.load_new_mesh(mesh_path)
-
-    if triangulate_flag:
-        print('Retriangulating shape')
-        ms.meshing_isotropic_explicit_remeshing()
-
-    if not ms.current_mesh().has_wedge_tex_coord():
-        # some arbitrarily high number
-        ms.compute_texcoord_parametrization_triangle_trivial_per_wedge(textdim=10000)
-
-    ms.save_current_mesh(str(output_path / 'tmp' / mesh_name))
-
-    load_mesh = obj.load_obj(str(output_path / 'tmp' / mesh_name))
-    load_mesh = mesh.unit_size(load_mesh)
-
-    ms.add_mesh(
-        pymeshlab.Mesh(vertex_matrix=load_mesh.v_pos.cpu().numpy(), face_matrix=load_mesh.t_pos_idx.cpu().numpy()))
-    ms.save_current_mesh(str(output_path / 'tmp' / mesh_name), save_vertex_color=False)
-
-    load_mesh = mesh.Mesh(
-        material={
-            'bsdf': bsdf_flag,
-            'kd': texture_map,
-            'ks': specular_map,
-            'normal': normal_map,
-        },
-        base=load_mesh  # Get UVs from original loaded mesh
-    )
-    return load_mesh
+    try:
+        print(f"Loading mesh from: {mesh_path}")
+        ms = pymeshlab.MeshSet()
+        ms.load_new_mesh(mesh_path)
+
+        if triangulate_flag:
+            print('Retriangulating shape')
+            ms.meshing_isotropic_explicit_remeshing()
+
+        if not ms.current_mesh().has_wedge_tex_coord():
+            # some arbitrarily high number
+            ms.compute_texcoord_parametrization_triangle_trivial_per_wedge(textdim=10000)
+
+        # Ensure the tmp directory exists
+        tmp_dir = output_path / 'tmp'
+        tmp_dir.mkdir(exist_ok=True)
+        
+        tmp_mesh_path = tmp_dir / mesh_name
+        print(f"Saving temporary mesh to: {tmp_mesh_path}")
+        ms.save_current_mesh(str(tmp_mesh_path))
+
+        print(f"Loading OBJ from temporary path: {tmp_mesh_path}")
+        load_mesh = obj.load_obj(str(tmp_mesh_path))
+        load_mesh = mesh.unit_size(load_mesh)
+
+        ms.add_mesh(
+            pymeshlab.Mesh(vertex_matrix=load_mesh.v_pos.cpu().numpy(), face_matrix=load_mesh.t_pos_idx.cpu().numpy()))
+        ms.save_current_mesh(str(tmp_mesh_path), save_vertex_color=False)
+
+        load_mesh = mesh.Mesh(
+            material={
+                'bsdf': bsdf_flag,
+                'kd': texture_map,
+                'ks': specular_map,
+                'normal': normal_map,
+            },
+            base=load_mesh  # Get UVs from original loaded mesh
+        )
+        return load_mesh
+    except Exception as e:
+        print(f"Error in get_mesh: {e}")
+        import traceback
+        traceback.print_exc()
+        raise
 
 
 def get_og_mesh(mesh_path, output_path, triangulate_flag, bsdf_flag, mesh_name='mesh.obj'):