Update app.py

app.py

@@ -12,364 +12,278 @@ import numpy as np
 import cv2
 from skimage import exposure
 import torch
-from dataclasses import dataclass
-from enum import Enum
-import textwrap
 
-# Configuration
 logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 load_dotenv()
 
-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"
+# Constantes pour les styles disponibles
+STYLE_CATEGORIES = {
+    "TRADITIONAL": {
+        "Renaissance": {
+            "prompt": "renaissance style masterpiece, anatomical precision, detailed texture, chiaroscuro lighting, oil painting technique, museum quality",
+            "negative_prompt": "modern, abstract, simple, flat, digital art",
+            "params": {
+                "guidance_scale": 9.0,
+                "num_inference_steps": 50,
+                "resolution": (4096, 4096),
+                "detail_threshold": 0.95,
+            }
         },
-        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
+        "Impressionnisme": {
+            "prompt": "impressionist style, loose brushstrokes, natural light, vivid colors, en plein air painting",
+            "negative_prompt": "sharp details, digital art, modern",
+            "params": {
+                "guidance_scale": 7.5,
+                "num_inference_steps": 40,
+                "resolution": (2048, 2048),
+                "brush_simulation": True,
+            }
         },
-        recommended_resolution=(2560, 1440),
-        processing_steps=["neon_enhancement", "volumetric_shading", "color_grading"]
-    ),
+        # ... autres styles traditionnels
+    },
     
-    # Styles supplémentaires similaires...
-}
-
-TEXT_EFFECTS = {
-    "Réaliste": {
-        "render_params": {
-            "sharpness": 1.4,
-            "antialiasing": True,
-            "realistic_shadows": True
+    "DIGITAL": {
+        "Cyberpunk": {
+            "prompt": "cyberpunk style, neon lights, volumetric fog, tech noir, high contrast, futuristic city",
+            "negative_prompt": "natural, vintage, traditional art",
+            "params": {
+                "guidance_scale": 8.0,
+                "neon_intensity": 1.5,
+                "volumetric_lighting": True,
+                "resolution": (3840, 2160),
+            }
         },
-        "font_requirements": ["high_resolution", "professional"],
-        "processing_steps": ["shadow_mapping", "texture_overlay"]
-    },
-    "Néon": {
-        "render_params": {
-            "glow_intensity": 1.5,
-            "bloom_radius": 10,
-            "color_vibrance": 1.8
+        "Holographique": {
+            "prompt": "holographic effect, iridescent colors, light refraction, transparent layers, futuristic",
+            "negative_prompt": "flat, matte, solid colors",
+            "params": {
+                "iridescence": 1.0,
+                "transparency": 0.7,
+                "resolution": (2560, 1440),
+            }
         },
-        "effects": ["outer_glow", "inner_glow", "light_rays"],
-        "processing_steps": ["glow_generation", "bloom_effect", "color_enhancement"]
-    },
-    # 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
+        # ... autres styles numériques
     }
+}
 
-class ImageProcessor:
-    """Processeur avancé pour le traitement d'images"""
-    
+class TextEffectProcessor:
     def __init__(self):
-        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        
-    def process_image(self, image: Image.Image, style: StyleDefinition, quality: QualityPreset) -> Image.Image:
-        """Pipeline complet de traitement d'image"""
+        self.effects = {
+            "Réaliste": self._realistic_text,
+            "Néon": self._neon_text,
+            "Holographique": self._holographic_text,
+            "3D": self._3d_text,
+            "Vintage": self._vintage_text,
+            "Graffiti": self._graffiti_text,
+            "Matrix": self._matrix_text
+        }
+
+    def apply_effect(self, image: Image.Image, text: str, effect: str, position: Tuple[int, int]) -> Image.Image:
+        if effect in self.effects:
+            return self.effects[effect](image, text, position)
+        return self._default_text(image, text, position)
+
+    def _realistic_text(self, image: Image.Image, text: str, position: Tuple[int, int]) -> Image.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)
+            draw = ImageDraw.Draw(image)
+            # Chargement d'une police par défaut
+            font = ImageFont.load_default()
             
-            return image
+            # Effet d'ombre réaliste
+            shadow_offset = 2
+            # Dessiner l'ombre
+            draw.text((position[0] + shadow_offset, position[1] + shadow_offset), 
+                     text, font=font, fill=(0, 0, 0, 128))
+            # Dessiner le texte principal
+            draw.text(position, text, font=font, fill=(255, 255, 255))
             
+            return image
         except Exception as e:
-            logger.error(f"Erreur lors du traitement de l'image: {str(e)}")
+            logger.error(f"Erreur lors du rendu réaliste: {str(e)}")
             return 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)
-        
-        # 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)
-        
-        return Image.fromarray(filtered)
-        
-    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)
-        
-        # Augmentation de la saturation
-        hsv[..., 1] = hsv[..., 1] * params.get("saturation_boost", 1.5)
-        
-        # 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 __init__(self):
-        self.default_font = ImageFont.load_default()
-        self.fonts = self._initialize_fonts()
-        
-    def _initialize_fonts(self) -> Dict[str, ImageFont.FreeTypeFont]:
-        """Initialise les polices disponibles"""
-        fonts = {
-            "default": self.default_font,
-        }
-        
-        # Tentative de chargement des polices système courantes
-        common_fonts = {
-            "arial": "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
-            "times": "/usr/share/fonts/truetype/liberation/LiberationSerif-Regular.ttf",
-            "courier": "/usr/share/fonts/truetype/liberation/LiberationMono-Regular.ttf"
-        }
-        
-        for name, path in common_fonts.items():
-            try:
-                fonts[name] = ImageFont.truetype(path, size=40)
-            except OSError:
-                logger.warning(f"Police {name} non trouvée, utilisation police par défaut")
-                fonts[name] = self.default_font
-                
-        return fonts
-        
-    def render_text(self, image: Image.Image, text: str, effect: str, position: Tuple[int, int], font_name: str = "default") -> 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)
-            
-        return layer
+    def _neon_text(self, image: Image.Image, text: str, position: Tuple[int, int]) -> Image.Image:
+        try:
+            # Création d'un calque pour le texte néon
+            text_layer = Image.new('RGBA', image.size, (0, 0, 0, 0))
+            draw = ImageDraw.Draw(text_layer)
+            font = ImageFont.load_default()
 
-class EquityArtEngine:
-    """Moteur principal de génération artistique"""
-    def __init__(self):
-        self.image_processor = ImageProcessor()
-        self.text_renderer = TextRenderer()
-        self.model_url = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
-        token = os.getenv('HUGGINGFACE_TOKEN')
-        if not token:
-            logger.error("HUGGINGFACE_TOKEN non trouvé!")
-        self.headers = {"Authorization": f"Bearer {token}"}
-    
+            # Effet de glow
+            glow_colors = [(255, 182, 193), (255, 192, 203), (255, 202, 213)]
+            for i, color in enumerate(glow_colors):
+                offset = (3 - i) * 2
+                draw.text((position[0] - offset, position[1] - offset), 
+                         text, font=font, fill=color + (150,))
+
+            # Texte principal
+            draw.text(position, text, font=font, fill=(255, 255, 255, 255))
+
+            # Fusion des calques
+            return Image.alpha_composite(image.convert('RGBA'), text_layer)
+        except Exception as e:
+            logger.error(f"Erreur lors du rendu néon: {str(e)}")
+            return image
+
+    # ... autres méthodes d'effets de texte
+
+class ImageGenerator:
     def __init__(self):
-        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.api_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 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"""
+        self.text_processor = TextEffectProcessor()
+
+    async def generate_image(self, prompt: str, style_category: str, style_name: str, 
+                           text: Optional[str] = None, text_effect: Optional[str] = None,
+                           position: Optional[Tuple[int, int]] = None) -> Tuple[Optional[Image.Image], str]:
         try:
-            # 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}"
+            # Récupération des paramètres du style
+            style_info = STYLE_CATEGORIES[style_category][style_name]
             
+            # Construction du prompt final
+            final_prompt = f"{style_info['prompt']}, {prompt}"
+
             # Paramètres de génération
-            params = {
-                "prompt": full_prompt,
-                "negative_prompt": style_def.negative_prompt,
-                **quality.value
+            generation_params = {
+                "inputs": final_prompt,
+                "negative_prompt": style_info["negative_prompt"],
+                "num_inference_steps": style_info["params"]["num_inference_steps"],
+                "guidance_scale": style_info["params"]["guidance_scale"],
             }
-            
-            # 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:
+
+            # Appel à l'API
             response = requests.post(
-                self.model_url,
+                self.api_url,
                 headers=self.headers,
-                json={"inputs": params["prompt"], "parameters": params},
+                json=generation_params,
                 timeout=30
             )
-            
+
             if response.status_code != 200:
-                return None
-                
-            return Image.open(io.BytesIO(response.content))
-            
+                return None, f"Erreur API: {response.status_code}"
+
+            # Traitement de l'image générée
+            image = Image.open(io.BytesIO(response.content))
+
+            # Application des effets de style spécifiques
+            image = self._apply_style_effects(image, style_info["params"])
+
+            # Ajout de texte si demandé
+            if text and text_effect:
+                image = self.text_processor.apply_effect(
+                    image, text, text_effect, 
+                    position or (image.width//2, image.height//2)
+                )
+
+            return 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)}"
+
+    def _apply_style_effects(self, image: Image.Image, style_params: Dict) -> Image.Image:
+        """Application des effets spécifiques au style"""
+        try:
+            # Conversion pour traitement
+            img_array = np.array(image)
+
+            # Application des effets selon les paramètres
+            if style_params.get("neon_intensity"):
+                img_array = self._apply_neon_effect(img_array, style_params["neon_intensity"])
+
+            if style_params.get("volumetric_lighting"):
+                img_array = self._apply_volumetric_lighting(img_array)
+
+            # Reconversion en image PIL
+            return Image.fromarray(img_array)
+
         except Exception as e:
-            logger.error(f"Erreur API: {str(e)}")
-            return None
+            logger.error(f"Erreur lors de l'application des effets: {str(e)}")
+            return image
+
+    def _apply_neon_effect(self, img_array: np.ndarray, intensity: float) -> np.ndarray:
+        """Applique un effet néon à l'image"""
+        # Conversion en HSV pour manipulation des couleurs
+        hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
+        # Augmentation de la saturation
+        hsv[..., 1] = np.clip(hsv[..., 1] * intensity, 0, 255)
+        return cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)
+
+    def _apply_volumetric_lighting(self, img_array: np.ndarray) -> np.ndarray:
+        """Ajoute un effet de lumière volumétrique"""
+        # Création d'un masque de luminosité
+        gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+        blur = cv2.GaussianBlur(gray, (0, 0), 15)
+        return cv2.addWeighted(img_array, 1, cv2.cvtColor(blur, cv2.COLOR_GRAY2RGB), 0.2, 0)
 
 def create_interface():
-    """Interface utilisateur Gradio"""
-    engine = EquityArtEngine()
-    
-    with gr.Blocks(css="style.css") as app:
-        gr.HTML("""
-            <div class="header">
-                <h1>🎨 Equity Art Engine Pro</h1>
-                <p>Système de Génération Artistique Avancé</p>
-            </div>
-        """)
-        
-        with gr.Tab("Création"):
-            with gr.Row():
-                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"
+    generator = ImageGenerator()
+
+    with gr.Blocks() as demo:
+        gr.HTML("""<h1 style='text-align: center'>🎨 Equity Art Engine</h1>""")
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Contrôles de génération
+                prompt = gr.Textbox(label="Description de l'image")
+                style_category = gr.Dropdown(
+                    choices=list(STYLE_CATEGORIES.keys()),
+                    label="Catégorie de Style"
+                )
+                style_name = gr.Dropdown(
+                    label="Style Spécifique"
+                )
+                
+                # Mise à jour dynamique des styles disponibles
+                def update_styles(category):
+                    return gr.Dropdown.update(
+                        choices=list(STYLE_CATEGORIES[category].keys())
                     )
-                    
-            generate_btn = gr.Button("Générer", variant="primary")
-            image_output = gr.Image(label="Résultat")
-            status = gr.Textbox(label="Status")
-            
+                style_category.change(
+                    update_styles,
+                    inputs=[style_category],
+                    outputs=[style_name]
+                )
+
+                # Contrôles de texte
+                text_input = gr.Textbox(label="Texte à ajouter (optionnel)")
+                text_effect = gr.Dropdown(
+                    choices=["Réaliste", "Néon", "Holographique", "3D", "Vintage", "Graffiti", "Matrix"],
+                    label="Effet de texte"
+                )
+
+            with gr.Column(scale=2):
+                # Zone de résultat
+                image_output = gr.Image(label="Image générée")
+                status_output = gr.Textbox(label="Status")
+
+        # Bouton de génération
+        generate_btn = gr.Button("Générer")
+        
         # 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
-            
-            result, status_msg = engine.generate(
+        def generate(prompt, category, style, text, effect):
+            if not prompt or not category or not style:
+                return None, "Veuillez remplir tous les champs requis"
+                
+            image, status = generator.generate_image(
                 prompt=prompt,
-                style=style,
-                quality=QualityPreset[quality],
-                text_params=text_params
+                style_category=category,
+                style_name=style,
+                text=text if text else None,
+                text_effect=effect if text else None
             )
             
-            return result, status_msg
-            
+            return image, status
+
         generate_btn.click(
-            generate_artwork,
-            inputs=[prompt, style, quality, text_input, text_effect],
-            outputs=[image_output, status]
+            generate,
+            inputs=[prompt, style_category, style_name, text_input, text_effect],
+            outputs=[image_output, status_output]
         )
-        
-    return app
+
+    return demo
 
 if __name__ == "__main__":
-    app = create_interface()
-    app.launch()
+    demo = create_interface()
+    demo.launch()