Update app.py

app.py

@@ -1,212 +1,142 @@
 import gradio as gr
 import time
 import random
-from diffusers import StableDiffusionPipeline
-import torch
 from PIL import Image, ImageFilter, ImageStat
 import numpy as np
 
-# ========== AGENTES DEFINIDOS DIRECTAMENTE EN EL ARCHIVO ==========
+# ========== AGENTES SIMPLIFICADOS ==========
 
 class LightingAgent:
     def __init__(self):
-        print("✅ LightingAgent inicializado")
         self.lighting_styles = {
-            "cinematic": "dramatic lighting, cinematic style, film noir, high contrast, volumetric light",
-            "natural": "natural sunlight, soft light, golden hour, ambient light, realistic lighting",
-            "studio": "studio lighting, professional photo, softbox, beauty dish, even lighting", 
-            "moody": "moody lighting, low key, chiaroscuro, atmospheric, dramatic shadows"
+            "cinematic": "dramatic lighting, cinematic style, high contrast",
+            "natural": "natural sunlight, soft light, golden hour", 
+            "studio": "studio lighting, professional photo, softbox"
         }
     
     def optimize_lighting(self, base_prompt, lighting_style):
-        lighting_terms = self.lighting_styles.get(lighting_style, self.lighting_styles["natural"])
-        optimized_prompt = f"{base_prompt}, {lighting_terms}"
-        return optimized_prompt, lighting_style
+        lighting_terms = self.lighting_styles.get(lighting_style, "professional lighting")
+        return f"{base_prompt}, {lighting_terms}", lighting_style
 
 class TextureAgent:
     def __init__(self):
-        print("✅ TextureAgent inicializado")
-        self.texture_library = {
-            "skin": [
-                "detailed skin texture", "natural skin pores", "skin microdetails",
-                "subsurface scattering", "realistic skin", "skin imperfections"
-            ],
-            "hair": [
-                "individual hair strands", "hair texture", "realistic hair flow",
-                "hair details", "natural hair"
-            ]
-        }
+        self.texture_terms = ["detailed skin texture", "natural skin pores", "realistic skin"]
     
     def enhance_textures(self, prompt):
-        enhanced_prompt = prompt
-        skin_terms = random.sample(self.texture_library["skin"], 2)
-        enhanced_prompt += f", {', '.join(skin_terms)}"
-        
-        if "8k" not in enhanced_prompt.lower():
-            enhanced_prompt += ", detailed texture, high quality details"
-        
-        return enhanced_prompt
+        texture = random.choice(self.texture_terms)
+        return f"{prompt}, {texture}, high quality details"
 
 class CompositionAgent:
     def __init__(self):
-        print("✅ CompositionAgent inicializado")
         self.composition_rules = {
-            "portrait": [
-                "head and shoulders composition", "rule of thirds", "vertical portrait",
-                "close-up shot", "professional portrait composition"
-            ],
-            "full_body": [
-                "full body portrait", "vertical composition", "environmental portrait", 
-                "full figure", "standing pose vertical"
-            ]
+            "portrait": "vertical portrait, head and shoulders composition",
+            "full_body": "full body portrait, vertical composition"
         }
     
     def optimize_composition(self, prompt, composition_type="portrait"):
-        composition_terms = self.composition_rules.get(composition_type, self.composition_rules["portrait"])
-        selected_terms = composition_terms[:2]
-        optimized_prompt = f"{prompt}, {', '.join(selected_terms)}, vertical format 9:16"
-        return optimized_prompt, composition_type
+        composition = self.composition_rules.get(composition_type, "vertical portrait")
+        return f"{prompt}, {composition}, 9:16 format", composition_type
 
 class StyleTransferAgent:
     def __init__(self):
-        print("✅ StyleTransferAgent inicializado")
-        self.hyperreal_styles = {
-            "photorealistic": {
-                "terms": "photorealistic, 8k resolution, professional photography, highly detailed",
-                "description": "Máximo realismo fotográfico"
-            },
-            "cinematic": {
-                "terms": "cinematic, movie still, film photography, dramatic, cinematic style",
-                "description": "Estilo de película o cine"
-            }
+        self.styles = {
+            "photorealistic": "photorealistic, professional photography",
+            "cinematic": "cinematic, movie style, dramatic"
         }
     
     def apply_style(self, prompt, style_name="photorealistic"):
-        style_data = self.hyperreal_styles.get(style_name, self.hyperreal_styles["photorealistic"])
-        styled_prompt = f"{prompt}, {style_data['terms']}"
-        return styled_prompt, style_name, style_data["description"]
+        style = self.styles.get(style_name, "photorealistic")
+        return f"{prompt}, {style}", style_name, f"Estilo {style_name}"
 
 class QualityControlAgent:
-    def __init__(self):
-        print("✅ QualityControlAgent inicializado")
-    
     def analyze_image_quality(self, image):
-        if not isinstance(image, Image.Image):
-            return {"score": 0.5, "feedback": ["No se pudo analizar la imagen"]}
-        
         try:
-            metrics = {
-                "contrast": self._analyze_contrast(image),
-                "sharpness": self._analyze_sharpness(image),
-                "brightness": self._analyze_brightness(image)
-            }
+            if not isinstance(image, Image.Image):
+                return {"score": 0.5, "feedback": ["No se pudo analizar"]}
+            
+            # Métrica simple de contraste
+            stat = ImageStat.Stat(image)
+            if len(stat.stddev) == 3:
+                contrast = np.mean(stat.stddev) / 255.0
+            else:
+                contrast = 0.5
+                
+            score = min(contrast * 2, 1.0)  # Escalar a 0-1
             
-            overall_score = np.mean(list(metrics.values()))
+            feedback = ["Buena calidad"] if score > 0.6 else ["Calidad mejorable"]
             
             return {
-                "score": round(overall_score, 2),
-                "metrics": metrics,
-                "feedback": self._generate_feedback(metrics)
+                "score": round(score, 2),
+                "metrics": {"contrast": contrast},
+                "feedback": feedback
             }
-        except Exception as e:
+        except:
             return {"score": 0.5, "feedback": ["Error en análisis"]}
-    
-    def _analyze_contrast(self, image):
-        stat = ImageStat.Stat(image)
-        if len(stat.stddev) == 3:
-            return np.mean(stat.stddev) / 255.0
-        return 0.5
-    
-    def _analyze_sharpness(self, image):
-        small_img = image.resize((100, 100))
-        edges = small_img.filter(ImageFilter.FIND_EDGES)
-        stat = ImageStat.Stat(edges)
-        return min(np.mean(stat.stddev) / 255.0, 1.0)
-    
-    def _analyze_brightness(self, image):
-        stat = ImageStat.Stat(image)
-        if len(stat.mean) == 3:
-            brightness = np.mean(stat.mean) / 255.0
-            return 1.0 - abs(brightness - 0.5) * 2
-        return 0.5
-    
-    def _generate_feedback(self, metrics):
-        feedback = []
-        if metrics.get("contrast", 0) < 0.3:
-            feedback.append("Puedes mejorar el contraste")
-        if metrics.get("sharpness", 0) < 0.4:
-            feedback.append("La imagen está algo borrosa")
-        return feedback if feedback else ["¡Buena calidad de imagen!"]
 
 class EmotionAgent:
     def __init__(self):
-        self.emotion_profiles = {
-            "subtle_smile": "hint of smile, gentle eye crinkles, relaxed forehead, natural expression",
-            "contemplative": "distant gaze, soft frown, pensive expression, thoughtful look",
-            "joyful_laugh": "crow's feet, teeth slightly visible, raised cheeks, genuine smile",
-            "serious": "neutral expression, focused gaze, composed demeanor, professional"
+        self.emotions = {
+            "subtle_smile": "hint of smile, natural expression",
+            "serious": "neutral expression, focused gaze",
+            "joyful": "genuine smile, happy expression"
         }
-        print("✅ EmotionAgent inicializado")
     
     def add_emotion_cues(self, base_prompt, emotion):
-        emotion_cues = self.emotion_profiles.get(emotion, "natural expression")
+        emotion_cues = self.emotions.get(emotion, "natural expression")
         return f"{base_prompt}, {emotion_cues}"
     
     def get_available_emotions(self):
-        return list(self.emotion_profiles.keys())
+        return list(self.emotions.keys())
+
+# ========== GENERADOR DE IMÁGENES SIMPLIFICADO ==========
 
 class ImageGenerator:
     def __init__(self):
-        print("🔄 Cargando generador de imágenes...")
-        self.device = "cpu"
-        self.pipeline = None
-        self.model_id = "runwayml/stable-diffusion-v1-5"
-        self.load_model()
-    
-    def load_model(self):
-        try:
-            print("📥 Descargando modelo Stable Diffusion...")
-            
-            self.pipeline = StableDiffusionPipeline.from_pretrained(
-                self.model_id,
-                torch_dtype=torch.float32,
-                use_safetensors=True,
-                safety_checker=None,
-                requires_safety_checker=False,
-            )
-            
-            self.pipeline = self.pipeline.to(self.device)
-            self.pipeline.enable_attention_slicing()
-            
-            print("✅ Generador de imágenes cargado")
-        except Exception as e:
-            print(f"❌ Error cargando el generador: {e}")
-            raise e
+        self.model_loaded = False
+        print("🔄 Inicializando generador...")
     
     def generate_image(self, prompt, negative_prompt="", width=512, height=768):
-        print(f"🎨 Generando: {prompt[:80]}...")
-        start_time = time.time()
+        print(f"🎨 Generando: {prompt[:50]}...")
         
         try:
-            with torch.no_grad():
-                result = self.pipeline(
-                    prompt=prompt,
-                    negative_prompt=negative_prompt,
-                    width=width,
-                    height=height,
-                    num_inference_steps=20,
-                    guidance_scale=7.5,
-                    generator=torch.manual_seed(42)
+            # Intentar cargar diffusers solo cuando sea necesario
+            from diffusers import StableDiffusionPipeline
+            import torch
+            
+            if not self.model_loaded:
+                print("📥 Cargando modelo...")
+                self.pipeline = StableDiffusionPipeline.from_pretrained(
+                    "runwayml/stable-diffusion-v1-5",
+                    torch_dtype=torch.float32,
+                    safety_checker=None,
+                    requires_safety_checker=False,
                 )
+                self.pipeline = self.pipeline.to("cpu")
+                self.pipeline.enable_attention_slicing()
+                self.model_loaded = True
+            
+            # Generar imagen
+            result = self.pipeline(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                width=width,
+                height=height,
+                num_inference_steps=15,  # Menos pasos para más velocidad
+                guidance_scale=7.0,
+                generator=torch.manual_seed(42)
+            )
             
-            image = result.images[0]
-            generation_time = time.time() - start_time
-            print(f"✅ Imagen generada en {generation_time:.1f}s")
-            return image
+            return result.images[0]
             
         except Exception as e:
-            print(f"❌ Error generando imagen: {e}")
-            return Image.new('RGB', (width, height), color='gray')
+            print(f"❌ Error: {e}")
+            # Crear imagen de placeholder
+            return self.create_placeholder_image(width, height)
+    
+    def create_placeholder_image(self, width, height):
+        # Crear una imagen simple de placeholder
+        img = Image.new('RGB', (width, height), color=(73, 109, 137))
+        return img
 
 # ========== APLICACIÓN PRINCIPAL ==========
 
@@ -214,7 +144,6 @@ class HyperRealStudio916:
     def __init__(self):
         print("🚀 Iniciando HyperReal Studio 916...")
         
-        # Inicializar todos los agentes
         self.lighting_agent = LightingAgent()
         self.texture_agent = TextureAgent()
         self.composition_agent = CompositionAgent()
@@ -226,121 +155,84 @@ class HyperRealStudio916:
         print("✅ ¡Aplicación lista!")
 
     def generate_portrait(self, description, lighting_style, emotion, composition_type, enhance_texture, style_preset):
-        print(f"🎨 Iniciando generación...")
-        start_time = time.time()
+        print("🎨 Iniciando generación...")
         
-        # Negative prompt
-        negative_prompt = "cartoon, 3d, render, anime, fake, plastic, doll, deformed, blurry"
+        negative_prompt = "cartoon, 3d, render, anime, fake, deformed, blurry"
         
         # Aplicar agentes
         current_prompt = description
-        
-        # Agente de emociones
         current_prompt = self.emotion_agent.add_emotion_cues(current_prompt, emotion)
-        
-        # Agente de iluminación
         current_prompt, _ = self.lighting_agent.optimize_lighting(current_prompt, lighting_style)
-        
-        # Agente de composición
         current_prompt, _ = self.composition_agent.optimize_composition(current_prompt, composition_type)
-        
-        # Agente de estilo
         current_prompt, _, _ = self.style_agent.apply_style(current_prompt, style_preset)
         
-        # Agente de texturas
         if enhance_texture:
             current_prompt = self.texture_agent.enhance_textures(current_prompt)
         
         # Generar imagen
-        image = self.image_generator.generate_image(
-            prompt=current_prompt,
-            negative_prompt=negative_prompt,
-            width=512,
-            height=768
-        )
+        image = self.image_generator.generate_image(current_prompt, negative_prompt)
         
         # Analizar calidad
         quality_analysis = self.quality_agent.analyze_image_quality(image)
         
-        total_time = time.time() - start_time
-        print(f"✅ Proceso completado en {total_time:.1f}s")
+        print("✅ Proceso completado")
         
         return image, quality_analysis['score'], current_prompt, quality_analysis
 
 def create_interface():
     studio = HyperRealStudio916()
     
-    with gr.Blocks(theme=gr.themes.Soft(), title="HyperReal Studio 916") as demo:
-        gr.Markdown("""
-        # 🎨 HyperReal Studio 916
-        ### Generador de Retratos Hiperrealistas
-        """)
+    with gr.Blocks(title="HyperReal Studio 916") as demo:
+        gr.Markdown("# 🎨 HyperReal Studio 916")
+        gr.Markdown("Generador de retratos hiperrealistas")
         
         with gr.Row():
-            with gr.Column(scale=1):
+            with gr.Column():
                 description = gr.Textbox(
-                    label="📝 Descripción",
-                    placeholder="Ej: mujer joven con cabello castaño, sonriendo...",
-                    lines=3
+                    label="Descripción",
+                    placeholder="Describe la persona o escena...",
+                    lines=2
                 )
                 
                 lighting_style = gr.Dropdown(
-                    choices=["cinematic", "natural", "studio", "moody"],
-                    label="💡 Iluminación",
+                    choices=["cinematic", "natural", "studio"],
+                    label="Iluminación",
                     value="natural"
                 )
                 
                 emotion = gr.Dropdown(
                     choices=studio.emotion_agent.get_available_emotions(),
-                    label="😊 Emoción", 
+                    label="Emoción", 
                     value="subtle_smile"
                 )
                 
                 composition_type = gr.Dropdown(
                     choices=["portrait", "full_body"],
-                    label="📐 Composición",
+                    label="Composición",
                     value="portrait"
                 )
                 
                 style_preset = gr.Dropdown(
                     choices=["photorealistic", "cinematic"],
-                    label="🎨 Estilo", 
+                    label="Estilo", 
                     value="photorealistic"
                 )
                 
-                enhance_texture = gr.Checkbox(
-                    label="🔍 Mejorar Texturas",
-                    value=True
-                )
-                
-                generate_btn = gr.Button("🎨 Generar Retrato", variant="primary")
+                enhance_texture = gr.Checkbox(label="Mejorar texturas", value=True)
+                generate_btn = gr.Button("Generar Retrato", variant="primary")
             
-            with gr.Column(scale=2):
-                output_image = gr.Image(
-                    label="🖼️ Retrato Generado",
-                    format="png",
-                    height=400
-                )
-                
-                realism_score = gr.Number(
-                    label="📊 Calidad",
-                    precision=2
-                )
-                
-                used_prompt = gr.Textbox(
-                    label="📝 Prompt Utilizado",
-                    lines=2
-                )
+            with gr.Column():
+                output_image = gr.Image(label="Retrato Generado", height=400)
+                realism_score = gr.Number(label="Calidad", precision=2)
+                used_prompt = gr.Textbox(label="Prompt Utilizado", lines=2)
                 
-                with gr.Accordion("📈 Análisis", open=False):
-                    quality_analysis = gr.JSON(
-                        label="Métricas"
-                    )
+                with gr.Accordion("Análisis", open=False):
+                    quality_analysis = gr.JSON(label="Métricas")
         
         gr.Examples(
             examples=[
-                ["mujer joven con cabello largo, sonriendo", "natural", "subtle_smile", "portrait", "photorealistic"],
-                ["hombre maduro con barba, serio", "cinematic", "serious", "portrait", "cinematic"]
+                ["mujer joven sonriendo", "natural", "subtle_smile", "portrait", "photorealistic"],
+                ["hombre serio con barba", "cinematic", "serious", "portrait", "cinematic"]
             ],
             inputs=[description, lighting_style, emotion, composition_type, style_preset],
         )
@@ -355,4 +247,4 @@ def create_interface():
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    demo.launch()