final fixes

app.py

@@ -27,6 +27,94 @@ try:
 except:
     pass
 
+# Function to convert OBJ to GLB format
+def convert_obj_to_glb(obj_file_path, glb_file_path=None):
+    """
+    Convert OBJ file to GLB format using trimesh
+    
+    Args:
+        obj_file_path: Path to the OBJ file
+        glb_file_path: Path for the output GLB file (optional)
+    
+    Returns:
+        Path to the created GLB file or None if conversion failed
+    """
+    try:
+        import trimesh
+        print(f"Converting {obj_file_path} to GLB format...")
+        
+        # Check if input file exists
+        if not os.path.exists(obj_file_path):
+            print(f"Error: OBJ file {obj_file_path} does not exist")
+            return None
+        
+        # Load the OBJ file
+        mesh = trimesh.load(obj_file_path)
+        
+        # If no GLB path specified, create one in the same directory
+        if glb_file_path is None:
+            glb_file_path = str(Path(obj_file_path).with_suffix('.glb'))
+        
+        # Export as GLB
+        mesh.export(glb_file_path, file_type='glb')
+        print(f"Successfully converted to GLB: {glb_file_path}")
+        return glb_file_path
+        
+    except ImportError:
+        print("trimesh not available for GLB conversion")
+        return None
+    except Exception as e:
+        print(f"Error converting OBJ to GLB: {e}")
+        return None
+
+# Function to ensure both OBJ and GLB files are created
+def ensure_mesh_formats(output_dir):
+    """
+    Ensure both OBJ and GLB files are available in the output directory
+    
+    Args:
+        output_dir: Directory containing mesh files
+    
+    Returns:
+        tuple: (obj_files, glb_files) - lists of available files
+    """
+    obj_files = []
+    glb_files = []
+    
+    output_path = Path(output_dir)
+    
+    if not output_path.exists():
+        print(f"Warning: Output directory {output_dir} does not exist")
+        return obj_files, glb_files
+    
+    # Find all OBJ files
+    for obj_file in output_path.rglob("*.obj"):
+        obj_files.append(str(obj_file))
+        print(f"Found OBJ file: {obj_file}")
+        
+        # Try to create corresponding GLB file
+        glb_file = obj_file.with_suffix('.glb')
+        if not glb_file.exists():
+            print(f"Creating GLB file for {obj_file}")
+            glb_path = convert_obj_to_glb(str(obj_file), str(glb_file))
+            if glb_path:
+                glb_files.append(glb_path)
+                print(f"Successfully created GLB: {glb_path}")
+            else:
+                print(f"Failed to create GLB for {obj_file}")
+        else:
+            glb_files.append(str(glb_file))
+            print(f"GLB file already exists: {glb_file}")
+    
+    # Also check for existing GLB files that might not have corresponding OBJ
+    for glb_file in output_path.rglob("*.glb"):
+        if str(glb_file) not in glb_files:
+            glb_files.append(str(glb_file))
+            print(f"Found standalone GLB file: {glb_file}")
+    
+    print(f"Total files found: {len(obj_files)} OBJ files, {len(glb_files)} GLB files")
+    return obj_files, glb_files
+
 # Check if complex dependencies are installed
 def check_complex_dependencies():
     """Check if complex dependencies are available"""
@@ -668,25 +756,20 @@ def process_garment(input_type, text_prompt, base_text_prompt, mesh_target_image
                 
             progress(0.9, desc="Processing complete, preparing output...")
             
-            # Look for output files, prioritize mesh files
+            # Look for output files and ensure both OBJ and GLB formats are available
             obj_files = []
             glb_files = []
             image_files = []
             
-            print("Searching for output files...")
+            print("Searching for output files and ensuring GLB conversion...")
             
             # First check for mesh files in mesh_final directory (priority)
             mesh_final_dir = Path(temp_dir) / "mesh_final"
             if mesh_final_dir.exists():
                 print(f"Found mesh_final directory at {mesh_final_dir}")
-                for file_path in mesh_final_dir.rglob("*"):
-                    if file_path.is_file():
-                        if file_path.suffix.lower() == '.obj':
-                            obj_files.append(str(file_path))
-                            print(f"Found OBJ file: {file_path}")
-                        elif file_path.suffix.lower() == '.glb':
-                            glb_files.append(str(file_path))
-                            print(f"Found GLB file: {file_path}")
+                # Ensure both OBJ and GLB formats are available
+                obj_files, glb_files = ensure_mesh_formats(mesh_final_dir)
+                print(f"Found {len(obj_files)} OBJ files and {len(glb_files)} GLB files in mesh_final")
             else:
                 print("mesh_final directory not found")
             
@@ -694,14 +777,9 @@ def process_garment(input_type, text_prompt, base_text_prompt, mesh_target_image
             for mesh_dir in Path(temp_dir).glob("mesh_*"):
                 if mesh_dir.is_dir() and mesh_dir.name != 'mesh_final':
                     print(f"Checking directory: {mesh_dir}")
-                    for file_path in mesh_dir.rglob("*"):
-                        if file_path.is_file():
-                            if file_path.suffix.lower() == '.obj':
-                                obj_files.append(str(file_path))
-                                print(f"Found OBJ file: {file_path}")
-                            elif file_path.suffix.lower() == '.glb':
-                                glb_files.append(str(file_path))
-                                print(f"Found GLB file: {file_path}")
+                    dir_obj_files, dir_glb_files = ensure_mesh_formats(mesh_dir)
+                    obj_files.extend(dir_obj_files)
+                    glb_files.extend(dir_glb_files)
             
             # Collect image files for visualization
             for file_path in Path(temp_dir).rglob("*"):
@@ -732,6 +810,28 @@ def process_garment(input_type, text_prompt, base_text_prompt, mesh_target_image
         # Return None instead of an error string to avoid file not found errors with Gradio
         return None
 
+def create_combined_mesh_output(output_dir):
+    """
+    Create a combined output showing both OBJ and GLB files if available
+    
+    Args:
+        output_dir: Directory containing mesh files
+    
+    Returns:
+        tuple: (primary_file, secondary_file, status_message)
+    """
+    obj_files, glb_files = ensure_mesh_formats(output_dir)
+    
+    if glb_files and obj_files:
+        # Both formats available - return GLB as primary (better for web viewing)
+        return glb_files[0], obj_files[0], "🎉 Success! Both GLB and OBJ files generated. GLB file is displayed (better for web viewing), OBJ file is also available."
+    elif glb_files:
+        return glb_files[0], None, "🎉 Success! GLB file generated and ready for download."
+    elif obj_files:
+        return obj_files[0], None, "🎉 Success! OBJ file generated and ready for download."
+    else:
+        return None, None, "❌ No mesh files were generated. Please check the processing logs."
+
 def create_interface():
     """
     Create the Gradio interface with simplified components
@@ -748,6 +848,7 @@ def create_interface():
         2. For **Text** mode: Enter descriptions of your target and base garment styles
         3. For **Image to Mesh** mode: Upload an image to generate a 3D mesh directly and select a base mesh type
         4. Click "Generate 3D Garment" to create your 3D mesh file
+        5. **GLB files** are automatically generated for better web viewing and virtual try-on compatibility
         """)
         
         with gr.Row():
@@ -838,12 +939,21 @@ def create_interface():
                 generate_btn = gr.Button("Generate 3D Garment")
             
             with gr.Column():
+                # Primary output (GLB preferred)
                 output = gr.File(
-                    label="Generated 3D Garment",
+                    label="Generated 3D Garment (GLB/OBJ)",
                     file_types=[".obj", ".glb", ".png", ".jpg"],
                     file_count="single"
                 )
                 
+                # Secondary output (OBJ if GLB is primary)
+                secondary_output = gr.File(
+                    label="Alternative Format (OBJ/GLB)",
+                    file_types=[".obj", ".glb"],
+                    file_count="single",
+                    visible=False
+                )
+                
                 gr.Markdown("""
                 ## Tips:
                 
@@ -851,6 +961,8 @@ def create_interface():
                 - For image to mesh mode: Use clear, front-facing garment images to generate a 3D mesh directly
                 - Choose the appropriate base mesh type that matches your target garment
                 - Higher epochs = better quality but longer processing time
+                - **GLB files** are automatically generated for better web viewing and virtual try-on compatibility
+                - **OBJ files** are also available for traditional 3D software compatibility
                 - Output files can be downloaded by clicking on them
                 
                 Processing may take several minutes.
@@ -887,33 +999,55 @@ def create_interface():
                 status_msg
             )
             
-        # Function to handle processing with better error feedback
+        # Function to handle processing with better error feedback and dual output
         def process_with_feedback(*args):
             try:
                 # Check if processing engine is available
                 if loop is None:
-                    return None, "❌ ERROR: Processing engine not available. Please check that all dependencies are properly installed."
+                    return None, None, "❌ ERROR: Processing engine not available. Please check that all dependencies are properly installed."
                 
                 result = process_garment(*args)
                 if result is None:
-                    return None, "Processing completed but no output files were generated. Please check the logs for more details."
+                    return None, 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
+                    # Return None for the file outputs and the error message for status
+                    return None, 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."
+                    # Valid file path - check if we can create a combined output
+                    result_path = Path(result)
+                    if result_path.suffix.lower() == '.glb':
+                        # GLB file - try to find corresponding OBJ
+                        obj_file = result_path.with_suffix('.obj')
+                        if obj_file.exists():
+                            return result, str(obj_file), "🎉 Success! Both GLB and OBJ files generated. GLB file is displayed (better for web viewing), OBJ file is also available."
+                        else:
+                            return result, None, "🎉 Success! GLB file generated and ready for download."
+                    elif result_path.suffix.lower() == '.obj':
+                        # OBJ file - try to find corresponding GLB or create one
+                        glb_file = result_path.with_suffix('.glb')
+                        if glb_file.exists():
+                            return str(glb_file), result, "🎉 Success! Both GLB and OBJ files generated. GLB file is displayed (better for web viewing), OBJ file is also available."
+                        else:
+                            # Try to convert OBJ to GLB
+                            glb_path = convert_obj_to_glb(result)
+                            if glb_path:
+                                return glb_path, result, "🎉 Success! Both GLB and OBJ files generated. GLB file is displayed (better for web viewing), OBJ file is also available."
+                            else:
+                                return result, None, "🎉 Success! OBJ file generated and ready for download."
+                    else:
+                        # Some other file type
+                        return result, None, "🎉 Processing completed successfully! Download your 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}"
+                    return None, None, f"Unexpected result: {result}"
                 else:
                     # Should be a file path or None
-                    return result, "🎉 Processing completed successfully! Download your 3D garment file below."
+                    return result, None, "🎉 Processing completed successfully! Download your 3D garment file below."
             except Exception as e:
                 import traceback
                 print(f"Error in interface: {str(e)}")
                 print(traceback.format_exc())
-                return None, f"❌ Error: {str(e)}"
+                return None, None, f"❌ Error: {str(e)}"
         
         # Toggle visibility based on input mode with better feedback
         input_type.change(
@@ -923,7 +1057,7 @@ def create_interface():
             show_progress=True
         )
         
-        # Connect the button to the processing function with error handling
+        # Connect the button to the processing function with error handling and dual output
         generate_btn.click(
             fn=process_with_feedback,
             inputs=[
@@ -938,7 +1072,32 @@ def create_interface():
                 clip_weight,
                 delta_clip_weight
             ],
-            outputs=[output, status_output]
+            outputs=[output, secondary_output, status_output]
+        )
+        
+        # Update secondary output visibility when primary output changes
+        def update_secondary_visibility(primary_file):
+            """Update secondary output visibility based on whether both formats are available"""
+            if primary_file is not None and primary_file != "":
+                # Check if there's a corresponding file in the other format
+                primary_path = Path(primary_file)
+                if primary_path.suffix.lower() == '.glb':
+                    # Check if corresponding OBJ exists
+                    obj_file = primary_path.with_suffix('.obj')
+                    if obj_file.exists():
+                        return gr.update(visible=True)
+                elif primary_path.suffix.lower() == '.obj':
+                    # Check if corresponding GLB exists
+                    glb_file = primary_path.with_suffix('.glb')
+                    if glb_file.exists():
+                        return gr.update(visible=True)
+            return gr.update(visible=False)
+        
+        # Connect the secondary output visibility to the primary output
+        output.change(
+            fn=update_secondary_visibility,
+            inputs=[output],
+            outputs=[secondary_output]
         )
     
     return interface

loop.py

@@ -1,4 +1,3 @@
-import clip
 import kornia
 import os
 import sys
@@ -108,15 +107,26 @@ def loop(cfg):
     fashion_image = cfg.get('fashion_image', False)
     fashion_text = cfg.get('fashion_text', True)  # Default to fashion text mode
     use_target_mesh = cfg.get('use_target_mesh', True)
-    CLIP_embeddings = False
+    CLIP_embeddings = False  # Always use FashionCLIP to avoid CLIP issues
 
-    if CLIP_embeddings:
-        print('Loading CLIP Models')
-        model, preprocess = clip.load(cfg.clip_model, device=device)
-    else:
+    # Always use FashionCLIP to avoid CLIP loading issues
+    print('Loading FashionCLIP model...')
+    try:
         fclip = FashionCLIP('fashion-clip')
-
-    fe = CLIPVisualEncoder(cfg.consistency_clip_model, cfg.consistency_vit_stride, device)
+        print('FashionCLIP loaded successfully')
+    except Exception as e:
+        print(f'Error loading FashionCLIP: {e}')
+        raise RuntimeError(f"Failed to load FashionCLIP: {e}")
+
+    # Load CLIPVisualEncoder with error handling
+    print('Loading CLIPVisualEncoder...')
+    try:
+        fe = CLIPVisualEncoder(cfg.consistency_clip_model, cfg.consistency_vit_stride, device)
+        print('CLIPVisualEncoder loaded successfully')
+    except Exception as e:
+        print(f'Error loading CLIPVisualEncoder: {e}')
+        print('Continuing without CLIPVisualEncoder...')
+        fe = None
 
     # Use FashionCLIP for all modes to avoid CLIP loading issues
     if fashion_image:
@@ -434,7 +444,7 @@ def loop(cfg):
         r_loss = (((gt_jacobians) - torch.eye(3, 3, device=device)) ** 2).mean()
         logger.add_scalar('jacobian_regularization', r_loss, global_step=it)
 
-        if cfg.consistency_loss_weight != 0:
+        if cfg.consistency_loss_weight != 0 and fe is not None:
             consistency_loss = compute_mv_cl(final_mesh, fe, normalized_clip_render, params_camera, train_rast_map, cfg, device)
         else:
             consistency_loss = r_loss

utilities/clip_spatial.py

@@ -3,11 +3,18 @@ import math
 import types
 import typing
 
-import clip
 import torch
 import torch.nn as nn
 from torchvision import models, transforms
 
+# Try to import CLIP, but handle import errors gracefully
+try:
+    import clip
+    CLIP_AVAILABLE = True
+except ImportError:
+    print("Warning: CLIP not available, using FashionCLIP fallback")
+    CLIP_AVAILABLE = False
+
 # code lifted from CLIPasso
 
 # For ViT
@@ -25,10 +32,50 @@ class CLIPVisualEncoder(nn.Module):
 
     
     def load_model(self, model_name, device):
-        model, preprocess = clip.load(model_name, device=device)
-        self.model = model.visual
-        self.mean = torch.tensor(preprocess.transforms[-1].mean, device=device)
-        self.std = torch.tensor(preprocess.transforms[-1].std, device=device)
+        if CLIP_AVAILABLE:
+            try:
+                model, preprocess = clip.load(model_name, device=device)
+                self.model = model.visual
+                self.mean = torch.tensor(preprocess.transforms[-1].mean, device=device)
+                self.std = torch.tensor(preprocess.transforms[-1].std, device=device)
+            except Exception as e:
+                print(f"Error loading CLIP model: {e}")
+                print("Falling back to FashionCLIP...")
+                self._load_fashion_clip_fallback(device)
+        else:
+            print("CLIP not available, using FashionCLIP fallback...")
+            self._load_fashion_clip_fallback(device)
+    
+    def _load_fashion_clip_fallback(self, device):
+        """Fallback method using FashionCLIP when regular CLIP is not available"""
+        try:
+            from packages.fashion_clip.fashion_clip.fashion_clip import FashionCLIP
+            fclip = FashionCLIP('fashion-clip')
+            self.model = fclip.model.vision_model
+            # Use standard CLIP mean and std values
+            self.mean = torch.tensor([0.48154660, 0.45782750, 0.40821073], device=device)
+            self.std = torch.tensor([0.26862954, 0.26130258, 0.27577711], device=device)
+            print("Successfully loaded FashionCLIP fallback")
+        except Exception as e:
+            print(f"Error loading FashionCLIP fallback: {e}")
+            # Create a dummy model if all else fails
+            self._create_dummy_model(device)
+    
+    def _create_dummy_model(self, device):
+        """Create a dummy model when all CLIP options fail"""
+        print("Creating dummy CLIP model - functionality will be limited")
+        # Create a simple dummy model structure
+        class DummyModel:
+            def __init__(self):
+                self.conv1 = nn.Conv2d(3, 768, kernel_size=16, stride=16)
+                self.class_embedding = nn.Parameter(torch.randn(768))
+                self.positional_embedding = nn.Parameter(torch.randn(197, 768))
+                self.ln_pre = nn.LayerNorm(768)
+                self.transformer = nn.TransformerEncoder(nn.TransformerEncoderLayer(768, 12), 12)
+        
+        self.model = DummyModel()
+        self.mean = torch.tensor([0.48154660, 0.45782750, 0.40821073], device=device)
+        self.std = torch.tensor([0.26862954, 0.26130258, 0.27577711], device=device)
 
     @staticmethod
     def _fix_pos_enc(patch_size: int, stride_hw: typing.Tuple[int, int]):

utils.py

@@ -77,6 +77,11 @@ def get_og_mesh(mesh_path, output_path, triangulate_flag, bsdf_flag, mesh_name='
 
 def compute_mv_cl(final_mesh, fe, normalized_clip_render, params_camera, train_rast_map, cfg, device):
     # Consistency loss
+    # Check if fe is available
+    if fe is None:
+        print("Warning: CLIPVisualEncoder not available, skipping consistency loss")
+        return torch.tensor(0.0, device=device)
+    
     # Get mapping from vertex to pixels
     curr_vp_map = get_vp_map(final_mesh.v_pos, params_camera['mvp'], 224)
     for idx, rast_faces in enumerate(train_rast_map[:, :, :, 3].view(cfg.batch_size, -1)):