Update app.py

app.py

@@ -12,7 +12,6 @@ import pytz
 import time
 import shutil
 import numpy as np
-import cv2
 from PIL import Image, ImageEnhance, ImageFilter
 
 # Get API key from Hugging Face Spaces secrets
@@ -156,37 +155,66 @@ def make_younger(input_image, youth_level=50):
         if input_image is None:
             return None, "No image uploaded. Please upload an image first."
         
+        # Debug info
+        print(f"Input image type: {type(input_image)}")
+        
         # Convert to PIL Image if necessary
         if isinstance(input_image, np.ndarray):
-            input_image = Image.fromarray(input_image.astype('uint8'))
+            print("Converting numpy array to PIL Image")
+            # Ensure the array is in the correct format (RGB, uint8)
+            if input_image.dtype != np.uint8:
+                input_image = input_image.astype(np.uint8)
+            input_image = Image.fromarray(input_image)
+        
+        # Ensure we have a valid PIL Image
+        if not isinstance(input_image, Image.Image):
+            return None, f"Expected PIL Image or numpy array, got {type(input_image)}"
+        
+        # Make a copy to avoid modifying the original
+        img = input_image.copy()
         
         # Youth level should be between 0 and 100
         youth_level = max(0, min(100, youth_level))
+        print(f"Applying youth level: {youth_level}")
+        
+        # Convert to RGB if in another mode
+        if img.mode != 'RGB':
+            print(f"Converting image from {img.mode} to RGB")
+            img = img.convert('RGB')
         
         # Apply a series of transformations to make the person look younger
         
         # 1. Smooth skin (reduce wrinkles)
         smoothing_factor = youth_level / 100
-        smoothed = input_image.filter(ImageFilter.GaussianBlur(radius=smoothing_factor * 1.5))
+        print(f"Applying smoothing with factor: {smoothing_factor}")
+        smoothed = img.filter(ImageFilter.GaussianBlur(radius=smoothing_factor * 1.2))
         
         # 2. Enhance brightness slightly (younger skin tends to be brighter)
+        print("Enhancing brightness")
         brightness_enhancer = ImageEnhance.Brightness(smoothed)
-        brightened = brightness_enhancer.enhance(1 + (smoothing_factor * 0.2))
+        brightened = brightness_enhancer.enhance(1 + (smoothing_factor * 0.15))
         
         # 3. Enhance color (more vibrant)
+        print("Enhancing color")
         color_enhancer = ImageEnhance.Color(brightened)
-        colored = color_enhancer.enhance(1 + (smoothing_factor * 0.3))
+        colored = color_enhancer.enhance(1 + (smoothing_factor * 0.2))
         
         # 4. Adjust contrast (younger skin has better contrast)
+        print("Adjusting contrast")
         contrast_enhancer = ImageEnhance.Contrast(colored)
-        contrasted = contrast_enhancer.enhance(1 + (smoothing_factor * 0.1))
+        contrasted = contrast_enhancer.enhance(1 + (smoothing_factor * 0.08))
         
         # 5. Sharpen to maintain some details
+        print("Applying sharpening")
         sharpened = contrasted.filter(ImageFilter.SHARPEN)
         
+        print("Image processing completed successfully")
         return sharpened, f"Image processed successfully! Youth level applied: {youth_level}%"
     
     except Exception as e:
+        import traceback
+        error_details = traceback.format_exc()
+        print(f"Error in make_younger: {str(e)}\n{error_details}")
         return None, f"Error processing image: {str(e)}"
 
 # Function to handle the case when no PDF is found
@@ -313,19 +341,43 @@ def main():
                 gr.Markdown("<p style='text-align: center; color: black;'>Upload an image to make the person look younger.</p>")
                 
                 with gr.Row():
+                    # Use a specific type parameter that's compatible
                     input_image = gr.Image(label="Upload Image", type="pil")
-                    output_image = gr.Image(label="Younger Version", show_download_button=False)
+                    output_image = gr.Image(label="Younger Version", type="pil")
                 
                 with gr.Row():
                     youth_slider = gr.Slider(minimum=0, maximum=100, value=50, step=5, label="Youth Level (%)")
-                    process_button = gr.Button("Make Younger")
                 
+                process_button = gr.Button("Make Younger")
                 result_text = gr.Textbox(label="Processing Result", interactive=False)
                 
+                # Add debugging output
+                debug_output = gr.Textbox(label="Debug Info", visible=True)
+                
+                def process_with_debug(image, level):
+                    if image is None:
+                        return None, "No image uploaded.", "Error: No image provided"
+                    
+                    try:
+                        debug_info = f"Processing image of type: {type(image)}, youth level: {level}"
+                        
+                        if isinstance(image, dict) and 'image' in image:
+                            debug_info += f"\nImage is a dictionary with keys: {list(image.keys())}"
+                            image = image['image']
+                            debug_info += f"\nExtracted image of type: {type(image)}"
+                        
+                        result_img, result_msg = make_younger(image, level)
+                        debug_info += f"\nResult: {result_msg}"
+                        return result_img, result_msg, debug_info
+                    except Exception as e:
+                        import traceback
+                        error_details = traceback.format_exc()
+                        return None, f"Error: {str(e)}", f"Exception: {str(e)}\n{error_details}"
+                
                 process_button.click(
-                    fn=make_younger,
+                    fn=process_with_debug,
                     inputs=[input_image, youth_slider],
-                    outputs=[output_image, result_text]
+                    outputs=[output_image, result_text, debug_output]
                 )
 
     # Launch the interface