Upload 3 files

README.md

@@ -1,12 +1,45 @@
 ---
-title: Loss Stable Diffusion
-emoji: 🐨
-colorFrom: pink
-colorTo: green
+title: Color Loss Demo
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 5.19.0
+sdk_version: 3.32.0
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Color Loss Demo
+
+This app demonstrates different color loss functions that can modify the color distribution in images.
+
+## Features
+
+- Apply different color loss effects:
+  - Yellow Loss: Reduces yellow tones in the image
+  - Cyan Loss: Reduces cyan tones in the image
+  - Magenta Loss: Reduces magenta tones in the image
+- Control the strength of the color loss effect
+- Upload your own images to apply color loss effects
+- Generate placeholder images in different styles
+
+## How to Use
+
+1. Enter a prompt (for placeholder image text)
+2. Select a style for the placeholder image
+3. Choose a color loss type (or "None" for no effect)
+4. Set a seed value (for reproducibility)
+5. Adjust the color loss strength
+6. Upload your own image (optional)
+7. Click "Apply Color Loss"
+
+## Examples
+
+The app includes several example configurations that you can try with a single click.
+
+## Technical Details
+
+This app uses:
+- PIL for image processing
+- NumPy for efficient array operations
+- Custom color loss functions that target specific color ranges 

app.py

@@ -0,0 +1,138 @@
+import numpy as np
+from PIL import Image, ImageDraw
+import gradio as gr
+import base64
+from io import BytesIO
+from diffusers import StableDiffusionPipeline
+import torch
+
+# Define style names and their corresponding prompts
+style_configs = {
+    "Watercolor": {
+        "prompt": "a serene mountain landscape with lake and sunset, watercolor painting style, yellow sun, artistic",
+        "negative_prompt": "digital art, photorealistic, sketch"
+    },
+    "Cyberpunk": {
+        "prompt": "cyberpunk city at night with neon signs in yellow, futuristic buildings, blade runner style",
+        "negative_prompt": "daytime, natural, watercolor"
+    },
+    "Anime": {
+        "prompt": "anime character portrait, Studio Ghibli style, yellow hair, bright colors",
+        "negative_prompt": "photorealistic, western art"
+    },
+    "Oil Painting": {
+        "prompt": "still life with yellow sunflowers in vase, oil painting style, Van Gogh inspired",
+        "negative_prompt": "watercolor, digital art, photograph"
+    },
+    "Sketch": {
+        "prompt": "pencil sketch of a landscape with yellow highlights, detailed drawing",
+        "negative_prompt": "color, painting, digital"
+    }
+}
+
+# Initialize Stable Diffusion pipeline
+device = "cuda" if torch.cuda.is_available() else "cpu"
+pipe = StableDiffusionPipeline.from_pretrained(
+    "runwayml/stable-diffusion-v1-5",
+    torch_dtype=torch.float16 if device == "cuda" else torch.float32
+)
+pipe = pipe.to(device)
+
+# Cache for generated images
+image_cache = {}
+
+def generate_styled_image(style):
+    """Generate an image using Stable Diffusion based on style"""
+    if style in image_cache:
+        return image_cache[style]
+    
+    config = style_configs[style]
+    image = pipe(
+        prompt=config["prompt"],
+        negative_prompt=config["negative_prompt"],
+        num_inference_steps=30,
+        guidance_scale=7.5
+    ).images[0]
+    
+    # Cache the generated image
+    image_cache[style] = image
+    return image
+
+def yellow_loss(image, strength=0.8):
+    """Reduces yellow colors in the image."""
+    try:
+        img_array = np.array(image).astype(np.float32) / 255.0
+        r, g, b = img_array[:, :, 0], img_array[:, :, 1], img_array[:, :, 2]
+        
+        yellow_mask = np.logical_and(np.logical_and(r > 0.5, g > 0.5), b < 0.4)
+        
+        if np.any(yellow_mask):
+            r[yellow_mask] *= (1 - strength * 0.7)
+            g[yellow_mask] *= (1 - strength)
+            b[yellow_mask] += (1 - b[yellow_mask]) * strength
+            
+            img_array[:, :, 0] = r
+            img_array[:, :, 1] = g
+            img_array[:, :, 2] = b
+        
+        return Image.fromarray((img_array * 255).astype(np.uint8))
+    except Exception as e:
+        print(f"Error in yellow_loss: {e}")
+        return image
+
+def apply_color_loss(style, strength, image_input=None):
+    """Apply yellow loss to an image."""
+    try:
+        if image_input is not None:
+            try:
+                image = Image.fromarray(image_input) if isinstance(image_input, np.ndarray) else image_input
+                image.thumbnail((512, 512), Image.LANCZOS)
+            except Exception as e:
+                print(f"Error processing input image: {e}")
+                image = generate_styled_image(style)
+        else:
+            image = generate_styled_image(style)
+        
+        # Apply yellow loss
+        result = yellow_loss(image, strength)
+        
+        # Create side-by-side comparison
+        comparison = Image.new('RGB', (image.width * 2 + 10, image.height), (240, 240, 240))
+        comparison.paste(image, (0, 0))
+        comparison.paste(result, (image.width + 10, 0))
+        
+        # Add labels
+        draw = ImageDraw.Draw(comparison)
+        draw.text((10, 10), f"Original ({style})", fill=(255, 255, 255), stroke_fill=(0, 0, 0), stroke_width=2)
+        draw.text((image.width + 20, 10), f"Yellow Loss: {strength:.1f}", fill=(255, 255, 255), stroke_fill=(0, 0, 0), stroke_width=2)
+        
+        return comparison
+    
+    except Exception as e:
+        print(f"Error in apply_color_loss: {e}")
+        return Image.new('RGB', (512, 256), (200, 200, 200))
+
+# Create Gradio interface
+demo = gr.Interface(
+    fn=apply_color_loss,
+    inputs=[
+        gr.Dropdown(choices=list(style_configs.keys()), value="Watercolor", label="Style"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.8, step=0.1, label="Yellow Loss Strength"),
+        gr.Image(label="Upload an image (optional)", type="pil")
+    ],
+    outputs=gr.Image(label="Result (Before and After)"),
+    title="Yellow Loss Demo",
+    description="This demo shows how yellow loss affects different artistic styles. Each style is generated using Stable Diffusion.",
+    examples=[
+        ["Watercolor", 0.8, None],
+        ["Cyberpunk", 0.5, None],
+        ["Anime", 0.9, None],
+        ["Oil Painting", 0.7, None],
+        ["Sketch", 0.6, None]
+    ],
+    cache_examples=True
+)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch() 

requirements.txt

@@ -0,0 +1,6 @@
+numpy>=1.24.0
+pillow>=9.0.0
+gradio>=4.0.0
+torch>=2.0.0
+diffusers>=0.21.4
+transformers>=4.31.0