update 20003

loop.py

@@ -224,11 +224,42 @@ def loop(cfg):
     jacobian_source = SourceMesh.SourceMesh(0, str(output_path / 'tmp' / 'mesh.obj'), {}, 1, ttype=torch.float)
     if len(list((output_path / 'tmp').glob('*.npz'))) > 0:
         logging.warn(f'Using existing Jacobian .npz files in {str(output_path)}/tmp/ ! Please check if this is intentional.')
+    
+    # Check if the mesh file exists before loading
+    mesh_file_path = output_path / 'tmp' / 'mesh.obj'
+    print(f"Looking for mesh file at: {mesh_file_path}")
+    print(f"Absolute path: {mesh_file_path.absolute()}")
+    
+    if not mesh_file_path.exists():
+        # List files in the tmp directory to see what's there
+        tmp_dir = output_path / 'tmp'
+        if tmp_dir.exists():
+            print(f"Files in {tmp_dir}:")
+            for file in tmp_dir.iterdir():
+                print(f"  - {file.name}")
+        else:
+            print(f"Tmp directory {tmp_dir} does not exist")
+        raise FileNotFoundError(f"Mesh file not found: {mesh_file_path}. This indicates an issue with the mesh loading process.")
+    
+    print(f"Mesh file exists at: {mesh_file_path}")
+    print("Loading jacobian source...")
     jacobian_source.load()
     jacobian_source.to(device)
+    
+    # Validate that jacobian source loaded properly
+    if not hasattr(jacobian_source, 'jacobians_from_vertices') or jacobian_source.jacobians_from_vertices is None:
+        raise ValueError("Failed to load jacobian source. The jacobians_from_vertices method is not available.")
+    
+    print("Jacobian source loaded successfully")
 
     with torch.no_grad():
         gt_jacobians = jacobian_source.jacobians_from_vertices(load_mesh.v_pos.unsqueeze(0))
+    
+    # Validate that gt_jacobians is not empty
+    if gt_jacobians is None or gt_jacobians.shape[0] == 0:
+        raise ValueError("Failed to generate jacobians from vertices. This indicates an issue with the mesh or jacobian source.")
+    
+    print(f"Generated jacobians with shape: {gt_jacobians.shape}")
     gt_jacobians.requires_grad_(True)
 
     optimizer = torch.optim.Adam([gt_jacobians], lr=cfg.lr)
@@ -268,6 +299,12 @@ def loop(cfg):
 
         # updated vertices from jacobians
         n_vert = jacobian_source.vertices_from_jacobians(gt_jacobians).squeeze()
+        
+        # Validate that n_vert is not empty
+        if n_vert is None or n_vert.shape[0] == 0:
+            raise ValueError("Generated vertices are empty. This indicates an issue with the jacobian source or mesh loading.")
+        
+        print(f"Iteration {it}: Generated {n_vert.shape[0]} vertices")
 
         # TODO: More texture code required to make it work ...
         ready_texture = texture.Texture2D(

nvdiffmodeling/src/obj.py

@@ -163,6 +163,14 @@ def load_obj(filename, clear_ks=True, mtl_override=None):
     tfaces = torch.tensor(tfaces, dtype=torch.int64, device='cuda') if texcoords is not None else None
     nfaces = torch.tensor(nfaces, dtype=torch.int64, device='cuda') if normals is not None else None
 
+    # Validate that we have valid mesh data
+    if len(vertices) == 0:
+        raise ValueError(f"No vertices found in mesh file: {filename}")
+    if len(faces) == 0:
+        raise ValueError(f"No faces found in mesh file: {filename}")
+    
+    print(f"Loaded mesh from {filename}: {len(vertices)} vertices, {len(faces)} faces")
+
     # Read weights and bones if available
     try:
         v_weights = torch.tensor(np.load(os.path.splitext(filename)[0] + ".weights.npy"), dtype=torch.float32, device='cuda')

utils.py

@@ -5,6 +5,7 @@ from nvdiffmodeling.src     import mesh
 from nvdiffmodeling.src     import texture
 import numpy as np
 from utilities.helpers import get_vp_map
+import os
 
 texture_map = texture.create_trainable(np.random.uniform(size=[512] * 2 + [3], low=0.0, high=1.0), [512] * 2, True)
 normal_map = texture.create_trainable(np.array([0, 0, 1]), [512] * 2, True)
@@ -13,8 +14,19 @@ 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'):
     try:
         print(f"Loading mesh from: {mesh_path}")
+        
+        # Check if mesh file exists
+        if not os.path.exists(mesh_path):
+            raise FileNotFoundError(f"Mesh file not found: {mesh_path}")
+        
         ms = pymeshlab.MeshSet()
         ms.load_new_mesh(mesh_path)
+        
+        # Check if mesh was loaded successfully
+        if ms.current_mesh().vertex_number() == 0:
+            raise ValueError(f"Mesh file {mesh_path} has no vertices")
+        
+        print(f"Loaded mesh with {ms.current_mesh().vertex_number()} vertices and {ms.current_mesh().face_number()} faces")
 
         if triangulate_flag:
             print('Retriangulating shape')
@@ -34,6 +46,16 @@ def get_mesh(mesh_path, output_path, triangulate_flag, bsdf_flag, mesh_name='mes
 
         print(f"Loading OBJ from temporary path: {tmp_mesh_path}")
         load_mesh = obj.load_obj(str(tmp_mesh_path))
+        
+        # Check if mesh was loaded successfully
+        if load_mesh.v_pos is None or load_mesh.v_pos.shape[0] == 0:
+            raise ValueError(f"Failed to load mesh vertices from {tmp_mesh_path}")
+        
+        if load_mesh.t_pos_idx is None or load_mesh.t_pos_idx.shape[0] == 0:
+            raise ValueError(f"Failed to load mesh faces from {tmp_mesh_path}")
+        
+        print(f"Loaded mesh with {load_mesh.v_pos.shape[0]} vertices and {load_mesh.t_pos_idx.shape[0]} faces")
+        
         load_mesh = mesh.unit_size(load_mesh)
 
         ms.add_mesh(
@@ -49,7 +71,17 @@ def get_mesh(mesh_path, output_path, triangulate_flag, bsdf_flag, mesh_name='mes
             },
             base=load_mesh  # Get UVs from original loaded mesh
         )
+        
+        # Final check to ensure mesh is valid
+        if load_mesh.v_pos is None or load_mesh.v_pos.shape[0] == 0:
+            raise ValueError("Final mesh has no vertices")
+        
+        if load_mesh.t_pos_idx is None or load_mesh.t_pos_idx.shape[0] == 0:
+            raise ValueError("Final mesh has no faces")
+        
+        print(f"Successfully loaded mesh with {load_mesh.v_pos.shape[0]} vertices and {load_mesh.t_pos_idx.shape[0]} faces")
         return load_mesh
+        
     except Exception as e:
         print(f"Error in get_mesh: {e}")
         import traceback