Update app.py

app.py

@@ -10,6 +10,8 @@ import logging
 from dotenv import load_dotenv
 import numpy as np
 import cv2
+from skimage import exposure
+import torch
 
 # Configuration du logging
 logging.basicConfig(
@@ -23,100 +25,122 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 load_dotenv()
 
-# 1. STYLES EQUITY (basés sur les 8 documents)
+# Définition des styles Equity avec paramètres d'optimisation avancés
 ART_STYLES = {
-    "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",
+    "Ultra Technique": {
+        "prompt_prefix": """ultra detailed technical drawing, engineering precision,
+        scientific accuracy, professional schematic, architectural detail, perfect measurements,
+        masterful technical illustration, 8k UHD quality, professional engineering visualization""",
+        "negative_prompt": "artistic, painterly, imprecise, blurry, sketchy",
         "quality_boost": 1.5,
-        "style_params": {
-            "detail_level": "maximum",
-            "technical_precision": True,
-            "historical_accuracy": True
+        "image_params": {
+            "sharpness": 1.4,
+            "technical_detail": True,
+            "contrast": 1.2,
+            "denoise": 0.3
         }
     },
     "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",
+        "prompt_prefix": """cutting-edge technological design, modern engineering aesthetic,
+        innovative technical concept, futuristic schematic, professional industrial visualization,
+        high-tech blueprint, advanced technical detail, ultra modern technical drawing""",
+        "negative_prompt": "vintage, traditional, hand-drawn, artistic",
         "quality_boost": 1.4,
-        "style_params": {
-            "tech_detail": "ultra",
-            "innovation_focus": True
+        "image_params": {
+            "sharpness": 1.3,
+            "contrast": 1.3,
+            "clarity": 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",
+    "Précision Scientifique": {
+        "prompt_prefix": """scientific visualization, mathematical accuracy, 
+        precise technical detail, analytical illustration, professional documentation,
+        engineering excellence, technical mastery, detailed scientific diagram""",
+        "negative_prompt": "artistic interpretation, abstract, undefined",
         "quality_boost": 1.5,
-        "style_params": {
-            "photographic_precision": True,
-            "detail_preservation": "maximum"
+        "image_params": {
+            "detail_enhancement": True,
+            "precision": 1.4,
+            "clarity": True
         }
     },
     "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",
+        "prompt_prefix": """future technology concept, advanced engineering design,
+        next-generation technical visualization, innovative blueprint style,
+        high-tech schematic art, professional futuristic documentation""",
+        "negative_prompt": "retro, vintage, traditional technique",
         "quality_boost": 1.4,
-        "style_params": {
-            "future_tech": True,
-            "concept_clarity": "high"
+        "image_params": {
+            "tech_enhancement": True,
+            "modern_look": True,
+            "sharpness": 1.3
         }
     }
 }
 
-# 2. OPTIMISATION DE LA QUALITÉ
 class ImageEnhancer:
+    """Classe de traitement et d'amélioration d'image avancée"""
+    
     def __init__(self):
-        self.enhancement_pipeline = {
-            "technical_detail": self._enhance_technical_detail,
-            "color_refinement": self._refine_colors,
-            "sharpness_boost": self._boost_sharpness,
-            "contrast_optimization": self._optimize_contrast
-        }
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+    def _apply_clahe(self, image: np.ndarray) -> np.ndarray:
+        """Amélioration adaptative du contraste"""
+        if len(image.shape) == 3:
+            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)
+        return image
 
-    def _enhance_technical_detail(self, image: np.ndarray) -> np.ndarray:
-        kernel = np.array([[-1,-1,-1], [-1,9,-1], [-1,-1,-1]])
+    def _enhance_details(self, image: np.ndarray) -> np.ndarray:
+        """Amélioration des détails techniques"""
+        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:
+    def _reduce_noise(self, image: np.ndarray, strength: float = 0.3) -> np.ndarray:
+        """Réduction du bruit adaptative"""
+        return cv2.fastNlMeansDenoisingColored(
+            image,
+            None,
+            h=10 * strength,
+            hColor=10,
+            templateWindowSize=7,
+            searchWindowSize=21
+        )
+
+    def _adjust_gamma(self, image: np.ndarray, gamma: float = 1.0) -> np.ndarray:
+        """Ajustement gamma pour l'optimisation des tons"""
+        return exposure.adjust_gamma(image, gamma)
+
+    def enhance_image(self, image: Image.Image, params: Dict) -> Image.Image:
+        """Pipeline complet d'amélioration d'image"""
+        # Conversion en format CV2
         cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-        
-        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)
-        
+
+        # Application des améliorations selon les paramètres
+        if params.get('technical_detail', False):
+            cv_image = self._enhance_details(cv_image)
+
+        if params.get('clarity', False):
+            cv_image = self._apply_clahe(cv_image)
+
+        if params.get('denoise', 0) > 0:
+            cv_image = self._reduce_noise(cv_image, params['denoise'])
+
+        if params.get('gamma', 1.0) != 1.0:
+            cv_image = self._adjust_gamma(cv_image, params['gamma'])
+
+        # Reconversion en format PIL
         return Image.fromarray(cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB))
 
-# 3. GÉNÉRATEUR D'IMAGES PRINCIPAL
 class ImageGenerator:
+    """Générateur d'images principal avec optimisations Equity"""
+
     def __init__(self):
         self.API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-xl-base-1.0"
         self.enhancer = ImageEnhancer()
@@ -126,26 +150,36 @@ class ImageGenerator:
         self.headers = {"Authorization": f"Bearer {token}"}
         logger.info("ImageGenerator initialisé")
 
+    def _prepare_prompt(self, params: Dict[str, Any], style_info: Dict) -> str:
+        """Prépare le prompt optimisé"""
+        base_prompt = params['subject']
+        if params.get('title'):
+            base_prompt += f", with text: {params['title']}"
+        return f"{base_prompt}, {style_info['prompt_prefix']}"
+
+    def _get_generation_params(self, params: Dict[str, Any], style_info: Dict) -> Dict:
+        """Configure les paramètres de génération optimaux"""
+        return {
+            "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
+        }
+
     def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
+        """Génération d'image avec optimisations Equity"""
         try:
             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']}"
+            prompt = self._prepare_prompt(params, style_info)
+            generation_params = self._get_generation_params(params, style_info)
 
             payload = {
                 "inputs": prompt,
-                "parameters": {
-                    "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
-                }
+                "parameters": generation_params
             }
 
             response = requests.post(
@@ -158,8 +192,8 @@ class ImageGenerator:
             if response.status_code == 200:
                 image = Image.open(io.BytesIO(response.content))
                 enhanced_image = self.enhancer.enhance_image(
-                    image, 
-                    style_info["style_params"]
+                    image,
+                    style_info["image_params"]
                 )
                 return enhanced_image, "✨ Création réussie!"
             else:
@@ -174,31 +208,11 @@ class ImageGenerator:
         finally:
             gc.collect()
 
-# 4. INTERFACE UTILISATEUR
 def create_interface():
+    """Création de l'interface utilisateur Equity"""
     generator = ImageGenerator()
 
-    # Style CSS personnalisé
-    css = """
-    .container { max-width: 1200px; margin: auto; }
-    .welcome { 
-        text-align: center; 
-        margin: 20px 0; 
-        padding: 20px; 
-        background: linear-gradient(135deg, #1e293b, #334155);
-        border-radius: 10px;
-        color: white;
-    }
-    .controls-group { 
-        background: #2d3748; 
-        padding: 15px; 
-        border-radius: 5px; 
-        margin: 10px 0;
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-    }
-    """
-
-    with gr.Blocks(css=css) as app:
+    with gr.Blocks(css="style.css") as app:
         gr.HTML("""
             <div class="welcome">
                 <h1>🎨 Equity Artisan 3.0</h1>
@@ -207,7 +221,6 @@ def create_interface():
         """)
 
         with gr.Column(elem_classes="container"):
-            # Format et Style
             with gr.Group(elem_classes="controls-group"):
                 with gr.Row():
                     format_size = gr.Dropdown(
@@ -222,15 +235,14 @@ def create_interface():
                     )
                     style = gr.Dropdown(
                         choices=list(ART_STYLES.keys()),
-                        value="Renaissance Technologique",
-                        label="Style Artistique"
+                        value="Ultra Technique",
+                        label="Style Technique"
                     )
 
-            # Description
             with gr.Group(elem_classes="controls-group"):
                 subject = gr.Textbox(
                     label="Description",
-                    placeholder="Décrivez votre vision technique ou artistique...",
+                    placeholder="Décrivez votre vision technique...",
                     lines=3
                 )
                 title = gr.Textbox(
@@ -238,14 +250,13 @@ def create_interface():
                     placeholder="Titre à inclure dans l'image..."
                 )
 
-            # Paramètres avancés
             with gr.Group(elem_classes="controls-group"):
                 with gr.Row():
                     quality = gr.Slider(
                         minimum=30,
                         maximum=50,
                         value=40,
-                        label="Qualité"
+                        label="Qualité Technique"
                     )
                     detail_level = gr.Slider(
                         minimum=1,
@@ -255,12 +266,10 @@ def create_interface():
                         label="Niveau de Détail"
                     )
 
-            # Boutons
             with gr.Row():
                 generate_btn = gr.Button("✨ Générer", variant="primary")
                 clear_btn = gr.Button("🗑️ Effacer")
 
-            # Résultat
             image_output = gr.Image(label="Résultat")
             status = gr.Textbox(label="Status", interactive=False)