Update app.py

app.py

@@ -1,221 +1,347 @@
 import gradio as gr
 import os
-from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageFilter
+from PIL import Image
 import requests
 import io
 import gc
 import json
-from typing import Tuple, Optional, Dict, Any, List
+from typing import Tuple, Optional, Dict, Any
 import logging
 from dotenv import load_dotenv
-import numpy as np
-import cv2
-from skimage import exposure
-import torch
-import asyncio
 
-logging.basicConfig(level=logging.DEBUG)
+# Configuration du logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
 logger = logging.getLogger(__name__)
+
+# Chargement des variables d'environnement
 load_dotenv()
 
-STYLES = {
-    "Styles Traditionnels": {
-        "Renaissance": {
-            "prompt": "renaissance masterpiece, anatomical precision, detailed texture, chiaroscuro lighting, oil painting technique, museum quality",
-            "negative_prompt": "modern, abstract, simple, digital",
-            "params": {"resolution": 4096, "detail_level": 0.95}
-        },
-        "Impressionnisme": {
-            "prompt": "impressionist style, visible brushstrokes, natural light, plein air painting",
-            "negative_prompt": "sharp, digital, modern",
-            "params": {"resolution": 3072, "noise_level": 0.3}
-        },
-        "Surréalisme": {
-            "prompt": "surrealist dreamlike scene, symbolic imagery, unconscious imagination",
-            "negative_prompt": "realistic, ordinary",
-            "params": {"resolution": 3072, "randomization": 0.4}
-        },
-        "Cubisme": {
-            "prompt": "cubist style, geometric forms, multiple perspectives, abstract interpretation",
-            "negative_prompt": "realistic, photographic",
-            "params": {"resolution": 2048, "geometric_strength": 0.8}
-        }
+# Styles artistiques étendus
+ART_STYLES = {
+    "Art Moderne": {
+        "prompt_prefix": "modern art style poster, professional design",
+        "negative_prompt": "traditional, photorealistic, cluttered, busy design"
+    },
+    "Neo Vintage": {
+        "prompt_prefix": "vintage style advertising poster, retro design",
+        "negative_prompt": "modern, digital, contemporary style"
+    },
+    "Pop Art": {
+        "prompt_prefix": "pop art style poster, bold design",
+        "negative_prompt": "subtle, realistic, traditional art"
+    },
+    "Minimaliste": {
+        "prompt_prefix": "minimalist design poster, clean composition",
+        "negative_prompt": "complex, detailed, ornate, busy"
     },
-    "Rendus Numériques": {
-        "Synthwave": {
-            "prompt": "synthwave aesthetic, neon grid, retro-futuristic, dramatic lighting, vibrant colors",
-            "negative_prompt": "natural, realistic, muted colors",
-            "params": {"saturation": 1.8, "neon_effect": True}
-        },
-        "Cyberpunk": {
-            "prompt": "cyberpunk style, neon-lit cityscape, high-tech, volumetric fog, futuristic",
-            "negative_prompt": "natural, vintage, rural",
-            "params": {"volumetric": True, "neon_intensity": 1.5}
-        }
+    "Cyberpunk": {
+        "prompt_prefix": "cyberpunk style poster, neon lights, futuristic design",
+        "negative_prompt": "vintage, natural, rustic, traditional"
     },
-    "Photographie": {
-        "HDR": {
-            "prompt": "HDR photography, extreme dynamic range, rich details in shadows and highlights",
-            "negative_prompt": "flat lighting, low contrast",
-            "params": {"hdr_strength": 1.5, "resolution": 4096}
-        },
-        "Portrait Studio": {
-            "prompt": "professional studio portrait, perfect lighting, bokeh effect, sharp focus",
-            "negative_prompt": "blurry, noisy",
-            "params": {"bokeh": 0.7, "sharpness": 1.4}
-        }
+    "Aquarelle": {
+        "prompt_prefix": "watercolor art style poster, fluid artistic design",
+        "negative_prompt": "digital, sharp, photorealistic"
+    },
+    "Art Déco": {
+        "prompt_prefix": "art deco style poster, geometric patterns, luxury design",
+        "negative_prompt": "modern, minimalist, casual"
+    },
+    "Japonais": {
+        "prompt_prefix": "japanese art style poster, ukiyo-e inspired design",
+        "negative_prompt": "western, modern, photographic"
     }
 }
 
-class ImageProcessor:
-    def __init__(self):
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    
-    def process_image(self, image: Image.Image, params: Dict) -> Image.Image:
-        try:
-            # Conversion en array numpy
-            img_array = np.array(image)
-            
-            # Application des effets selon les paramètres
-            if params.get("neon_effect"):
-                img_array = self._apply_neon_effect(img_array)
-                
-            if params.get("volumetric"):
-                img_array = self._apply_volumetric(img_array)
-                
-            if params.get("bokeh"):
-                img_array = self._apply_bokeh(img_array, params["bokeh"])
-                
-            if params.get("hdr_strength"):
-                img_array = self._apply_hdr(img_array, params["hdr_strength"])
-            
-            return Image.fromarray(img_array)
-            
-        except Exception as e:
-            logger.error(f"Erreur traitement: {str(e)}")
-            return image
-            
-    def _apply_neon_effect(self, image: np.ndarray) -> np.ndarray:
-        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
-        hsv[..., 1] = np.clip(hsv[..., 1] * 1.5, 0, 255)  # Boost saturation
-        rgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
-        # Ajout de glow
-        blur = cv2.GaussianBlur(rgb, (0, 0), 15)
-        return cv2.addWeighted(rgb, 1, blur, 0.5, 0)
-        
-    def _apply_volumetric(self, image: np.ndarray) -> np.ndarray:
-        gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
-        fog = cv2.GaussianBlur(gray, (0, 0), 20)
-        return cv2.addWeighted(image, 1, cv2.cvtColor(fog, cv2.COLOR_GRAY2RGB), 0.2, 0)
-        
-    def _apply_bokeh(self, image: np.ndarray, strength: float) -> np.ndarray:
-        blur = cv2.GaussianBlur(image, (0, 0), int(30 * strength))
-        mask = np.random.random(image.shape[:2]) > 0.5
-        result = image.copy()
-        result[mask] = blur[mask]
-        return result
-        
-    def _apply_hdr(self, image: np.ndarray, strength: float) -> np.ndarray:
-        return exposure.adjust_gamma(image, 1.0 / strength)
+# Paramètres de composition
+COMPOSITION_PARAMS = {
+    "Layouts": {
+        "Centré": "centered composition, balanced layout",
+        "Asymétrique": "dynamic asymmetrical composition",
+        "Grille": "grid-based layout, structured composition",
+        "Diagonal": "diagonal dynamic composition",
+        "Minimaliste": "minimal composition, lots of whitespace"
+    },
+    "Ambiances": {
+        "Dramatique": "dramatic lighting, high contrast",
+        "Doux": "soft lighting, gentle atmosphere",
+        "Vibrant": "vibrant colors, energetic mood",
+        "Mystérieux": "mysterious atmosphere, moody lighting",
+        "Serein": "peaceful atmosphere, calm mood"
+    },
+    "Palette": {
+        "Monochrome": "monochromatic color scheme",
+        "Contrasté": "high contrast color palette",
+        "Pastel": "soft pastel color palette",
+        "Terre": "earthy color palette",
+        "Néon": "neon color palette"
+    }
+}
 
 class ImageGenerator:
     def __init__(self):
-        self.processor = ImageProcessor()
-        self.api_url = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+        self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
         token = os.getenv('HUGGINGFACE_TOKEN')
         if not token:
-            raise ValueError("HUGGINGFACE_TOKEN non trouvé dans les variables d'environnement!")
+            logger.error("HUGGINGFACE_TOKEN non trouvé!")
         self.headers = {"Authorization": f"Bearer {token}"}
-        
-    def generate(self, prompt: str, style_category: str, style_name: str) -> Tuple[Optional[Image.Image], str]:
+        logger.info("ImageGenerator initialisé")
+
+    def _build_prompt(self, params: Dict[str, Any]) -> str:
+        """Construction de prompt améliorée"""
+        style_info = ART_STYLES.get(params["style"], ART_STYLES["Neo Vintage"])
+        prompt = f"{style_info['prompt_prefix']}, {params['subject']}"
+
+        # Ajout des paramètres de composition
+        if params.get("layout"):
+            prompt += f", {COMPOSITION_PARAMS['Layouts'][params['layout']]}"
+        if params.get("ambiance"):
+            prompt += f", {COMPOSITION_PARAMS['Ambiances'][params['ambiance']]}"
+        if params.get("palette"):
+            prompt += f", {COMPOSITION_PARAMS['Palette'][params['palette']]}"
+
+        # Ajout des ajustements fins
+        if params.get("detail_level"):
+            detail_strength = params["detail_level"]
+            prompt += f", {'highly detailed' if detail_strength > 7 else 'moderately detailed'}"
+
+        if params.get("contrast"):
+            contrast_strength = params["contrast"]
+            prompt += f", {'high contrast' if contrast_strength > 7 else 'balanced contrast'}"
+
+        if params.get("saturation"):
+            saturation_strength = params["saturation"]
+            prompt += f", {'vibrant colors' if saturation_strength > 7 else 'subtle colors'}"
+
+        if params.get("title"):
+            prompt += f", with text saying '{params['title']}'"
+
+        logger.debug(f"Prompt final: {prompt}")
+        return prompt
+
+    def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
         try:
-            # Récupération du style
-            style_info = STYLES[style_category][style_name]
+            logger.info(f"Début de génération avec paramètres: {json.dumps(params, indent=2)}")
             
-            # Construction du prompt final
-            final_prompt = f"{prompt}, {style_info['prompt']}"
+            if 'Bearer None' in self.headers['Authorization']:
+                return None, "⚠️ Erreur: Token Hugging Face non configuré"
+
+            prompt = self._build_prompt(params)
             
-            # Paramètres de génération
-            params = {
-                "inputs": final_prompt,
-                "negative_prompt": style_info["negative_prompt"],
-                "num_inference_steps": 50,
-                "guidance_scale": 7.5,
-                "width": style_info["params"].get("resolution", 1024),
-                "height": style_info["params"].get("resolution", 1024),
+            # Configuration de base
+            payload = {
+                "inputs": prompt,
+                "parameters": {
+                    "negative_prompt": ART_STYLES[params["style"]]["negative_prompt"],
+                    "num_inference_steps": min(int(35 * (params["quality"]/100)), 40),
+                    "guidance_scale": min(7.5 * (params["creativity"]/10), 10.0),
+                    "width": 768,
+                    "height": 768 if params["orientation"] == "Portrait" else 512
+                }
             }
             
-            # Appel API
+            logger.debug(f"Payload: {json.dumps(payload, indent=2)}")
+
             response = requests.post(
-                self.api_url,
+                self.API_URL,
                 headers=self.headers,
-                json=params,
+                json=payload,
                 timeout=30
             )
             
-            if response.status_code != 200:
-                return None, f"Erreur API: {response.status_code}"
-                
-            # Traitement de l'image
-            image = Image.open(io.BytesIO(response.content))
-            processed = self.processor.process_image(image, style_info["params"])
-            
-            return processed, "✨ Génération réussie!"
-            
+            if response.status_code == 200:
+                image = Image.open(io.BytesIO(response.content))
+                return image, "✨ Création réussie!"
+            else:
+                error_msg = f"⚠️ Erreur API {response.status_code}: {response.text}"
+                logger.error(error_msg)
+                return None, error_msg
+
         except Exception as e:
-            logger.error(f"Erreur génération: {str(e)}")
-            return None, f"Erreur: {str(e)}"
+            error_msg = f"⚠️ Erreur: {str(e)}"
+            logger.exception("Erreur pendant la génération:")
+            return None, error_msg
         finally:
             gc.collect()
 
 def create_interface():
+    logger.info("Création de l'interface Gradio")
+    
+    css = """
+    .container { max-width: 1200px; margin: auto; }
+    .welcome { text-align: center; margin: 20px 0; padding: 20px; background: #1e293b; border-radius: 10px; }
+    .controls-group { background: #2d3748; padding: 15px; border-radius: 5px; margin: 10px 0; }
+    .advanced-controls { background: #374151; padding: 12px; border-radius: 5px; margin: 8px 0; }
+    """
+    
     generator = ImageGenerator()
     
-    with gr.Blocks() as demo:
+    with gr.Blocks(css=css) as app:
         gr.HTML("""
-            <div style='text-align: center; margin-bottom: 1rem'>
-                <h1>🎨 Equity Art Engine</h1>
-                <p>Générateur d'Images avec Styles Artistiques</p>
+            <div class="welcome">
+                <h1>🎨 Equity Artisan 3.0</h1>
+                <p>Assistant de création d'affiches professionnelles</p>
             </div>
         """)
         
-        with gr.Row():
-            with gr.Column():
-                prompt = gr.Textbox(label="Description", placeholder="Décrivez votre image...")
-                
-                style_category = gr.Dropdown(
-                    choices=list(STYLES.keys()),
-                    label="Catégorie de Style"
+        with gr.Column(elem_classes="container"):
+            # Format et Orientation
+            with gr.Group(elem_classes="controls-group"):
+                gr.Markdown("### 📐 Format et Orientation")
+                with gr.Row():
+                    format_size = gr.Dropdown(
+                        choices=["A4", "A3", "A2", "A1", "A0"],
+                        value="A4",
+                        label="Format"
+                    )
+                    orientation = gr.Radio(
+                        choices=["Portrait", "Paysage"],
+                        value="Portrait",
+                        label="Orientation"
+                    )
+            
+            # Style et Composition
+            with gr.Group(elem_classes="controls-group"):
+                gr.Markdown("### 🎨 Style et Composition")
+                with gr.Row():
+                    style = gr.Dropdown(
+                        choices=list(ART_STYLES.keys()),
+                        value="Neo Vintage",
+                        label="Style artistique"
+                    )
+                    layout = gr.Dropdown(
+                        choices=list(COMPOSITION_PARAMS["Layouts"].keys()),
+                        value="Centré",
+                        label="Composition"
+                    )
+
+                with gr.Row():
+                    ambiance = gr.Dropdown(
+                        choices=list(COMPOSITION_PARAMS["Ambiances"].keys()),
+                        value="Dramatique",
+                        label="Ambiance"
+                    )
+                    palette = gr.Dropdown(
+                        choices=list(COMPOSITION_PARAMS["Palette"].keys()),
+                        value="Contrasté",
+                        label="Palette"
+                    )
+            
+            # Contenu
+            with gr.Group(elem_classes="controls-group"):
+                gr.Markdown("### 📝 Contenu")
+                subject = gr.Textbox(
+                    label="Description",
+                    placeholder="Décrivez votre vision..."
                 )
-                
-                style_name = gr.Dropdown(label="Style Spécifique")
-                
-                # Mise à jour dynamique des styles
-                def update_styles(category):
-                    return gr.Dropdown.update(choices=list(STYLES[category].keys()) if category else [])
-                    
-                style_category.change(update_styles, inputs=style_category, outputs=style_name)
-                
-                generate_btn = gr.Button("✨ Générer")
-                
-            with gr.Column():
-                image_output = gr.Image(label="Résultat")
-                status_output = gr.Textbox(label="Status")
-        
-        def generate(prompt, category, style):
-            if not all([prompt, category, style]):
-                return None, "⚠️ Veuillez remplir tous les champs requis"
+                title = gr.Textbox(
+                    label="Titre",
+                    placeholder="Titre de l'affiche..."
+                )
+            
+            # Ajustements fins
+            with gr.Group(elem_classes="advanced-controls"):
+                gr.Markdown("### 🎯 Ajustements Fins")
+                with gr.Row():
+                    detail_level = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=7,
+                        step=1,
+                        label="Niveau de Détail"
+                    )
+                    contrast = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Contraste"
+                    )
+                    saturation = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=5,
+                        step=1,
+                        label="Saturation"
+                    )
+            
+            # Paramètres de génération
+            with gr.Group(elem_classes="controls-group"):
+                with gr.Row():
+                    quality = gr.Slider(
+                        minimum=30,
+                        maximum=50,
+                        value=35,
+                        label="Qualité"
+                    )
+                    creativity = gr.Slider(
+                        minimum=5,
+                        maximum=15,
+                        value=7.5,
+                        label="Créativité"
+                    )
             
-            return generator.generate(prompt, category, style)
+            # Boutons
+            with gr.Row():
+                generate_btn = gr.Button("✨ Générer", variant="primary")
+                clear_btn = gr.Button("🗑️ Effacer", variant="secondary")
+            
+            # Sortie
+            image_output = gr.Image(label="Aperçu")
+            status = gr.Textbox(label="Statut", interactive=False)
+        
+        def generate(*args):
+            logger.info("Démarrage d'une nouvelle génération")
+            params = {
+                "format_size": args[0],
+                "orientation": args[1],
+                "style": args[2],
+                "layout": args[3],
+                "ambiance": args[4],
+                "palette": args[5],
+                "subject": args[6],
+                "title": args[7],
+                "detail_level": args[8],
+                "contrast": args[9],
+                "saturation": args[10],
+                "quality": args[11],
+                "creativity": args[12]
+            }
+            result = generator.generate(params)
+            logger.info(f"Génération terminée avec statut: {result[1]}")
+            return result
         
         generate_btn.click(
             generate,
-            inputs=[prompt, style_category, style_name],
-            outputs=[image_output, status_output]
+            inputs=[
+                format_size,
+                orientation,
+                style,
+                layout,
+                ambiance,
+                palette,
+                subject,
+                title,
+                detail_level,
+                contrast,
+                saturation,
+                quality,
+                creativity
+            ],
+            outputs=[image_output, status]
+        )
+        
+        clear_btn.click(
+            lambda: (None, "🗑️ Image effacée"),
+            outputs=[image_output, status]
         )
     
-    return demo
+    logger.info("Interface créée avec succès")
+    return app
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch()
+    app = create_interface()
+    logger.info("Démarrage de l'application")
+    app.launch()