Update app.py

app.py

@@ -1,6 +1,6 @@
 import gradio as gr
 import os
-from PIL import Image, ImageEnhance
+from PIL import Image, ImageEnhance, ImageFilter
 import requests
 import io
 import gc
@@ -14,296 +14,270 @@ from skimage import exposure
 import torch
 
 # Configuration du logging
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('equity_space.log'),
-        logging.StreamHandler()
-    ]
-)
+logging.basicConfig(level=logging.DEBUG)
 logger = logging.getLogger(__name__)
 load_dotenv()
 
-# Définition des styles Equity avec paramètres d'optimisation avancés
-ART_STYLES = {
-    "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,
-        "image_params": {
+# Configurations photographiques inspirées d'appareils emblématiques
+PHOTO_STYLES = {
+    "Leica": {
+        "description": "Style Leica classique 35mm - Netteté exceptionnelle, contraste naturel",
+        "params": {
             "sharpness": 1.4,
-            "technical_detail": True,
             "contrast": 1.2,
-            "denoise": 0.3
+            "black_point": 5,
+            "white_point": 248,
+            "color_balance": "neutral"
         }
     },
-    "Innovation Moderne": {
-        "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,
-        "image_params": {
-            "sharpness": 1.3,
-            "contrast": 1.3,
-            "clarity": True
+    "Hasselblad": {
+        "description": "Qualité moyen format - Détails riches, tons subtils",
+        "params": {
+            "sharpness": 1.6,
+            "contrast": 1.1,
+            "dynamic_range": "extended",
+            "color_depth": "high",
+            "medium_format": True
         }
     },
-    "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,
-        "image_params": {
-            "detail_enhancement": True,
-            "precision": 1.4,
-            "clarity": True
+    "Polaroid": {
+        "description": "Look vintage instantané - Tons chauds, vignettage doux",
+        "params": {
+            "vintage_effect": True,
+            "color_shift": "warm",
+            "vignette": 0.3,
+            "grain": "fine"
         }
     },
-    "Vision Futuriste": {
-        "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,
-        "image_params": {
-            "tech_enhancement": True,
-            "modern_look": True,
-            "sharpness": 1.3
+    "Fujifilm": {
+        "description": "Rendu Fujifilm - Couleurs riches, tons chair naturels",
+        "params": {
+            "color_profile": "fuji",
+            "skin_tones": "enhanced",
+            "dynamic_range": "wide",
+            "film_simulation": True
         }
     }
 }
 
-class ImageEnhancer:
-    """Classe de traitement et d'amélioration d'image avancée"""
+class ImageProcessor:
+    """Processeur d'image avec simulations d'appareils photos classiques"""
     
     def __init__(self):
         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)
+    
+    def apply_photo_style(self, image: Image.Image, style: str) -> Image.Image:
+        """Applique un style photographique inspiré d'appareils classiques"""
+        style_params = PHOTO_STYLES[style]["params"]
+        
+        # Création d'une copie de l'image pour le traitement
+        processed = image.copy()
+        
+        # Application des paramètres de base
+        if style_params.get("sharpness"):
+            processed = ImageEnhance.Sharpness(processed).enhance(style_params["sharpness"])
+            
+        if style_params.get("contrast"):
+            processed = ImageEnhance.Contrast(processed).enhance(style_params["contrast"])
+            
+        # Effets spéciaux selon le style
+        if style_params.get("vintage_effect"):
+            processed = self._apply_vintage_effect(processed)
+            
+        if style_params.get("medium_format"):
+            processed = self._simulate_medium_format(processed)
+            
+        if style_params.get("vignette"):
+            processed = self._add_vignette(processed, style_params["vignette"])
+            
+        return processed
+    
+    def _apply_vintage_effect(self, image: Image.Image) -> Image.Image:
+        """Simule l'effet vintage type Polaroid"""
+        # Conversion en numpy array pour le traitement
+        img_array = np.array(image)
+        
+        # Ajustement des courbes de couleur
+        img_array = exposure.adjust_gamma(img_array, 1.2)
+        
+        # Ajout de grain subtil
+        noise = np.random.normal(0, 2, img_array.shape)
+        img_array = np.clip(img_array + noise, 0, 255).astype(np.uint8)
+        
+        # Léger flou pour adoucir
+        return Image.fromarray(img_array).filter(ImageFilter.GaussianBlur(0.5))
+    
+    def _simulate_medium_format(self, image: Image.Image) -> Image.Image:
+        """Simule le rendu moyen format type Hasselblad"""
+        # Augmentation de la netteté et du micro-contraste
+        enhanced = ImageEnhance.Sharpness(image).enhance(1.6)
+        
+        # Optimisation de la plage dynamique
+        img_array = np.array(enhanced)
+        img_array = exposure.equalize_adapthist(img_array, clip_limit=0.02)
+        
+        return Image.fromarray((img_array * 255).astype(np.uint8))
+    
+    def _add_vignette(self, image: Image.Image, strength: float) -> Image.Image:
+        """Ajoute un effet de vignettage"""
+        # Création du masque de vignettage
+        mask = Image.new('L', image.size, 255)
+        draw = ImageDraw.Draw(mask)
+        
+        width, height = image.size
+        for i in range(min(width, height) // 2):
+            alpha = int(255 * (1 - i * strength / (min(width, height) // 2)))
+            draw.ellipse([i, i, width-i, height-i], fill=alpha)
+            
+        # Application du masque
+        image.putalpha(mask)
         return image
 
-    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 _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)
-
-        # 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))
-
 class ImageGenerator:
-    """Générateur d'images principal avec optimisations Equity"""
-
+    """Générateur d'images avec confirmation et styles photographiques"""
+    
     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 _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
-        }
-
+        self.processor = ImageProcessor()
+        self.headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_TOKEN')}"}
+        
+    async def confirm_generation(self, params: Dict[str, Any]) -> bool:
+        """Demande confirmation avant génération"""
+        style_info = PHOTO_STYLES[params["photo_style"]]
+        confirmation_message = f"""
+        🎨 Paramètres de génération :
+        - Style photo : {params['photo_style']} ({style_info['description']})
+        - Description : {params['prompt']}
+        - Format : {params['orientation']}
+        
+        Voulez-vous continuer ?
+        """
+        return await self._show_confirmation_dialog(confirmation_message)
+    
     def generate(self, params: Dict[str, Any]) -> Tuple[Optional[Image.Image], str]:
-        """Génération d'image avec optimisations Equity"""
+        """Génération d'image avec style photographique"""
         try:
-            style_info = ART_STYLES.get(params["style"])
-            if not style_info:
-                return None, "⚠️ Style non trouvé"
-
-            prompt = self._prepare_prompt(params, style_info)
-            generation_params = self._get_generation_params(params, style_info)
-
-            payload = {
-                "inputs": prompt,
-                "parameters": generation_params
+            if not await self.confirm_generation(params):
+                return None, "Génération annulée par l'utilisateur"
+            
+            # Configuration de la requête
+            generation_params = {
+                "prompt": params["prompt"],
+                "negative_prompt": "low quality, blurry, distorted",
+                "num_inference_steps": 50,
+                "guidance_scale": 7.5,
+                "width": 1024 if params["orientation"] == "landscape" else 768,
+                "height": 768 if params["orientation"] == "landscape" else 1024
             }
-
+            
+            # Génération via API
             response = requests.post(
                 self.API_URL,
                 headers=self.headers,
-                json=payload,
-                timeout=45
+                json={"inputs": generation_params["prompt"], "parameters": generation_params},
+                timeout=30
             )
-
-            if response.status_code == 200:
-                image = Image.open(io.BytesIO(response.content))
-                enhanced_image = self.enhancer.enhance_image(
-                    image,
-                    style_info["image_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
-
+            
+            if response.status_code != 200:
+                return None, f"Erreur API: {response.status_code}"
+            
+            # Traitement de l'image
+            image = Image.open(io.BytesIO(response.content))
+            
+            # Application du style photographique
+            processed_image = self.processor.apply_photo_style(
+                image, 
+                params["photo_style"]
+            )
+            
+            return processed_image, "✨ Génération réussie"
+            
         except Exception as e:
-            error_msg = f"⚠️ Erreur: {str(e)}"
-            logger.exception("Erreur génération:")
-            return None, error_msg
+            logger.error(f"Erreur lors de la génération: {str(e)}")
+            return None, f"Erreur: {str(e)}"
         finally:
             gc.collect()
 
 def create_interface():
-    """Création de l'interface utilisateur Equity"""
+    """Création de l'interface utilisateur avec confirmation"""
     generator = ImageGenerator()
-
+    
     with gr.Blocks(css="style.css") as app:
         gr.HTML("""
-            <div class="welcome">
-                <h1>🎨 Equity Artisan 3.0</h1>
-                <p>Assistant de Création d'Images Professionnelles</p>
+            <div class="header">
+                <h1>🎨 Equity Art Studio Pro</h1>
+                <p>Création d'images avec styles photographiques classiques</p>
             </div>
         """)
-
-        with gr.Column(elem_classes="container"):
-            with gr.Group(elem_classes="controls-group"):
-                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 Technique",
-                        label="Style Technique"
-                    )
-
-            with gr.Group(elem_classes="controls-group"):
-                subject = gr.Textbox(
-                    label="Description",
-                    placeholder="Décrivez votre vision technique...",
-                    lines=3
+        
+        with gr.Column():
+            # Contrôles de base
+            prompt = gr.Textbox(
+                label="Description",
+                placeholder="Décrivez l'image souhaitée..."
+            )
+            
+            with gr.Row():
+                orientation = gr.Radio(
+                    choices=["portrait", "landscape", "square"],
+                    value="portrait",
+                    label="Format"
                 )
-                title = gr.Textbox(
-                    label="Titre (optionnel)",
-                    placeholder="Titre à inclure dans l'image..."
+                
+                photo_style = gr.Dropdown(
+                    choices=list(PHOTO_STYLES.keys()),
+                    value="Leica",
+                    label="Style Photographique"
                 )
-
-            with gr.Group(elem_classes="controls-group"):
-                with gr.Row():
-                    quality = gr.Slider(
-                        minimum=30,
-                        maximum=50,
-                        value=40,
-                        label="Qualité Technique"
-                    )
-                    detail_level = gr.Slider(
-                        minimum=1,
-                        maximum=10,
-                        value=8,
-                        step=1,
-                        label="Niveau de Détail"
-                    )
-
+            
+            # Description du style sélectionné
+            style_info = gr.HTML()
+            
+            def update_style_info(style):
+                return f"<div class='style-info'>{PHOTO_STYLES[style]['description']}</div>"
+            
+            photo_style.change(update_style_info, inputs=[photo_style], outputs=[style_info])
+            
+            # Boutons
             with gr.Row():
-                generate_btn = gr.Button("✨ Générer", variant="primary")
-                clear_btn = gr.Button("🗑️ Effacer")
-
-            image_output = gr.Image(label="Résultat")
-            status = gr.Textbox(label="Status", interactive=False)
-
-        def generate(*args):
-            params = {
-                "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)
-
-        generate_btn.click(
-            generate,
-            inputs=[
-                format_size,
-                orientation,
-                style,
-                subject,
-                title,
-                quality,
-                detail_level
-            ],
-            outputs=[image_output, status]
-        )
-
-        clear_btn.click(
-            lambda: (None, "🗑️ Image effacée"),
-            outputs=[image_output, status]
-        )
-
+                generate_btn = gr.Button("🎨 Prévisualiser", variant="secondary")
+                confirm_btn = gr.Button("✨ Générer", variant="primary")
+            
+            # Sorties
+            preview = gr.Image(label="Prévisualisation", visible=False)
+            result = gr.Image(label="Résultat")
+            status = gr.Textbox(label="Status")
+            
+            # Logique de génération
+            def preview_params(prompt, orientation, style):
+                return f"""
+                    <div class='preview'>
+                        <h3>Paramètres de génération</h3>
+                        <ul>
+                            <li>Description : {prompt}</li>
+                            <li>Format : {orientation}</li>
+                            <li>Style : {style}</li>
+                        </ul>
+                        <p>Confirmez pour lancer la génération.</p>
+                    </div>
+                """
+            
+            generate_btn.click(
+                preview_params,
+                inputs=[prompt, orientation, photo_style],
+                outputs=[preview]
+            )
+            
+            confirm_btn.click(
+                generator.generate,
+                inputs={
+                    "prompt": prompt,
+                    "orientation": orientation,
+                    "photo_style": photo_style
+                },
+                outputs=[result, status]
+            )
+    
     return app
 
 if __name__ == "__main__":