Create app.py

app.py

@@ -0,0 +1,358 @@
+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 ==========
+
+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"
+        }
+    
+    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
+
+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"
+            ]
+        }
+    
+    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
+
+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"
+            ]
+        }
+    
+    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
+
+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"
+            }
+        }
+    
+    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"]
+
+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)
+            }
+            
+            overall_score = np.mean(list(metrics.values()))
+            
+            return {
+                "score": round(overall_score, 2),
+                "metrics": metrics,
+                "feedback": self._generate_feedback(metrics)
+            }
+        except Exception as e:
+            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"
+        }
+        print("✅ EmotionAgent inicializado")
+    
+    def add_emotion_cues(self, base_prompt, emotion):
+        emotion_cues = self.emotion_profiles.get(emotion, "natural expression")
+        return f"{base_prompt}, {emotion_cues}"
+    
+    def get_available_emotions(self):
+        return list(self.emotion_profiles.keys())
+
+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
+    
+    def generate_image(self, prompt, negative_prompt="", width=512, height=768):
+        print(f"🎨 Generando: {prompt[:80]}...")
+        start_time = time.time()
+        
+        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)
+                )
+            
+            image = result.images[0]
+            generation_time = time.time() - start_time
+            print(f"✅ Imagen generada en {generation_time:.1f}s")
+            return image
+            
+        except Exception as e:
+            print(f"❌ Error generando imagen: {e}")
+            return Image.new('RGB', (width, height), color='gray')
+
+# ========== APLICACIÓN PRINCIPAL ==========
+
+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()
+        self.style_agent = StyleTransferAgent()
+        self.quality_agent = QualityControlAgent()
+        self.emotion_agent = EmotionAgent()
+        self.image_generator = ImageGenerator()
+        
+        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()
+        
+        # Negative prompt
+        negative_prompt = "cartoon, 3d, render, anime, fake, plastic, doll, 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
+        )
+        
+        # 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")
+        
+        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.Row():
+            with gr.Column(scale=1):
+                description = gr.Textbox(
+                    label="📝 Descripción",
+                    placeholder="Ej: mujer joven con cabello castaño, sonriendo...",
+                    lines=3
+                )
+                
+                lighting_style = gr.Dropdown(
+                    choices=["cinematic", "natural", "studio", "moody"],
+                    label="💡 Iluminación",
+                    value="natural"
+                )
+                
+                emotion = gr.Dropdown(
+                    choices=studio.emotion_agent.get_available_emotions(),
+                    label="😊 Emoción", 
+                    value="subtle_smile"
+                )
+                
+                composition_type = gr.Dropdown(
+                    choices=["portrait", "full_body"],
+                    label="📐 Composición",
+                    value="portrait"
+                )
+                
+                style_preset = gr.Dropdown(
+                    choices=["photorealistic", "cinematic"],
+                    label="🎨 Estilo", 
+                    value="photorealistic"
+                )
+                
+                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.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"]
+            ],
+            inputs=[description, lighting_style, emotion, composition_type, style_preset],
+        )
+        
+        generate_btn.click(
+            fn=studio.generate_portrait,
+            inputs=[description, lighting_style, emotion, composition_type, enhance_texture, style_preset],
+            outputs=[output_image, realism_score, used_prompt, quality_analysis]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860)