Update app.py

app.py

@@ -17,268 +17,295 @@ logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 load_dotenv()
 
-# Constantes pour les styles disponibles
-STYLE_CATEGORIES = {
-    "TRADITIONAL": {
+# Définition complète des styles artistiques
+ART_STYLES = {
+    "Styles Traditionnels": {
         "Renaissance": {
-            "prompt": "renaissance style masterpiece, anatomical precision, detailed texture, chiaroscuro lighting, oil painting technique, museum quality",
-            "negative_prompt": "modern, abstract, simple, flat, digital art",
+            "prompt": "renaissance masterpiece, anatomical precision, high detail texture quality, chiaroscuro lighting, oil painting, 4K resolution, museum quality, classical art",
+            "negative_prompt": "modern, abstract, simple, digital",
             "params": {
-                "guidance_scale": 9.0,
-                "num_inference_steps": 50,
+                "pixel_detail": 0.95,
                 "resolution": (4096, 4096),
-                "detail_threshold": 0.95,
+                "guidance_scale": 9.0,
+                "steps": 50
             }
         },
         "Impressionnisme": {
-            "prompt": "impressionist style, loose brushstrokes, natural light, vivid colors, en plein air painting",
-            "negative_prompt": "sharp details, digital art, modern",
+            "prompt": "impressionist style painting, visible brushstrokes, natural light effects, plein air scene, vibrant colors, monet-like technique",
+            "negative_prompt": "sharp details, photorealistic, digital",
             "params": {
-                "guidance_scale": 7.5,
-                "num_inference_steps": 40,
+                "noise_strength": 0.3,
                 "resolution": (2048, 2048),
-                "brush_simulation": True,
+                "guidance_scale": 7.5,
+                "steps": 40
             }
         },
-        # ... autres styles traditionnels
+        "Surréalisme": {
+            "prompt": "surrealist dreamlike scene, dream-like quality, unconscious imagination, unexpected juxtapositions",
+            "negative_prompt": "realistic, ordinary, conventional",
+            "params": {
+                "randomization": 0.3,
+                "guidance_scale": 8.0,
+                "steps": 45
+            }
+        }
     },
-    
-    "DIGITAL": {
+    "Rendus Numériques": {
         "Cyberpunk": {
-            "prompt": "cyberpunk style, neon lights, volumetric fog, tech noir, high contrast, futuristic city",
-            "negative_prompt": "natural, vintage, traditional art",
+            "prompt": "cyberpunk style, neon lights, volumetric fog, high tech, dynamic lighting, futuristic cityscape",
+            "negative_prompt": "natural, vintage, traditional",
             "params": {
-                "guidance_scale": 8.0,
-                "neon_intensity": 1.5,
-                "volumetric_lighting": True,
-                "resolution": (3840, 2160),
+                "saturation": 1.9,
+                "neon_strength": 1.5,
+                "volumetric": True
             }
         },
-        "Holographique": {
-            "prompt": "holographic effect, iridescent colors, light refraction, transparent layers, futuristic",
-            "negative_prompt": "flat, matte, solid colors",
+        "Synthwave": {
+            "prompt": "synthwave aesthetic, retro-futuristic, neon grid, 80s style, dramatic lighting",
+            "negative_prompt": "realistic, modern, natural",
+            "params": {
+                "saturation": 1.8,
+                "neon_strength": 1.4,
+                "lut_intensity": 0.9
+            }
+        }
+    },
+    "Photographie": {
+        "HDR": {
+            "prompt": "HDR photography, extreme dynamic range, rich details in shadows and highlights, 8K quality",
+            "negative_prompt": "flat lighting, low contrast",
+            "params": {
+                "dynamic_range": 1.5,
+                "resolution": (7680, 4320),
+                "exposure_levels": 3
+            }
+        },
+        "Portrait Studio": {
+            "prompt": "professional studio portrait photography, bokeh effect, controlled lighting, sharp focus on subject",
+            "negative_prompt": "blurry, noisy, low quality",
+            "params": {
+                "bokeh_strength": 0.7,
+                "sharpness": 1.4,
+                "focus_area": 0.5
+            }
+        }
+    },
+    "Art Moderne": {
+        "Flat Design": {
+            "prompt": "flat design style, minimal, clean shapes, solid colors, modern aesthetic",
+            "negative_prompt": "detailed, textured, realistic",
             "params": {
-                "iridescence": 1.0,
-                "transparency": 0.7,
-                "resolution": (2560, 1440),
+                "simplification": 0.8,
+                "resolution": (1920, 1080),
+                "color_reduction": True
             }
         },
-        # ... autres styles numériques
+        "3D Isométrique": {
+            "prompt": "isometric 3D design, clean geometric shapes, precise angles, modern visualization",
+            "negative_prompt": "realistic perspective, organic shapes",
+            "params": {
+                "geometric_precision": 1.0,
+                "angle_snap": 30,
+                "shading": "flat"
+            }
+        }
     }
 }
 
-class TextEffectProcessor:
+class TextProcessor:
+    """Processeur de texte avec effets de base"""
+    
     def __init__(self):
-        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:
+        self.font = ImageFont.load_default()
+    
+    def add_text(self, image: Image.Image, text: str, position: Tuple[int, int]) -> Image.Image:
+        """Ajoute du texte basique à l'image"""
         try:
             draw = ImageDraw.Draw(image)
-            # Chargement d'une police par défaut
-            font = ImageFont.load_default()
+            # Texte simple avec ombre
+            shadow_color = "black"
+            text_color = "white"
             
-            # 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))
+            # Dessine l'ombre
+            draw.text((position[0]+2, position[1]+2), text, 
+                     font=self.font, fill=shadow_color)
+            # Dessine le texte
+            draw.text(position, text, font=self.font, fill=text_color)
             
             return image
         except Exception as e:
-            logger.error(f"Erreur lors du rendu réaliste: {str(e)}")
-            return image
-
-    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()
-
-            # 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)}")
+            logger.error(f"Erreur lors de l'ajout de texte: {str(e)}")
             return image
 
-    # ... autres méthodes d'effets de texte
-
 class ImageGenerator:
+    """Générateur d'images avec styles artistiques"""
+    
     def __init__(self):
         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')}"}
-        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]:
+        token = os.getenv('HUGGINGFACE_TOKEN')
+        if not token:
+            logger.error("HUGGINGFACE_TOKEN non trouvé!")
+        self.headers = {"Authorization": f"Bearer {token}"}
+        self.text_processor = TextProcessor()
+
+    def generate(self, prompt: str, style_category: str, style_name: str, 
+                text: Optional[str] = None) -> Tuple[Optional[Image.Image], str]:
         try:
-            # Récupération des paramètres du style
-            style_info = STYLE_CATEGORIES[style_category][style_name]
+            # Récupération du style
+            style_info = ART_STYLES[style_category][style_name]
             
             # Construction du prompt final
-            final_prompt = f"{style_info['prompt']}, {prompt}"
-
+            final_prompt = f"{prompt}, {style_info['prompt']}"
+            
             # Paramètres de génération
-            generation_params = {
+            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"],
+                "guidance_scale": style_info["params"].get("guidance_scale", 7.5),
+                "num_inference_steps": style_info["params"].get("steps", 50),
             }
-
-            # Appel à l'API
+            
+            # Appel API
             response = requests.post(
                 self.api_url,
                 headers=self.headers,
-                json=generation_params,
+                json=params,
                 timeout=30
             )
-
+            
             if response.status_code != 200:
+                logger.error(f"Erreur API: {response.status_code}")
                 return None, f"Erreur API: {response.status_code}"
-
-            # Traitement de l'image générée
+            
+            # Traitement de l'image
             image = Image.open(io.BytesIO(response.content))
-
-            # Application des effets de style spécifiques
+            
+            # Application des effets de style
             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)
+            
+            # Ajout de texte si nécessaire
+            if text:
+                image = self.text_processor.add_text(
+                    image, 
+                    text, 
+                    (image.width//2, image.height//2)
                 )
-
-            return image, "Génération réussie!"
-
+            
+            return image, "✨ Génération réussie!"
+            
         except Exception as e:
-            logger.error(f"Erreur lors de la génération: {str(e)}")
+            logger.error(f"Erreur de génération: {str(e)}")
             return None, f"Erreur: {str(e)}"
+        finally:
+            gc.collect()
 
     def _apply_style_effects(self, image: Image.Image, style_params: Dict) -> Image.Image:
-        """Application des effets spécifiques au style"""
+        """Applique les 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
+            if style_params.get("saturation"):
+                img_array = self._adjust_saturation(img_array, style_params["saturation"])
+                
+            if style_params.get("neon_strength"):
+                img_array = self._apply_neon_effect(img_array, style_params["neon_strength"])
+                
+            if style_params.get("volumetric"):
+                img_array = self._add_volumetric_effect(img_array)
+                
+            if style_params.get("bokeh_strength"):
+                img_array = self._apply_bokeh(img_array, style_params["bokeh_strength"])
+            
             return Image.fromarray(img_array)
-
+            
         except Exception as e:
             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)
+    def _adjust_saturation(self, image: np.ndarray, factor: float) -> np.ndarray:
+        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+        hsv[..., 1] = np.clip(hsv[..., 1] * factor, 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 _apply_neon_effect(self, image: np.ndarray, strength: float) -> np.ndarray:
+        blurred = cv2.GaussianBlur(image, (0, 0), 15)
+        return cv2.addWeighted(image, 1, blurred, strength, 0)
+
+    def _add_volumetric_effect(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:
+        blurred = cv2.GaussianBlur(image, (0, 0), int(30 * strength))
+        mask = np.random.random(image.shape[:2]) > 0.5
+        result = image.copy()
+        result[mask] = blurred[mask]
+        return result
 
 def create_interface():
+    """Création de l'interface utilisateur"""
     generator = ImageGenerator()
 
     with gr.Blocks() as demo:
-        gr.HTML("""<h1 style='text-align: center'>🎨 Equity Art Engine</h1>""")
-
+        gr.HTML("<h1>🎨 Equity Art Engine Pro</h1>")
+        
         with gr.Row():
-            with gr.Column(scale=1):
-                # Contrôles de génération
+            with gr.Column():
+                # Contrôles principaux
                 prompt = gr.Textbox(label="Description de l'image")
+                
                 style_category = gr.Dropdown(
-                    choices=list(STYLE_CATEGORIES.keys()),
+                    choices=list(ART_STYLES.keys()),
                     label="Catégorie de Style"
                 )
+                
                 style_name = gr.Dropdown(
                     label="Style Spécifique"
                 )
                 
-                # Mise à jour dynamique des styles disponibles
+                # Mise à jour dynamique des styles
                 def update_styles(category):
                     return gr.Dropdown.update(
-                        choices=list(STYLE_CATEGORIES[category].keys())
+                        choices=list(ART_STYLES[category].keys()) if category else []
                     )
+                
                 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"
+                
+                text_input = gr.Textbox(
+                    label="Texte à ajouter (optionnel)",
+                    placeholder="Laissez vide pour une image sans texte"
                 )
-
-            with gr.Column(scale=2):
-                # Zone de résultat
-                image_output = gr.Image(label="Image générée")
+                
+                generate_btn = gr.Button("✨ Générer")
+                
+            with gr.Column():
+                # Affichage
+                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(prompt, category, style, text, effect):
+        def generate_image(prompt, category, style, text):
             if not prompt or not category or not style:
-                return None, "Veuillez remplir tous les champs requis"
-                
-            image, status = generator.generate_image(
+                return None, "⚠️ Veuillez remplir tous les champs requis"
+            
+            image, status = generator.generate(
                 prompt=prompt,
                 style_category=category,
                 style_name=style,
-                text=text if text else None,
-                text_effect=effect if text else None
+                text=text if text else None
             )
             
             return image, status
-
+        
         generate_btn.click(
-            generate,
-            inputs=[prompt, style_category, style_name, text_input, text_effect],
+            generate_image,
+            inputs=[prompt, style_category, style_name, text_input],
             outputs=[image_output, status_output]
         )