Update app.py

app.py

@@ -1,207 +1,150 @@
 import gradio as gr
 import os
-from PIL import Image, ImageEnhance, ImageFilter
+from PIL import Image, ImageEnhance
 import requests
 import io
 import gc
 import json
+from typing import Tuple, Optional, Dict, Any
 import logging
 from dotenv import load_dotenv
-from typing import Tuple, Optional, Dict, Any, List
 import numpy as np
-from dataclasses import dataclass
+import cv2
 
-# Configuration avancée du logging
+# Configuration du logging
 logging.basicConfig(
     level=logging.DEBUG,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('equity_space.log'),
+        logging.StreamHandler()
+    ]
 )
-logger = logging.getLogger("EquityArtisan")
-
-# Chargement des variables d'environnement
+logger = logging.getLogger(__name__)
 load_dotenv()
 
-@dataclass
-class RenderingParams:
-    """Paramètres de rendu avancés pour le contrôle fin de la génération"""
-    steps: int  # Nombre d'étapes d'inférence
-    cfg_scale: float  # Échelle de guidance
-    width: int  # Largeur
-    height: int  # Hauteur
-    sampler: str  # Méthode d'échantillonnage
-    seed: Optional[int]  # Seed pour la reproductibilité
-
-@dataclass
-class StyleConfig:
-    """Configuration complète d'un style artistique"""
-    prompt_prefix: str
-    negative_prompt: str
-    quality_modifiers: List[str]
-    detail_modifiers: List[str]
-    composition_rules: List[str]
-
-# Styles artistiques enrichis
+# 1. STYLES EQUITY (basés sur les 8 documents)
 ART_STYLES = {
-    "Ultra Photoréaliste": StyleConfig(
-        prompt_prefix="masterpiece, ultra realistic photograph, octane render, unreal engine 5 rendering, ray tracing, global illumination, subsurface scattering, volumetric lighting, 8k uhd, photorealistic",
-        negative_prompt="cartoon, illustration, painting, drawing, sketch, anime, low quality, blurry, noise, grain, deformed, ugly, disfigured",
-        quality_modifiers=["hyperdetailed", "photographic", "award winning photography"],
-        detail_modifiers=["intricate details", "sharp focus", "professional lighting"],
-        composition_rules=["rule of thirds", "golden ratio", "perfect composition"]
-    ),
-    "Cinématique": StyleConfig(
-        prompt_prefix="cinematic scene, anamorphic lens, movie still, dramatic lighting, high production value, professional cinematography, ARRI camera",
-        negative_prompt="amateur, low budget, poor lighting, webcam, phone camera",
-        quality_modifiers=["film grain", "color grading", "bokeh effect"],
-        detail_modifiers=["depth of field", "motion blur", "lens flare"],
-        composition_rules=["wide aspect ratio", "leading lines", "frame within frame"]
-    ),
-    # ... [Autres styles similaires] ...
-}
-
-# Paramètres de qualité avancés
-QUALITY_PRESETS = {
-    "Standard": RenderingParams(
-        steps=30,
-        cfg_scale=7.5,
-        width=768,
-        height=768,
-        sampler="Euler a",
-        seed=None
-    ),
-    "Haute Qualité": RenderingParams(
-        steps=40,
-        cfg_scale=8.5,
-        width=1024,
-        height=1024,
-        sampler="DPM++ 2M Karras",
-        seed=None
-    ),
-    "Ultra Qualité": RenderingParams(
-        steps=50,
-        cfg_scale=9.0,
-        width=1536,
-        height=1536,
-        sampler="DPM++ SDE Karras",
-        seed=None
-    )
-}
-
-# Enrichissement des paramètres de composition
-COMPOSITION_PARAMS = {
-    "Layouts": {
-        "Dynamique": {
-            "description": "Composition dynamique avec lignes de force",
-            "modifiers": ["dynamic composition", "leading lines", "visual flow"],
-            "weights": {"foreground": 1.2, "background": 0.8}
-        },
-        "Équilibré": {
-            "description": "Composition harmonieuse et équilibrée",
-            "modifiers": ["balanced composition", "symmetrical layout", "visual harmony"],
-            "weights": {"foreground": 1.0, "background": 1.0}
+    "Renaissance Technologique": {
+        "prompt_prefix": """ultra-detailed technical drawing, da vinci style engineering precision, 
+        anatomical accuracy, golden ratio proportions, scientific illustration quality, 
+        masterful light and shadow, highest level of detail, museum quality artwork""",
+        "negative_prompt": "simple sketch, imprecise, cartoon, abstract, low detail",
+        "quality_boost": 1.5,
+        "style_params": {
+            "detail_level": "maximum",
+            "technical_precision": True,
+            "historical_accuracy": True
         }
-        # ... [Autres layouts] ...
     },
-    "Éclairages": {
-        "Studio": {
-            "description": "Éclairage professionnel type studio",
-            "modifiers": ["professional studio lighting", "three-point lighting", "soft boxes"],
-            "technical_params": {"contrast": 1.2, "highlights": 1.1}
-        },
-        "Naturel": {
-            "description": "Éclairage naturel avec lumière ambiante",
-            "modifiers": ["natural lighting", "golden hour", "ambient occlusion"],
-            "technical_params": {"contrast": 0.9, "shadows": 0.8}
+    "Innovation Moderne": {
+        "prompt_prefix": """cutting-edge technological design, futuristic engineering visual, 
+        advanced mechanical detail, precise technical schematic, innovative concept art, 
+        professional industrial visualization, high-tech aesthetic""",
+        "negative_prompt": "vintage, retro, simplified, abstract",
+        "quality_boost": 1.4,
+        "style_params": {
+            "tech_detail": "ultra",
+            "innovation_focus": True
+        }
+    },
+    "Photographie Analytique": {
+        "prompt_prefix": """professional analytical photography, ansel adams zone system, 
+        ultra sharp detail, perfect exposure, museum grade quality, technical perfection, 
+        masterful composition, extreme clarity""",
+        "negative_prompt": "blurry, artistic, painterly, low quality",
+        "quality_boost": 1.5,
+        "style_params": {
+            "photographic_precision": True,
+            "detail_preservation": "maximum"
+        }
+    },
+    "Vision Futuriste": {
+        "prompt_prefix": """advanced technological concept, future engineering visualization, 
+        innovative architectural design, sci-fi technical precision, ultra modern aesthetic, 
+        professional technical illustration""",
+        "negative_prompt": "historical, vintage, traditional, hand-drawn",
+        "quality_boost": 1.4,
+        "style_params": {
+            "future_tech": True,
+            "concept_clarity": "high"
         }
-        # ... [Autres éclairages] ...
     }
 }
 
-class AdvancedImageGenerator:
+# 2. OPTIMISATION DE LA QUALITÉ
+class ImageEnhancer:
     def __init__(self):
-        self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
-        self.token = os.getenv('HUGGINGFACE_TOKEN')
-        if not self.token:
-            raise EnvironmentError("HUGGINGFACE_TOKEN non configuré")
-        self.headers = {"Authorization": f"Bearer {self.token}"}
-        
-        # Initialisation du cache pour les paramètres optimaux
-        self.optimization_cache = {}
-        logger.info("AdvancedImageGenerator initialisé avec paramètres enrichis")
-
-    def _optimize_prompt(self, base_prompt: str, style_config: StyleConfig, params: Dict[str, Any]) -> str:
-        """Optimisation avancée du prompt avec analyse sémantique"""
-        components = [
-            style_config.prompt_prefix,
-            base_prompt
-        ]
+        self.enhancement_pipeline = {
+            "technical_detail": self._enhance_technical_detail,
+            "color_refinement": self._refine_colors,
+            "sharpness_boost": self._boost_sharpness,
+            "contrast_optimization": self._optimize_contrast
+        }
 
-        # Ajout des modificateurs de qualité selon le niveau demandé
-        quality_level = params.get("quality", 50)
-        if quality_level > 40:
-            components.extend(style_config.quality_modifiers)
+    def _enhance_technical_detail(self, image: np.ndarray) -> np.ndarray:
+        kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
+        return cv2.filter2D(image, -1, kernel)
+
+    def _refine_colors(self, image: np.ndarray) -> np.ndarray:
+        lab = cv2.cvtColor(image, cv2.COLOR_BGR2Lab)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+        l = clahe.apply(l)
+        lab = cv2.merge((l,a,b))
+        return cv2.cvtColor(lab, cv2.COLOR_Lab2BGR)
+
+    def _boost_sharpness(self, image: np.ndarray) -> np.ndarray:
+        blurred = cv2.GaussianBlur(image, (0, 0), 3)
+        return cv2.addWeighted(image, 1.5, blurred, -0.5, 0)
+
+    def _optimize_contrast(self, image: np.ndarray) -> np.ndarray:
+        lab = cv2.cvtColor(image, cv2.COLOR_BGR2Lab)
+        l, a, b = cv2.split(lab)
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+        l = clahe.apply(l)
+        lab = cv2.merge((l,a,b))
+        return cv2.cvtColor(lab, cv2.COLOR_Lab2BGR)
+
+    def enhance_image(self, image: Image.Image, style_params: Dict) -> Image.Image:
+        cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
         
-        # Ajout des règles de composition
-        components.extend(style_config.composition_rules)
-
-        # Optimisation contextuelle basée sur le sujet
-        if "portrait" in base_prompt.lower():
-            components.extend([
-                "perfect facial features",
-                "detailed skin texture",
-                "professional portrait lighting"
-            ])
-        elif "paysage" in base_prompt.lower():
-            components.extend([
-                "atmospheric perspective",
-                "perfect weather conditions",
-                "golden hour lighting"
-            ])
-
-        return ", ".join(components)
+        for enhancement, should_apply in style_params.items():
+            if should_apply and enhancement in self.enhancement_pipeline:
+                cv_image = self.enhancement_pipeline[enhancement](cv_image)
+        
+        return Image.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
 
-    def _apply_advanced_processing(self, image: Image.Image, params: Dict[str, Any]) -> Image.Image:
-        """Application de traitements avancés post-génération"""
-        try:
-            # Amélioration des détails
-            if params.get("detail_enhancement", True):
-                image = image.filter(ImageFilter.DETAIL)
-            
-            # Optimisation du contraste local
-            if params.get("local_contrast", True):
-                enhancer = ImageEnhance.Contrast(image)
-                image = enhancer.enhance(1.2)
-            
-            # Ajustement des couleurs
-            if params.get("color_optimization", True):
-                enhancer = ImageEnhance.Color(image)
-                image = enhancer.enhance(1.1)
-            
-            return image
-        except Exception as e:
-            logger.error(f"Erreur lors du post-traitement: {e}")
-            return image
+# 3. GÉNÉRATEUR D'IMAGES PRINCIPAL
+class ImageGenerator:
+    def __init__(self):
+        self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
+        self.enhancer = ImageEnhancer()
+        token = os.getenv('HUGGINGFACE_TOKEN')
+        if not token:
+            logger.error("HUGGINGFACE_TOKEN non trouvé!")
+        self.headers = {"Authorization": f"Bearer {token}"}
+        logger.info("ImageGenerator initialisé")
 
     def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
-        """Génération d'image avec paramètres avancés"""
         try:
-            logger.info(f"Démarrage génération avec paramètres: {json.dumps(params, indent=2)}")
-            
-            style_config = ART_STYLES[params["style"]]
-            prompt = self._optimize_prompt(params["subject"], style_config, params)
-            
-            # Sélection des paramètres de rendu
-            quality_preset = QUALITY_PRESETS["Ultra Qualité" if params["quality"] > 45 else "Haute Qualité"]
-            
+            style_info = ART_STYLES.get(params["style"])
+            if not style_info:
+                return None, "⚠️ Style non trouvé"
+
+            # Construction du prompt optimisé
+            prompt = f"{params['subject']}, {style_info['prompt_prefix']}"
+            if params.get('title'):
+                prompt += f", with text: {params['title']}"
+
             payload = {
                 "inputs": prompt,
                 "parameters": {
-                    "negative_prompt": style_config.negative_prompt,
-                    "num_inference_steps": quality_preset.steps,
-                    "guidance_scale": quality_preset.cfg_scale,
-                    "width": quality_preset.width,
-                    "height": quality_preset.height,
-                    "sampler": quality_preset.sampler
+                    "negative_prompt": style_info["negative_prompt"],
+                    "num_inference_steps": int(50 * style_info["quality_boost"]),
+                    "guidance_scale": min(9.0 * style_info["quality_boost"], 12.0),
+                    "width": 1024 if params.get("quality", 35) > 40 else 768,
+                    "height": 1024 if params["orientation"] == "Portrait" else 768
                 }
             }
 
@@ -209,138 +152,138 @@ class AdvancedImageGenerator:
                 self.API_URL,
                 headers=self.headers,
                 json=payload,
-                timeout=60
+                timeout=45
             )
 
-            if response.status_code != 200:
-                raise Exception(f"Erreur API: {response.status_code}")
-
-            # Traitement et optimisation de l'image générée
-            image = Image.open(io.BytesIO(response.content))
-            image = self._apply_advanced_processing(image, params)
-            
-            return image, "✨ Génération réussie avec paramètres optimaux!"
+            if response.status_code == 200:
+                image = Image.open(io.BytesIO(response.content))
+                enhanced_image = self.enhancer.enhance_image(
+                    image, 
+                    style_info["style_params"]
+                )
+                return enhanced_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.exception("Erreur pendant la génération:")
-            return None, f"⚠️ Erreur: {str(e)}"
+            error_msg = f"⚠️ Erreur: {str(e)}"
+            logger.exception("Erreur génération:")
+            return None, error_msg
+        finally:
+            gc.collect()
 
+# 4. INTERFACE UTILISATEUR
 def create_interface():
-    """Création de l'interface utilisateur enrichie"""
-    logger.info("Initialisation de l'interface avancée")
+    generator = ImageGenerator()
 
+    # Style CSS personnalisé
     css = """
-    .container { max-width: 1400px; margin: auto; padding: 20px; }
+    .container { max-width: 1200px; margin: auto; }
     .welcome { 
         text-align: center; 
         margin: 20px 0; 
-        padding: 30px;
+        padding: 20px; 
         background: linear-gradient(135deg, #1e293b, #334155);
-        border-radius: 15px;
+        border-radius: 10px;
         color: white;
     }
     .controls-group { 
         background: #2d3748; 
-        padding: 20px;
-        border-radius: 10px;
-        margin: 15px 0;
+        padding: 15px; 
+        border-radius: 5px; 
+        margin: 10px 0;
         box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
     }
     """
 
-    generator = AdvancedImageGenerator()
-
     with gr.Blocks(css=css) as app:
         gr.HTML("""
             <div class="welcome">
-                <h1>🎨 Equity Artisan 4.0 Pro</h1>
-                <p>Studio de Création Visuelle Avancé</p>
+                <h1>🎨 Equity Artisan 3.0</h1>
+                <p>Assistant de Création d'Images Professionnelles</p>
             </div>
         """)
 
         with gr.Column(elem_classes="container"):
-            # Configuration principale
+            # Format et Style
             with gr.Group(elem_classes="controls-group"):
-                gr.Markdown("### 🎭 Style et Composition")
                 with gr.Row():
+                    format_size = gr.Dropdown(
+                        choices=["A4", "A3", "A2", "A1"],
+                        value="A4",
+                        label="Format"
+                    )
+                    orientation = gr.Radio(
+                        choices=["Portrait", "Paysage"],
+                        value="Portrait",
+                        label="Orientation"
+                    )
                     style = gr.Dropdown(
                         choices=list(ART_STYLES.keys()),
-                        value="Ultra Photoréaliste",
+                        value="Renaissance Technologique",
                         label="Style Artistique"
                     )
-                    quality_preset = gr.Dropdown(
-                        choices=list(QUALITY_PRESETS.keys()),
-                        value="Haute Qualité",
-                        label="Preset de Qualité"
-                    )
 
-            # Paramètres créatifs
+            # Description
             with gr.Group(elem_classes="controls-group"):
-                gr.Markdown("### 🎨 Paramètres Créatifs")
-                with gr.Row():
-                    subject = gr.Textbox(
-                        label="Description",
-                        placeholder="Décrivez votre vision en détail...",
-                        lines=3
-                    )
-                    composition = gr.Dropdown(
-                        choices=list(COMPOSITION_PARAMS["Layouts"].keys()),
-                        value="Dynamique",
-                        label="Type de Composition"
-                    )
-
-            # Contrôles techniques
+                subject = gr.Textbox(
+                    label="Description",
+                    placeholder="Décrivez votre vision technique ou artistique...",
+                    lines=3
+                )
+                title = gr.Textbox(
+                    label="Titre (optionnel)",
+                    placeholder="Titre à inclure dans l'image..."
+                )
+
+            # Paramètres avancés
             with gr.Group(elem_classes="controls-group"):
-                gr.Markdown("### ⚙️ Paramètres Techniques")
                 with gr.Row():
                     quality = gr.Slider(
                         minimum=30,
-                        maximum=100,
-                        value=75,
-                        label="Niveau de Qualité"
+                        maximum=50,
+                        value=40,
+                        label="Qualité"
                     )
                     detail_level = gr.Slider(
                         minimum=1,
                         maximum=10,
                         value=8,
+                        step=1,
                         label="Niveau de Détail"
                     )
 
-            # Génération
+            # Boutons
             with gr.Row():
-                generate_btn = gr.Button("✨ Générer", variant="primary", size="lg")
-                clear_btn = gr.Button("🗑️ Réinitialiser", variant="secondary")
+                generate_btn = gr.Button("✨ Générer", variant="primary")
+                clear_btn = gr.Button("🗑️ Effacer")
 
-            # Résultats
-            image_output = gr.Image(
-                label="Aperçu",
-                elem_classes="result-image"
-            )
-            status = gr.Textbox(
-                label="Statut",
-                interactive=False
-            )
+            # Résultat
+            image_output = gr.Image(label="Résultat")
+            status = gr.Textbox(label="Status", interactive=False)
 
-        # Logique de génération
-        def generate_image(*args):
+        def generate(*args):
             params = {
-                "style": args[0],
-                "quality_preset": args[1],
-                "subject": args[2],
-                "composition": args[3],
-                "quality": args[4],
-                "detail_level": args[5]
+                "format_size": args[0],
+                "orientation": args[1],
+                "style": args[2],
+                "subject": args[3],
+                "title": args[4],
+                "quality": args[5],
+                "detail_level": args[6]
             }
             return generator.generate(params)
 
-        # Événements
         generate_btn.click(
-            generate_image,
+            generate,
             inputs=[
+                format_size,
+                orientation,
                 style,
-                quality_preset,
                 subject,
-                composition,
+                title,
                 quality,
                 detail_level
             ],
@@ -348,11 +291,10 @@ def create_interface():
         )
 
         clear_btn.click(
-            lambda: (None, "🔄 Interface réinitialisée"),
+            lambda: (None, "🗑️ Image effacée"),
             outputs=[image_output, status]
         )
 
-    logger.info("Interface créée avec succès")
     return app
 
 if __name__ == "__main__":