Upload 4 files

app.py

@@ -18,38 +18,24 @@ except ImportError:
 
 # --- IMPORTACIONES DE MODELOS ---
 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 ---
 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"
 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),
@@ -67,111 +53,10 @@ 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 = {
@@ -181,7 +66,10 @@ CATALOGO_POR_ENTORNO = {
         "🚪 Puertas Principales": "front door.",
         "🏠 Techos / Tejados": "roof.",
         "🪵 Balcones / Terrazas": "balcony.",
-        "🪧 Estructuras / Letreros": "signboard. billboard. cladding."
+        "🪧 Estructuras / Letreros": "signboard. billboard. cladding.",
+        "🚧 Aceras / Bordillos": "sidewalk. pavement.",
+        "🌿 Vegetación / Jardines": "landscape. plants. greenery.",
+        "🔲 Revestimientos de Fachada": "cladding. facade finish.",
     },
     "🛋️ Interiores (Sala / Cuartos)": {
         "🧱 Paredes Interiores": "wall.",
@@ -189,49 +77,70 @@ CATALOGO_POR_ENTORNO = {
         "🪟 Ventanas": "window.",
         "قف Techos / Cielos Falsos": "ceiling.",
         "🚪 Puertas / Marcos": "door.",
-        "➖ Zócalos / Molduras": "baseboard. molding."
+        "➖ Zócalos / Molduras": "baseboard. molding.",
+        "🛋️ Muebles Empotrados": "built-in furniture. wardrobe. closet.",
+        "💡 Luminarias": "light fixture. lamp.",
+        "🔌 Tomas / Enchufes": "electrical outlet. socket.",
     },
     "🛁 Baño / Cocina": {
         "🧱 Azulejos / Paredes": "wall. tile.",
         "🪵 Pisos": "floor.",
         "🚰 Encimeras / Topes": "countertop.",
         "🚽 Sanitarios / Duchas": "toilet. shower.",
-        "🗄️ Gabinetes fijos": "cabinet."
+        "🗄️ Gabinetes fijos": "cabinet.",
+        "🪟 Ventanas": "window.",
+        "🪞 Espejos": "mirror.",
+        "🍽️ Estanterías / Repisas": "shelf. rack.",
     },
     "🌳 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."
+        "💧 Piscinas / Fuentes": "pool.",
+        "🌿 Vegetación / Plantas": "plants. vegetation.",
+        "🪑 Muebles de Exterior": "outdoor furniture. patio set.",
+        "☂️ Sombrillas / Toldos": "umbrella. canopy.",
+        "🪟 Ventanas / Puertas de cristal": "window. glass door. sliding door.",
+        "💡 Iluminación Exterior": "outdoor lamp. wall light.",
+        "🚧 Barandales": "railing.",
     },
     "🏢 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."
+        "🏛️ Columnas / Pilares": "column. pillar.",
+        "💻 Escritorios / Workstations": "desk. workstation.",
+        "🪑 Sillas": "chair.",
+        "📚 Estanterías / Archiveros": "shelving. storage.",
     },
     "🏪 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."
+        "💡 Iluminación de Techo": "ceiling light.",
+        "🍽️ Mesas / Sillas": "table. chair.",
+        "🛍️ Estantes / Góndolas": "shelves. gondola.",
+        "🛒 Áreas de Caja": "cash register. checkout.",
     },
     "🏭 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."
+        "🏗️ Vigas / Estructuras metálicas": "metal beam. structure.",
+        "📦 Estanterías / Pallets": "shelving. pallet.",
+        "⚙️ Maquinaria / Equipos": "machine. equipment.",
+        "⛓️ Rejas / Barreras": "grill. barrier.",
     }
 }
 
 DESCRIPCIONES_CLIP = [
-    "a photo of the exterior of a building facade",
+    "a photo of the exterior of a building facade or commercial storefront",
     "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 an outdoor patio, terrace, or garden with plants",
     "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"
@@ -249,7 +158,6 @@ def create_instance_overlay(image: Image.Image, masks_np: list, etiquetas: list,
     overlay_image = image.convert("RGBA").copy()
     
     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)
@@ -265,7 +173,6 @@ def draw_dino_detections(image: Image.Image, boxes: list, labels: list, scores:
     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
@@ -277,35 +184,21 @@ def draw_dino_detections(image: Image.Image, boxes: list, labels: list, scores:
     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.
-    """
+    """Elimina salpicaduras usando Operaciones Morfológicas y filtrado."""
     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
                 
@@ -315,9 +208,18 @@ def limpiar_mascara(mask: np.ndarray, area_minima: int = 2000) -> np.ndarray:
 @torch.no_grad()
 def autodetectar_entorno(imagen: Image.Image):
     global clip_model, clip_processor
+    claves_entorno = list(CATALOGO_POR_ENTORNO.keys())
+    exteriores = ["🏙️ Fachada / Exterior", "🌳 Terraza / Patio / Jardín"]
+
     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()))
+        entorno_predicho = claves_entorno[0]
+        nuevas_opciones = list(CATALOGO_POR_ENTORNO[entorno_predicho].keys())
+        motor_seleccionado = "Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)" if entorno_predicho in exteriores else "SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1"
+        return (
+            gr.update(value=entorno_predicho),
+            gr.update(choices=nuevas_opciones, value=nuevas_opciones),
+            gr.update(value=motor_seleccionado)
+        )
 
     if clip_model is None:
         clip_processor = CLIPProcessor.from_pretrained(CLIP_ID)
@@ -328,173 +230,42 @@ def autodetectar_entorno(imagen: Image.Image):
     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])
+    motor_seleccionado = "Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)" if entorno_detectado in exteriores else "SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1"
+
+    return (
+        gr.update(value=entorno_detectado),
+        gr.update(choices=nuevas_opciones, value=nuevas_opciones),
+        gr.update(value=motor_seleccionado)
+    )
 
 @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)
+def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umbral_sensibilidad: float, motor: str, usar_limpieza: bool):
+    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
+
+    if imagen is None or len(seleccion) == 0:
+        return None, "Sube una imagen y selecciona al menos un elemento.", None
+
+    terminos_crudos = [CATALOGO_POR_ENTORNO[entorno][item] for item in seleccion]
+    texto_para_ia = " ".join(terminos_crudos)
     
-    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}") #
+    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.") #
+    debug_image = None
 
     # ==========================================================
-    # MOTOR: DINO + SAM 2.1 (Objetos Contables)
+    # MOTOR 1: DINO + SAM 2.1 (Objetos Contables)
     # ==========================================================
-    elif motor == "DINO + SAM 2.1 (Objetos Contables)":
+    if 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)
@@ -502,15 +273,11 @@ def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umb
             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}'...") #
+        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 = [], []
@@ -518,233 +285,193 @@ def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umb
             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)
+    # MOTOR 2: HÍBRIDO EXTERIORES (Cityscapes Base + DINO Detalles)
     # ==========================================================
-    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)
+    elif motor == "Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)":
+        if segformer_city_model is None:
+            print("Cargando SegFormer-B5 Cityscapes (Capa Base)...")
+            segformer_city_processor = SegformerImageProcessor.from_pretrained(CITYSCAPES_ID)
+            segformer_city_model = SegformerForSemanticSegmentation.from_pretrained(CITYSCAPES_ID).to(DEVICE)
 
         if sam2_predictor is None or gdino_model is None:
+            print("Cargando DINO y SAM 2.1 (Capa Detalles)...")
             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"])
+        sam2_predictor.set_image(imagen_np)
+        cajas_todos, etiquetas_todos = [], []
+
+        # Fase 1: SegFormer
+        inputs_city = segformer_city_processor(images=imagen_rgb, return_tensors="pt").to(DEVICE)
+        outputs_city = segformer_city_model(**inputs_city)
+        logits = F.interpolate(outputs_city.logits, size=imagen_rgb.size[::-1], mode="bilinear", align_corners=False)
+        pred_seg = logits.argmax(dim=1)[0].cpu().numpy()
+
+        base_classes = {2: 'building (Base)', 1: 'sidewalk (Base)'}
+        for cls_id, etiqueta_base in base_classes.items():
+            mask_cls = pred_seg == cls_id
+            if np.sum(mask_cls) > 2000:
+                mask_uint8 = (mask_cls * 255).astype(np.uint8)
+                num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask_uint8, connectivity=8)
+                for i in range(1, num_labels):
+                    x = stats[i, cv2.CC_STAT_LEFT]; y = stats[i, cv2.CC_STAT_TOP]
+                    w = stats[i, cv2.CC_STAT_WIDTH]; h = stats[i, cv2.CC_STAT_HEIGHT]
+                    if stats[i, cv2.CC_STAT_AREA] > 1000:
+                        cajas_todos.append([x, y, x + w, y + h])
+                        etiquetas_todos.append(etiqueta_base)
+
+        # Fase 2: DINO
+        inputs_dino = gdino_processor(images=imagen_rgb, text=texto_para_ia, 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]
 
-        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)
+            min_score = umbral_sensibilidad
+            if score > min_score:
+                etiquetas_todos.append(f"{label} (Detalle DINO)")
+                cajas_todos.append(box.cpu().numpy())
+
+        # Fase 3: SAM
+        if cajas_todos:
+            masks, _, _ = sam2_predictor.predict(box=np.array(cajas_todos, 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 = labels_filt
-            print(f"SAM 2.1 generó {len(masks_finales)} máscaras.") #
+            etiquetas_finales = etiquetas_todos
 
     # ==========================================================
-    # MOTOR: AGENTE IA AUTÓNOMO (BLIP-2 + FLAN-T5 + DINO + SAM 2.1)
+    # MOTOR 3: HÍBRIDO INTERIORES: SegFormer (SegFormer ADE20K+ 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)
-            
-        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)
+    elif motor == "SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1":
+        if segformer_ade_model is None:
+            print("Cargando SegFormer ADE20K (Estructura Interior)...")
+            segformer_ade_processor = SegformerImageProcessor.from_pretrained(ADE20K_ID)
+            segformer_ade_model = SegformerForSemanticSegmentation.from_pretrained(ADE20K_ID).to(DEVICE)
 
         if sam2_predictor is None or gdino_model is None:
-            print("Cargando DINO y SAM 2.1 (Manos)...")
+            print("Cargando DINO y SAM 2.1 (Objetos)...")
             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)
-        
-        # 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}")
-
-        # PASO C: Grounding DINO busca los objetos
-        inputs_dino = gdino_processor(images=imagen_rgb, text=texto_para_ia_agente, return_tensors="pt").to(DEVICE)
+        sam2_predictor.set_image(imagen_np)
+        cajas_todos, etiquetas_todos = [], []
+
+        # Fase 1: SegFormer
+        inputs_ade = segformer_ade_processor(images=imagen_rgb, return_tensors="pt").to(DEVICE)
+        outputs_ade = segformer_ade_model(**inputs_ade)
+        logits = F.interpolate(outputs_ade.logits, size=imagen_rgb.size[::-1], mode="bilinear", align_corners=False)
+        pred_seg = logits.argmax(dim=1)[0].cpu().numpy()
+
+        base_classes_ade = {0: 'wall (Base)', 3: 'floor (Base)', 5: 'ceiling (Base)'}
+        for cls_id, etiqueta_base in base_classes_ade.items():
+            mask_cls = pred_seg == cls_id
+            if np.sum(mask_cls) > 2000:
+                mask_uint8 = (mask_cls * 255).astype(np.uint8)
+                num_labels, labels, stats, centroids = cv2.connectedComponentsWithStats(mask_uint8, connectivity=8)
+                for i in range(1, num_labels):
+                    if stats[i, cv2.CC_STAT_AREA] > 2000:
+                        x = stats[i, cv2.CC_STAT_LEFT]; y = stats[i, cv2.CC_STAT_TOP]
+                        w = stats[i, cv2.CC_STAT_WIDTH]; h = stats[i, cv2.CC_STAT_HEIGHT]
+                        cajas_todos.append([x, y, x + w, y + h])
+                        etiquetas_todos.append(etiqueta_base)
+
+        # Fase 2: DINO
+        inputs_dino = gdino_processor(images=imagen_rgb, text=texto_para_ia, 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]
 
-        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)
+            min_score = umbral_sensibilidad
+            if score > min_score:
+                etiquetas_todos.append(f"{label} (Detalle DINO)")
+                cajas_todos.append(box.cpu().numpy())
+
+        # Fase 3: SAM
+        if cajas_todos:
+            masks, _, _ = sam2_predictor.predict(box=np.array(cajas_todos, 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 = labels_filt
+            etiquetas_finales = etiquetas_todos
 
     # ==========================================================
     # 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)))
-    
-    # 2. Asignar un color único a cada categoría
     mapa_colores_rgb = {}
-    label_color_map = {} # Para el código HEX del HTML
+    label_color_map = {} 
     
     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
+        color_rgb = color_completo[:3] 
         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)
     
-    # 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>")
     
-    print("--- Análisis completado ---") #
+    print("--- Análisis completado ---")
     return resultado_img, f"📊 REPORTE ({motor}):<br>" + "<br>".join(reporte_lineas), debug_image
 
-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"],
-}
+def seleccionar_motor_por_entorno(entorno):
+    exteriores = ["🏙️ Fachada / Exterior", "🌳 Terraza / Patio / Jardín"]
+    interiores = [
+        "🛋️ Interiores (Sala / Cuartos)",
+        "🛁 Baño / Cocina",
+        "🏢 Oficinas / Corporativo",
+        "🏪 Locales Comerciales / Restaurantes",
+        "🏭 Garaje / Bodega / Industrial"
+    ]
+    if entorno in exteriores:
+        return gr.update(value="Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)")
+    if entorno in interiores:
+        return gr.update(value="SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1")
+    return gr.update(value="SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1")
 
-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 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 🤖)"
+    opciones = list(CATALOGO_POR_ENTORNO[entorno].keys())
+    if motor in ["Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)", "SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1"]:
+        label = "2. Elementos (Detalles a buscar con DINO 🎯)"
     else:
-        opciones = list(CATALOGO_POR_ENTORNO[entorno].keys())
         label = "2. Elementos"
-    return gr.update(choices=opciones, value=opciones[:2] if opciones else [], label=label)
+    return gr.update(choices=opciones, value=opciones if opciones else [], label=label)
 
 def crear_app():
     with gr.Blocks(title="Comparativa IA Arquitectura") as demo:
@@ -755,22 +482,19 @@ def crear_app():
                 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)"
+                        "SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1",
+                        "Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)",
+                        "DINO + SAM 2.1 (Objetos Contables)"
                     ],
-                    value="SegFormer Cityscapes + SAM 2.1 (Exteriores)",
+                    value="Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)",
                     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)")
+                elementos = gr.CheckboxGroup(choices=list(CATALOGO_POR_ENTORNO[list(CATALOGO_POR_ENTORNO.keys())[0]].keys()), value=list(CATALOGO_POR_ENTORNO[list(CATALOGO_POR_ENTORNO.keys())[0]].keys()), label="2. Elementos")
+                umbral = gr.Slider(0.05, 0.9, 0.2, step=0.05, label="Sensibilidad de Detección (Umbral)")
                 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):
                 with gr.Tabs():
                     with gr.TabItem("Resultado Final"):
@@ -779,14 +503,15 @@ def crear_app():
                         debug_dino_image = gr.Image(label="Detecciones Crudas de DINO")
                 estado = gr.Markdown(label="Análisis Comercial")
 
-        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)
+        tipo_entorno.change(fn=seleccionar_motor_por_entorno, inputs=[tipo_entorno], outputs=[motor])
+        imagen_entrada.upload(fn=autodetectar_entorno, inputs=imagen_entrada, outputs=[tipo_entorno, elementos, motor])
         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])
+        boton.click(fn=segmentar_y_analizar, inputs=[imagen_entrada, tipo_entorno, elementos, umbral, motor, usar_limpieza], outputs=[imagen_salida, estado, debug_dino_image])
 
     return demo
 
 download_sam_checkpoint()
 demo = crear_app()
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()