more elegent fixes

NeuralJacobianFields/PoissonSystem.py

@@ -49,7 +49,11 @@ if USE_SCIPY:
 
 
 if USE_TORCH_SPARSE:
-    import torch_sparse
+    try:
+        import torch_sparse
+    except ImportError:
+        print("Warning: torch_sparse not available, falling back to built-in PyTorch sparse operations")
+        USE_TORCH_SPARSE = False
 
 
 USE_UGLY_PATCH_FOR_CUPY_ERROR = False

app.py

@@ -461,8 +461,22 @@ def process_garment(input_type, text_prompt, base_text_prompt, mesh_target_image
                     print(error_message)
                     return error_message
                 
+                # Check if loop is a dummy function (which raises RuntimeError)
+                if hasattr(loop, '__name__') and loop.__name__ == 'dummy_loop':
+                    error_message = "Error: Processing engine not available. Please check dependencies."
+                    print(error_message)
+                    return error_message
+                
                 # Run the loop with error handling
-                loop(config)
+                try:
+                    loop(config)
+                except RuntimeError as e:
+                    if "Processing engine not available" in str(e):
+                        error_message = "Error: Processing engine not available. Please check dependencies."
+                        print(error_message)
+                        return error_message
+                    else:
+                        raise e
             except RuntimeError as e:
                 print(f"Runtime error during processing: {e}")
                 if "operator torchvision::nms does not exist" in str(e):
@@ -534,7 +548,7 @@ def process_garment(input_type, text_prompt, base_text_prompt, mesh_target_image
                 return image_files[0]  # Return an image if no mesh was found
             else:
                 print("No output files found")
-                return "Processing completed but no output files found. Please check the logs for more information."
+                return None
                 
     except Exception as e:
         import traceback
@@ -704,10 +718,18 @@ def create_interface():
             try:
                 result = process_garment(*args)
                 if result is None:
-                    return None, "Processing failed. Please check the logs for details."
+                    return None, "Processing completed but no output files were generated. Please check the logs for more details."
                 elif isinstance(result, str) and result.startswith("Error:"):
+                    # Return None for the file output and the error message for status
                     return None, result
+                elif isinstance(result, str) and os.path.exists(result):
+                    # Valid file path
+                    return result, "Processing completed successfully! Download your 3D garment file below."
+                elif isinstance(result, str):
+                    # Some other string that's not an error and not a file path
+                    return None, f"Unexpected result: {result}"
                 else:
+                    # Should be a file path or None
                     return result, "Processing completed successfully! Download your 3D garment file below."
             except Exception as e:
                 import traceback

loop.py

@@ -3,12 +3,45 @@ import kornia
 import os
 import sys
 import pathlib
-import torchvision
 import logging
 import yaml
 import nvdiffrast.torch as dr
 from easydict import EasyDict
 
+# Apply torchvision compatibility fixes
+try:
+    import torchvision
+    print(f"torchvision {torchvision.__version__} imported successfully")
+except (RuntimeError, AttributeError) as e:
+    if "operator torchvision::nms does not exist" in str(e) or "extension" in str(e):
+        print("Applying torchvision compatibility fixes...")
+        # Apply the same fixes as in app.py
+        import types
+        if not hasattr(torch, 'ops'):
+            torch.ops = types.SimpleNamespace()
+        if not hasattr(torch.ops, 'torchvision'):
+            torch.ops.torchvision = types.SimpleNamespace()
+        
+        # Create dummy functions for problematic operators
+        torchvision_ops = ['nms', 'roi_align', 'roi_pool', 'ps_roi_align', 'ps_roi_pool']
+        for op_name in torchvision_ops:
+            if not hasattr(torch.ops.torchvision, op_name):
+                if op_name == 'nms':
+                    setattr(torch.ops.torchvision, op_name, lambda *args, **kwargs: torch.zeros(0, dtype=torch.int64))
+                else:
+                    setattr(torch.ops.torchvision, op_name, lambda *args, **kwargs: torch.zeros(0))
+        
+        # Try importing again
+        try:
+            import torchvision
+            print("torchvision imported successfully after fixes")
+        except Exception as e2:
+            print(f"torchvision still has issues, but continuing: {e2}")
+    else:
+        print(f"Other torchvision error: {e}")
+except ImportError:
+    print("torchvision not available, continuing without it")
+
 from NeuralJacobianFields import SourceMesh
 
 from nvdiffmodeling.src import render

main.py

@@ -44,7 +44,7 @@ def main():
     ## Camera Parameters ##
     parser.add_argument('--fov_min', help='Minimum camera field of view angle during renders', type=float, default=argparse.SUPPRESS)
     parser.add_argument('--fov_max', help='Maximum camera field of view angle during renders', type=float, default=argparse.SUPPRESS)
-    parser.add_argument('--dist_mi  n', help= 'Minimum distance of camera from mesh during renders', type=float, default=argparse.SUPPRESS)
+    parser.add_argument('--dist_min', help='Minimum distance of camera from mesh during renders', type=float, default=argparse.SUPPRESS)
     parser.add_argument('--dist_max', help='Maximum distance of camera from mesh during renders', type=float, default=argparse.SUPPRESS)
     parser.add_argument('--light_power', help='Light intensity', type=float, default=argparse.SUPPRESS)
     parser.add_argument('--elev_alpha', help='Alpha parameter for Beta distribution for elevation sampling', type=float, default=argparse.SUPPRESS)
@@ -58,7 +58,7 @@ def main():
     parser.add_argument('--adapt_dist', help='Adjust camera distance to account for scale of shape', type=int, default=argparse.SUPPRESS, choices=[0, 1])
 
     # Logging
-    parser.add_argument('--log_inter val', help='Interval for logging, every X epochs',  type=int, default=argparse.SUPPRESS)
+    parser.add_argument('--log_interval', help='Interval for logging, every X epochs', type=int, default=argparse.SUPPRESS)
     parser.add_argument('--log_interval_im', help='Interval for logging renders image, every X epochs',  type=int, default=argparse.SUPPRESS)
     parser.add_argument('--log_elev', help='Logging elevation angle',  type=float, default=argparse.SUPPRESS)
     parser.add_argument('--log_fov', help='Logging field of view',  type=float, default=argparse.SUPPRESS)

utilities/helpers.py

@@ -56,13 +56,16 @@ class Vgg19(torch.nn.Module):
 
 cosine_sim = torch.nn.CosineSimilarity()
 render_loss = torch.nn.L1Loss()
-mean = torch.tensor([0.485, 0.456, 0.406], device='cuda')
-std = torch.tensor([0.229, 0.224, 0.225], device='cuda')
+# Use CUDA if available, otherwise CPU
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+mean = torch.tensor([0.485, 0.456, 0.406], device=device)
+std = torch.tensor([0.229, 0.224, 0.225], device=device)
 
 class VGGLoss(nn.Module):
     def __init__(self):
         super(VGGLoss, self).__init__()
-        self.vgg = Vgg19().cuda()
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.vgg = Vgg19().to(device)
         self.criterion = nn.L1Loss()
         self.weights = [1.0/32, 1.0/16, 1.0/8, 1.0/4, 1.0]