Upload folder using huggingface_hub

README.md

@@ -4,7 +4,6 @@ emoji: 😁
 colorFrom: indigo
 colorTo: blue
 sdk: gradio
-sdk_version: 5.25.2
 app_file: app.py
 pinned: true
 ---
@@ -21,6 +20,9 @@ A simple, user-friendly application that uses Google's Gemini AI to enhance smil
 - Maintains each person's unique smile features and tooth coloration
 - Enhances eye crinkles and cheek raising for authentic expressions
 - Preserves facial identity while enhancing smiles
+- Multi-attempt enhancement that compares results to select the best outcome
+- Intelligent backend processing that may run multiple enhancement passes for better results
+- Results may improve or degrade across multiple attempts as the system learns what works best
 - Works with most portrait photos showing visible teeth
 - No API key or login required
 
@@ -28,4 +30,15 @@ A simple, user-friendly application that uses Google's Gemini AI to enhance smil
 
 1. Upload a clear selfie with a visible smile
 2. Click "Enhance Smile with Natural Expressions" to process your image
-3. Download your enhanced smile image
+3. Download your enhanced smile image
+
+## How It Works
+
+This application uses an advanced process that may run multiple enhancement attempts to achieve the best results:
+
+- The first enhancement attempt might not always be the best result
+- Our system intelligently runs multiple passes on your image (up to 3 attempts)
+- Each attempt is assessed and compared to find the highest quality enhancement
+- The best result is automatically selected and presented to you
+
+Please note that results may vary as we haven't provided the system with extensive example data. Sometimes later attempts produce better results, while in other cases earlier attempts may be superior. The system intelligently selects the best outcome from all attempts.

app.py

@@ -13,8 +13,7 @@ from google.genai import types
 
 def save_binary_file(file_name, data):
     with open(file_name, "wb") as f:
-        f.write(data
-)
+        f.write(data)
 
 def generate(text, file_name, api_key, model="gemini-2.0-flash-exp"):
     # Initialize client using provided api_key (or fallback to env variable)
@@ -139,7 +138,32 @@ def assess_image_quality(original_image, enhanced_image):
         # Default to not accepting the image if assessment fails
         return False, f"Assessment error: {str(e)}"
 
-def process_smile_enhancement(input_image, max_attempts=2):
+def compare_image_results(results_list):
+    """
+    Compares multiple generated images and returns the best one.
+    If no valid results, returns None.
+    """
+    if not results_list or all(img is None for img in results_list):
+        return None
+        
+    # Filter out None values
+    valid_results = [img for img in results_list if img is not None]
+    
+    if not valid_results:
+        return None
+    
+    # If there's only one valid result, return it
+    if len(valid_results) == 1:
+        return valid_results[0]
+    
+    # For now, we just return the last valid result
+    # In a more advanced implementation, this could use computer vision techniques
+    # to analyze facial features, smile quality, and natural appearance
+    
+    print(f"Comparing {len(valid_results)} valid results and selecting best one")
+    return valid_results[-1]  # Return the last attempt as potentially the best one
+
+def process_smile_enhancement(input_image, max_attempts=3):
     try:
         if input_image is None:
             return None, "", ""
@@ -158,9 +182,9 @@ def process_smile_enhancement(input_image, max_attempts=2):
             
         # Initialize attempt counter and result variables    
         current_attempt = 0
-        result_img = None
+        result_images = []  # Store all generated images for comparison
         feedback_history = []
-        max_processing_time = 120  # Maximum time in seconds for overall processing
+        max_processing_time = 150  # Maximum time in seconds for overall processing
         start_processing_time = time.time()
         
         while current_attempt < max_attempts:
@@ -175,32 +199,32 @@ def process_smile_enhancement(input_image, max_attempts=2):
             # Create a comprehensive prompt for true smile enhancement that affects facial features naturally
             # Adjust prompt based on previous attempts if needed
             prompt = """
-            Create a naturally enhanced smile that suits this specific person's face and character. Make the following personalized improvements:
-            
-            - Slightly enhance the existing teeth while PRESERVING their natural color, spacing, and individual characteristics
-            - DO NOT make teeth perfectly white or perfectly aligned - keep some natural variation and character
-            - Create subtle, natural smile lines around the eyes (crow's feet) appropriate for this person's age and face
-            - Slightly raise the cheeks WITHOUT widening the face
-            - Add a slight narrowing of the eyes that happens in genuine smiles
-            - Create subtle dimples ONLY if they already exist in the original image
-            - Enhance the overall joyful expression while maintaining the person's unique facial structure
-            
-            IMPORTANT GUIDELINES:
-            - PRESERVE THE PERSON'S NATURAL DENTAL CHARACTERISTICS - teeth should still look like THEIR teeth, just slightly enhanced
-            - Keep teeth coloration natural and appropriate for the person - avoid unnaturally white teeth
-            - Maintain slight natural imperfections in tooth alignment that give character to the smile
-            - Create a genuine, authentic-looking smile that affects the entire face naturally
-            - ABSOLUTELY CRITICAL: DO NOT widen the face or change face width at all
-            - Preserve the person's identity completely (extremely important)
-            - Preserve exact facial proportions and face width of the original image
-            - Maintain natural-looking results appropriate for the person's age and face structure
-            - Keep teeth proportionate to the face - avoid making them too large or prominent
-            - Maintain proper tooth-to-face ratio and ensure teeth fit naturally within the mouth
-            - Keep the original background, lighting, and image quality intact
-            - Ensure the enhanced smile looks natural, genuine, and believable
-            - Create a smile that looks like a moment of true happiness for THIS specific person
-            - Remember that not everyone has or wants perfect white teeth - the enhancements should SUIT THE INDIVIDUAL
-            - If teeth are enhanced, maintain their natural characteristics while making subtle improvements
+            Create a naturally enhanced smile that focuses primarily on the overall facial expression rather than perfect teeth. Make the following personalized improvements:
+
+- Focus on enhancing the OVERALL SMILE EXPRESSION with natural eye crinkles, cheeks, and subtle facial changes
+- Create authentic "Duchenne smile" characteristics with proper eye corner crinkles (crow's feet) appropriate for this person's age
+- Enhance the natural lifting of cheeks that occurs in genuine smiles WITHOUT widening the face
+- Add the characteristic slight narrowing of the eyes that happens in genuine smiles
+- Create subtle dimples ONLY if they already exist in the original image
+- Boost the overall joyful expression while maintaining the person's unique facial structure
+- Maintain natural-looking nasolabial folds (smile lines) consistent with the smile intensity
+- Subtly complement existing teeth - they should remain natural looking with their original character
+
+IMPORTANT GUIDELINES:
+- FOCUS ON THE SMILE AS A COMPLETE FACIAL EXPRESSION - not just teeth
+- The most important aspects are eye crinkles, cheek raising, and natural facial expressions
+- Teeth should be subtly complemented but NOT the main focus of the enhancement
+- PRESERVE THE PERSON'S NATURAL DENTAL CHARACTERISTICS - teeth should look like THEIR teeth
+- Keep teeth coloration natural and appropriate for the person - avoid any artificial whitening
+- Maintain all natural imperfections in tooth alignment that give character to the smile
+- Create a genuine, authentic-looking smile that affects the entire face naturally
+- ABSOLUTELY CRITICAL: DO NOT widen the face or change face width/shape at all
+- Preserve the person's identity completely (extremely important)
+- Preserve exact facial proportions of the original image
+- Maintain natural-looking results appropriate for the person's age and face structure
+- Keep the original background, lighting, and image quality intact
+- Ensure the enhanced smile looks natural, genuine, and believable
+- Create a smile that looks like a moment of true happiness for THIS specific person
             """
             
             # If not the first attempt, add previous feedback to the prompt
@@ -233,28 +257,32 @@ def process_smile_enhancement(input_image, max_attempts=2):
                 if image_path:
                     # Load and convert the image if needed
                     try:
-                        result_img = Image.open(image_path)
-                        if result_img.mode == "RGBA":
-                            result_img = result_img.convert("RGB")
+                        current_result = Image.open(image_path)
+                        if current_result.mode == "RGBA":
+                            current_result = current_result.convert("RGB")
                         
-                        print("Successfully loaded generated image")
+                        print("Successfully loaded generated image for attempt " + str(current_attempt))
                         
                         # Assess the quality of the enhanced image
-                        is_acceptable, assessment_feedback = assess_image_quality(input_image, result_img)
+                        is_acceptable, assessment_feedback = assess_image_quality(input_image, current_result)
                         print(f"Image quality assessment: {is_acceptable}, {assessment_feedback}")
                         
                         if is_acceptable:
-                            # Return the enhanced image with success message
-                            success_message = "Successfully loaded generated image\nImage quality assessment: True, Image passes quality assessment criteria"
-                            return [result_img], "", success_message
+                            # Store the acceptable result for later comparison
+                            result_images.append(current_result)
+                            print(f"Added acceptable result from attempt {current_attempt} to results list")
+                            
+                            # Continue with additional attempts to potentially get even better results
+                            if current_attempt < max_attempts:
+                                feedback_history.append("Previous attempt successful, trying to further improve...")
+                                continue
                         else:
                             # Image didn't pass quality assessment, add feedback for next attempt
                             feedback_history.append(assessment_feedback)
                             
-                            # If we've reached max attempts, return the best result so far
-                            if current_attempt >= max_attempts:
-                                print("Max attempts reached, returning best result")
-                                return [result_img], "", ""
+                            # Still store the result for potential use if no better options are found
+                            result_images.append(current_result)
+                            
                     except Exception as img_error:
                         print(f"Error processing the generated image: {str(img_error)}")
                         feedback_history.append(f"Error with image: {str(img_error)}")
@@ -262,22 +290,24 @@ def process_smile_enhancement(input_image, max_attempts=2):
                     # No image was generated, only text response
                     print("No image was generated, only text response")
                     feedback_history.append("No image was generated in the previous attempt.")
-                    
-                    # If we've reached max attempts, return the original image
-                    if current_attempt >= max_attempts:
-                        print("Max attempts reached, returning original image")
-                        return [input_image], "", ""
             except Exception as gen_error:
                 print(f"Error during generation attempt {current_attempt}: {str(gen_error)}")
                 feedback_history.append(f"Error during processing: {str(gen_error)}")
-                
-                # If we've reached max attempts, return the original image
-                if current_attempt >= max_attempts:
-                    return [input_image], "", ""
+        
+        # Compare all results and select the best one
+        print(f"All attempts completed. Comparing {len(result_images)} results")
+        
+        if result_images:
+            # Select the best result from all generated images
+            best_result = compare_image_results(result_images)
+            if best_result:
+                print("Returning best result from multiple attempts")
+                success_message = "Enhancement completed after multiple attempts to find the best result"
+                return [best_result], "", success_message
         
         # Return the original image as a fallback without messages
-        print("Returning original image as fallback")
-        return [input_image], "", ""
+        print("Returning original image as fallback - no valid results generated")
+        return [input_image], "", "No satisfactory enhancements could be generated"
     except Exception as e:
         # Return the original image silently on error
         print(f"Overall error in process_smile_enhancement: {str(e)}")