Update app.py

app.py

@@ -95,15 +95,11 @@ def remove_background(image):
 # ======================
 # Dominant Color Detection using K-Means
 # ======================
-def get_dominant_color(image, n_colors=1):
+def get_dominant_color(image, n_colors=3):
     """
-    Get THE most dominant color from clothing using K-means clustering
+    Get THE most dominant colors from clothing using K-means clustering
     
-    Steps:
-    1. Remove background
-    2. Extract only clothing pixels
-    3. Use K-means to find dominant color cluster
-    4. Convert to color name
+    Returns: List of color names and their RGB values
     """
     try:
         # Step 1: Remove background
@@ -115,23 +111,14 @@ def get_dominant_color(image, n_colors=1):
         
         # Step 3: Extract only non-transparent pixels (clothing only)
         if img_array.shape[-1] == 4:  # RGBA
-            # Get alpha channel
             alpha = img_array[:, :, 3]
-            
-            # Only pixels that are NOT transparent (alpha > 100)
             mask = alpha > 100
-            
-            # Get RGB pixels of clothing only
             pixels = img_array[:, :, :3][mask]
         else:  # RGB
-            # Reshape all pixels
             pixels = img_array.reshape(-1, 3)
         
-        # Step 4: Filter out pure white and pure black (background remnants)
-        # Remove whites (background)
+        # Step 4: Filter out pure white and pure black
         pixels = pixels[~((pixels[:, 0] > 240) & (pixels[:, 1] > 240) & (pixels[:, 2] > 240))]
-        
-        # Remove blacks (shadows)
         pixels = pixels[~((pixels[:, 0] < 15) & (pixels[:, 1] < 15) & (pixels[:, 2] < 15))]
         
         if len(pixels) < 10:
@@ -139,26 +126,24 @@ def get_dominant_color(image, n_colors=1):
         
         print(f"[INFO] 📊 Analyzing {len(pixels)} clothing pixels...")
         
-        # Step 5: Sample pixels if too many (for speed)
+        # Step 5: Sample pixels if too many
         if len(pixels) > 5000:
             indices = np.random.choice(len(pixels), 5000, replace=False)
             pixels = pixels[indices]
         
-        # Step 6: Use K-Means clustering to find dominant colors
+        # Step 6: K-Means clustering
         kmeans = KMeans(n_clusters=min(n_colors, len(pixels)), random_state=42, n_init=10)
         kmeans.fit(pixels)
         
-        # Step 7: Get the cluster centers (dominant colors in RGB)
+        # Step 7: Get cluster centers
         dominant_colors_rgb = kmeans.cluster_centers_
         
-        # Step 8: Count pixels in each cluster to find THE most dominant
+        # Step 8: Sort by frequency
         labels = kmeans.labels_
         label_counts = np.bincount(labels)
-        
-        # Sort by frequency
         sorted_indices = np.argsort(label_counts)[::-1]
         
-        # Step 9: Convert dominant colors to color names
+        # Step 9: Convert to color names
         color_names = []
         color_rgb_values = []
         
@@ -166,12 +151,11 @@ def get_dominant_color(image, n_colors=1):
             rgb = dominant_colors_rgb[idx].astype(int)
             color_name = rgb_to_color_name(tuple(rgb))
             
-            # Avoid duplicates
             if color_name not in color_names:
                 color_names.append(color_name)
                 color_rgb_values.append(rgb)
         
-        print(f"[INFO] 🎨 Dominant color detected: {color_names[0]}")
+        print(f"[INFO] 🎨 Dominant colors detected: {', '.join(color_names)}")
         
         return color_names, color_rgb_values
         
@@ -185,14 +169,9 @@ def get_dominant_color(image, n_colors=1):
 def rgb_to_color_name(rgb):
     """
     Convert RGB to human-readable color name
-    Enhanced with more color ranges
     """
     r, g, b = rgb
     
-    # Calculate color properties
-    max_val = max(r, g, b)
-    min_val = min(r, g, b)
-    
     # White
     if r > 220 and g > 220 and b > 220:
         return "White"
@@ -297,7 +276,7 @@ def rgb_to_color_name(rgb):
     if r > 180 and g > 160 and b > 200:
         return "Lavender"
     
-    # Default - multicolor
+    # Default
     return "Multicolor"
 
 
@@ -319,15 +298,55 @@ def detect_clothing_type(category):
     return "🌍 Western Wear"
 
 
+def get_color_emoji(color_name):
+    """
+    Get emoji for color (visual representation)
+    """
+    color_emojis = {
+        "Red": "🔴",
+        "Blue": "🔵",
+        "Green": "🟢",
+        "Yellow": "🟡",
+        "Orange": "🟠",
+        "Purple": "🟣",
+        "Pink": "🩷",
+        "Brown": "🟤",
+        "Black": "⚫",
+        "White": "⚪",
+        "Gray": "⚫",
+        "Light Gray": "⚪",
+        "Dark Gray": "⚫",
+        "Navy": "🔵",
+        "Sky Blue": "🔵",
+        "Light Green": "🟢",
+        "Dark Green": "🟢",
+        "Maroon": "🔴",
+        "Coral": "🩷",
+        "Gold": "🟡",
+        "Beige": "🟤",
+        "Cream": "⚪",
+        "Olive": "🟢",
+        "Cyan": "🔵",
+        "Magenta": "🟣",
+        "Violet": "🟣",
+        "Lavender": "🟣",
+        "Light Yellow": "🟡",
+        "Dark Brown": "🟤",
+        "Multicolor": "🌈"
+    }
+    
+    return color_emojis.get(color_name, "🎨")
+
+
 # ======================
 # Prediction Function
 # ======================
 def predict_fashion(image, custom_categories=None):
     """
-    Classify fashion item + detect dominant color
+    Classify fashion item + detect dominant color (TEXT OUTPUT)
     """
     if image is None:
-        return "⚠️ Please upload an image first!", {}, None
+        return "⚠️ Please upload an image first!", {}
     
     try:
         # Step 1: Categories
@@ -356,18 +375,13 @@ def predict_fashion(image, custom_categories=None):
         top_confidence = probs[top_prob_idx].item()
         
         # Step 3: Dominant Color Detection
-        print("[INFO] 🎨 Detecting dominant color...")
+        print("[INFO] 🎨 Detecting dominant colors...")
         dominant_colors, rgb_values = get_dominant_color(image, n_colors=3)
         
         # Step 4: Type Detection
         clothing_type = detect_clothing_type(top_category)
         
-        # Step 5: Create color preview image
-        color_preview = None
-        if rgb_values is not None and len(rgb_values) > 0:
-            color_preview = create_color_preview(rgb_values, dominant_colors)
-        
-        # Step 6: Format result
+        # Step 5: Format result with TEXT COLORS
         result = f"""
 ### 🎯 Fashion Item Detected
 
@@ -377,13 +391,32 @@ def predict_fashion(image, custom_categories=None):
 
 ---
 
-### 🎨 Dominant Color Analysis
+### 🎨 Detected Colors (Text Format)
 
-**Primary Color:** {dominant_colors[0] if dominant_colors else 'Unknown'} ✨
 """
         
-        if len(dominant_colors) > 1:
-            result += f"**Secondary Colors:** {', '.join(dominant_colors[1:])} 🌈\n"
+        # ✅ DISPLAY COLORS AS TEXT
+        if dominant_colors and dominant_colors[0] != "Unable to detect":
+            # Primary Color
+            primary_color = dominant_colors[0]
+            primary_emoji = get_color_emoji(primary_color)
+            primary_rgb = rgb_values[0] if rgb_values else [0, 0, 0]
+            
+            result += f"**Primary Color:** {primary_emoji} **{primary_color}** ✨\n"
+            result += f"*RGB Values: ({primary_rgb[0]}, {primary_rgb[1]}, {primary_rgb[2]})*\n\n"
+            
+            # Secondary Colors
+            if len(dominant_colors) > 1:
+                result += "**Secondary Colors:**\n"
+                for i, (color, rgb) in enumerate(zip(dominant_colors[1:], rgb_values[1:]), 1):
+                    emoji = get_color_emoji(color)
+                    result += f"  {i}. {emoji} **{color}** - RGB({rgb[0]}, {rgb[1]}, {rgb[2]})\n"
+                result += "\n"
+            
+            # Color Summary
+            result += f"**Color Summary:** {', '.join(dominant_colors)} 🌈\n"
+        else:
+            result += "⚠️ Unable to detect colors from image\n"
         
         result += f"""
 ---
@@ -413,6 +446,33 @@ def predict_fashion(image, custom_categories=None):
 - Suitable for casual/formal settings
 """
         
+        # Color-based suggestions
+        if dominant_colors[0] != "Unable to detect":
+            primary = dominant_colors[0].lower()
+            
+            result += f"\n**Color Styling Tips for {dominant_colors[0]}:**\n"
+            
+            if "black" in primary:
+                result += "- Classic and versatile ⚫\n- Pairs well with any color\n- Perfect for formal events\n"
+            elif "white" in primary:
+                result += "- Clean and fresh look ⚪\n- Great for summer\n- Easy to accessorize\n"
+            elif "red" in primary:
+                result += "- Bold and confident 🔴\n- Statement piece\n- Pair with neutral colors\n"
+            elif "blue" in primary:
+                result += "- Cool and calming 🔵\n- Professional look\n- Versatile for day/night\n"
+            elif "green" in primary:
+                result += "- Natural and refreshing 🟢\n- Great for outdoor events\n- Pairs with earth tones\n"
+            elif "yellow" in primary or "gold" in primary:
+                result += "- Bright and cheerful 🟡\n- Perfect for festivities\n- Eye-catching choice\n"
+            elif "pink" in primary:
+                result += "- Soft and feminine 🩷\n- Romantic vibe\n- Great for parties\n"
+            elif "purple" in primary or "violet" in primary:
+                result += "- Royal and elegant 🟣\n- Sophisticated choice\n- Unique statement\n"
+            elif "brown" in primary or "beige" in primary:
+                result += "- Earthy and warm 🟤\n- Natural aesthetic\n- Timeless appeal\n"
+            elif "gray" in primary:
+                result += "- Neutral and modern ⚫\n- Professional look\n- Easy to style\n"
+        
         # Top predictions
         top_probs, top_indices = torch.topk(probs, k=min(5, len(categories)))
         top_predictions = {}
@@ -420,50 +480,12 @@ def predict_fashion(image, custom_categories=None):
             category = categories[idx.item()]
             top_predictions[category] = float(prob.item())
         
-        return result, top_predictions, color_preview
+        return result, top_predictions
         
     except Exception as e:
         import traceback
         error_msg = f"❌ Error: {str(e)}\n\n{traceback.format_exc()}"
-        return error_msg, {}, None
-
-
-def create_color_preview(rgb_values, color_names):
-    """
-    Create a visual preview of detected colors
-    """
-    try:
-        # Create image with color swatches
-        num_colors = len(rgb_values)
-        swatch_height = 100
-        swatch_width = 200
-        
-        img = Image.new('RGB', (swatch_width, swatch_height * num_colors), 'white')
-        
-        import PIL.ImageDraw as ImageDraw
-        import PIL.ImageFont as ImageFont
-        
-        draw = ImageDraw.Draw(img)
-        
-        for i, (rgb, name) in enumerate(zip(rgb_values, color_names)):
-            y_start = i * swatch_height
-            y_end = (i + 1) * swatch_height
-            
-            # Draw color swatch
-            draw.rectangle([0, y_start, swatch_width, y_end], fill=tuple(rgb))
-            
-            # Add text (color name)
-            text = f"{name}\nRGB: {rgb[0]}, {rgb[1]}, {rgb[2]}"
-            
-            # Use white or black text depending on background
-            text_color = 'white' if sum(rgb) < 384 else 'black'
-            draw.text((10, y_start + 30), text, fill=text_color)
-        
-        return img
-        
-    except Exception as e:
-        print(f"[ERROR] Color preview failed: {e}")
-        return None
+        return error_msg, {}
 
 
 # ======================
@@ -473,7 +495,7 @@ with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) a
     
     gr.Markdown("""
     # 👗 AI Fashion Classifier with Smart Color Detection
-    ### Background Removal + K-Means Clustering for Accurate Colors
+    ### Background Removal + K-Means Clustering for Accurate Colors (Text Output)
     """)
     
     status = "🟢 High Quality (rembg)" if REMBG_AVAILABLE else "🟡 Standard (GrabCut)"
@@ -481,13 +503,15 @@ with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) a
     gr.Markdown(f"""
     **Model:** Fashion-CLIP  
     **Color Detection:** K-Means Clustering  
-    **Background Removal:** {status}
+    **Background Removal:** {status}  
+    **Output Format:** Text-based color names with RGB values
     
     ### ✨ How it works:
     1. 🖼️ **Upload** your fashion item image
     2. 🔄 **Background** is automatically removed
-    3. 🎨 **K-means** finds the dominant color from clothing only
+    3. 🎨 **K-means** finds the dominant colors from clothing only
     4. 👗 **Fashion-CLIP** classifies the item type
+    5. 📝 **Colors displayed as text** with emojis and RGB values
     """)
     
     with gr.Row():
@@ -507,6 +531,7 @@ with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) a
             - Clear, well-lit photos work best
             - Single clothing item preferred
             - Background will be auto-removed
+            - Colors shown as text with RGB values
             
             **📦 For Best Results:**
             ```bash
@@ -517,13 +542,12 @@ with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) a
         with gr.Column():
             output_text = gr.Markdown(label="📋 Results")
             output_label = gr.Label(label="📊 Top 5 Predictions", num_top_classes=5)
-            color_preview = gr.Image(label="🎨 Detected Colors", type="pil")
     
     # Event
     predict_btn.click(
         fn=predict_fashion,
         inputs=[input_image, custom_categories],
-        outputs=[output_text, output_label, color_preview]
+        outputs=[output_text, output_label]
     )
     
     gr.Markdown("""
@@ -539,10 +563,24 @@ with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) a
     
     ---
     
+    ### 🎨 Color Output Format:
+    
+    **Primary Color:** 🔴 **Red** ✨  
+    *RGB Values: (255, 0, 0)*
+    
+    **Secondary Colors:**  
+      1. ⚪ **White** - RGB(255, 255, 255)  
+      2. ⚫ **Black** - RGB(0, 0, 0)
+    
+    **Color Summary:** Red, White, Black 🌈
+    
+    ---
+    
     **🚀 Powered by:**
     - Fashion-CLIP (patrickjohncyh/fashion-clip)
     - K-Means Clustering for dominant colors
     - rembg/GrabCut for background removal
+    - Text-based color output with emojis
     """)
 
 # ======================
@@ -550,12 +588,13 @@ with gr.Blocks(title="Fashion-CLIP + Color Detection", theme=gr.themes.Soft()) a
 # ======================
 if __name__ == "__main__":
     print("\n" + "="*60)
-    print("🚀 FASHION CLASSIFIER WITH SMART COLOR DETECTION")
+    print("🚀 FASHION CLASSIFIER WITH SMART COLOR DETECTION (TEXT)")
     print("="*60)
     print(f"✅ Fashion-CLIP Model: Loaded")
     print(f"✅ Categories: {len(FASHION_CATEGORIES)}")
     print(f"✅ Background Removal: {'rembg (High Quality)' if REMBG_AVAILABLE else 'GrabCut (Standard)'}")
     print(f"✅ Color Detection: K-Means Clustering")
+    print(f"✅ Output Format: Text with RGB values")
     print("="*60 + "\n")
     
     demo.launch(server_name="0.0.0.0", server_port=7860)