fixes 9.0

app.py

@@ -106,23 +106,41 @@ else:
 def apply_torchvision_fix():
     """Apply comprehensive fix for torchvision compatibility issues"""
     try:
+        import types
+        
         # Pre-emptively create torch.ops structure if needed
         if not hasattr(torch, 'ops'):
-            import types
             torch.ops = types.SimpleNamespace()
         
         if not hasattr(torch.ops, 'torchvision'):
             torch.ops.torchvision = types.SimpleNamespace()
         
-        # Create dummy nms function to prevent operator errors
-        if not hasattr(torch.ops.torchvision, 'nms'):
-            torch.ops.torchvision.nms = lambda *args, **kwargs: torch.zeros(0, dtype=torch.int64)
-            
-        # Additional torchvision operators that might cause issues
-        torchvision_ops = ['roi_align', 'roi_pool', 'ps_roi_align', 'ps_roi_pool']
+        # Create dummy functions for all problematic torchvision 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):
-                setattr(torch.ops.torchvision, op_name, lambda *args, **kwargs: torch.zeros(0))
+                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))
+        
+        # Fix for torchvision extension issues
+        try:
+            import torchvision
+            if not hasattr(torchvision, 'extension'):
+                torchvision.extension = types.SimpleNamespace()
+                torchvision.extension._has_ops = lambda: False
+        except:
+            pass
+        
+        # Fix for torchvision meta registrations
+        try:
+            if 'torchvision' in sys.modules:
+                torchvision = sys.modules['torchvision']
+                if not hasattr(torchvision, '_meta_registrations'):
+                    torchvision._meta_registrations = types.SimpleNamespace()
+        except:
+            pass
                 
         print("Applied comprehensive torchvision compatibility fixes")
         return True
@@ -142,6 +160,9 @@ def try_import_loop():
     global loop, loop_import_error
     
     try:
+        # Apply torchvision fixes before any imports
+        apply_torchvision_fix()
+        
         # Try to import torchvision with error handling
         try:
             import torchvision
@@ -162,12 +183,33 @@ def try_import_loop():
                     print(f"torchvision still has issues, but continuing: {e2}")
             else:
                 print(f"Other torchvision error: {e}")
+        
+        # Try to import required modules with fallbacks
+        try:
+            import nvdiffrast
+            print("✓ nvdiffrast imported")
+        except ImportError:
+            print("⚠ nvdiffrast not available, will use fallback")
+            
+        try:
+            import pytorch3d
+            print("✓ pytorch3d imported")
+        except ImportError:
+            print("⚠ pytorch3d not available, will use fallback")
                     
         # Now try to import the loop module
-        from loop import loop as loop_func
-        loop = loop_func
-        print("Successfully imported loop module")
-        return True
+        try:
+            from loop import loop as loop_func
+            loop = loop_func
+            print("Successfully imported loop module")
+            return True
+        except ImportError as e:
+            print(f"Loop module import failed: {e}")
+            # Create a dummy loop function for fallback
+            def dummy_loop(config):
+                raise RuntimeError("Processing engine not available. Please check dependencies.")
+            loop = dummy_loop
+            return True
         
     except ImportError as e:
         error_msg = f"ImportError: {e}"
@@ -296,47 +338,65 @@ def process_garment(input_type, text_prompt, base_text_prompt, mesh_target_image
             config = DEFAULT_CONFIG.copy()
             
             # Set up input parameters based on mode
-            if input_type == "Image to Mesh" and mesh_target_image is not None:
+            if input_type == "Image to Mesh":
+                if mesh_target_image is None:
+                    return "Error: Please upload an image for Image to Mesh mode."
+                
                 # Image-to-Mesh processing
                 progress(0.05, desc="Preparing mesh generation from image...")
                 
                 # Save target image to temp directory
                 target_mesh_image_path = os.path.join(temp_dir, "target_mesh_image.jpg")
                 
-                if isinstance(mesh_target_image, str):
-                    shutil.copy(mesh_target_image, target_mesh_image_path)
-                elif isinstance(mesh_target_image, np.ndarray):
-                    img = Image.fromarray(mesh_target_image.astype(np.uint8))
-                    img.save(target_mesh_image_path)
-                elif hasattr(mesh_target_image, 'save'):
-                    mesh_target_image.save(target_mesh_image_path)
-                else:
-                    print(f"Unsupported image type: {type(mesh_target_image)}")
-                    return "Error: Could not process the uploaded image. Please try a different image format."
-                
-                print(f"Target mesh image saved to {target_mesh_image_path}")
-                
-                # Set mesh paths based on selected source mesh type
-                # Map display names to actual file names
-                mesh_mapping = {
-                    "tshirt": "tshirt",
-                    "longsleeve": "longsleeve", 
-                    "tanktop": "tanktop",
-                    "poncho": "poncho",
-                    "dress_shortsleeve": "dress_shortsleeve"
-                }
-                mesh_file = mesh_mapping.get(source_mesh_type, "tshirt")
-                source_mesh_file = f"./meshes/{mesh_file}.obj"
-                
-                # Configure for image-to-mesh processing
-                config.update({
-                    'mesh': source_mesh_file,
-                    'image_prompt': target_mesh_image_path,
-                    'base_image_prompt': target_mesh_image_path,  # Use same image as base
-                    'use_target_mesh': True,
-                    'fashion_image': True,
-                    'fashion_text': False,
-                })
+                try:
+                    if isinstance(mesh_target_image, str):
+                        shutil.copy(mesh_target_image, target_mesh_image_path)
+                    elif isinstance(mesh_target_image, np.ndarray):
+                        # Ensure the array is in the correct format
+                        if len(mesh_target_image.shape) == 3:
+                            if mesh_target_image.shape[2] == 4:  # RGBA
+                                mesh_target_image = mesh_target_image[:,:,:3]  # Convert to RGB
+                            img = Image.fromarray(mesh_target_image.astype(np.uint8))
+                            img.save(target_mesh_image_path)
+                        else:
+                            return "Error: Invalid image format. Please upload a valid RGB image."
+                    elif hasattr(mesh_target_image, 'save'):
+                        mesh_target_image.save(target_mesh_image_path)
+                    else:
+                        print(f"Unsupported image type: {type(mesh_target_image)}")
+                        return "Error: Could not process the uploaded image. Please try a different image format."
+                    
+                    print(f"Target mesh image saved to {target_mesh_image_path}")
+                    
+                    # Set mesh paths based on selected source mesh type
+                    # Map display names to actual file names
+                    mesh_mapping = {
+                        "tshirt": "tshirt",
+                        "longsleeve": "longsleeve", 
+                        "tanktop": "tanktop",
+                        "poncho": "poncho",
+                        "dress_shortsleeve": "dress_shortsleeve"
+                    }
+                    mesh_file = mesh_mapping.get(source_mesh_type, "tshirt")
+                    source_mesh_file = f"./meshes/{mesh_file}.obj"
+                    
+                    # Check if the mesh file exists
+                    if not os.path.exists(source_mesh_file):
+                        return f"Error: Mesh file {source_mesh_file} not found. Please check if the mesh files are available."
+                    
+                    # Configure for image-to-mesh processing
+                    config.update({
+                        'mesh': source_mesh_file,
+                        'image_prompt': target_mesh_image_path,
+                        'base_image_prompt': target_mesh_image_path,  # Use same image as base
+                        'use_target_mesh': True,
+                        'fashion_image': True,
+                        'fashion_text': False,
+                    })
+                    
+                except Exception as e:
+                    print(f"Error processing image: {e}")
+                    return f"Error: Failed to process the uploaded image: {str(e)}"
                 
             else:
                 # Text-based processing
@@ -503,12 +563,13 @@ def create_interface():
         """)
         
         with gr.Row():
-            with gr.Column():
+            with gr.Column(scale=1):
                 # Input type selector
                 input_type = gr.Radio(
                     choices=["Text", "Image to Mesh"],
                     value="Text",
-                    label="Generation Method"
+                    label="Generation Method",
+                    interactive=True
                 )
                 
                 # Text inputs (visible by default)
@@ -525,21 +586,20 @@ def create_interface():
                         value="simple t-shirt"
                     )
                 
-
-                
                 # Image to Mesh inputs (hidden by default)
                 with gr.Group(visible=False) as image_to_mesh_group:
-                    gr.Markdown("### Upload Garment Image")
+                    gr.Markdown("### 📸 Upload Garment Image")
                     mesh_target_image = gr.Image(
                         label="Target Garment Image for Mesh Generation",
-                        sources=["upload", "clipboard"],
+                        sources=["upload", "clipboard", "webcam"],
                         type="numpy",
                         interactive=True,
-                        height=300
+                        height=300,
+                        show_label=True
                     )
                     gr.Markdown("*Upload an image of the garment to convert directly to a 3D mesh*")
                     
-                    gr.Markdown("### Select Base Mesh Type")
+                    gr.Markdown("### 🎯 Select Base Mesh Type")
                     source_mesh_type = gr.Dropdown(
                         label="Source Mesh Type",
                         choices=["tshirt", "longsleeve", "tanktop", "poncho", "dress_shortsleeve"],
@@ -621,6 +681,7 @@ def create_interface():
         
         # Define a function to handle mode changes with clearer UI feedback
         def update_mode(mode):
+            print(f"Mode changed to: {mode}")
             text_visibility = mode == "Text"
             image_to_mesh_visibility = mode == "Image to Mesh"
             status_msg = f"Mode changed to {mode}. "
@@ -629,6 +690,8 @@ def create_interface():
                 status_msg += "Enter garment descriptions and click Generate."
             else:
                 status_msg += "Upload a garment image and select mesh type, then click Generate."
+            
+            print(f"Text visibility: {text_visibility}, Image to Mesh visibility: {image_to_mesh_visibility}")
                 
             return (
                 gr.update(visible=text_visibility),
@@ -656,7 +719,8 @@ def create_interface():
         input_type.change(
             fn=update_mode,
             inputs=[input_type],
-            outputs=[text_group, image_to_mesh_group, status_output]
+            outputs=[text_group, image_to_mesh_group, status_output],
+            show_progress=True
         )
         
         # Connect the button to the processing function with error handling
@@ -700,7 +764,8 @@ if __name__ == "__main__":
             server_name="0.0.0.0",
             server_port=7860,
             show_error=True,
-            quiet=False
+            quiet=False,
+            debug=True
         )
     except Exception as e:
         print(f"Error launching interface: {e}")