Upload 4 files

app.py

@@ -2,48 +2,239 @@ import os
 import gradio as gr
 import numpy as np
 import torch
+import torch.nn.functional as F
 from pathlib import Path
 from huggingface_hub import hf_hub_download
 from PIL import Image
+import cv2
 
-# --- GESTIÓN DE ENTORNO (Hugging Face Spaces vs. Local) ---
+# --- GESTIÓN DE ENTORNO ---
 try:
     import spaces
 except ImportError:
-    # Si 'spaces' no existe, creamos un decorador falso que no hace nada.
-    # Esto permite que el código se ejecute localmente sin el decorador @spaces.GPU.
     class DummySpaces:
         def GPU(self, fn): return fn
     spaces = DummySpaces()
 
 # --- IMPORTACIONES DE MODELOS ---
-from transformers import AutoProcessor, AutoModelForZeroShotObjectDetection
+from transformers import (
+    Blip2Processor, 
+    Blip2ForConditionalGeneration,
+    BlipProcessor,
+    AutoProcessor,
+    AutoImageProcessor,
+    AutoModelForZeroShotObjectDetection,
+    CLIPModel,
+    CLIPProcessor,
+    SegformerImageProcessor,
+    SegformerForSemanticSegmentation,
+    AutoTokenizer,
+    CLIPSegProcessor,
+    BlipForConditionalGeneration,
+    CLIPSegForImageSegmentation,
+    Mask2FormerForUniversalSegmentation,
+)
 from sam2.build_sam import build_sam2
 from sam2.sam2_image_predictor import SAM2ImagePredictor
+from transformers import AutoModelForSeq2SeqLM
 
 # --- CONFIGURACIÓN DE MODELOS ---
-# SAM 2.1
 SAM2_REPO = "facebook/sam2.1-hiera-base-plus"
 CHECKPOINT_FILENAME = "sam2.1_hiera_base_plus.pt"
 SAM2_CONFIG = "configs/sam2.1/sam2.1_hiera_b+.yaml"
-
-# GroundingDINO
 GDINO_ID = "IDEA-Research/grounding-dino-base"
+SEGFORMER_ID = "nvidia/segformer-b2-finetuned-ade-512-512"
+CITYSCAPES_ID = "nvidia/segformer-b5-finetuned-cityscapes-1024-1024"
+ADE20K_ID       = "nvidia/segformer-b5-finetuned-ade-640-640"
+MASK2FORMER_ID  = "facebook/mask2former-swin-base-coco-panoptic"
+CLIP_ID = "openai/clip-vit-base-patch32"
+BLIP_ID = "Salesforce/blip-image-captioning-base" # Modelo BLIP para generación de texto
+CLIPSEG_ID = "CIDAS/clipseg-rd64-refined"
+
+EXTENDED_PALETTE = [
+    (255, 0, 0, 150), (0, 255, 0, 150), (0, 0, 255, 150), (255, 255, 0, 150),
+    (0, 255, 255, 150), (255, 0, 255, 150), (255, 165, 0, 150), (128, 0, 128, 150),
+    (0, 128, 0, 150), (0, 0, 128, 150), (128, 128, 0, 150), (128, 0, 128, 150),
+    (192, 192, 192, 150), (128, 128, 0, 150), (0, 128, 128, 150), (128, 0, 0, 150),
+    (0, 128, 0, 150), (0, 0, 128, 150), (255, 192, 203, 150), (255, 215, 0, 150)
+]
 
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Variables globales para Lazy Loading (ZeroGPU)
+# --- VARIABLES GLOBALES (Lazy Loading) ---
 sam2_predictor = None
 gdino_model = None
 gdino_processor = None
+clip_model = None
+clip_processor = None
+segformer_model = None
+segformer_processor = None
+clipseg_model = None
+clipseg_processor = None
+yolo_model = None
+segformer_city_model = None
+segformer_city_processor = None
+segformer_ade_model = None
+segformer_ade_processor = None
+mask2former_model = None
+mask2former_processor = None
+blip_processor = None
+blip_model = None
+blip2_model = None
+blip2_processor = None
+flan_tokenizer = None
+flan_model = None
+
+# Cityscapes 19 classes: 0=road 1=sidewalk 2=building 3=wall 4=fence 5=pole
+#   6=traffic light 7=traffic sign 8=vegetation 9=terrain 10=sky ...
+PHRASE_TO_CITYSCAPES = {
+    "exterior wall":  [2, 3],
+    "window":         [2],
+    "front door":     [2],
+    "roof":           [2],
+    "balcony":        [2],
+    "wall":           [3, 2],
+    "floor":          [0, 1, 9],
+    "door":           [2],
+    "wooden deck":    [1, 9],
+    "fence":          [4],
+    "pergola":        [2],
+    "awning":         [2],
+    "paving stone":   [0, 1],
+    "gravel":         [9],
+    "glass partition":[3],
+    "glass wall":     [3],
+    "glass door":     [2],
+    "column":         [5],
+    "pillar":         [5],
+    "display window": [2],
+    "storefront":     [2],
+    "concrete floor": [0, 1],
+    "garage door":    [2],
+    "rolling door":   [2],
+    "metal beam":     [5],
+    "structure":      [2, 5],
+    "facade":         [2, 3],
+    "building":       [2],
+    "signboard":      [2],
+    "billboard":      [2],
+    "cladding":       [2, 3],
+}
+
+# ADE20K 150 classes relevant for architecture (0-indexed)
+# 0=wall 3=floor 5=ceiling 8=window 10=cabinet 14=door 28=carpet 32=fence
+# 37=bathtub 42=column 45=counter 47=sink 53=stairs 65=toilet 70=countertop
+# 82=light 85=chandelier 145=shower
+PHRASE_TO_ADE20K = {
+    "wall":           [0],
+    "exterior wall":  [0],
+    "floor":          [3, 28],
+    "ceiling":        [5],
+    "window":         [8],
+    "cabinet":        [10],
+    "door":           [14],
+    "front door":     [14],
+    "glass door":     [14],
+    "carpet":         [28],
+    "fence":          [32],
+    "baseboard":      [0],
+    "molding":        [0],
+    "tile":           [0, 3],
+    "bathtub":        [37],
+    "column":         [42],
+    "pillar":         [42],
+    "counter":        [45, 70],
+    "countertop":     [70],
+    "sink":           [47],
+    "stairs":         [53],
+    "step":           [53],
+    "toilet":         [65],
+    "shower":         [145],
+    "ceiling light":  [82, 85],
+    "drop ceiling":   [5],
+    "glass partition":[0],
+    "glass wall":     [0],
+    "wooden deck":    [3],
+    "concrete floor": [3],
+    "paving stone":   [3],
+    "gravel":         [3],
+    "display window": [8, 55],
+    "storefront":     [8],
+    "pergola":        [1],
+    "awning":         [86],
+    "garage door":    [14],
+    "rolling door":   [14],
+    "metal beam":     [42],
+    "structure":      [42],
+    "facade":         [1, 0],
+    "building":       [1],
+    "signboard":      [43],
+    "billboard":      [43],
+    "cladding":       [0, 1],
+}
+
+# --- CATÁLOGO CONTEXTUAL ---
+CATALOGO_POR_ENTORNO = {
+    "🏙️ Fachada / Exterior": {
+        "🧱 Muros / Fachadas": "exterior wall. facade. building.",
+        "🪟 Ventanas": "window.",
+        "🚪 Puertas Principales": "front door.",
+        "🏠 Techos / Tejados": "roof.",
+        "🪵 Balcones / Terrazas": "balcony.",
+        "🪧 Estructuras / Letreros": "signboard. billboard. cladding."
+    },
+    "🛋️ Interiores (Sala / Cuartos)": {
+        "🧱 Paredes Interiores": "wall.",
+        "🪵 Pisos / Revestimientos": "floor.",
+        "🪟 Ventanas": "window.",
+        "قف Techos / Cielos Falsos": "ceiling.",
+        "🚪 Puertas / Marcos": "door.",
+        "➖ Zócalos / Molduras": "baseboard. molding."
+    },
+    "🛁 Baño / Cocina": {
+        "🧱 Azulejos / Paredes": "wall. tile.",
+        "🪵 Pisos": "floor.",
+        "🚰 Encimeras / Topes": "countertop.",
+        "🚽 Sanitarios / Duchas": "toilet. shower.",
+        "🗄️ Gabinetes fijos": "cabinet."
+    },
+    "🌳 Terraza / Patio / Jardín": {
+        "🪵 Pisos de Exterior (Deck)": "wooden deck. floor.",
+        "🧱 Muros / Cercas": "fence. exterior wall.",
+        "🪵 Pérgolas / Techos": "pergola. awning.",
+        "🪨 Caminos / Piedras": "paving stone. gravel.",
+        "💧 Piscinas / Fuentes": "pool."
+    },
+    "🏢 Oficinas / Corporativo": {
+        "🧱 Mamparas / Divisiones": "glass partition. glass wall.",
+        "🪵 Alfombras / Pisos Técnicos": "carpet. floor.",
+        "قف Techos Acústicos": "drop ceiling. ceiling.",
+        "🚪 Puertas de Cristal": "glass door.",
+        "🏛️ Columnas / Pilares": "column. pillar."
+    },
+    "🏪 Locales Comerciales / Restaurantes": {
+        "🧱 Muros de Exhibición": "wall.",
+        "🪵 Pisos Comerciales": "floor.",
+        "🪟 Vitrinas / Aparadores": "display window. storefront.",
+        "🧾 Barras / Mostradores fijos": "counter.",
+        "💡 Iluminación de Techo": "ceiling light."
+    },
+    "🏭 Garaje / Bodega / Industrial": {
+        "🪵 Suelos de Concreto / Epóxico": "concrete floor.",
+        "🧱 Muros Industriales": "wall.",
+        "🚪 Portones Corredizos": "garage door. rolling door.",
+        "🏗️ Vigas / Estructuras metálicas": "metal beam. structure."
+    }
+}
 
-COLOR_PALETTE = [
-    (0, 255, 255, 150),  # Cian (queda muy bien para resaltar)
-    (255, 0, 255, 150),  # Magenta
-    (255, 255, 0, 150),  # Amarillo
-    (0, 255, 0, 150),    # Verde
-    (255, 0, 0, 150),    # Rojo
-    (0, 0, 255, 150),    # Azul
+DESCRIPCIONES_CLIP = [
+    "a photo of the exterior of a building facade",
+    "a photo of the interior of a living room or bedroom",
+    "a photo of the interior of a bathroom or kitchen",
+    "a photo of an outdoor patio, terrace, wooden deck, or garden",
+    "a photo of the interior of an office or corporate workspace",
+    "a photo of the interior of a retail store, shop, or restaurant",
+    "a photo of the interior of a garage, warehouse, or industrial space"
 ]
 
 def download_sam_checkpoint() -> str:
@@ -51,143 +242,551 @@ def download_sam_checkpoint() -> str:
     cache_dir.mkdir(parents=True, exist_ok=True)
     local_path = cache_dir / CHECKPOINT_FILENAME
     if not local_path.exists():
-        print(f"Descargando {CHECKPOINT_FILENAME}...")
         local_path = Path(hf_hub_download(repo_id=SAM2_REPO, filename=CHECKPOINT_FILENAME, cache_dir=str(cache_dir)))
     return str(local_path)
 
-def create_mask_overlay(image: Image.Image, masks_np: np.ndarray) -> Image.Image:
-    """Superpone las máscaras booleanas (N, H, W) sobre la imagen."""
+def create_instance_overlay(image: Image.Image, masks_np: list, etiquetas: list, mapa_colores_rgb: dict) -> Image.Image:
     overlay_image = image.convert("RGBA").copy()
     
-    for i, mask_bool in enumerate(masks_np):
-        color = COLOR_PALETTE[i % len(COLOR_PALETTE)]
+    for mask_bool, etiqueta in zip(masks_np, etiquetas):
+        # Toma el color asignado a la categoría desde el mapa
+        color = mapa_colores_rgb[etiqueta]
         mask_image = Image.fromarray((mask_bool * 255).astype(np.uint8), mode="L")
         color_overlay = Image.new("RGBA", overlay_image.size, color)
         overlay_image.paste(color_overlay, (0, 0), mask_image)
-
+        
     return overlay_image
 
+def draw_dino_detections(image: Image.Image, boxes: list, labels: list, scores: list) -> Image.Image:
+    """Dibuja todos los bounding boxes de DINO, coloreados por confianza."""
+    from PIL import ImageDraw, ImageFont
+    
+    img_copy = image.convert("RGB").copy()
+    draw = ImageDraw.Draw(img_copy)
+    
+    for box, label, score in zip(boxes, labels, scores):
+        # Color basado en la confianza
+        if score > 0.6: color = "lime"      # Verde para alta confianza
+        elif score > 0.3: color = "yellow"  # Amarillo para media
+        else: color = "red"                 # Rojo para baja
+        
+        draw.rectangle(box.tolist(), outline=color, width=2)
+        text = f"{label}: {score:.2f}"
+        draw.text((box[0], box[1] - 10), text, fill=color)
+        
+    return img_copy
+
+def limpiar_mascara(mask: np.ndarray, area_minima: int = 2000) -> np.ndarray:
+    """
+    Elimina salpicaduras usando Operaciones Morfológicas y filtrado de componentes conectados avanzado.
+    """
+    mask_uint8 = (mask * 255).astype(np.uint8)
+    
+    # 1. Operaciones Morfológicas
+    # Kernel de 7x7 (bastante fuerte para comerse las salpicaduras finas)
+    kernel = np.ones((7, 7), np.uint8)
+    
+    # Opening: Erosión + Dilatación (borra ruido fino y salpicaduras externas)
+    mask_limpia = cv2.morphologyEx(mask_uint8, cv2.MORPH_OPEN, kernel)
+    
+    # Closing: Dilatación + Erosión (rellena pequeños huecos internos)
+    mask_limpia = cv2.morphologyEx(mask_limpia, cv2.MORPH_CLOSE, kernel)
+    
+    # 2. Filtrado por Componentes Conectados
+    num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask_limpia, connectivity=8)
+    mask_final = np.zeros_like(mask_limpia)
+    
+    if num_labels > 1:
+        # Obtener el área del componente más grande (ignorando el fondo que es index 0)
+        areas = stats[1:, cv2.CC_STAT_AREA]
+        max_area = np.max(areas)
+        
+        for i in range(1, num_labels):
+            area_del_fragmento = stats[i, cv2.CC_STAT_AREA]
+            
+            # Conservar el fragmento SOLO si supera el área mínima absoluta 
+            # Y si su tamaño es al menos el 5% del fragmento más grande de esta máscara.
+            if area_del_fragmento >= area_minima and area_del_fragmento >= (max_area * 0.05):
+                mask_final[labels == i] = 1
+                
+    return mask_final.astype(bool)
+
 @spaces.GPU
 @torch.no_grad()
-def segmentar_con_dino_y_sam(imagen: Image.Image, texto: str, box_threshold: float):
-    global sam2_predictor, gdino_model, gdino_processor
+def autodetectar_entorno(imagen: Image.Image):
+    global clip_model, clip_processor
+    if imagen is None:
+        claves = list(CATALOGO_POR_ENTORNO.keys())
+        return gr.update(value=claves[0]), gr.update(choices=list(CATALOGO_POR_ENTORNO[claves[0]].keys()))
+
+    if clip_model is None:
+        clip_processor = CLIPProcessor.from_pretrained(CLIP_ID)
+        clip_model = CLIPModel.from_pretrained(CLIP_ID).to(DEVICE)
+
+    imagen = imagen.convert("RGB")
+    inputs = clip_processor(text=DESCRIPCIONES_CLIP, images=imagen, return_tensors="pt", padding=True).to(DEVICE)
+    outputs = clip_model(**inputs)
+    probabilidades = outputs.logits_per_image.softmax(dim=1).cpu().numpy()[0]
+    indice_ganador = probabilidades.argmax()
+    
+    claves_entorno = list(CATALOGO_POR_ENTORNO.keys())
+    entorno_detectado = claves_entorno[indice_ganador]
+    nuevas_opciones = list(CATALOGO_POR_ENTORNO[entorno_detectado].keys())
+    
+    return gr.update(value=entorno_detectado), gr.update(choices=nuevas_opciones, value=nuevas_opciones[:2])
+
+@spaces.GPU
+@torch.no_grad()
+def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umbral_sensibilidad: float, motor: str, usar_limpieza: bool, prompt_personalizado: str):
+    print(f"\n--- Iniciando análisis con motor: {motor} ---") #
+    global sam2_predictor, gdino_model, gdino_processor, segformer_city_model, segformer_city_processor, segformer_ade_model, segformer_ade_processor, blip_processor, blip_model
+    global sam2_predictor, gdino_model, gdino_processor, segformer_city_model, segformer_city_processor, segformer_ade_model, segformer_ade_processor, blip_processor, blip_model, blip2_model, blip2_processor, flan_tokenizer, flan_model
+
+    if imagen is None or (len(seleccion) == 0 and not prompt_personalizado.strip() and motor not in ["Automático (BLIP + DINO + SAM 2.1)", "Agente IA Autónomo (BLIP-2 + FLAN-T5 + DINO + SAM 2.1)"]):
+        return None, "Sube una imagen y selecciona al menos un elemento (excepto para el modo automático).", None
+
+    if prompt_personalizado and prompt_personalizado.strip():
+        print(f"Usando prompt manual: '{prompt_personalizado}'")
+        texto_para_ia = prompt_personalizado.strip()
+        # Para DINO, las frases separadas por comas se convierten en 'terminos_crudos'
+        terminos_crudos = [p.strip() for p in texto_para_ia.split(',')]
+    else:
+        # Comportamiento original si la caja de texto está vacía
+        terminos_crudos = [CATALOGO_POR_ENTORNO[entorno][item] for item in seleccion]
+        texto_para_ia = " ".join(terminos_crudos)
     
-    if imagen is None or not texto.strip():
-        return None, "Sube una imagen y escribe qué quieres buscar."
-
-    # 1. LAZY LOADING: Inicializar modelos en la GPU la primera vez
-    if sam2_predictor is None:
-        print(f"Inicializando modelos en dispositivo: {DEVICE.upper()}...")
-        if DEVICE == "cuda":
-            torch.autocast("cuda", dtype=torch.bfloat16).__enter__()
-            if torch.cuda.get_device_properties(0).major >= 8:
-                torch.backends.cuda.matmul.allow_tf32 = True
-                torch.backends.cudnn.allow_tf32 = True
+    palabras_clave = []
+    for term in terminos_crudos:
+        palabras_clave.extend([t.strip() for t in term.replace(".", " ").split() if t.strip()])
+    print(f"Palabras clave/términos crudos para DINO: {terminos_crudos}") #
+        
+    imagen_rgb = imagen.convert("RGB")
+    imagen_np = np.array(imagen_rgb)
+    total_pixels = imagen.width * imagen.height
+    masks_finales = []
+    etiquetas_finales = []
+    debug_image = None # Inicializar la imagen de debug
+
+    # ==========================================================
+    # MOTOR: SEGFORMER CITYSCAPES + SAM 2.1 (Exteriores)
+    # ==========================================================
+    if motor == "SegFormer Cityscapes + SAM 2.1 (Exteriores)":
+        if segformer_city_model is None:
+            print("Cargando SegFormer-B5 Cityscapes...")
+            segformer_city_processor = SegformerImageProcessor.from_pretrained(CITYSCAPES_ID)
+            segformer_city_model = SegformerForSemanticSegmentation.from_pretrained(CITYSCAPES_ID).to(DEVICE)
+
+        if sam2_predictor is None:
+            checkpoint_path = download_sam_checkpoint()
+            sam2_model = build_sam2(SAM2_CONFIG, checkpoint_path, device=DEVICE)
+            sam2_predictor = SAM2ImagePredictor(sam2_model)
+
+        print("Preparando entradas para SegFormer Cityscapes...")
+        inputs = segformer_city_processor(images=imagen_rgb, return_tensors="pt").to(DEVICE) #
+        print("Realizando inferencia con SegFormer Cityscapes...")
+        outputs = segformer_city_model(**inputs)
+        print("Procesando logits y aplicando umbral de confianza...") #
+        logits = F.interpolate(outputs.logits, size=imagen_rgb.size[::-1], mode="bilinear", align_corners=False)
+        probs = F.softmax(logits, dim=1)[0] # HxW
+
+        # Map selected elements → Cityscapes class IDs (deduplicated)
+        cls_a_etiqueta = {}
+        for term in terminos_crudos:
+            for frase in [f.strip() for f in term.split(".") if f.strip()]:
+                for cls_id in PHRASE_TO_CITYSCAPES.get(frase, []):
+                    if cls_id not in cls_a_etiqueta:
+                        cls_a_etiqueta[cls_id] = segformer_city_model.config.id2label[cls_id]
+        print(f"Clases de Cityscapes a buscar: {list(cls_a_etiqueta.values())}") #
+
+        # Get one bounding box per matched class → SAM2 refines it
+        cajas, etiquetas_cajas = [], []
+        UMBRAL_CONFIANZA_SEGFORMER = 0.65 # Definir umbral de confianza para SegFormer
+        for cls_id, etiqueta in cls_a_etiqueta.items():
+            # 1. Crear y limpiar la máscara de probabilidad para la clase actual
+            mask_inicial = (probs[cls_id] > UMBRAL_CONFIANZA_SEGFORMER).cpu().numpy()
+            mask_limpia = limpiar_mascara(mask_inicial, area_minima=1000)
+            if not np.any(mask_limpia):
+                continue
+
+            # 2. Encontrar componentes conectados (objetos separados) en la máscara limpia
+            mask_uint8 = (mask_limpia * 255).astype(np.uint8)
+            num_labels, _, stats, _ = cv2.connectedComponentsWithStats(mask_uint8, connectivity=8)
+
+            # 3. Generar una caja para cada componente suficientemente grande
+            for i in range(1, num_labels): # Ignorar el fondo (label 0)
+                area = stats[i, cv2.CC_STAT_AREA]
+                if area > 1500: # Umbral para considerar un objeto como válido
+                    x, y, w, h = stats[i, cv2.CC_STAT_LEFT], stats[i, cv2.CC_STAT_TOP], stats[i, cv2.CC_STAT_WIDTH], stats[i, cv2.CC_STAT_HEIGHT]
+                    cajas.append([x, y, x + w, y + h])
+                    etiquetas_cajas.append(etiqueta)
+
+        if cajas:
+            sam2_predictor.set_image(imagen_np)
+            print(f"Enviando {len(cajas)} cajas a SAM 2.1 para refinamiento...") #
+            masks, _, _ = sam2_predictor.predict(box=np.array(cajas, dtype=float), multimask_output=False)
+            if masks.ndim == 4:
+                masks = masks.squeeze(1)
+            masks_finales = [masks[i] for i in range(masks.shape[0])]
+            etiquetas_finales = etiquetas_cajas
+            print(f"SAM 2.1 generó {len(masks_finales)} máscaras.") #
+
+    # ==========================================================
+    # MOTOR: SEGFORMER ADE20K + SAM 2.1 (Interiores)
+    # ==========================================================
+    elif motor == "SegFormer ADE20K + SAM 2.1 (Interiores)":
+        print("Cargando SegFormer-B5 ADE20K...")
+        if segformer_ade_model is None:
+            print("Cargando SegFormer-B5 ADE20K...")
+            segformer_ade_processor = SegformerImageProcessor.from_pretrained(ADE20K_ID)
+            segformer_ade_model = SegformerForSemanticSegmentation.from_pretrained(ADE20K_ID).to(DEVICE)
+
+        if sam2_predictor is None:
+            checkpoint_path = download_sam_checkpoint()
+            sam2_model = build_sam2(SAM2_CONFIG, checkpoint_path, device=DEVICE)
+            sam2_predictor = SAM2ImagePredictor(sam2_model)
+
+        print("Preparando entradas para SegFormer ADE20K...")
+        inputs = segformer_ade_processor(images=imagen_rgb, return_tensors="pt").to(DEVICE) #
+        print("Realizando inferencia con SegFormer ADE20K...")
+        outputs = segformer_ade_model(**inputs)
+        print("Procesando logits y aplicando umbral de confianza...") #
+        logits = F.interpolate(outputs.logits, size=imagen_rgb.size[::-1], mode="bilinear", align_corners=False)
+        probs = F.softmax(logits, dim=1)[0]
+
+        cls_a_etiqueta = {}
+        for term in terminos_crudos:
+            for frase in [f.strip() for f in term.split(".") if f.strip()]:
+                for cls_id in PHRASE_TO_ADE20K.get(frase, []):
+                    if cls_id not in cls_a_etiqueta:
+                        cls_a_etiqueta[cls_id] = segformer_ade_model.config.id2label[cls_id]
+        print(f"Clases de ADE20K a buscar: {list(cls_a_etiqueta.values())}") #
+
+        cajas, etiquetas_cajas = [], []
+        UMBRAL_CONFIANZA_SEGFORMER = 0.65 # Definir umbral de confianza para SegFormer
+        for cls_id, etiqueta in cls_a_etiqueta.items():
+            # 1. Crear y limpiar la máscara de probabilidad para la clase actual
+            mask_inicial = (probs[cls_id] > UMBRAL_CONFIANZA_SEGFORMER).cpu().numpy()
+            mask_limpia = limpiar_mascara(mask_inicial, area_minima=1000)
+            if not np.any(mask_limpia):
+                continue
+
+            # 2. Encontrar componentes conectados (objetos separados) en la máscara limpia
+            mask_uint8 = (mask_limpia * 255).astype(np.uint8)
+            num_labels, _, stats, _ = cv2.connectedComponentsWithStats(mask_uint8, connectivity=8)
+
+            # 3. Generar una caja para cada componente suficientemente grande
+            for i in range(1, num_labels): # Ignorar el fondo (label 0)
+                area = stats[i, cv2.CC_STAT_AREA]
+                if area > 1500: # Umbral para considerar un objeto como válido
+                    x, y, w, h = stats[i, cv2.CC_STAT_LEFT], stats[i, cv2.CC_STAT_TOP], stats[i, cv2.CC_STAT_WIDTH], stats[i, cv2.CC_STAT_HEIGHT]
+                    cajas.append([x, y, x + w, y + h])
+                    etiquetas_cajas.append(etiqueta)
+        if cajas:
+            sam2_predictor.set_image(imagen_np)
+            print(f"Enviando {len(cajas)} cajas a SAM 2.1 para refinamiento...") #
+            masks, _, _ = sam2_predictor.predict(box=np.array(cajas, dtype=float), multimask_output=False)
+            if masks.ndim == 4:
+                masks = masks.squeeze(1)
+            masks_finales = [masks[i] for i in range(masks.shape[0])]
+            etiquetas_finales = etiquetas_cajas
+            print(f"SAM 2.1 generó {len(masks_finales)} máscaras.") #
+
+    # ==========================================================
+    # MOTOR: DINO + SAM 2.1 (Objetos Contables)
+    # ==========================================================
+    elif motor == "DINO + SAM 2.1 (Objetos Contables)":
+        if sam2_predictor is None or gdino_model is None:
+            checkpoint_path = download_sam_checkpoint()
+            sam2_model = build_sam2(SAM2_CONFIG, checkpoint_path, device=DEVICE)
+            sam2_predictor = SAM2ImagePredictor(sam2_model)
+            gdino_processor = AutoProcessor.from_pretrained(GDINO_ID)
+            gdino_model = AutoModelForZeroShotObjectDetection.from_pretrained(GDINO_ID).to(DEVICE)
+
+        print(f"Preparando entradas para DINO con texto: '{texto_para_ia}'...") #
+        inputs = gdino_processor(images=imagen_rgb, text=texto_para_ia, return_tensors="pt").to(DEVICE)
+        print("Realizando inferencia con DINO...")
+        outputs = gdino_model(**inputs)
+        print("Procesando resultados de DINO y filtrando por umbral de sensibilidad...") #
+        results = gdino_processor.post_process_grounded_object_detection(outputs, inputs.input_ids, target_sizes=[imagen_rgb.size[::-1]])[0]
+
+        # --- DIBUJAR RAZONAMIENTO DE DINO ---
+        # Dibuja TODOS los cuadros detectados, antes de filtrar, para depuración.
+        debug_image = draw_dino_detections(imagen_rgb, results["boxes"], results["labels"], results["scores"])
+
+        boxes_filt, labels_filt = [], []
+        for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+            if score > umbral_sensibilidad:
+                boxes_filt.append(box)
+                labels_filt.append(label)
+        print(f"DINO detectó {len(boxes_filt)} objetos con confianza > {umbral_sensibilidad}.") #
+        
+        if boxes_filt:
+            sam2_predictor.set_image(imagen_np)
+            print(f"Enviando {len(boxes_filt)} cajas a SAM 2.1 para refinamiento...") #
+            masks, _, _ = sam2_predictor.predict(box=torch.stack(boxes_filt).cpu().numpy(), multimask_output=False)
+            if masks.ndim == 4: masks = masks.squeeze(1)
+            masks_finales = [masks[i] for i in range(masks.shape[0])]
+            etiquetas_finales = labels_filt
+            print(f"SAM 2.1 generó {len(masks_finales)} máscaras.") #
+
+    # ==========================================================
+    # MOTOR: AUTOMÁTICO (BLIP + DINO + SAM 2.1)
+    # ==========================================================
+    elif motor == "Automático (BLIP + DINO + SAM 2.1)":
+        if blip_model is None:
+            print("Cargando BLIP para generación de texto...")
+            blip_processor = BlipProcessor.from_pretrained(BLIP_ID)
+            blip_model = BlipForConditionalGeneration.from_pretrained(BLIP_ID).to(DEVICE)
+
+        if sam2_predictor is None or gdino_model is None:
+            checkpoint_path = download_sam_checkpoint()
+            sam2_model = build_sam2(SAM2_CONFIG, checkpoint_path, device=DEVICE)
+            sam2_predictor = SAM2ImagePredictor(sam2_model)
+            gdino_processor = AutoProcessor.from_pretrained(GDINO_ID)
+            gdino_model = AutoModelForZeroShotObjectDetection.from_pretrained(GDINO_ID).to(DEVICE)
+
+        print("Generando descripción de la imagen con BLIP...")
+        # BLIP requiere la imagen en formato PIL
+        inputs_blip = blip_processor(images=imagen_rgb, return_tensors="pt").to(DEVICE)
+        out_blip = blip_model.generate(**inputs_blip)
+        texto_generado = blip_processor.decode(out_blip[0], skip_special_tokens=True)
+        print(f"BLIP generó el prompt: '{texto_generado}'")
+
+        # Usar el texto generado por BLIP como prompt para DINO
+        texto_para_ia = texto_generado
+        
+        print(f"Preparando entradas para DINO con texto: '{texto_para_ia}'...")
+        inputs = gdino_processor(images=imagen_rgb, text=texto_para_ia, return_tensors="pt").to(DEVICE)
+        print("Realizando inferencia con DINO...")
+        outputs = gdino_model(**inputs)
+        print("Procesando resultados de DINO y filtrando por umbral de sensibilidad...")
+        results = gdino_processor.post_process_grounded_object_detection(outputs, inputs.input_ids, target_sizes=[imagen_rgb.size[::-1]])[0]
+
+        # --- DIBUJAR RAZONAMIENTO DE DINO ---
+        # Dibuja TODOS los cuadros detectados, antes de filtrar, para depuración.
+        debug_image = draw_dino_detections(imagen_rgb, results["boxes"], results["labels"], results["scores"])
+
+        boxes_filt, labels_filt = [], []
+        for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+            if score > umbral_sensibilidad:
+                boxes_filt.append(box)
+                labels_filt.append(label)
+        print(f"DINO detectó {len(boxes_filt)} objetos con confianza > {umbral_sensibilidad}.") #
+        
+        if boxes_filt:
+            sam2_predictor.set_image(imagen_np)
+            print(f"Enviando {len(boxes_filt)} cajas a SAM 2.1 para refinamiento...") #
+            masks, _, _ = sam2_predictor.predict(box=torch.stack(boxes_filt).cpu().numpy(), multimask_output=False)
+            if masks.ndim == 4: masks = masks.squeeze(1)
+            masks_finales = [masks[i] for i in range(masks.shape[0])]
+            etiquetas_finales = labels_filt
+            print(f"SAM 2.1 generó {len(masks_finales)} máscaras.") #
+
+    # ==========================================================
+    # MOTOR: AGENTE IA AUTÓNOMO (BLIP-2 + FLAN-T5 + DINO + SAM 2.1)
+    # ==========================================================
+    elif motor == "Agente IA Autónomo (BLIP-2 + FLAN-T5 + DINO + SAM 2.1)":
+        # 1. Cargar modelos si no están en memoria
+        if blip2_model is None:
+            print("Cargando BLIP-2 (Ojos)...")
+            blip2_processor = Blip2Processor.from_pretrained("Salesforce/blip2-opt-2.7b")
+            blip2_model = Blip2ForConditionalGeneration.from_pretrained("Salesforce/blip2-opt-2.7b").to(DEVICE)
             
-        # Cargar SAM 2.1 en modo Predictor (para cajas), no AutomaticMaskGenerator
-        checkpoint_path = download_sam_checkpoint()
-        sam2_model = build_sam2(SAM2_CONFIG, checkpoint_path, device=DEVICE)
-        sam2_predictor = SAM2ImagePredictor(sam2_model)
+        if flan_model is None:
+            print("Cargando FLAN-T5 (Cerebro)...")
+            flan_tokenizer = AutoTokenizer.from_pretrained("google/flan-t5-base")
+            flan_model = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-base").to(DEVICE)
+
+        if sam2_predictor is None or gdino_model is None:
+            print("Cargando DINO y SAM 2.1 (Manos)...")
+            checkpoint_path = download_sam_checkpoint()
+            sam2_model = build_sam2(SAM2_CONFIG, checkpoint_path, device=DEVICE)
+            sam2_predictor = SAM2ImagePredictor(sam2_model)
+            gdino_processor = AutoProcessor.from_pretrained(GDINO_ID)
+            gdino_model = AutoModelForZeroShotObjectDetection.from_pretrained(GDINO_ID).to(DEVICE)
+
+        # PASO A: BLIP-2 describe la imagen
+        inputs_blip = blip2_processor(imagen_rgb, return_tensors="pt").to(DEVICE)
+        out_blip = blip2_model.generate(**inputs_blip, max_new_tokens=50)
+        descripcion_cruda = blip2_processor.decode(out_blip[0], skip_special_tokens=True)
+        print(f"[BLIP-2] Vio: {descripcion_cruda}")
+
+        # PASO B: FLAN-T5 extrae y formatea para DINO (Pide separación por puntos)
+        instruccion = f"Extract only the architectural components and objects from this description. Output them as a list separated by periods (.). Description: {descripcion_cruda}"
+        inputs_flan = flan_tokenizer(instruccion, return_tensors="pt").to(DEVICE)
+        out_flan = flan_model.generate(**inputs_flan, max_length=50)
+        texto_para_ia_agente = flan_tokenizer.decode(out_flan[0], skip_special_tokens=True)
         
-        # Cargar GroundingDINO
-        gdino_processor = AutoProcessor.from_pretrained(GDINO_ID)
-        gdino_model = AutoModelForZeroShotObjectDetection.from_pretrained(GDINO_ID).to(DEVICE)
-        print("¡Modelos listos!")
+        # Aseguramos que termine en punto para DINO
+        if not texto_para_ia_agente.endswith("."): texto_para_ia_agente += " ."
+        print(f"[FLAN-T5] Tradujo para DINO: {texto_para_ia_agente}")
 
-    # Asegurarnos de que el texto termine en punto (GroundingDINO funciona mejor así)
-    texto = texto.strip()
-    if not texto.endswith("."):
-        texto += "."
+        # PASO C: Grounding DINO busca los objetos
+        inputs_dino = gdino_processor(images=imagen_rgb, text=texto_para_ia_agente, return_tensors="pt").to(DEVICE)
+        outputs_dino = gdino_model(**inputs_dino)
+        results = gdino_processor.post_process_grounded_object_detection(outputs_dino, inputs_dino.input_ids, target_sizes=[imagen_rgb.size[::-1]])[0]
 
-    imagen = imagen.convert("RGB")
-    imagen_np = np.array(imagen)
+        boxes_filt, labels_filt = [], []
+        for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+            # Para el Agente Autónomo, ignoramos el slider y usamos un umbral muy bajo
+            # para capturar todo lo posible. Dejamos que el filtro de limpieza se encargue
+            # de eliminar el ruido después.
+            if score > 0.1:
+                boxes_filt.append(box)
+                labels_filt.append(label)
+        
+        # PASO D: SAM 2.1 recorta
+        if boxes_filt:
+            sam2_predictor.set_image(imagen_np)
+            masks, _, _ = sam2_predictor.predict(box=torch.stack(boxes_filt).cpu().numpy(), multimask_output=False)
+            if masks.ndim == 4: masks = masks.squeeze(1)
+            masks_finales = [masks[i] for i in range(masks.shape[0])]
+            etiquetas_finales = labels_filt
 
-    # 2. GROUNDING DINO: Encontrar las cajas delimitadoras
-    inputs = gdino_processor(images=imagen, text=texto, return_tensors="pt").to(DEVICE)
-    outputs = gdino_model(**inputs)
-    
-    # Extraer las cajas con un umbral de confianza
-    # Modificación para compatibilidad: filtramos manualmente en lugar de pasar el umbral a la función.
-    results = gdino_processor.post_process_grounded_object_detection(outputs, inputs.input_ids, target_sizes=[imagen.size[::-1]])[0]
-
-    # Filtrar los resultados basados en el umbral de la caja (box_threshold)
-    boxes_filt = []
-    scores_filt = []
-    labels_filt = []
-    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-        if score > box_threshold:
-            boxes_filt.append(box)
-            scores_filt.append(score)
-            labels_filt.append(label)
+    # ==========================================================
+    # FILTRO ANTI-SALPICADURAS (RUIDO)
+    # ==========================================================
+    if usar_limpieza:
+        print(f"Aplicando filtro anti-ruido (limpieza morfológica). Máscaras iniciales: {len(masks_finales)}")
+        masks_limpias = []
+        etiquetas_limpias = []
+        
+        # Puedes ajustar este número. 1500 píxeles suele ser un buen tamaño
+        # para ignorar manchas pequeñas en imágenes de alta resolución.
+        UMBRAL_AREA_MINIMA = 1500 
+        
+        for mask, etiqueta in zip(masks_finales, etiquetas_finales):
+            mask_sin_ruido = limpiar_mascara(mask, area_minima=UMBRAL_AREA_MINIMA)
+            
+            # Validar si después de limpiar la máscara, aún queda suficiente área válida.
+            # Si la máscara entera era pura salpicadura, np.sum() será muy bajo y la descartamos.
+            if np.sum(mask_sin_ruido) > 2000: 
+                masks_limpias.append(mask_sin_ruido)
+                etiquetas_limpias.append(etiqueta)
+                
+        # Sobrescribimos las listas originales con las versiones limpias
+        masks_finales = masks_limpias
+        print(f"Máscaras después de la limpieza: {len(masks_finales)}") #
+        etiquetas_finales = etiquetas_limpias
+
+    # --- RESULTADOS Y REPORTE ---
+    if not masks_finales:
+        return imagen_rgb, f"No se encontró nada válido o las detecciones tenían demasiado ruido con {motor}.", debug_image
+
+    # 1. Identificar las categorías únicas ordenadas
+    print("Generando reporte final...") #
+    categorias_unicas = sorted(list(set(etiquetas_finales)))
     
-    # Convertir las listas filtradas de nuevo a tensores
-    cajas = torch.stack(boxes_filt) if boxes_filt else torch.empty((0, 4))
-    scores = torch.stack(scores_filt) if scores_filt else torch.empty((0,))
-    etiquetas = labels_filt
-
-    if len(cajas) == 0:
-        return imagen, f"No se encontró nada para '{texto}' con el umbral actual ({box_threshold}). Intenta bajarlo."
-    # 3. SAM 2.1: Segmentar dentro de las cajas encontradas
-    sam2_predictor.set_image(imagen_np)
+    # 2. Asignar un color único a cada categoría
+    mapa_colores_rgb = {}
+    label_color_map = {} # Para el código HEX del HTML
     
-    # SAM 2.1 requiere que las cajas sean un array numpy
-    input_boxes = cajas.cpu().numpy()
+    for i, cat in enumerate(categorias_unicas):
+        # Asignamos el color desde la paleta basándonos en el índice de la categoría
+        color_completo = EXTENDED_PALETTE[i % len(EXTENDED_PALETTE)]
+        mapa_colores_rgb[cat] = color_completo
+        
+        color_rgb = color_completo[:3] # Obtener solo RGB para el HEX
+        hex_color = '#%02x%02x%02x' % color_rgb
+        label_color_map[cat] = hex_color
+
+    # 3. Generar la imagen con las etiquetas y el mapa de colores
+    resultado_img = create_instance_overlay(imagen_rgb, masks_finales, etiquetas_finales, mapa_colores_rgb)
     
-    masks, _, _ = sam2_predictor.predict(
-        point_coords=None,
-        point_labels=None,
-        box=input_boxes,
-        multimask_output=False, # Queremos 1 máscara final por caja
-    )
+    # 4. Generar el reporte
+    reporte_lineas = []
+    for l in categorias_unicas:
+        area_percentage = (sum(np.sum(masks_finales[i]) for i,x in enumerate(etiquetas_finales) if x==l)/total_pixels)*100
+        reporte_lineas.append(f"• {etiquetas_finales.count(l)}x {l} ({area_percentage:.1f}% área) <span style='color:{label_color_map[l]};'>■</span>")
     
-    # Las máscaras de SAM tienen forma (N, 1, H, W). Las aplanamos a (N, H, W)
-    # Solo hacemos squeeze si hay máscaras, para evitar errores con tensores vacíos.
-    if masks.ndim == 4 and masks.shape[1] == 1:
-        masks = masks.squeeze(1)
-    # 4. SUPERPONER MÁSCARAS
-    resultado_img = create_mask_overlay(imagen, masks)
+    print("--- Análisis completado ---") #
+    return resultado_img, f"📊 REPORTE ({motor}):<br>" + "<br>".join(reporte_lineas), debug_image
 
-    # Preparar el mensaje de estado
-    objetos_encontrados = [f"{label} ({score:.2f})" for label, score in zip(etiquetas, scores)]
-    mensaje = f"Encontrados {len(cajas)} objeto(s): {', '.join(objetos_encontrados)}"
+ELEMENTOS_CITYSCAPES_COMPATIBLES = {
+    "🏙️ Fachada / Exterior":               ["🧱 Muros / Fachadas", "🪟 Ventanas", "🚪 Puertas Principales", "🏠 Techos / Tejados"],
+    "🛋️ Interiores (Sala / Cuartos)":      [],
+    "🛁 Baño / Cocina":                     [],
+    "🌳 Terraza / Patio / Jardín":          ["🪵 Pisos de Exterior (Deck)", "🧱 Muros / Cercas", "🪵 Pérgolas / Techos", "🪨 Caminos / Piedras"],
+    "🏢 Oficinas / Corporativo":            ["🧱 Mamparas / Divisiones", "🏛️ Columnas / Pilares"],
+    "🏪 Locales Comerciales / Restaurantes":["🪟 Vitrinas / Aparadores"],
+    "🏭 Garaje / Bodega / Industrial":      ["🪵 Suelos de Concreto / Epóxico", "🚪 Portones Corredizos", "🏗️ Vigas / Estructuras metálicas"],
+}
 
-    return resultado_img, mensaje
+ELEMENTOS_YOLO_COMPATIBLES = {
+    "🏙️ Fachada / Exterior":               ["🪟 Ventanas", "🚪 Puertas Principales", "🪵 Balcones / Terrazas"],
+    "🛋️ Interiores (Sala / Cuartos)":      ["🪟 Ventanas", "🚪 Puertas / Marcos"],
+    "🛁 Baño / Cocina":                     ["🚰 Encimeras / Topes", "🚽 Sanitarios / Duchas", "🗄️ Gabinetes fijos"],
+    "🌳 Terraza / Patio / Jardín":          ["🧱 Muros / Cercas", "🪵 Pérgolas / Techos", "💧 Piscinas / Fuentes"],
+    "🏢 Oficinas / Corporativo":            ["🧱 Mamparas / Divisiones", "🚪 Puertas de Cristal", "🏛️ Columnas / Pilares"],
+    "🏪 Locales Comerciales / Restaurantes":["🪟 Vitrinas / Aparadores", "🧾 Barras / Mostradores fijos", "💡 Iluminación de Techo"],
+    "🏭 Garaje / Bodega / Industrial":      ["🚪 Portones Corredizos", "🏗️ Vigas / Estructuras metálicas"],
+}
 
-def crear_app():
-    with gr.Blocks(title="GroundingDINO + SAM 2.1") as demo:
-        gr.Markdown("# 🦖 GroundingDINO + 🎯 SAM 2.1 (Base Plus)")
-        gr.Markdown(
-            "Segmentación de alta precisión basada en texto. Escribe lo que buscas (ej. `bed`, `lamp`, `pillow`).\n\n"
-            "*Nota: La primera imagen tardará unos segundos mientras se inicializa la GPU.*"
-        )
+def actualizar_opciones(entorno, motor):
+    if motor == "YOLO-World + SAM 2.1 (Ultra Rápido)":
+        opciones = ELEMENTOS_YOLO_COMPATIBLES.get(entorno, [])
+        label = "2. Elementos (solo objetos detectables por YOLO 🎯)"
+    elif motor == "SegFormer Cityscapes + SAM 2.1 (Exteriores)":
+        opciones = ELEMENTOS_CITYSCAPES_COMPATIBLES.get(entorno, [])
+        label = "2. Elementos (escena urbana/exterior — Cityscapes 🏙️)"
+    elif motor == "SegFormer ADE20K + SAM 2.1 (Interiores)":
+        opciones = list(CATALOGO_POR_ENTORNO[entorno].keys())
+        label = "2. Elementos (interiores completos — ADE20K 🏠)"
+    elif motor == "SegFormer ADE20K (Solo)":
+        opciones = list(CATALOGO_POR_ENTORNO[entorno].keys())
+        label = "2. Elementos (interiores completos — ADE20K 🏠)"
+    elif motor == "Mask2Former COCO + SAM 2.1 (NYU Interior)":
+        opciones = list(CATALOGO_POR_ENTORNO[entorno].keys())
+        label = "2. Elementos (detección por instancia — COCO Panoptic 🏘️)"
+    elif motor == "Automático (BLIP + DINO + SAM 2.1)":
+        opciones = [] # No hay elementos seleccionables, BLIP los genera
+        label = "2. Elementos (BLIP genera el prompt automáticamente 🤖)"
+    else:
+        opciones = list(CATALOGO_POR_ENTORNO[entorno].keys())
+        label = "2. Elementos"
+    return gr.update(choices=opciones, value=opciones[:2] if opciones else [], label=label)
 
+def crear_app():
+    with gr.Blocks(title="Comparativa IA Arquitectura") as demo:
+        gr.Markdown("# 🏗️ Asistente IA B2B (Comparativa de Motores)")
+        
         with gr.Row():
             with gr.Column(scale=1):
-                imagen_entrada = gr.Image(type="pil", label="Sube tu foto")
-                texto_objeto = gr.Textbox(label="Buscar objeto (en inglés funciona mejor)", placeholder="Ej. bed, pillow, carpet")
-                
-                # Deslizador para ajustar la sensibilidad de GroundingDINO
-                umbral = gr.Slider(minimum=0.1, maximum=0.9, value=0.3, step=0.05, label="Umbral de detección (Box Threshold)", info="Bájalo si no detecta el objeto, súbelo si detecta cosas incorrectas.")
-                
-                boton = gr.Button("Segmentar", variant="primary")
-            
+                imagen_entrada = gr.Image(type="pil", label="Foto del Espacio")
+                motor = gr.Radio(
+                    choices=[
+                        "SegFormer Cityscapes + SAM 2.1 (Exteriores)",
+                        "SegFormer ADE20K + SAM 2.1 (Interiores)",
+                        "DINO + SAM 2.1 (Objetos Contables)",
+                        "Automático (BLIP + DINO + SAM 2.1)" # Nuevo motor
+                        "Automático (BLIP + DINO + SAM 2.1)", # Nuevo motor
+                        "Agente IA Autónomo (BLIP-2 + FLAN-T5 + DINO + SAM 2.1)"
+                    ],
+                    value="SegFormer Cityscapes + SAM 2.1 (Exteriores)",
+                    label="🧠 Motor de Inteligencia Artificial"
+                )
+                tipo_entorno = gr.Dropdown(choices=list(CATALOGO_POR_ENTORNO.keys()), value=list(CATALOGO_POR_ENTORNO.keys())[0], label="1. Entorno (Autodetectado 🪄)")
+                elementos = gr.CheckboxGroup(choices=list(CATALOGO_POR_ENTORNO[list(CATALOGO_POR_ENTORNO.keys())[0]].keys()), label="2. Elementos")
+                prompt_personalizado = gr.Textbox(label="📝 Prompt Manual (Opcional)", placeholder="Ej: white wall, concrete floor, mirror... (Deja vacío para usar las casillas)", lines=2)
+                umbral = gr.Slider(0.05, 0.9, 0.2, step=0.05, label="Sensibilidad (Excepto SegFormer)")
+                usar_limpieza = gr.Checkbox(label="🛠️ Filtro Anti-Ruido (Limpieza Morfológica)", value=True)
+                boton = gr.Button("Analizar Espacio", variant="primary")
             with gr.Column(scale=1):
-                imagen_salida = gr.Image(label="Resultado Segmentado")
-                estado = gr.Textbox(label="Estado", interactive=False)
+                with gr.Tabs():
+                    with gr.TabItem("Resultado Final"):
+                        imagen_salida = gr.Image(label="Segmentación")
+                    with gr.TabItem("Razonamiento del Modelo (DINO)"):
+                        debug_dino_image = gr.Image(label="Detecciones Crudas de DINO")
+                estado = gr.Markdown(label="Análisis Comercial")
 
-        boton.click(
-            fn=segmentar_con_dino_y_sam,
-            inputs=[imagen_entrada, texto_objeto, umbral],
-            outputs=[imagen_salida, estado],
-        )
+        imagen_entrada.upload(fn=autodetectar_entorno, inputs=imagen_entrada, outputs=[tipo_entorno, elementos])
+        tipo_entorno.change(fn=actualizar_opciones, inputs=[tipo_entorno, motor], outputs=elementos)
+        motor.change(fn=actualizar_opciones, inputs=[tipo_entorno, motor], outputs=elementos)
+        boton.click(fn=segmentar_y_analizar, inputs=[imagen_entrada, tipo_entorno, elementos, umbral, motor, usar_limpieza, prompt_personalizado], outputs=[imagen_salida, estado, debug_dino_image])
 
     return demo
 
-# --- INICIALIZACIÓN GLOBAL ---
-print("Descargando peso de SAM 2.1 al iniciar Space...")
 download_sam_checkpoint()
-
 demo = crear_app()
-
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -2,7 +2,9 @@ gradio==6.13.0
 git+https://github.com/facebookresearch/sam2.git
 torch>=2.0.0
 torchvision
-transformers
+transformers>=4.48.0,<5.0.0
 huggingface-hub
 numpy
-pillow
+pillow
+accelerate
+ultralytics