Upload 4 files

README.md

@@ -1,71 +1,17 @@
----
-title: Hyper Reality SAM2 GPU
-emoji: 🏠
-colorFrom: blue
-colorTo: indigo
-sdk: gradio
-sdk_version: 6.13.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-# Hyper Reality — SAM2 Segmentation GPU
-
-
-# Demo de Gradio con SAM
-
-Este proyecto es una app de Gradio que usa SAM para segmentar automáticamente una imagen subida.
-
-## Qué hace
-
-- Permite subir una imagen
-- Ejecuta la segmentación automática con SAM
-- Permite buscar uno o varios objetos por palabra clave (separados por comas) y solo segmentar las máscaras encontradas
-- Muestra la imagen con las máscaras superpuestas
-
-## Ejecutar localmente
-
-1. Crear un entorno virtual:
-
-```powershell
-python -m venv .venv
-```
-
-2. Activar el entorno:
-
-```powershell
-.venv\Scripts\activate
-```
-
-3. Instalar dependencias:
-
-```powershell
-pip install -r requirements.txt
-```
-
-Si ya habías instalado antes y recibiste el error de `torchvision`, ejecuta:
-
-```powershell
-pip install torchvision
-```
-
-4. Ejecutar la app:
-
-```powershell
-python app.py
-```
-
-5. Abrir el enlace local que muestra Gradio, por ejemplo `http://127.0.0.1:7860`.
-
-## Notas
-
-- La primera vez que corras la app, descargará el checkpoint del modelo SAM desde Hugging Face.
-- Si quieres usar otro modelo de SAM, cambia `MODEL_REPO` y `CHECKPOINT_FILENAME` en `app.py`.
-
-## Subir a Hugging Face Spaces
-
-1. Crea una nueva Space en Hugging Face.
-2. Selecciona el tipo `Gradio`.
-3. Sube este repositorio completo o copia `app.py` y `requirements.txt`.
-4. La Space descargará el checkpoint y ejecutará la app.
+---
+title: Hyper Reality SAM2 GPU
+emoji: 🏠
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.29.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Hyper Reality — SAM2 Segmentation GPU
+
+Segmentación automática de habitaciones con SAM 2.1 usando ZeroGPU.
+
+Este Space actúa como motor de IA para el [visualizador principal](https://huggingface.co/spaces/eduardo4547/hyper-reality-visualizer).

app.py

@@ -1,4 +1,8 @@
+import base64
+import io
+import json
 import os
+import traceback
 import gradio as gr
 import numpy as np
 import torch
@@ -204,60 +208,17 @@ def limpiar_mascara(mask: np.ndarray, area_minima: int = 2000) -> np.ndarray:
                 
     return mask_final.astype(bool)
 
-@spaces.GPU
-@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:
-        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)
-        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()
-
-    entorno_detectado = claves_entorno[indice_ganador]
-    nuevas_opciones = list(CATALOGO_POR_ENTORNO[entorno_detectado].keys())
-    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):
-    print(f"\n--- Iniciando análisis con motor: {motor} ---")
+def _run_engines_raw(imagen_rgb, imagen_np, entorno, seleccion, umbral_sensibilidad, motor, usar_limpieza):
+    """
+    Núcleo de los 3 motores, sin decoradores GPU.
+    Debe llamarse siempre desde una función con @spaces.GPU.
+    Retorna (masks_finales, etiquetas_finales, debug_image).
+    """
     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)
-    
-    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
@@ -285,7 +246,7 @@ def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umb
             if score > umbral_sensibilidad:
                 boxes_filt.append(box)
                 labels_filt.append(label)
-        
+
         if boxes_filt:
             sam2_predictor.set_image(imagen_np)
             masks, _, _ = sam2_predictor.predict(box=torch.stack(boxes_filt).cpu().numpy(), multimask_output=False)
@@ -338,8 +299,7 @@ def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umb
         results = gdino_processor.post_process_grounded_object_detection(outputs_dino, inputs_dino.input_ids, target_sizes=[imagen_rgb.size[::-1]])[0]
 
         for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-            min_score = umbral_sensibilidad
-            if score > min_score:
+            if score > umbral_sensibilidad:
                 etiquetas_todos.append(f"{label} (Detalle DINO)")
                 cajas_todos.append(box.cpu().numpy())
 
@@ -395,8 +355,7 @@ def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umb
         results = gdino_processor.post_process_grounded_object_detection(outputs_dino, inputs_dino.input_ids, target_sizes=[imagen_rgb.size[::-1]])[0]
 
         for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-            min_score = umbral_sensibilidad
-            if score > min_score:
+            if score > umbral_sensibilidad:
                 etiquetas_todos.append(f"{label} (Detalle DINO)")
                 cajas_todos.append(box.cpu().numpy())
 
@@ -413,17 +372,73 @@ def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umb
     if usar_limpieza:
         masks_limpias = []
         etiquetas_limpias = []
-        UMBRAL_AREA_MINIMA = 1500 
-        
+        UMBRAL_AREA_MINIMA = 1500
+
         for mask, etiqueta in zip(masks_finales, etiquetas_finales):
             mask_sin_ruido = limpiar_mascara(mask, area_minima=UMBRAL_AREA_MINIMA)
-            if np.sum(mask_sin_ruido) > 2000: 
+            if np.sum(mask_sin_ruido) > 2000:
                 masks_limpias.append(mask_sin_ruido)
                 etiquetas_limpias.append(etiqueta)
-                
+
         masks_finales = masks_limpias
         etiquetas_finales = etiquetas_limpias
 
+    return masks_finales, etiquetas_finales, debug_image
+
+
+@spaces.GPU
+@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:
+        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)
+        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()
+
+    entorno_detectado = claves_entorno[indice_ganador]
+    nuevas_opciones = list(CATALOGO_POR_ENTORNO[entorno_detectado].keys())
+    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):
+    print(f"\n--- Iniciando análisis con motor: {motor} ---")
+
+    if imagen is None or len(seleccion) == 0:
+        return None, "Sube una imagen y selecciona al menos un elemento.", None
+
+    imagen_rgb = imagen.convert("RGB")
+    imagen_np = np.array(imagen_rgb)
+    total_pixels = imagen.width * imagen.height
+
+    masks_finales, etiquetas_finales, debug_image = _run_engines_raw(
+        imagen_rgb, imagen_np, entorno, seleccion, umbral_sensibilidad, motor, usar_limpieza
+    )
+
     # --- 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
@@ -449,6 +464,80 @@ def segmentar_y_analizar(imagen: Image.Image, entorno: str, seleccion: list, umb
     print("--- Análisis completado ---")
     return resultado_img, f"📊 REPORTE ({motor}):<br>" + "<br>".join(reporte_lineas), debug_image
 
+@spaces.GPU
+@torch.no_grad()
+def segment_for_backend(image_np: np.ndarray):
+    """
+    Endpoint para el backend Docker (llamado via gradio_client).
+    Entrada : imagen numpy uint8 H×W×3.
+    Salida  : (overlay_np, combined_json_str)
+      combined_json tiene "masks" (lista de dicts) y "label_map_b64" (PNG base64).
+    """
+    try:
+        if image_np is None:
+            empty = np.zeros((100, 100, 3), dtype=np.uint8)
+            return empty, json.dumps({"masks": [], "label_map_b64": ""})
+
+        pil_image = Image.fromarray(image_np.astype(np.uint8)).convert("RGB")
+        img_np = np.array(pil_image)
+        h, w = img_np.shape[:2]
+
+        # Auto-detectar entorno con CLIP
+        global clip_model, clip_processor
+        claves_entorno = list(CATALOGO_POR_ENTORNO.keys())
+        exteriores = ["🏙️ Fachada / Exterior", "🌳 Terraza / Patio / Jardín"]
+
+        if clip_model is None:
+            clip_processor = CLIPProcessor.from_pretrained(CLIP_ID)
+            clip_model = CLIPModel.from_pretrained(CLIP_ID).to(DEVICE)
+
+        inputs = clip_processor(text=DESCRIPCIONES_CLIP, images=pil_image, return_tensors="pt", padding=True).to(DEVICE)
+        outputs = clip_model(**inputs)
+        probabilidades = outputs.logits_per_image.softmax(dim=1).cpu().numpy()[0]
+        entorno = claves_entorno[int(probabilidades.argmax())]
+        motor = "Híbrido Arquitectura (Cityscapes Grande + DINO Pequeño)" if entorno in exteriores else "SegFormer (SegFormer ADE20K+ DINO) + SAM 2.1"
+        seleccion = list(CATALOGO_POR_ENTORNO[entorno].keys())
+
+        # Ejecutar motores
+        masks_finales, etiquetas_finales, _ = _run_engines_raw(
+            pil_image, img_np, entorno, seleccion, 0.25, motor, True
+        )
+
+        if not masks_finales:
+            return np.array(pil_image), json.dumps({"masks": [], "label_map_b64": "", "entorno": entorno, "motor": motor})
+
+        # Construir label_map (uint8, valores 1..N por segmento)
+        label_map = np.zeros((h, w), dtype=np.uint8)
+        masks_out = []
+        for i, (mask, etiqueta) in enumerate(zip(masks_finales[:254], etiquetas_finales[:254]), start=1):
+            m = mask.astype(bool)
+            label_map[m] = i
+            area_ratio = float(np.sum(m)) / max(1, h * w)
+            ys, xs = np.where(m)
+            bbox = [int(xs.min()), int(ys.min()), int(xs.max() - xs.min()), int(ys.max() - ys.min())] if len(ys) else [0, 0, 0, 0]
+            masks_out.append({"index": i, "surface": etiqueta, "area_ratio": round(area_ratio, 4), "bbox_xywh": bbox})
+
+        # Codificar label_map como PNG base64 (sin pérdida, preserva valores uint8)
+        pil_label = Image.fromarray(label_map, mode="L")
+        buf = io.BytesIO()
+        pil_label.save(buf, format="PNG")
+        label_map_b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+
+        # Overlay coloreado
+        categorias_unicas = sorted(set(etiquetas_finales))
+        mapa_colores = {cat: EXTENDED_PALETTE[i % len(EXTENDED_PALETTE)] for i, cat in enumerate(categorias_unicas)}
+        overlay_pil = create_instance_overlay(pil_image, masks_finales, etiquetas_finales, mapa_colores)
+        overlay_np = np.array(overlay_pil.convert("RGB"))
+
+        combined = {"masks": masks_out, "label_map_b64": label_map_b64, "entorno": entorno, "motor": motor}
+        return overlay_np, json.dumps(combined, ensure_ascii=False)
+
+    except Exception:
+        err = traceback.format_exc()
+        empty = np.zeros((100, 100, 3), dtype=np.uint8)
+        return empty, json.dumps({"error": err, "masks": [], "label_map_b64": ""})
+
+
 def seleccionar_motor_por_entorno(entorno):
     exteriores = ["🏙️ Fachada / Exterior", "🌳 Terraza / Patio / Jardín"]
     interiores = [
@@ -509,6 +598,19 @@ def crear_app():
         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], outputs=[imagen_salida, estado, debug_dino_image])
 
+        # ── Endpoint oculto para el backend Docker (gradio_client lo llama) ──────
+        with gr.Row(visible=False):
+            _api_in    = gr.Image(type="numpy", label="backend_input")
+            _api_over  = gr.Image(type="numpy", label="backend_overlay")
+            _api_json  = gr.Textbox(label="backend_json")
+
+        gr.Button(visible=False).click(
+            fn=segment_for_backend,
+            inputs=[_api_in],
+            outputs=[_api_over, _api_json],
+            api_name="segment",
+        )
+
     return demo
 
 download_sam_checkpoint()

packages.txt

@@ -0,0 +1,2 @@
+libgl1-mesa-glx
+libglib2.0-0