Update app.py

app.py

@@ -17,298 +17,236 @@ logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 load_dotenv()
 
-# Définition complète des styles artistiques
-ART_STYLES = {
-    "Styles Traditionnels": {
-        "Renaissance": {
-            "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": {
-                "pixel_detail": 0.95,
-                "resolution": (4096, 4096),
-                "guidance_scale": 9.0,
-                "steps": 50
-            }
+def load_art_styles():
+    return {
+        "Styles Traditionnels": {
+            "Renaissance": {"prompt": "renaissance masterpiece, anatomical precision, detailed texture, chiaroscuro lighting", "params": {"resolution": (4096, 4096), "detail_level": 0.95}},
+            "Impressionnisme": {"prompt": "impressionist style painting, visible brushstrokes, natural light", "params": {"resolution": (3072, 3072), "noise_level": 0.3}},
+            "Surréalisme": {"prompt": "surrealist dreamlike scene, symbolic elements, subconscious imagery", "params": {"randomization": 0.4}},
+            "Cubisme": {"prompt": "cubist style, geometric forms, multiple perspectives", "params": {"geometric_strength": 0.8}}
         },
-        "Impressionnisme": {
-            "prompt": "impressionist style painting, visible brushstrokes, natural light effects, plein air scene, vibrant colors, monet-like technique",
-            "negative_prompt": "sharp details, photorealistic, digital",
-            "params": {
-                "noise_strength": 0.3,
-                "resolution": (2048, 2048),
-                "guidance_scale": 7.5,
-                "steps": 40
-            }
+        "Rendus Numériques": {
+            "Synthwave": {"prompt": "synthwave aesthetic, neon grid, retro-futuristic, vibrant", "params": {"saturation": 1.8, "neon": True}},
+            "Cyberpunk": {"prompt": "cyberpunk style, neon-lit, high-tech, volumetric lighting", "params": {"volumetric": True, "neon": True}},
+            "Sci-Fi": {"prompt": "sci-fi environment, futuristic technology, advanced architecture", "params": {"tech_level": 0.9}}
         },
-        "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
-            }
-        }
-    },
-    "Rendus Numériques": {
-        "Cyberpunk": {
-            "prompt": "cyberpunk style, neon lights, volumetric fog, high tech, dynamic lighting, futuristic cityscape",
-            "negative_prompt": "natural, vintage, traditional",
-            "params": {
-                "saturation": 1.9,
-                "neon_strength": 1.5,
-                "volumetric": True
-            }
+        "Photographie": {
+            "HDR": {"prompt": "HDR photography, extreme dynamic range, detailed shadows and highlights", "params": {"hdr_strength": 1.5}},
+            "Macro": {"prompt": "macro photography, extreme close-up, fine details", "params": {"detail_scale": 0.5}},
+            "Portrait": {"prompt": "professional portrait photography, studio lighting, bokeh", "params": {"bokeh": 0.7}},
+            "Vintage": {"prompt": "vintage photography, aged effect, retro colors", "params": {"grain": 0.4}}
         },
-        "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
-            }
+        "Illustration": {
+            "Aquarelle": {"prompt": "watercolor illustration, fluid transparency, soft edges", "params": {"transparency": 0.6}},
+            "Encre": {"prompt": "ink drawing, bold strokes, high contrast", "params": {"contrast": 1.4}},
+            "Huile": {"prompt": "oil painting, thick impasto, rich colors", "params": {"texture": 0.8}}
         },
-        "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": {
-                "simplification": 0.8,
-                "resolution": (1920, 1080),
-                "color_reduction": True
-            }
+        "Photoréalisme": {
+            "Nature_Morte": {"prompt": "photorealistic still life, extreme detail, perfect lighting", "params": {"detail_level": 0.98}},
+            "Paysage": {"prompt": "photorealistic landscape, natural lighting, atmospheric", "params": {"atmosphere": 0.7}}
         },
-        "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"
-            }
+        "Fantasy": {
+            "Fantasy": {"prompt": "fantasy art, magical atmosphere, mythical elements", "params": {"magic_effect": 0.8}},
+            "Dark_Fantasy": {"prompt": "dark fantasy, gothic elements, mysterious atmosphere", "params": {"darkness": 0.7}},
+            "Steampunk": {"prompt": "steampunk style, brass and copper, mechanical elements", "params": {"mechanical": 0.9}}
+        },
+        "Abstrait": {
+            "Holographique": {"prompt": "holographic effect, iridescent colors, light refraction", "params": {"iridescence": 0.8}},
+            "Fractal": {"prompt": "fractal art, recursive patterns, mathematical beauty", "params": {"complexity": 0.9}}
+        },
+        "Graphisme": {
+            "Flat": {"prompt": "flat design, minimal shapes, solid colors", "params": {"simplification": 0.8}},
+            "Material": {"prompt": "material design, subtle shadows, layered elements", "params": {"layers": 0.6}},
+            "Isométrique": {"prompt": "isometric design, geometric precision, clean lines", "params": {"precision": 0.9}}
+        },
+        "Gaming": {
+            "Pixel_Art": {"prompt": "pixel art style, retro gaming aesthetic, limited palette", "params": {"pixelation": 0.7}},
+            "Cel_Shading": {"prompt": "cel shaded style, anime-like, bold outlines", "params": {"outline": 0.8}}
         }
     }
-}
 
-class TextProcessor:
-    """Processeur de texte avec effets de base"""
-    
+class ImageProcessor:
     def __init__(self):
-        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"""
+        self.effects = {
+            "neon": self._apply_neon,
+            "bokeh": self._apply_bokeh,
+            "grain": self._apply_grain,
+            "hdr": self._apply_hdr,
+            "pixelation": self._apply_pixelation
+        }
+
+    def process_image(self, image: Image.Image, style_params: Dict) -> Image.Image:
         try:
-            draw = ImageDraw.Draw(image)
-            # Texte simple avec ombre
-            shadow_color = "black"
-            text_color = "white"
-            
-            # 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)
+            img_array = np.array(image)
             
-            return image
+            for effect, value in style_params.items():
+                if effect in self.effects and value:
+                    img_array = self.effects[effect](img_array, value)
+                    
+            return Image.fromarray(img_array)
         except Exception as e:
-            logger.error(f"Erreur lors de l'ajout de texte: {str(e)}")
+            logger.error(f"Erreur traitement: {str(e)}")
             return image
 
+    def _apply_neon(self, image: np.ndarray, strength: float) -> np.ndarray:
+        hsv = cv2.cvtColor(image, cv2.COLOR_RGB2HSV)
+        hsv[..., 1] = np.clip(hsv[..., 1] * strength, 0, 255)
+        glow = cv2.GaussianBlur(cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB), (0, 0), 15)
+        return cv2.addWeighted(image, 1, glow, 0.5, 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_grain(self, image: np.ndarray, strength: float) -> np.ndarray:
+        noise = np.random.normal(0, strength * 50, image.shape).astype(np.uint8)
+        return np.clip(image + noise, 0, 255)
+
+    def _apply_hdr(self, image: np.ndarray, strength: float) -> np.ndarray:
+        return exposure.adjust_gamma(image, 1.0 / strength)
+
+    def _apply_pixelation(self, image: np.ndarray, strength: float) -> np.ndarray:
+        h, w = image.shape[:2]
+        size = int(max(h, w) * (1 - strength))
+        small = cv2.resize(image, (size, size), interpolation=cv2.INTER_LINEAR)
+        return cv2.resize(small, (w, h), interpolation=cv2.INTER_NEAREST)
+
 class ImageGenerator:
-    """Générateur d'images avec styles artistiques"""
-    
     def __init__(self):
+        self.processor = ImageProcessor()
         self.api_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}"}
-        self.text_processor = TextProcessor()
+        self.headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_TOKEN')}"}
+        self.styles = load_art_styles()
 
-    def generate(self, prompt: str, style_category: str, style_name: str, 
-                text: Optional[str] = None) -> Tuple[Optional[Image.Image], str]:
+    async def generate(self, prompt: str, style_category: str, style_name: str) -> Tuple[Optional[Image.Image], str]:
         try:
-            # Récupération du style
-            style_info = ART_STYLES[style_category][style_name]
-            
-            # Construction du prompt final
+            style_info = self.styles[style_category][style_name]
             final_prompt = f"{prompt}, {style_info['prompt']}"
             
-            # Paramètres de génération
-            params = {
-                "inputs": final_prompt,
-                "negative_prompt": style_info["negative_prompt"],
-                "guidance_scale": style_info["params"].get("guidance_scale", 7.5),
-                "num_inference_steps": style_info["params"].get("steps", 50),
-            }
-            
-            # Appel API
             response = requests.post(
                 self.api_url,
                 headers=self.headers,
-                json=params,
+                json={"inputs": final_prompt},
                 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
+
             image = Image.open(io.BytesIO(response.content))
+            processed = self.processor.process_image(image, style_info['params'])
             
-            # Application des effets de style
-            image = self._apply_style_effects(image, style_info["params"])
-            
-            # 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 processed, "✨ Génération réussie!"
         except Exception as e:
-            logger.error(f"Erreur de génération: {str(e)}")
+            logger.error(f"Erreur: {str(e)}")
             return None, f"Erreur: {str(e)}"
         finally:
-            gc.collect()
-
-    def _apply_style_effects(self, image: Image.Image, style_params: Dict) -> Image.Image:
-        """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("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 _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_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"""
+            gc.collect()def create_interface():
     generator = ImageGenerator()
 
     with gr.Blocks() as demo:
-        gr.HTML("<h1>🎨 Equity Art Engine Pro</h1>")
+        gr.HTML("""
+            <div style='text-align: center; margin-bottom: 1rem'>
+                <h1>🎨 Equity Art Engine</h1>
+                <p>Générateur d'Images Avancé avec Styles Artistiques</p>
+            </div>
+        """)
         
         with gr.Row():
-            with gr.Column():
-                # Contrôles principaux
-                prompt = gr.Textbox(label="Description de l'image")
+            with gr.Column(scale=1):
+                prompt = gr.Textbox(
+                    label="Description",
+                    placeholder="Décrivez votre image..."
+                )
                 
                 style_category = gr.Dropdown(
-                    choices=list(ART_STYLES.keys()),
-                    label="Catégorie de Style"
+                    choices=list(generator.styles.keys()),
+                    label="Catégorie de Style",
+                    value="Styles Traditionnels"
                 )
                 
                 style_name = gr.Dropdown(
                     label="Style Spécifique"
                 )
                 
-                # Mise à jour dynamique des styles
                 def update_styles(category):
                     return gr.Dropdown.update(
-                        choices=list(ART_STYLES[category].keys()) if category else []
+                        choices=list(generator.styles[category].keys()) if category else []
                     )
                 
                 style_category.change(
                     update_styles,
-                    inputs=[style_category],
-                    outputs=[style_name]
+                    inputs=style_category,
+                    outputs=style_name
                 )
                 
-                text_input = gr.Textbox(
-                    label="Texte à ajouter (optionnel)",
-                    placeholder="Laissez vide pour une image sans texte"
+                advanced_params = gr.Checkbox(
+                    label="Paramètres avancés",
+                    value=False
                 )
                 
-                generate_btn = gr.Button("✨ Générer")
+                with gr.Column(visible=False) as advanced_options:
+                    quality = gr.Slider(
+                        minimum=1,
+                        maximum=10,
+                        value=7,
+                        step=1,
+                        label="Qualité"
+                    )
+                    
+                    seed = gr.Number(
+                        label="Seed (-1 pour aléatoire)",
+                        value=-1
+                    )
                 
-            with gr.Column():
-                # Affichage
-                image_output = gr.Image(label="Image Générée")
-                status_output = gr.Textbox(label="Status")
+                def toggle_advanced(show):
+                    return gr.update(visible=show)
+                
+                advanced_params.change(
+                    toggle_advanced,
+                    inputs=advanced_params,
+                    outputs=advanced_options
+                )
+                
+                generate_btn = gr.Button("✨ Générer", variant="primary")
+                
+            with gr.Column(scale=2):
+                output_image = gr.Image(label="Image Générée")
+                status = gr.Textbox(label="Status")
         
-        def generate_image(prompt, category, style, text):
-            if not prompt or not category or not style:
+        def generate_image(prompt, category, style, use_advanced, quality, seed):
+            if not all([prompt, category, style]):
                 return None, "⚠️ Veuillez remplir tous les champs requis"
             
-            image, status = generator.generate(
+            params = {
+                "quality": quality if use_advanced else 7,
+                "seed": seed if use_advanced and seed != -1 else None
+            }
+            
+            image, status_msg = generator.generate(
                 prompt=prompt,
                 style_category=category,
-                style_name=style,
-                text=text if text else None
+                style_name=style
             )
             
-            return image, status
+            return image, status_msg
         
         generate_btn.click(
             generate_image,
-            inputs=[prompt, style_category, style_name, text_input],
-            outputs=[image_output, status_output]
+            inputs=[
+                prompt,
+                style_category,
+                style_name,
+                advanced_params,
+                quality,
+                seed
+            ],
+            outputs=[output_image, status]
         )
-
+    
     return demo
 
 if __name__ == "__main__":