Update app.py

app.py

@@ -1,283 +1,342 @@
 import gradio as gr
 import os
-from PIL import Image, ImageEnhance, ImageFilter
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageFilter
 import requests
 import io
 import gc
 import json
-from typing import Tuple, Optional, Dict, Any
+from typing import Tuple, Optional, Dict, Any, List
 import logging
 from dotenv import load_dotenv
 import numpy as np
 import cv2
 from skimage import exposure
 import torch
+from dataclasses import dataclass
+from enum import Enum
+import textwrap
 
-# Configuration du logging
+# Configuration
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 load_dotenv()
 
-# Configurations photographiques inspirées d'appareils emblématiques
-PHOTO_STYLES = {
-    "Leica": {
-        "description": "Style Leica classique 35mm - Netteté exceptionnelle, contraste naturel",
-        "params": {
+class StyleCategory(Enum):
+    TRADITIONAL = "Styles Traditionnels"
+    DIGITAL = "Rendus Numériques"
+    PHOTO = "Photographique"
+    ILLUSTRATION = "Illustration"
+    CONCEPT = "Conceptuel"
+    TYPOGRAPHY = "Typographie"
+
+@dataclass
+class StyleDefinition:
+    name: str
+    category: StyleCategory
+    prompt_prefix: str
+    negative_prompt: str
+    params: Dict[str, Any]
+    recommended_resolution: Tuple[int, int]
+    processing_steps: List[str]
+
+ARTISTIC_STYLES = {
+    # Styles Traditionnels
+    "Renaissance": StyleDefinition(
+        name="Renaissance",
+        category=StyleCategory.TRADITIONAL,
+        prompt_prefix="renaissance style, anatomically correct, detailed texture, chiaroscuro lighting",
+        negative_prompt="modern, abstract, simplified",
+        params={
+            "guidance_scale": 9.0,
+            "num_inference_steps": 50,
+            "detail_level": 0.95,
+            "lighting_complexity": "high"
+        },
+        recommended_resolution=(3840, 2160),
+        processing_steps=["detail_enhancement", "lighting_optimization", "texture_refinement"]
+    ),
+    
+    # Rendus Numériques
+    "Cyberpunk": StyleDefinition(
+        name="Cyberpunk",
+        category=StyleCategory.DIGITAL,
+        prompt_prefix="cyberpunk style, neon lights, high tech, volumetric fog",
+        negative_prompt="natural, vintage, traditional",
+        params={
+            "saturation_boost": 1.9,
+            "neon_glow": True,
+            "volumetric_lighting": True
+        },
+        recommended_resolution=(2560, 1440),
+        processing_steps=["neon_enhancement", "volumetric_shading", "color_grading"]
+    ),
+    
+    # Styles supplémentaires similaires...
+}
+
+TEXT_EFFECTS = {
+    "Réaliste": {
+        "render_params": {
             "sharpness": 1.4,
-            "contrast": 1.2,
-            "black_point": 5,
-            "white_point": 248,
-            "color_balance": "neutral"
-        }
+            "antialiasing": True,
+            "realistic_shadows": True
+        },
+        "font_requirements": ["high_resolution", "professional"],
+        "processing_steps": ["shadow_mapping", "texture_overlay"]
     },
-    "Hasselblad": {
-        "description": "Qualité moyen format - Détails riches, tons subtils",
-        "params": {
-            "sharpness": 1.6,
-            "contrast": 1.1,
-            "dynamic_range": "extended",
-            "color_depth": "high",
-            "medium_format": True
-        }
+    "Néon": {
+        "render_params": {
+            "glow_intensity": 1.5,
+            "bloom_radius": 10,
+            "color_vibrance": 1.8
+        },
+        "effects": ["outer_glow", "inner_glow", "light_rays"],
+        "processing_steps": ["glow_generation", "bloom_effect", "color_enhancement"]
     },
-    "Polaroid": {
-        "description": "Look vintage instantané - Tons chauds, vignettage doux",
-        "params": {
-            "vintage_effect": True,
-            "color_shift": "warm",
-            "vignette": 0.3,
-            "grain": "fine"
-        }
-    },
-    "Fujifilm": {
-        "description": "Rendu Fujifilm - Couleurs riches, tons chair naturels",
-        "params": {
-            "color_profile": "fuji",
-            "skin_tones": "enhanced",
-            "dynamic_range": "wide",
-            "film_simulation": True
-        }
-    }
+    # Autres effets textuels...
 }
 
+class QualityPreset(Enum):
+    DRAFT = {
+        "resolution_scale": 0.5,
+        "inference_steps": 20,
+        "guidance_scale": 7.0
+    }
+    STANDARD = {
+        "resolution_scale": 1.0,
+        "inference_steps": 50,
+        "guidance_scale": 7.5
+    }
+    PREMIUM = {
+        "resolution_scale": 2.0,
+        "inference_steps": 100,
+        "guidance_scale": 8.0
+    }
+
 class ImageProcessor:
-    """Processeur d'image avec simulations d'appareils photos classiques"""
+    """Processeur avancé pour le traitement d'images"""
     
     def __init__(self):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-    
-    def apply_photo_style(self, image: Image.Image, style: str) -> Image.Image:
-        """Applique un style photographique inspiré d'appareils classiques"""
-        style_params = PHOTO_STYLES[style]["params"]
-        
-        # Création d'une copie de l'image pour le traitement
-        processed = image.copy()
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         
-        # Application des paramètres de base
-        if style_params.get("sharpness"):
-            processed = ImageEnhance.Sharpness(processed).enhance(style_params["sharpness"])
-            
-        if style_params.get("contrast"):
-            processed = ImageEnhance.Contrast(processed).enhance(style_params["contrast"])
-            
-        # Effets spéciaux selon le style
-        if style_params.get("vintage_effect"):
-            processed = self._apply_vintage_effect(processed)
+    def process_image(self, image: Image.Image, style: StyleDefinition, quality: QualityPreset) -> Image.Image:
+        """Pipeline complet de traitement d'image"""
+        try:
+            # Application des étapes de traitement définies dans le style
+            for step in style.processing_steps:
+                processing_method = getattr(self, f"_apply_{step}")
+                image = processing_method(image, style.params)
+                
+            # Optimisation finale selon le preset de qualité
+            image = self._apply_quality_optimization(image, quality.value)
             
-        if style_params.get("medium_format"):
-            processed = self._simulate_medium_format(processed)
+            return image
             
-        if style_params.get("vignette"):
-            processed = self._add_vignette(processed, style_params["vignette"])
+        except Exception as e:
+            logger.error(f"Erreur lors du traitement de l'image: {str(e)}")
+            return image
             
-        return processed
-    
-    def _apply_vintage_effect(self, image: Image.Image) -> Image.Image:
-        """Simule l'effet vintage type Polaroid"""
-        # Conversion en numpy array pour le traitement
-        img_array = np.array(image)
+    def _apply_detail_enhancement(self, image: Image.Image, params: Dict) -> Image.Image:
+        """Amélioration des détails avec contrôle précis"""
+        np_image = np.array(image)
         
-        # Ajustement des courbes de couleur
-        img_array = exposure.adjust_gamma(img_array, 1.2)
+        # Application d'un filtre de netteté adaptatif
+        kernel_size = int(params.get("detail_level", 0.8) * 5)
+        kernel = np.ones((kernel_size, kernel_size), np.float32) / (kernel_size * kernel_size)
+        filtered = cv2.filter2D(np_image, -1, kernel)
         
-        # Ajout de grain subtil
-        noise = np.random.normal(0, 2, img_array.shape)
-        img_array = np.clip(img_array + noise, 0, 255).astype(np.uint8)
+        return Image.fromarray(filtered)
         
-        # Léger flou pour adoucir
-        return Image.fromarray(img_array).filter(ImageFilter.GaussianBlur(0.5))
-    
-    def _simulate_medium_format(self, image: Image.Image) -> Image.Image:
-        """Simule le rendu moyen format type Hasselblad"""
-        # Augmentation de la netteté et du micro-contraste
-        enhanced = ImageEnhance.Sharpness(image).enhance(1.6)
+    def _apply_neon_enhancement(self, image: Image.Image, params: Dict) -> Image.Image:
+        """Effets néon et lumineux avancés"""
+        # Conversion en HSV pour manipulation des couleurs
+        np_image = np.array(image)
+        hsv = cv2.cvtColor(np_image, cv2.COLOR_RGB2HSV)
         
-        # Optimisation de la plage dynamique
-        img_array = np.array(enhanced)
-        img_array = exposure.equalize_adapthist(img_array, clip_limit=0.02)
+        # Augmentation de la saturation
+        hsv[..., 1] = hsv[..., 1] * params.get("saturation_boost", 1.5)
         
-        return Image.fromarray((img_array * 255).astype(np.uint8))
+        # Effet de bloom
+        if params.get("neon_glow"):
+            bloom_intensity = params.get("bloom_intensity", 0.3)
+            blur = cv2.GaussianBlur(hsv, (15, 15), 0)
+            hsv = cv2.addWeighted(hsv, 1, blur, bloom_intensity, 0)
+            
+        # Reconversion en RGB
+        enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
+        return Image.fromarray(enhanced)
+
+class TextRenderer:
+    """Gestionnaire avancé de rendu de texte"""
     
-    def _add_vignette(self, image: Image.Image, strength: float) -> Image.Image:
-        """Ajoute un effet de vignettage"""
-        # Création du masque de vignettage
-        mask = Image.new('L', image.size, 255)
-        draw = ImageDraw.Draw(mask)
+    def __init__(self):
+        self.available_fonts = self._load_fonts()
         
-        width, height = image.size
-        for i in range(min(width, height) // 2):
-            alpha = int(255 * (1 - i * strength / (min(width, height) // 2)))
-            draw.ellipse([i, i, width-i, height-i], fill=alpha)
+    def render_text(self, image: Image.Image, text: str, effect: str, position: Tuple[int, int]) -> Image.Image:
+        """Application d'effets de texte avancés"""
+        effect_params = TEXT_EFFECTS[effect]
+        
+        # Création d'un calque pour le texte
+        text_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
+        draw = ImageDraw.Draw(text_layer)
+        
+        # Application des effets spécifiques
+        for step in effect_params.get("processing_steps", []):
+            text_layer = getattr(self, f"_apply_{step}")(text_layer, text, position, effect_params)
+            
+        # Fusion avec l'image principale
+        return Image.alpha_composite(image.convert('RGBA'), text_layer)
+        
+    def _apply_glow_generation(self, layer: Image.Image, text: str, position: Tuple[int, int], params: Dict) -> Image.Image:
+        """Génération d'effets de lumière pour le texte"""
+        glow_intensity = params["render_params"].get("glow_intensity", 1.0)
+        
+        # Création de plusieurs couches de glow
+        for radius in range(3, 15, 2):
+            glow_layer = layer.filter(ImageFilter.GaussianBlur(radius))
+            layer = Image.alpha_composite(layer, glow_layer)
             
-        # Application du masque
-        image.putalpha(mask)
-        return image
+        return layer
 
-class ImageGenerator:
-    """Générateur d'images avec confirmation et styles photographiques"""
+class EquityArtEngine:
+    """Moteur principal de génération artistique"""
     
     def __init__(self):
-        self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
-        self.processor = ImageProcessor()
+        self.image_processor = ImageProcessor()
+        self.text_renderer = TextRenderer()
+        self.model_url = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
         self.headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_TOKEN')}"}
         
-    async def confirm_generation(self, params: Dict[str, Any]) -> bool:
-        """Demande confirmation avant génération"""
-        style_info = PHOTO_STYLES[params["photo_style"]]
-        confirmation_message = f"""
-        🎨 Paramètres de génération :
-        - Style photo : {params['photo_style']} ({style_info['description']})
-        - Description : {params['prompt']}
-        - Format : {params['orientation']}
-        
-        Voulez-vous continuer ?
-        """
-        return await self._show_confirmation_dialog(confirmation_message)
-    
-    def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
-        """Génération d'image avec style photographique"""
+    async def generate(self, prompt: str, style: str, quality: QualityPreset, 
+                      text_params: Optional[Dict] = None) -> Tuple[Optional[Image.Image], str]:
+        """Génération complète avec tous les effets"""
         try:
-            if not await self.confirm_generation(params):
-                return None, "Génération annulée par l'utilisateur"
+            # Récupération du style et validation
+            style_def = ARTISTIC_STYLES.get(style)
+            if not style_def:
+                return None, "Style non reconnu"
+                
+            # Construction du prompt optimisé
+            full_prompt = f"{style_def.prompt_prefix}, {prompt}"
             
-            # Configuration de la requête
-            generation_params = {
-                "prompt": params["prompt"],
-                "negative_prompt": "low quality, blurry, distorted",
-                "num_inference_steps": 50,
-                "guidance_scale": 7.5,
-                "width": 1024 if params["orientation"] == "landscape" else 768,
-                "height": 768 if params["orientation"] == "landscape" else 1024
+            # Paramètres de génération
+            params = {
+                "prompt": full_prompt,
+                "negative_prompt": style_def.negative_prompt,
+                **quality.value
             }
             
-            # Génération via API
+            # Génération de l'image de base
+            response = await self._generate_base_image(params)
+            if not response:
+                return None, "Échec de la génération"
+                
+            # Traitement selon le style
+            processed_image = self.image_processor.process_image(response, style_def, quality)
+            
+            # Ajout de texte si nécessaire
+            if text_params:
+                processed_image = self.text_renderer.render_text(
+                    processed_image,
+                    text_params["text"],
+                    text_params["effect"],
+                    text_params["position"]
+                )
+                
+            return processed_image, "Génération réussie"
+            
+        except Exception as e:
+            logger.error(f"Erreur lors de la génération: {str(e)}")
+            return None, f"Erreur: {str(e)}"
+            
+    async def _generate_base_image(self, params: Dict) -> Optional[Image.Image]:
+        """Génération de l'image base via API"""
+        try:
             response = requests.post(
-                self.API_URL,
+                self.model_url,
                 headers=self.headers,
-                json={"inputs": generation_params["prompt"], "parameters": generation_params},
+                json={"inputs": params["prompt"], "parameters": params},
                 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))
-            
-            # Application du style photographique
-            processed_image = self.processor.apply_photo_style(
-                image, 
-                params["photo_style"]
-            )
-            
-            return processed_image, "✨ Génération réussie"
+                return None
+                
+            return Image.open(io.BytesIO(response.content))
             
         except Exception as e:
-            logger.error(f"Erreur lors de la génération: {str(e)}")
-            return None, f"Erreur: {str(e)}"
-        finally:
-            gc.collect()
+            logger.error(f"Erreur API: {str(e)}")
+            return None
 
 def create_interface():
-    """Création de l'interface utilisateur avec confirmation"""
-    generator = ImageGenerator()
+    """Interface utilisateur Gradio"""
+    engine = EquityArtEngine()
     
     with gr.Blocks(css="style.css") as app:
         gr.HTML("""
             <div class="header">
-                <h1>🎨 Equity Art Studio Pro</h1>
-                <p>Création d'images avec styles photographiques classiques</p>
+                <h1>🎨 Equity Art Engine Pro</h1>
+                <p>Système de Génération Artistique Avancé</p>
             </div>
         """)
         
-        with gr.Column():
-            # Contrôles de base
-            prompt = gr.Textbox(
-                label="Description",
-                placeholder="Décrivez l'image souhaitée..."
-            )
-            
-            with gr.Row():
-                orientation = gr.Radio(
-                    choices=["portrait", "landscape", "square"],
-                    value="portrait",
-                    label="Format"
-                )
-                
-                photo_style = gr.Dropdown(
-                    choices=list(PHOTO_STYLES.keys()),
-                    value="Leica",
-                    label="Style Photographique"
-                )
-            
-            # Description du style sélectionné
-            style_info = gr.HTML()
-            
-            def update_style_info(style):
-                return f"<div class='style-info'>{PHOTO_STYLES[style]['description']}</div>"
-            
-            photo_style.change(update_style_info, inputs=[photo_style], outputs=[style_info])
-            
-            # Boutons
+        with gr.Tab("Création"):
             with gr.Row():
-                generate_btn = gr.Button("🎨 Prévisualiser", variant="secondary")
-                confirm_btn = gr.Button("✨ Générer", variant="primary")
-            
-            # Sorties
-            preview = gr.Image(label="Prévisualisation", visible=False)
-            result = gr.Image(label="Résultat")
+                with gr.Column():
+                    prompt = gr.Textbox(
+                        label="Description",
+                        placeholder="Décrivez votre vision..."
+                    )
+                    
+                    style = gr.Dropdown(
+                        choices=[s.name for s in ARTISTIC_STYLES.values()],
+                        label="Style Artistique"
+                    )
+                    
+                    quality = gr.Radio(
+                        choices=[q.name for q in QualityPreset],
+                        value="STANDARD",
+                        label="Qualité"
+                    )
+                    
+                with gr.Column():
+                    text_input = gr.Textbox(
+                        label="Texte à ajouter",
+                        placeholder="Optionnel"
+                    )
+                    
+                    text_effect = gr.Dropdown(
+                        choices=list(TEXT_EFFECTS.keys()),
+                        label="Effet de Texte"
+                    )
+                    
+            generate_btn = gr.Button("Générer", variant="primary")
+            image_output = gr.Image(label="Résultat")
             status = gr.Textbox(label="Status")
             
-            # Logique de génération
-            def preview_params(prompt, orientation, style):
-                return f"""
-                    <div class='preview'>
-                        <h3>Paramètres de génération</h3>
-                        <ul>
-                            <li>Description : {prompt}</li>
-                            <li>Format : {orientation}</li>
-                            <li>Style : {style}</li>
-                        </ul>
-                        <p>Confirmez pour lancer la génération.</p>
-                    </div>
-                """
+        # Logique de génération
+        def generate_artwork(prompt, style, quality, text, effect):
+            text_params = {
+                "text": text,
+                "effect": effect,
+                "position": (50, 50)  # Position par défaut
+            } if text else None
             
-            generate_btn.click(
-                preview_params,
-                inputs=[prompt, orientation, photo_style],
-                outputs=[preview]
+            result, status_msg = engine.generate(
+                prompt=prompt,
+                style=style,
+                quality=QualityPreset[quality],
+                text_params=text_params
             )
             
-            confirm_btn.click(
-                generator.generate,
-                inputs={
-                    "prompt": prompt,
-                    "orientation": orientation,
-                    "photo_style": photo_style
-                },
-                outputs=[result, status]
-            )
-    
+            return result, status_msg
+            
+        generate_btn.click(
+            generate_artwork,
+            inputs=[prompt, style, quality, text_input, text_effect],
+            outputs=[image_output, status]
+        )
+        
     return app
 
 if __name__ == "__main__":