Upload 2 files

app.py

@@ -158,18 +158,34 @@ def process_garment(input_type, text_prompt, base_text_prompt, target_image, bas
                 target_image_path = os.path.join(temp_dir, "target_image.jpg")
                 
                 # Handle different possible image formats from Gradio
+                if target_image is None:
+                    return None
+                
+                print(f"Target image type: {type(target_image)}")
+                
                 if isinstance(target_image, str):
                     # Image is a file path
+                    print(f"Copying image from path: {target_image}")
                     shutil.copy(target_image, target_image_path)
                 elif isinstance(target_image, np.ndarray):
                     # Image is a numpy array from Gradio
-                    img = Image.fromarray(target_image)
+                    print(f"Converting numpy array image with shape: {target_image.shape}")
+                    # Make sure the array is in RGB format (convert if grayscale)
+                    if len(target_image.shape) == 2:
+                        target_image = np.stack([target_image] * 3, axis=2)
+                    elif target_image.shape[2] == 4:  # RGBA
+                        target_image = target_image[:,:,:3]  # Drop alpha channel
+                    
+                    img = Image.fromarray(target_image.astype(np.uint8))
                     img.save(target_image_path)
+                    print(f"Saved numpy array as image to: {target_image_path}")
                 elif hasattr(target_image, 'save'):
                     # Image is a PIL image
+                    print("Saving PIL image")
                     target_image.save(target_image_path)
                 else:
-                    return "Error: Unsupported target image format. Please try again."
+                    print(f"Unsupported image type: {type(target_image)}")
+                    return None
                 
                 print(f"Target image saved to {target_image_path}")
                 
@@ -317,7 +333,8 @@ def process_garment(input_type, text_prompt, base_text_prompt, target_image, bas
         error_details = traceback.format_exc()
         print(f"Error during processing: {str(e)}")
         print(f"Error details: {error_details}")
-        return f"Error during processing: {str(e)}. Please check the logs for more details."
+        # Return None instead of an error string to avoid file not found errors with Gradio
+        return None
 
 def create_interface():
     """
@@ -364,15 +381,17 @@ def create_interface():
                 with gr.Group(visible=False) as image_group:
                     target_image = gr.Image(
                         label="Target Garment Image",
-                        type="pil",
-                        image_mode="RGB"
+                        sources=["upload", "webcam"],
+                        type="numpy",
+                        interactive=True
                     )
                     gr.Markdown("*Upload an image of the desired garment style*")
                     
                     base_image = gr.Image(
                         label="Base Garment Image (Optional)",
-                        type="pil",
-                        image_mode="RGB"
+                        sources=["upload", "webcam"],
+                        type="numpy",
+                        interactive=True
                     )
                     gr.Markdown("*Upload a base garment image (optional)*")
                 
@@ -418,7 +437,11 @@ def create_interface():
                 generate_btn = gr.Button("Generate 3D Garment")
             
             with gr.Column():
-                output = gr.File(label="Generated 3D Garment")
+                output = gr.File(
+                    label="Generated 3D Garment",
+                    file_types=[".obj", ".glb", ".png", ".jpg"],
+                    file_count="single"
+                )
                 
                 gr.Markdown("""
                 ## Tips:
@@ -426,23 +449,54 @@ def create_interface():
                 - For text mode: Be specific in your descriptions
                 - For image mode: Use clear, front-facing garment images
                 - Higher epochs = better quality but longer processing time
+                - Output files can be downloaded by clicking on them
                 
                 Processing may take several minutes.
                 """)
         
-        # Toggle visibility based on input mode
+        # Add a status output for errors and messages
+        status_output = gr.Markdown("Ready to generate garments. Select an input method and click 'Generate 3D Garment'.")
+        
+        # Define a function to handle mode changes with clearer UI feedback
+        def update_mode(mode):
+            text_visibility = mode == "Text"
+            image_visibility = mode == "Image"
+            status_msg = f"Mode changed to {mode}. "
+            
+            if text_visibility:
+                status_msg += "Enter garment descriptions and click Generate."
+            else:
+                status_msg += "Upload garment images and click Generate."
+                
+            return (
+                gr.Group.update(visible=text_visibility),
+                gr.Group.update(visible=image_visibility),
+                status_msg
+            )
+            
+        # Function to handle processing with better error feedback
+        def process_with_feedback(*args):
+            try:
+                result = process_garment(*args)
+                if result is None:
+                    return None, "Processing failed. Please check the logs for details."
+                return result, "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)}"
+        
+        # Toggle visibility based on input mode with better feedback
         input_type.change(
-            fn=lambda mode: (
-                gr.Group.update(visible=(mode == "Text")),
-                gr.Group.update(visible=(mode == "Image"))
-            ),
+            fn=update_mode,
             inputs=[input_type],
-            outputs=[text_group, image_group]
+            outputs=[text_group, image_group, status_output]
         )
         
-        # Connect the button to the processing function
+        # Connect the button to the processing function with error handling
         generate_btn.click(
-            fn=process_garment,
+            fn=process_with_feedback,
             inputs=[
                 input_type,
                 text_prompt,
@@ -455,7 +509,7 @@ def create_interface():
                 clip_weight,
                 delta_clip_weight
             ],
-            outputs=[output]
+            outputs=[output, status_output]
         )
     
     return interface

loop.py

@@ -85,12 +85,19 @@ def loop(cfg):
 
     fe = CLIPVisualEncoder(cfg.consistency_clip_model, cfg.consistency_vit_stride, device)
 
-    if fashion_text or fashion_image:
+    # Use FashionCLIP for all modes to avoid CLIP loading issues
+    if fashion_image:
+        print('Processing with fashion image embeddings')
         target_direction_embeds, delta_direction_embeds = get_fashion_img_embeddings(fclip, cfg, device, True)
-    elif text_input:
-        target_direction_embeds, delta_direction_embeds = get_text_embeddings(clip, model, cfg, device)
-    elif image_input:
-        target_direction_embeds, delta_direction_embeds = get_img_embeddings(model, preprocess, cfg, device)
+    elif fashion_text:
+        print('Processing with fashion text embeddings')
+        target_direction_embeds, delta_direction_embeds = get_fashion_text_embeddings(fclip, cfg, device)
+    elif text_input or image_input:
+        print('WARNING: Regular CLIP embeddings are disabled, using FashionCLIP instead')
+        if text_input:
+            target_direction_embeds, delta_direction_embeds = get_fashion_text_embeddings(fclip, cfg, device)
+        else:
+            target_direction_embeds, delta_direction_embeds = get_fashion_img_embeddings(fclip, cfg, device, True)
 
     clip_mean = torch.tensor([0.48154660, 0.45782750, 0.40821073], device=device)
     clip_std = torch.tensor([0.26862954, 0.26130258, 0.27577711], device=device)