Upload 285 files

.gitattributes

@@ -156,3 +156,9 @@ backend/texturas/Texture_WPC_EXTERIOR_INTERIOR/WPC_negro.png filter=lfs diff=lfs
 backend/texturas/Texture_WPC_DECK/DECK_gris.png filter=lfs diff=lfs merge=lfs -text
 backend/texturas/Texture_WPC_DECK/DECK_madera_oscuro.png filter=lfs diff=lfs merge=lfs -text
 backend/texturas/Texture_WPC_DECK/DECK_madera.png filter=lfs diff=lfs merge=lfs -text
+backend/uploads/acm[[:space:]]azul_edit_edb46e2f.jpg filter=lfs diff=lfs merge=lfs -text
+backend/uploads/acm[[:space:]]gris_edit_09f2e747.jpg filter=lfs diff=lfs merge=lfs -text
+backend/uploads/acm[[:space:]]gris_edit_19d266a8.jpg filter=lfs diff=lfs merge=lfs -text
+backend/uploads/acm[[:space:]]gris.jpg filter=lfs diff=lfs merge=lfs -text
+backend/uploads/hyper-reality-1778254222964_edit_9c5de50a_edit_7e5043d5.jpg filter=lfs diff=lfs merge=lfs -text
+backend/uploads/hyper-reality-1778254222964_edit_a92f4266_edit_161ee5c4.jpg filter=lfs diff=lfs merge=lfs -text

backend/.env

@@ -1,8 +1,11 @@
 MONGODB_URI=mongodb+srv://alaneduardodelacruz407_db_user:YGUWdpXqUiGH104Q@naufar-cluster.n9htwoa.mongodb.net/
 # Space GPU (principal) — ZeroGPU, más rápido
-GRADIO_SPACE_URL=https://eduardo4547-hyper-reality-sam2-gpu.hf.space
+GRADIO_SPACE_URL=http://localhost:7860
 # Space CPU (respaldo automático si el GPU falla o agota quota)
 GRADIO_CPU_FALLBACK_URL=https://eduardo4547-hyper-reality-sam2-cpu.hf.space
 # Para desarrollo local:
 # GRADIO_SPACE_URL=http://localhost:7860
-# https://eduardo4547-hyper-reality-sam2-gpu.hf.space
+# https://eduardo4547-hyper-reality-sam2-gpu.hf.space
+# URL del servicio local que procesa imágenes con OpenAI (ejemplo Flask/Gradio proxy)
+OPENAI_PROCESS_URL=http://localhost:7861/api/process
+OPENAI_API_KEY=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

backend/core/config.py

@@ -1,92 +1,92 @@
-import logging
-import os
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-
-BASE_DIR = Path(__file__).resolve().parent.parent
-
-UPLOAD_DIR = BASE_DIR / "uploads"
-UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
-
-VIDEO_UPLOAD_DIR = UPLOAD_DIR / "videos"
-VIDEO_UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
-
-OUTPUT_DIR = BASE_DIR / "outputs"
-OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-VIDEO_OUTPUT_DIR = OUTPUT_DIR / "videos"
-VIDEO_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-TEXTURE_DIR = BASE_DIR / "texturas"
-TEXTURE_DIR.mkdir(parents=True, exist_ok=True)
-
-LOG_DIR = BASE_DIR / "logs"
-LOG_DIR.mkdir(exist_ok=True)
-
-TEMPLATES_DIR = BASE_DIR / "templates"
-TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
-
-CLASSIC_DASHBOARD_HTML_PATH = TEMPLATES_DIR / "classic_dashboard.html"
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
-    handlers=[
-        logging.FileHandler(LOG_DIR / "app.log", encoding="utf-8"),
-        logging.StreamHandler(),
-    ],
-)
-logger = logging.getLogger("backend.segmentation")
-
-SAM2_CONFIG_PATH = os.getenv("SAM2_CONFIG_PATH", "configs/sam2.1/sam2.1_hiera_l.yaml")
-SAM2_MODEL_PATH = os.getenv("SAM2_MODEL_PATH")
-SAM2_DEFAULT_MODEL_NAMES = (
-    "sam2.1_hiera_large_fresh.pt",
-    "sam2.1_hiera_large.pt",
-    "sam2.1_hiera_large.pth",
-    "sam2_hiera_large.pt",
-)
-SAM2_MODEL_DIR_CANDIDATES = ("models", "modelo")
-SAM2_UNLOAD_AFTER_USE = str(os.getenv("SAM2_UNLOAD_AFTER_USE", "0")).strip().lower() in {"1", "true", "yes"}
-FRONTEND_DEBUG = str(os.getenv("FRONTEND_DEBUG", "0")).strip().lower() in {"1", "true", "yes", "on"}
-
-# URL del Space de Gradio GPU (principal). Si falla, se usa el CPU fallback.
-# Local:      http://localhost:7860
-# Producción: https://<tu-space>.hf.space
-GRADIO_SPACE_URL: str = os.getenv("GRADIO_SPACE_URL", "").rstrip("/")
-
-# URL del Space de Gradio CPU (respaldo automático si el GPU falla o agota quota).
-GRADIO_CPU_FALLBACK_URL: str = os.getenv("GRADIO_CPU_FALLBACK_URL", "").rstrip("/")
-
-MAX_UPLOAD_WIDTH = 1024
-UPLOAD_JPEG_QUALITY = 82
-SD_JOB_STALE_SECONDS = 120
-UPLOAD_JOB_STALE_SECONDS = 900
-UPLOAD_BASE_SECONDS = 8.0
-UPLOAD_SECONDS_PER_MEGAPIXEL = 70.0
-SD_QUICK_TIMEOUT_SECONDS = 15.0
-
-SEMANTIC_MODEL_ID = "nvidia/segformer-b5-finetuned-ade-640-640"
-DEPTH_MODEL_ID = "Intel/dpt-hybrid-midas"
-
-
-def utc_now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def log_timing_start(step_name: str) -> float:
-    started = time.perf_counter()
-    logger.info(f"[{step_name}] START at {utc_now_iso()}")
-    return started
-
-
-def log_timing_end(step_name: str, started: float) -> None:
-    elapsed = time.perf_counter() - started
-    logger.info(f"[{step_name}] DONE {elapsed:.3f}s at {utc_now_iso()}")
-
-
-def load_classic_dashboard_html() -> str:
-    if not CLASSIC_DASHBOARD_HTML_PATH.exists() or not CLASSIC_DASHBOARD_HTML_PATH.is_file():
-        raise RuntimeError(f"Dashboard HTML template not found: {CLASSIC_DASHBOARD_HTML_PATH}")
-    return CLASSIC_DASHBOARD_HTML_PATH.read_text(encoding="utf-8")
+import logging
+import os
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+UPLOAD_DIR = BASE_DIR / "uploads"
+UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+VIDEO_UPLOAD_DIR = UPLOAD_DIR / "videos"
+VIDEO_UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+OUTPUT_DIR = BASE_DIR / "outputs"
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+VIDEO_OUTPUT_DIR = OUTPUT_DIR / "videos"
+VIDEO_OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+TEXTURE_DIR = BASE_DIR / "texturas"
+TEXTURE_DIR.mkdir(parents=True, exist_ok=True)
+
+LOG_DIR = BASE_DIR / "logs"
+LOG_DIR.mkdir(exist_ok=True)
+
+TEMPLATES_DIR = BASE_DIR / "templates"
+TEMPLATES_DIR.mkdir(parents=True, exist_ok=True)
+
+CLASSIC_DASHBOARD_HTML_PATH = TEMPLATES_DIR / "classic_dashboard.html"
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+    handlers=[
+        logging.FileHandler(LOG_DIR / "app.log", encoding="utf-8"),
+        logging.StreamHandler(),
+    ],
+)
+logger = logging.getLogger("backend.segmentation")
+
+SAM2_CONFIG_PATH = os.getenv("SAM2_CONFIG_PATH", "configs/sam2.1/sam2.1_hiera_l.yaml")
+SAM2_MODEL_PATH = os.getenv("SAM2_MODEL_PATH")
+SAM2_DEFAULT_MODEL_NAMES = (
+    "sam2.1_hiera_large_fresh.pt",
+    "sam2.1_hiera_large.pt",
+    "sam2.1_hiera_large.pth",
+    "sam2_hiera_large.pt",
+)
+SAM2_MODEL_DIR_CANDIDATES = ("models", "modelo")
+SAM2_UNLOAD_AFTER_USE = str(os.getenv("SAM2_UNLOAD_AFTER_USE", "0")).strip().lower() in {"1", "true", "yes"}
+FRONTEND_DEBUG = str(os.getenv("FRONTEND_DEBUG", "0")).strip().lower() in {"1", "true", "yes", "on"}
+
+# URL del Space de Gradio GPU (principal). Si falla, se usa el CPU fallback.
+# Local:      http://localhost:7860
+# Producción: https://<tu-space>.hf.space
+GRADIO_SPACE_URL: str = os.getenv("GRADIO_SPACE_URL", "").rstrip("/")
+
+# URL del Space de Gradio CPU (respaldo automático si el GPU falla o agota quota).
+GRADIO_CPU_FALLBACK_URL: str = os.getenv("GRADIO_CPU_FALLBACK_URL", "").rstrip("/")
+
+MAX_UPLOAD_WIDTH = 1024
+UPLOAD_JPEG_QUALITY = 82
+SD_JOB_STALE_SECONDS = 120
+UPLOAD_JOB_STALE_SECONDS = 900
+UPLOAD_BASE_SECONDS = 8.0
+UPLOAD_SECONDS_PER_MEGAPIXEL = 70.0
+SD_QUICK_TIMEOUT_SECONDS = 15.0
+
+SEMANTIC_MODEL_ID = "nvidia/segformer-b5-finetuned-ade-640-640"
+DEPTH_MODEL_ID = "Intel/dpt-hybrid-midas"
+
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def log_timing_start(step_name: str) -> float:
+    started = time.perf_counter()
+    logger.info(f"[{step_name}] START at {utc_now_iso()}")
+    return started
+
+
+def log_timing_end(step_name: str, started: float) -> None:
+    elapsed = time.perf_counter() - started
+    logger.info(f"[{step_name}] DONE {elapsed:.3f}s at {utc_now_iso()}")
+
+
+def load_classic_dashboard_html() -> str:
+    if not CLASSIC_DASHBOARD_HTML_PATH.exists() or not CLASSIC_DASHBOARD_HTML_PATH.is_file():
+        raise RuntimeError(f"Dashboard HTML template not found: {CLASSIC_DASHBOARD_HTML_PATH}")
+    return CLASSIC_DASHBOARD_HTML_PATH.read_text(encoding="utf-8")

backend/data/presets.json

@@ -3,8 +3,8 @@
     "ancho_panel_m": 0.3,
     "alto_panel_m": 0.3,
     "intensidad_textura": 0.85,
-    "separacion_vertical_px": 0.3,
-    "separacion_horizontal_px": 0.3,
+    "separacion_vertical_px": 0.4,
+    "separacion_horizontal_px": 0.4,
     "orientacion": "vertical",
     "perspectiva_horizontal": 0.5,
     "perspectiva_vertical": 0.7,
@@ -22,8 +22,8 @@
     "modo_fusion": "luz suave"
   },
   "WPC_DECK": {
-    "ancho_panel_m": 0.25,
-    "alto_panel_m": 0.05,
+    "ancho_panel_m": 0.14,
+    "alto_panel_m": 0.025,
     "intensidad_textura": 0.85,
     "separacion_vertical_px": 0,
     "separacion_horizontal_px": 5,

backend/main.py

@@ -1,129 +1,127 @@
-import mimetypes
-import os
-import subprocess
-import threading
-import time
-from pathlib import Path
-
-from dotenv import load_dotenv
-load_dotenv(Path(__file__).resolve().parent / ".env")
-
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-
-from core.config import GRADIO_SPACE_URL, logger
-from routers import auth, catalog, media, pages, segmentation, sessions, share, presets
-from routers.catalog import seed_catalog
-from services.sam2_service import lifespan
-
-mimetypes.add_type("application/javascript", ".js", strict=True)
-mimetypes.add_type("text/css", ".css", strict=True)
-mimetypes.add_type("image/svg+xml", ".svg", strict=True)
-
-logger.info("[STARTUP] GRADIO_SPACE_URL=%s", GRADIO_SPACE_URL or "(not set — using local SAM2)")
-
-app = FastAPI(title="Hyper Reality Backend", lifespan=lifespan)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-    allow_headers=["*"],
-)
-
-
-@app.middleware("http")
-async def remove_x_frame_options(request: Request, call_next):
-    response = await call_next(request)
-    if "x-frame-options" in response.headers:
-        del response.headers["x-frame-options"]
-    response.headers["Content-Security-Policy"] = "frame-ancestors *"
-    return response
-
-
-# Routers
-app.include_router(pages.router)
-app.include_router(auth.router)
-app.include_router(share.router)
-app.include_router(media.router)
-app.include_router(catalog.router)
-app.include_router(sessions.router)
-app.include_router(segmentation.router)
-app.include_router(presets.router)
-
-# Static files
-BASE_DIR = Path(__file__).resolve().parent
-UPLOADS_DIR = BASE_DIR / "uploads"
-FRONTEND_DIST = BASE_DIR.parent / "frontend" / "dist"
-
-UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
-app.mount("/uploads", StaticFiles(directory=UPLOADS_DIR), name="uploads")
-
-if (FRONTEND_DIST / "index.html").exists():
-    # Montado en "/" como catch-all para SPA — los routers de API tienen prioridad
-    app.mount("/", StaticFiles(directory=FRONTEND_DIST, html=True), name="frontend")
-
-
-# Frontend watcher (development helper)
-FRONTEND_DIR = BASE_DIR.parent / "frontend"
-FRONTEND_SRC = FRONTEND_DIR / "src"
-
-
-def scan_frontend_sources() -> dict:
-    if not FRONTEND_SRC.exists():
-        return {}
-    files = {}
-    for path in FRONTEND_SRC.rglob("*"):
-        if path.is_file() and path.suffix in {".ts", ".tsx", ".js", ".jsx", ".css", ".json", ".html"}:
-            files[path] = path.stat().st_mtime
-    for extra in [FRONTEND_DIR / "vite.config.ts", FRONTEND_DIR / "package.json", FRONTEND_DIR / "tsconfig.json"]:
-        if extra.exists():
-            files[extra] = extra.stat().st_mtime
-    return files
-
-
-def run_frontend_build() -> None:
-    if not FRONTEND_DIR.exists():
-        return
-    print("[backend] Ejecutando build del frontend...")
-    result = subprocess.run(["npm", "run", "build"], cwd=str(FRONTEND_DIR), capture_output=True, text=True)
-    if result.returncode != 0:
-        print("[backend] Build falló:")
-        print(result.stdout)
-        print(result.stderr)
-    else:
-        print("[backend] Build completado correctamente.")
-
-
-def watch_frontend_changes(interval: float = 2.0) -> None:
-    last_state = scan_frontend_sources()
-    while True:
-        time.sleep(interval)
-        current_state = scan_frontend_sources()
-        if current_state != last_state:
-            if last_state:
-                print("[backend] Cambio detectado en frontend. Reconstruyendo...")
-                run_frontend_build()
-            last_state = current_state
-
-
-@app.on_event("startup")
-async def startup_seed_catalog():
-    if MONGODB_URI := os.getenv("MONGODB_URI", ""):
-        try:
-            await seed_catalog()
-        except Exception as exc:
-            logger.warning("[STARTUP] seed_catalog falló: %s", exc)
-
-
-@app.on_event("startup")
-async def startup_watch_frontend():
-    thread = threading.Thread(target=watch_frontend_changes, daemon=True)
-    thread.start()
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
+import mimetypes
+import os
+import subprocess
+import threading
+import time
+from pathlib import Path
+
+from dotenv import load_dotenv
+load_dotenv(Path(__file__).resolve().parent / ".env")
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+from core.config import logger
+from routers import auth, catalog, media, pages, segmentation, sessions, share, openai_image, active_sessions
+from routers.catalog import seed_catalog
+
+mimetypes.add_type("application/javascript", ".js", strict=True)
+mimetypes.add_type("text/css", ".css", strict=True)
+mimetypes.add_type("image/svg+xml", ".svg", strict=True)
+
+app = FastAPI(title="Hyper Reality Backend")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["*"],
+)
+
+
+@app.middleware("http")
+async def remove_x_frame_options(request: Request, call_next):
+    response = await call_next(request)
+    if "x-frame-options" in response.headers:
+        del response.headers["x-frame-options"]
+    response.headers["Content-Security-Policy"] = "frame-ancestors *"
+    return response
+
+
+# Routers
+# Mantener sólo la ruta de subida de imágenes (/api/upload-image).
+# Comentamos las demás inclusiones para deshabilitar funcionalidades
+# posteriores (segmentación, inpainting, sesiones, catálogo, etc.).
+# Re-activar routers necesarios para el frontend
+app.include_router(sessions.router)
+app.include_router(segmentation.router)
+app.include_router(openai_image.router)
+app.include_router(active_sessions.router)
+app.include_router(catalog.router)
+
+# Static files
+BASE_DIR = Path(__file__).resolve().parent
+UPLOADS_DIR = BASE_DIR / "uploads"
+FRONTEND_DIST = BASE_DIR.parent / "frontend" / "dist"
+
+UPLOADS_DIR.mkdir(parents=True, exist_ok=True)
+app.mount("/uploads", StaticFiles(directory=UPLOADS_DIR), name="uploads")
+
+if (FRONTEND_DIST / "index.html").exists():
+    # Montado en "/" como catch-all para SPA — los routers de API tienen prioridad
+    app.mount("/", StaticFiles(directory=FRONTEND_DIST, html=True), name="frontend")
+
+
+# Frontend watcher (development helper)
+FRONTEND_DIR = BASE_DIR.parent / "frontend"
+FRONTEND_SRC = FRONTEND_DIR / "src"
+
+
+def scan_frontend_sources() -> dict:
+    if not FRONTEND_SRC.exists():
+        return {}
+    files = {}
+    for path in FRONTEND_SRC.rglob("*"):
+        if path.is_file() and path.suffix in {".ts", ".tsx", ".js", ".jsx", ".css", ".json", ".html"}:
+            files[path] = path.stat().st_mtime
+    for extra in [FRONTEND_DIR / "vite.config.ts", FRONTEND_DIR / "package.json", FRONTEND_DIR / "tsconfig.json"]:
+        if extra.exists():
+            files[extra] = extra.stat().st_mtime
+    return files
+
+
+def run_frontend_build() -> None:
+    if not FRONTEND_DIR.exists():
+        return
+    print("[backend] Ejecutando build del frontend...")
+    result = subprocess.run(["npm", "run", "build"], cwd=str(FRONTEND_DIR), capture_output=True, text=True)
+    if result.returncode != 0:
+        print("[backend] Build falló:")
+        print(result.stdout)
+        print(result.stderr)
+    else:
+        print("[backend] Build completado correctamente.")
+
+
+def watch_frontend_changes(interval: float = 2.0) -> None:
+    last_state = scan_frontend_sources()
+    while True:
+        time.sleep(interval)
+        current_state = scan_frontend_sources()
+        if current_state != last_state:
+            if last_state:
+                print("[backend] Cambio detectado en frontend. Reconstruyendo...")
+                run_frontend_build()
+            last_state = current_state
+
+
+@app.on_event("startup")
+async def startup_seed_catalog():
+    if MONGODB_URI := os.getenv("MONGODB_URI", ""):
+        try:
+            await seed_catalog()
+        except Exception as exc:
+            logger.warning("[STARTUP] seed_catalog falló: %s", exc)
+
+
+@app.on_event("startup")
+async def startup_watch_frontend():
+    thread = threading.Thread(target=watch_frontend_changes, daemon=True)
+    thread.start()
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")

backend/models/schemas.py

@@ -112,5 +112,7 @@ class ApplyColorRequest(BaseModel):
 class ApplyTextureAIRequest(BaseModel):
     filename: str
     original_filename: str = ""
-    mask_filename: str
+    mask_filename: str = ""
     prompt: str = ""
+    texture_name: str = ""
+

backend/requirements.txt

@@ -9,3 +9,4 @@ pydantic
 python-multipart
 gradio_client
 opencv-python-headless
+openai

backend/routers/active_sessions.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+
+router = APIRouter()
+
+
+@router.get("/api/active-sessions")
+async def get_active_sessions():
+    # Endpoint ligero que devuelve sesiones activas.
+    # Actualmente no consultamos BD aquí; devolvemos un objeto vacío para evitar errores en frontend.
+    return JSONResponse(content={"count": 0, "active_sessions": []})

backend/routers/catalog.py

@@ -1,241 +1,240 @@
-import os
-from datetime import datetime
-
-from fastapi import APIRouter
-from fastapi.responses import JSONResponse
-from motor.motor_asyncio import AsyncIOMotorClient
-from pydantic import BaseModel
-
-router = APIRouter(prefix="/api/catalog")
-
-MONGODB_URI = os.getenv("MONGODB_URI", "")
-_client: AsyncIOMotorClient | None = None
-_db = None
-_col = None
-
-
-def _get_col():
-    global _client, _db, _col
-    if _col is None:
-        if not MONGODB_URI:
-            raise RuntimeError("MONGODB_URI no configurado")
-        _client = AsyncIOMotorClient(MONGODB_URI)
-        _db = _client["hyper_reality"]
-        _col = _db["catalog"]
-    return _col
-
-
-# ── Datos iniciales (se insertan solo si la colección está vacía) ─────────────
-_SEED = [
-    {
-        "_id": "acm",
-        "nombre": "ACM (Aluminio Compuesto)",
-        "tipo": "paredes",
-        "descripcion": "Paneles de aluminio compuesto para fachadas y exteriores",
-        "especificaciones": [
-            "Espesor de ACM 4mm.",
-            "Medida 1.22m x 2.44m",
-            "Facil Mantenimiento.",
-            "Espesor de Aluminio 0.40mm.",
-            "Se puede doblar o biselar",
-        ],
-        "url_detalle": "https://heyzine.com/flip-book/447fe3eb8e.html#page/16",
-        "productos": [
-            {"id": "acm_white",       "nombre": "Glossy White",     "textura": "Texture_ACM/ACM_White.png",          "url_preview": "/seg/texture-preview/Texture_ACM/ACM_White.png",          "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_amarillo",    "nombre": "Amarillo",          "textura": "Texture_ACM/ACM_Amarillo.png",       "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Amarillo.png",       "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_orange",      "nombre": "Glossy Orange",     "textura": "Texture_ACM/ACM_Orange.png",         "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Orange.png",         "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_red",         "nombre": "Glossy Red",        "textura": "Texture_ACM/ACM_Glossy_Red.png",    "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Glossy_Red.png",    "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_light_blue",  "nombre": "Light Blue",        "textura": "Texture_ACM/ACM_Light_Blue.png",     "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Light_Blue.png",     "dimensiones": ["1.22x2.44"]},
-            {"id": "acm_azul",        "nombre": "Azul",              "textura": "Texture_ACM/ACM_Azul.png",           "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Azul.png",           "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_verde_hn",    "nombre": "Verde HN",          "textura": "Texture_ACM/ACM_Verde_HN.png",       "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Verde_HN.png",       "dimensiones": ["1.22x2.44"]},
-            {"id": "acm_verde_lima",  "nombre": "Verde Lima",        "textura": "Texture_ACM/ACM_Verde_Lima.png",     "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Verde_Lima.png",     "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_verde",       "nombre": "Verde",             "textura": "Texture_ACM/ACM_Verde.png",          "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Verde.png",          "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_madera_clara","nombre": "Madera Clara",      "textura": "Texture_ACM/ACM_Madera_Clara.png",   "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Madera_Clara.png",   "dimensiones": ["1.22x2.44"]},
-            {"id": "acm_roble",       "nombre": "Roble (Oak)",       "textura": "Texture_ACM/ACM_ROBLE(OAK).png",    "url_preview": "/seg/texture-preview/Texture_ACM/ACM_ROBLE(OAK).png",    "dimensiones": ["1.22x2.44"]},
-            {"id": "acm_grafito",     "nombre": "Grafito",           "textura": "Texture_ACM/ACM_Grafito.png",        "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Grafito.png",        "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_metalic",     "nombre": "Silver Metallic",   "textura": "Texture_ACM/ACM_Metalic.png",        "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Metalic.png",        "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_mouse_grey",  "nombre": "Mouse Grey",        "textura": "Texture_ACM/ACM_MouseGrey.png",      "url_preview": "/seg/texture-preview/Texture_ACM/ACM_MouseGrey.png",      "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_matte_black", "nombre": "Matte Black",       "textura": "Texture_ACM/ACM_Matteblack.png",    "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Matteblack.png",    "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-            {"id": "acm_glossy_black","nombre": "Glossy Black",      "textura": "Texture_ACM/ACM_Glossy_Black.png",  "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Glossy_Black.png",  "dimensiones": ["1.22x2.44", "1.50x4.98"]},
-        ],
-        "created_at": "2026-04-20T00:00:00Z",
-    },
-    {
-        "_id": "wpc",
-        "nombre": "WPC (Exterior e Interior)",
-        "tipo": "paredes",
-        "descripcion": "Los paneles de WPC se utilizan como revestimiento decorativo para paredes. No se deforma, no requiere mantenimiento constante y tiene mayor durabilidad. Crea mayor estetica e instalacion rapida.",
-        "especificaciones": [
-            "Revestimiento decorativo para paredes.",
-            "No se deforma ni requiere mantenimiento constante.",
-            "Mayor durabilidad y estetica.",
-            "Instalacion rapida.",
-            "Ideal para: sala principal (pared protagonista), comedor, interior de oficina, pasillo o entradas.",
-        ],
-        "url_detalle": "https://heyzine.com/flip-book/447fe3eb8e.html#page/39",
-        "productos": [
-            {"id": "WPC_madera_oscuro", "nombre": "WPC Madera Oscuro", "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_oscuro.png", "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_oscuro.png", "dimensiones": ["2.90x0.25"]},
-            {"id": "WPC_madera_claro",  "nombre": "WPC Madera Claro",  "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_claro.png",  "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_claro.png",  "dimensiones": ["2.90x0.25"]},
-            {"id": "WPC_madera_gris",   "nombre": "WPC Madera Gris",   "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_gris.png",   "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_gris.png",   "dimensiones": ["2.90x0.25"]},
-            {"id": "WPC_negro",         "nombre": "WPC Negro",          "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_negro.png",          "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_negro.png",          "dimensiones": ["2.90x0.25"]},
-        ],
-        "created_at": "2026-05-07T00:00:00Z",
-    },
-    {
-        "_id": "wpc_deck",
-        "nombre": "WPC Deck",
-        "tipo": "suelos",
-        "descripcion": "Deck de WPC para exteriores e interiores. Ideal para terrazas, jardines, bordes de piscina y espacios al aire libre.",
-        "especificaciones": [
-            "Resistencia a la intemperie.",
-            "Bajo mantenimiento.",
-            "Respetuosa con el medio ambiente.",
-            "Esteticamente agradable.",
-        ],
-        "url_detalle": "https://heyzine.com/flip-book/447fe3eb8e.html#page/38",
-        "productos": [
-            {"id": "DECK_madera",        "nombre": "Deck Madera",        "textura": "Texture_WPC_DECK/DECK_madera.png",        "url_preview": "/seg/texture-preview/Texture_WPC_DECK/DECK_madera.png",        "dimensiones": ["2.90x0.14"]},
-            {"id": "DECK_madera_oscuro", "nombre": "Deck Madera Oscuro", "textura": "Texture_WPC_DECK/DECK_madera_oscuro.png", "url_preview": "/seg/texture-preview/Texture_WPC_DECK/DECK_madera_oscuro.png", "dimensiones": ["2.90x0.14"]},
-            {"id": "DECK_gris",          "nombre": "Deck Gris",           "textura": "Texture_WPC_DECK/DECK_gris.png",          "url_preview": "/seg/texture-preview/Texture_WPC_DECK/DECK_gris.png",          "dimensiones": ["2.90x0.14"]},
-        ],
-        "created_at": "2026-05-08T00:00:00Z",
-    },
-]
-
-
-async def seed_catalog() -> None:
-    col = _get_col()
-    count = await col.count_documents({})
-    if count == 0:
-        await col.insert_many(_SEED)
-        return
-
-    # Insertar entradas nuevas del seed y parchar campos faltantes en las existentes
-    for seed_item in _SEED:
-        doc = await col.find_one({"_id": seed_item["_id"]})
-        if not doc:
-            await col.insert_one(dict(seed_item))
-            continue
-        patch = {k: v for k, v in seed_item.items() if k not in doc and k != "_id"}
-        if patch:
-            await col.update_one({"_id": seed_item["_id"]}, {"$set": patch})
-
-
-def _serialize(doc: dict) -> dict:
-    out = dict(doc)
-    out["id"] = str(out.pop("_id"))
-    return out
-
-
-def _seed_as_response() -> list[dict]:
-    return [{**{k: v for k, v in item.items() if k != "_id"}, "id": item["_id"]} for item in _SEED]
-
-
-# ── Endpoints de lectura ──────────────────────────────────────────────────────
-
-@router.get("/textures")
-async def get_texture_catalog() -> JSONResponse:
-    try:
-        col = _get_col()
-        docs = await col.find({}).to_list(length=200)
-        if docs:
-            return JSONResponse(content={"categories": [_serialize(d) for d in docs]})
-    except Exception:
-        pass
-    # Fallback a datos estáticos si MongoDB no está disponible o la colección está vacía
-    return JSONResponse(content={"categories": _seed_as_response()})
-
-
-@router.get("/textures/{category_id}")
-async def get_texture_category(category_id: str) -> JSONResponse:
-    try:
-        col = _get_col()
-        doc = await col.find_one({"_id": category_id})
-        if doc:
-            return JSONResponse(content=_serialize(doc))
-    except Exception:
-        pass
-    fallback = next((item for item in _SEED if item["_id"] == category_id), None)
-    if fallback:
-        return JSONResponse(content=_seed_as_response()[_SEED.index(fallback)])
-    return JSONResponse(content={"detail": f"Categoria '{category_id}' no encontrada"}, status_code=404)
-
-
-# ── Modelos ───────────────────────────────────────────────────────────────────
-
-class ProductoItem(BaseModel):
-    id: str
-    nombre: str
-    textura: str
-    url_preview: str
-    dimensiones: list[str] = []
-
-
-class CategoriaBody(BaseModel):
-    id: str
-    nombre: str
-    tipo: str = "paredes"
-    descripcion: str = ""
-    especificaciones: list[str] = []
-    url_detalle: str = ""
-    productos: list[ProductoItem] = []
-
-
-# ── Endpoints de escritura ────────────────────────────────────────────────────
-
-@router.post("/category")
-async def add_category(body: CategoriaBody) -> JSONResponse:
-    col = _get_col()
-    existing = await col.find_one({"_id": body.id})
-    if existing:
-        return JSONResponse(content={"error": f"Categoria '{body.id}' ya existe"}, status_code=409)
-    doc = body.model_dump()
-    doc["_id"] = doc.pop("id")
-    doc["created_at"] = datetime.utcnow().isoformat() + "Z"
-    await col.insert_one(doc)
-    return JSONResponse(content={"ok": True, "id": body.id}, status_code=201)
-
-
-@router.put("/category/{category_id}")
-async def update_category(category_id: str, body: CategoriaBody) -> JSONResponse:
-    col = _get_col()
-    doc = body.model_dump()
-    doc.pop("id", None)
-    doc["updated_at"] = datetime.utcnow().isoformat() + "Z"
-    result = await col.update_one({"_id": category_id}, {"$set": doc})
-    if result.matched_count == 0:
-        return JSONResponse(content={"error": "Categoria no encontrada"}, status_code=404)
-    return JSONResponse(content={"ok": True})
-
-
-@router.delete("/category/{category_id}")
-async def delete_category(category_id: str) -> JSONResponse:
-    col = _get_col()
-    result = await col.delete_one({"_id": category_id})
-    if result.deleted_count == 0:
-        return JSONResponse(content={"error": "Categoria no encontrada"}, status_code=404)
-    return JSONResponse(content={"ok": True, "deleted": category_id})
-
-
-@router.post("/category/{category_id}/product")
-async def add_product(category_id: str, product: ProductoItem) -> JSONResponse:
-    col = _get_col()
-    result = await col.update_one(
-        {"_id": category_id, "productos.id": {"$ne": product.id}},
-        {"$push": {"productos": product.model_dump()}, "$set": {"updated_at": datetime.utcnow().isoformat() + "Z"}},
-    )
-    if result.matched_count == 0:
-        return JSONResponse(content={"error": "Categoria no encontrada o producto duplicado"}, status_code=409)
-    return JSONResponse(content={"ok": True}, status_code=201)
-
-
-@router.delete("/category/{category_id}/product/{product_id}")
-async def delete_product(category_id: str, product_id: str) -> JSONResponse:
-    col = _get_col()
-    result = await col.update_one(
-        {"_id": category_id},
-        {"$pull": {"productos": {"id": product_id}}, "$set": {"updated_at": datetime.utcnow().isoformat() + "Z"}},
-    )
-    if result.matched_count == 0:
-        return JSONResponse(content={"error": "Categoria no encontrada"}, status_code=404)
-    return JSONResponse(content={"ok": True})
+import os
+from datetime import datetime
+
+from fastapi import APIRouter
+from fastapi.responses import JSONResponse
+from motor.motor_asyncio import AsyncIOMotorClient
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api/catalog")
+
+MONGODB_URI = os.getenv("MONGODB_URI", "")
+_client: AsyncIOMotorClient | None = None
+_db = None
+_col = None
+
+
+def _get_col():
+    global _client, _db, _col
+    if _col is None:
+        if not MONGODB_URI:
+            raise RuntimeError("MONGODB_URI no configurado")
+        _client = AsyncIOMotorClient(MONGODB_URI)
+        _db = _client["hyper_reality"]
+        _col = _db["catalog"]
+    return _col
+
+
+# ── Datos iniciales (se insertan solo si la colección está vacía) ─────────────
+_SEED = [
+    {
+        "_id": "acm",
+        "nombre": "ACM (Aluminio Compuesto)",
+        "tipo": "paredes",
+        "descripcion": "Paneles de aluminio compuesto para fachadas y exteriores",
+        "especificaciones": [
+            "Espesor de ACM 4mm.",
+            "Medida 1.22m x 2.44m",
+            "Facil Mantenimiento.",
+            "Espesor de Aluminio 0.40mm.",
+            "Se puede doblar o biselar",
+        ],
+        "url_detalle": "https://heyzine.com/flip-book/447fe3eb8e.html#page/16",
+        "productos": [
+            {"id": "acm_white",       "nombre": "Glossy White",     "textura": "Texture_ACM/ACM_White.png",          "url_preview": "/seg/texture-preview/Texture_ACM/ACM_White.png",          "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_amarillo",    "nombre": "Amarillo",          "textura": "Texture_ACM/ACM_Amarillo.png",       "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Amarillo.png",       "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_orange",      "nombre": "Glossy Orange",     "textura": "Texture_ACM/ACM_Orange.png",         "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Orange.png",         "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_red",         "nombre": "Glossy Red",        "textura": "Texture_ACM/ACM_Glossy_Red.png",    "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Glossy_Red.png",    "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_light_blue",  "nombre": "Light Blue",        "textura": "Texture_ACM/ACM_Light_Blue.png",     "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Light_Blue.png",     "dimensiones": ["1.22x2.44"]},
+            {"id": "acm_azul",        "nombre": "Azul",              "textura": "Texture_ACM/ACM_Azul.png",           "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Azul.png",           "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_verde_hn",    "nombre": "Verde HN",          "textura": "Texture_ACM/ACM_Verde_HN.png",       "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Verde_HN.png",       "dimensiones": ["1.22x2.44"]},
+            {"id": "acm_verde_lima",  "nombre": "Verde Lima",        "textura": "Texture_ACM/ACM_Verde_Lima.png",     "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Verde_Lima.png",     "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_verde",       "nombre": "Verde",             "textura": "Texture_ACM/ACM_Verde.png",          "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Verde.png",          "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_madera_clara","nombre": "Madera Clara",      "textura": "Texture_ACM/ACM_Madera_Clara.png",   "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Madera_Clara.png",   "dimensiones": ["1.22x2.44"]},
+            {"id": "acm_roble",       "nombre": "Roble (Oak)",       "textura": "Texture_ACM/ACM_ROBLE(OAK).png",    "url_preview": "/seg/texture-preview/Texture_ACM/ACM_ROBLE(OAK).png",    "dimensiones": ["1.22x2.44"]},
+            {"id": "acm_grafito",     "nombre": "Grafito",           "textura": "Texture_ACM/ACM_Grafito.png",        "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Grafito.png",        "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_metalic",     "nombre": "Silver Metallic",   "textura": "Texture_ACM/ACM_Metalic.png",        "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Metalic.png",        "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_mouse_grey",  "nombre": "Mouse Grey",        "textura": "Texture_ACM/ACM_MouseGrey.png",      "url_preview": "/seg/texture-preview/Texture_ACM/ACM_MouseGrey.png",      "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_matte_black", "nombre": "Matte Black",       "textura": "Texture_ACM/ACM_Matteblack.png",    "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Matteblack.png",    "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+            {"id": "acm_glossy_black","nombre": "Glossy Black",      "textura": "Texture_ACM/ACM_Glossy_Black.png",  "url_preview": "/seg/texture-preview/Texture_ACM/ACM_Glossy_Black.png",  "dimensiones": ["1.22x2.44", "1.50x4.98"]},
+        ],
+        "created_at": "2026-04-20T00:00:00Z",
+    },
+    {
+        "_id": "wpc",
+        "nombre": "WPC (Exterior e Interior)",
+        "tipo": "paredes",
+        "descripcion": "Los paneles de WPC se utilizan como revestimiento decorativo para paredes. No se deforma, no requiere mantenimiento constante y tiene mayor durabilidad. Crea mayor estetica e instalacion rapida.",
+        "especificaciones": [
+            "Revestimiento decorativo para paredes.",
+            "No se deforma ni requiere mantenimiento constante.",
+            "Mayor durabilidad y estetica.",
+            "Instalacion rapida.",
+            "Ideal para: sala principal (pared protagonista), comedor, interior de oficina, pasillo o entradas.",
+        ],
+        "url_detalle": "https://heyzine.com/flip-book/447fe3eb8e.html#page/39",
+        "productos": [
+            {"id": "WPC_madera_oscuro", "nombre": "WPC Madera Oscuro", "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_oscuro.png", "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_oscuro.png", "dimensiones": ["2.90x0.25"]},
+            {"id": "WPC_madera_claro",  "nombre": "WPC Madera Claro",  "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_claro.png",  "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_claro.png",  "dimensiones": ["2.90x0.25"]},
+            {"id": "WPC_madera_gris",   "nombre": "WPC Madera Gris",   "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_gris.png",   "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_madera_gris.png",   "dimensiones": ["2.90x0.25"]},
+            {"id": "WPC_negro",         "nombre": "WPC Negro",          "textura": "Texture_WPC_EXTERIOR_INTERIOR/WPC_negro.png",          "url_preview": "/seg/texture-preview/Texture_WPC_EXTERIOR_INTERIOR/WPC_negro.png",          "dimensiones": ["2.90x0.25"]},
+        ],
+        "created_at": "2026-05-07T00:00:00Z",
+    },
+    {
+        "_id": "wpc_deck",
+        "nombre": "WPC Deck",
+        "tipo": "suelos",
+        "descripcion": "Deck de WPC para exteriores e interiores. Ideal para terrazas, jardines, bordes de piscina y espacios al aire libre.",
+        "especificaciones": [
+            "Resistencia a la intemperie.",
+            "Bajo mantenimiento.",
+            "Respetuosa con el medio ambiente.",
+            "Esteticamente agradable.",
+        ],
+        "url_detalle": "https://heyzine.com/flip-book/447fe3eb8e.html#page/38",
+        "productos": [
+            {"id": "DECK_madera",        "nombre": "Deck Madera",        "textura": "Texture_wpc_deck/DECK_madera.png",        "url_preview": "/seg/texture-preview/Texture_wpc_deck/DECK_madera.png",        "dimensiones": ["2.90x0.14"]},
+            {"id": "DECK_madera_oscuro", "nombre": "Deck Madera Oscuro", "textura": "Texture_wpc_deck/DECK_madera_oscuro.png", "url_preview": "/seg/texture-preview/Texture_wpc_deck/DECK_madera_oscuro.png", "dimensiones": ["2.90x0.14"]},
+            {"id": "DECK_gris",          "nombre": "Deck Gris",           "textura": "Texture_wpc_deck/DECK_gris.png",          "url_preview": "/seg/texture-preview/Texture_wpc_deck/DECK_gris.png",          "dimensiones": ["2.90x0.14"]},
+        ],
+        "created_at": "2026-05-08T00:00:00Z",
+    },
+]
+
+
+async def seed_catalog() -> None:
+    col = _get_col()
+    count = await col.count_documents({})
+    if count == 0:
+        await col.insert_many(_SEED)
+        return
+
+    # Migrar documentos existentes: añadir campos que falten según _SEED
+    for seed_item in _SEED:
+        doc = await col.find_one({"_id": seed_item["_id"]})
+        if not doc:
+            continue
+        patch = {k: v for k, v in seed_item.items() if k not in doc and k != "_id"}
+        if patch:
+            await col.update_one({"_id": seed_item["_id"]}, {"$set": patch})
+
+
+def _serialize(doc: dict) -> dict:
+    out = dict(doc)
+    out["id"] = str(out.pop("_id"))
+    return out
+
+
+def _seed_as_response() -> list[dict]:
+    return [{**{k: v for k, v in item.items() if k != "_id"}, "id": item["_id"]} for item in _SEED]
+
+
+# ── Endpoints de lectura ──────────────────────────────────────────────────────
+
+@router.get("/textures")
+async def get_texture_catalog() -> JSONResponse:
+    try:
+        col = _get_col()
+        docs = await col.find({}).to_list(length=200)
+        if docs:
+            return JSONResponse(content={"categories": [_serialize(d) for d in docs]})
+    except Exception:
+        pass
+    # Fallback a datos estáticos si MongoDB no está disponible o la colección está vacía
+    return JSONResponse(content={"categories": _seed_as_response()})
+
+
+@router.get("/textures/{category_id}")
+async def get_texture_category(category_id: str) -> JSONResponse:
+    try:
+        col = _get_col()
+        doc = await col.find_one({"_id": category_id})
+        if doc:
+            return JSONResponse(content=_serialize(doc))
+    except Exception:
+        pass
+    fallback = next((item for item in _SEED if item["_id"] == category_id), None)
+    if fallback:
+        return JSONResponse(content=_seed_as_response()[_SEED.index(fallback)])
+    return JSONResponse(content={"detail": f"Categoria '{category_id}' no encontrada"}, status_code=404)
+
+
+# ── Modelos ───────────────────────────────────────────────────────────────────
+
+class ProductoItem(BaseModel):
+    id: str
+    nombre: str
+    textura: str
+    url_preview: str
+    dimensiones: list[str] = []
+
+
+class CategoriaBody(BaseModel):
+    id: str
+    nombre: str
+    tipo: str = "paredes"
+    descripcion: str = ""
+    especificaciones: list[str] = []
+    url_detalle: str = ""
+    productos: list[ProductoItem] = []
+
+
+# ── Endpoints de escritura ────────────────────────────────────────────────────
+
+@router.post("/category")
+async def add_category(body: CategoriaBody) -> JSONResponse:
+    col = _get_col()
+    existing = await col.find_one({"_id": body.id})
+    if existing:
+        return JSONResponse(content={"error": f"Categoria '{body.id}' ya existe"}, status_code=409)
+    doc = body.model_dump()
+    doc["_id"] = doc.pop("id")
+    doc["created_at"] = datetime.utcnow().isoformat() + "Z"
+    await col.insert_one(doc)
+    return JSONResponse(content={"ok": True, "id": body.id}, status_code=201)
+
+
+@router.put("/category/{category_id}")
+async def update_category(category_id: str, body: CategoriaBody) -> JSONResponse:
+    col = _get_col()
+    doc = body.model_dump()
+    doc.pop("id", None)
+    doc["updated_at"] = datetime.utcnow().isoformat() + "Z"
+    result = await col.update_one({"_id": category_id}, {"$set": doc})
+    if result.matched_count == 0:
+        return JSONResponse(content={"error": "Categoria no encontrada"}, status_code=404)
+    return JSONResponse(content={"ok": True})
+
+
+@router.delete("/category/{category_id}")
+async def delete_category(category_id: str) -> JSONResponse:
+    col = _get_col()
+    result = await col.delete_one({"_id": category_id})
+    if result.deleted_count == 0:
+        return JSONResponse(content={"error": "Categoria no encontrada"}, status_code=404)
+    return JSONResponse(content={"ok": True, "deleted": category_id})
+
+
+@router.post("/category/{category_id}/product")
+async def add_product(category_id: str, product: ProductoItem) -> JSONResponse:
+    col = _get_col()
+    result = await col.update_one(
+        {"_id": category_id, "productos.id": {"$ne": product.id}},
+        {"$push": {"productos": product.model_dump()}, "$set": {"updated_at": datetime.utcnow().isoformat() + "Z"}},
+    )
+    if result.matched_count == 0:
+        return JSONResponse(content={"error": "Categoria no encontrada o producto duplicado"}, status_code=409)
+    return JSONResponse(content={"ok": True}, status_code=201)
+
+
+@router.delete("/category/{category_id}/product/{product_id}")
+async def delete_product(category_id: str, product_id: str) -> JSONResponse:
+    col = _get_col()
+    result = await col.update_one(
+        {"_id": category_id},
+        {"$pull": {"productos": {"id": product_id}}, "$set": {"updated_at": datetime.utcnow().isoformat() + "Z"}},
+    )
+    if result.matched_count == 0:
+        return JSONResponse(content={"error": "Categoria no encontrada"}, status_code=404)
+    return JSONResponse(content={"ok": True})

backend/routers/openai_image.py

@@ -0,0 +1,32 @@
+from fastapi import APIRouter, File, Form, HTTPException, UploadFile
+from fastapi.responses import JSONResponse
+from PIL import Image
+import io
+
+from services.openai_service import generate_image_with_openai
+
+router = APIRouter()
+
+
+@router.post("/api/generate-image")
+async def generate_image_endpoint(
+    file: UploadFile = File(...),
+    texture: str = Form(...),
+    api_key: str | None = Form(None),
+    preserve: int | None = Form(0),
+):
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="El archivo debe ser una imagen")
+
+    try:
+        contents = await file.read()
+        pil = Image.open(io.BytesIO(contents)).convert("RGB")
+    except Exception:
+        raise HTTPException(status_code=400, detail="No se pudo leer la imagen subida")
+
+    png_bytes, msg = generate_image_with_openai(api_key, pil, texture, preserve)
+    if png_bytes is None:
+        raise HTTPException(status_code=500, detail=msg)
+
+    b64 = __import__("base64").b64encode(png_bytes).decode("ascii")
+    return JSONResponse(content={"result_b64": b64, "message": msg})

backend/routers/segmentation.py

@@ -1,723 +1,760 @@
-"""
-Segmentation router - todos los endpoints del editor de texturas con SAM2.
-Prefijo: /seg
-"""
-import asyncio
-import uuid
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, cast
-
-from fastapi import APIRouter, BackgroundTasks, File, HTTPException, UploadFile
-from fastapi.responses import FileResponse, HTMLResponse, Response
-
-from core.config import (
-    FRONTEND_DEBUG,
-    OUTPUT_DIR,
-    SD_JOB_STALE_SECONDS,
-    SD_QUICK_TIMEOUT_SECONDS,
-    UPLOAD_DIR,
-    UPLOAD_JOB_STALE_SECONDS,
-    VIDEO_OUTPUT_DIR,
-    VIDEO_UPLOAD_DIR,
-    load_classic_dashboard_html,
-    log_timing_end,
-    log_timing_start,
-    logger,
-    utc_now_iso,
-)
-from pydantic import BaseModel
-
-from models.schemas import (
-    ApplyColorRequest,
-    ApplyTextureAIRequest,
-    ApplyTextureRequest,
-    ExteriorBrickRequest,
-    ExteriorDepthRequest,
-    ExteriorGrabCutRequest,
-    ExteriorHybridRequest,
-    ExteriorSuggestRequest,
-    GuidedSegmentRequest,
-    SceneAnalyzeRequest,
-    SegmentAdaptiveRequest,
-    SegmentVideoRequest,
-)
-from services.image_service import (
-    prepare_and_store_upload,
-    run_upload_job,
-    save_label_map_for_owner,
-)
-from services.inpainting_service import run_inpainting_job, run_inpainting_sync
-from services.sam2_service import jobs, jobs_lock, release_resources
-from services.scene_service import (
-    build_adaptive_plan,
-    generate_label_map,
-    infer_scene_type,
-    normalize_priority,
-    normalize_scene_hint,
-    rank_exterior_candidates,
-    rank_interior_candidates,
-)
-from services.segmentation_service import (
-    generate_guided_label_map,
-    parse_mask_index,
-    parse_rgb_color,
-    segment_exterior_brick_sync,
-    segment_exterior_depth_sync,
-    segment_exterior_grabcut_sync,
-    segment_exterior_hybrid_sync,
-    segment_video_sync,
-)
-from services.texture_service import (
-    apply_local_texture_sync,
-    build_texture_preview_jpeg,
-    generate_texture_variations,
-    list_available_textures,
-    resolve_texture_path,
-)
-
-import cv2
-
-router = APIRouter(prefix="/seg")
-
-
-@router.get("/", response_class=HTMLResponse)
-async def home() -> HTMLResponse:
-    dashboard_html = load_classic_dashboard_html().replace(
-        "__FRONTEND_DEBUG_ENABLED__",
-        "true" if FRONTEND_DEBUG else "false",
-    )
-    return HTMLResponse(content=dashboard_html)
-
-
-@router.post("/upload_video")
-async def upload_video(file: UploadFile = File(...)) -> dict[str, Any]:
-    if not file.content_type or not file.content_type.startswith("video/"):
-        raise HTTPException(status_code=400, detail="Only video files are allowed")
-
-    safe_name = Path(file.filename or "uploaded_video").name
-    if not safe_name:
-        raise HTTPException(status_code=400, detail="Invalid filename")
-
-    destination = VIDEO_UPLOAD_DIR / safe_name
-    content = await file.read()
-    if not content:
-        raise HTTPException(status_code=400, detail="Uploaded video is empty")
-
-    destination.write_bytes(content)
-    return {
-        "message": "Video uploaded successfully",
-        "filename": safe_name,
-        "url": f"/seg/video/{safe_name}",
-    }
-
-
-@router.post("/upload_async")
-async def upload_image_async(
-    background_tasks: BackgroundTasks,
-    file: UploadFile = File(...),
-) -> dict[str, Any]:
-    if not file.content_type or not file.content_type.startswith("image/"):
-        raise HTTPException(status_code=400, detail="Only image files are allowed")
-
-    content = await file.read()
-    job_id = uuid.uuid4().hex
-    with jobs_lock:
-        jobs[job_id] = {
-            "kind": "upload",
-            "status": "processing",
-            "stage": "queued",
-            "progress": 2,
-            "message": "Queued for segmentation",
-            "created_at": utc_now_iso(),
-            "updated_at": utc_now_iso(),
-        }
-
-    background_tasks.add_task(run_upload_job, job_id, content, file.filename or "uploaded_image")
-    return {
-        "processing": True,
-        "job_id": job_id,
-        "status": "processing",
-        "stage": "queued",
-        "progress": 2,
-        "message": "Upload accepted. Segmentation started in background.",
-        "status_url": f"/seg/jobs/{job_id}",
-    }
-
-
-@router.post("/segment_guided")
-async def segment_guided(payload: GuidedSegmentRequest) -> dict[str, Any]:
-    started = log_timing_start("SEGMENT_GUIDED")
-    try:
-        from services.image_service import load_image_rgb_for_edit
-        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
-        label_map, ranked_scores = await asyncio.to_thread(
-            generate_guided_label_map,
-            image_rgb,
-            [list(point) for point in payload.point_coords],
-            list(payload.point_labels),
-            list(payload.box_xyxy) if payload.box_xyxy is not None else [],
-            payload.multimask_output,
-        )
-
-        guided_owner = f"{Path(safe_name).stem}_guided.jpg"
-        label_owner = await asyncio.to_thread(save_label_map_for_owner, guided_owner, label_map)
-        available_indices = list(range(1, len(ranked_scores) + 1))
-
-        return {
-            "message": "Guided segmentation completed",
-            "filename": safe_name,
-            "original_filename_for_apply": label_owner,
-            "mask_count": len(ranked_scores),
-            "available_mask_indices": available_indices,
-            "recommended_mask_index": 1,
-            "scores": [round(score, 6) for score in ranked_scores],
-        }
-    finally:
-        log_timing_end("SEGMENT_GUIDED", started)
-        try:
-            release_resources()
-        except Exception:
-            logger.exception("Error releasing resources after SEGMENT_GUIDED")
-
-
-@router.post("/suggest_exterior_masks")
-async def suggest_exterior_masks(payload: ExteriorSuggestRequest) -> dict[str, Any]:
-    started = log_timing_start("EXTERIOR_SUGGEST")
-    try:
-        from services.image_service import load_image_rgb_for_edit
-        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
-
-        label_owner_name = Path(payload.original_filename).name if payload.original_filename else safe_name
-
-        masks_dir = UPLOAD_DIR / "masks"
-        label_path = masks_dir / f"{label_owner_name}_labels.png"
-        if not label_path.exists():
-            label_map, _ = await asyncio.to_thread(generate_label_map, image_rgb)
-            label_owner_name = await asyncio.to_thread(save_label_map_for_owner, label_owner_name, label_map)
-            label_path = masks_dir / f"{label_owner_name}_labels.png"
-
-        label_map_arr = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
-        if label_map_arr is None:
-            raise HTTPException(status_code=404, detail="Label map not found")
-
-        candidates = rank_exterior_candidates(
-            label_map_arr,
-            payload.top_k,
-            target=payload.target,
-            min_area_ratio=payload.min_area_ratio,
-            max_area_ratio=payload.max_area_ratio,
-        )
-
-        return {
-            "message": "Exterior mask suggestions generated",
-            "filename": safe_name,
-            "original_filename_for_apply": label_owner_name,
-            "suggestions": candidates,
-            "target": payload.target,
-        }
-    finally:
-        log_timing_end("EXTERIOR_SUGGEST", started)
-        try:
-            release_resources()
-        except Exception:
-            logger.exception("Error releasing resources after EXTERIOR_SUGGEST")
-
-
-@router.post("/analyze_scene")
-async def analyze_scene(payload: SceneAnalyzeRequest) -> dict[str, Any]:
-    started = log_timing_start("ANALYZE_SCENE")
-    try:
-        from services.image_service import load_image_rgb_for_edit
-        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
-
-        label_owner_name = Path(payload.original_filename).name if payload.original_filename else safe_name
-        masks_dir = UPLOAD_DIR / "masks"
-        label_path = masks_dir / f"{label_owner_name}_labels.png"
-
-        if not label_path.exists():
-            label_map, _ = await asyncio.to_thread(generate_label_map, image_rgb)
-            label_owner_name = await asyncio.to_thread(save_label_map_for_owner, label_owner_name, label_map)
-
-        scene_info = await asyncio.to_thread(
-            infer_scene_type,
-            image_rgb,
-            payload.semantic_keywords,
-            payload.exterior_target,
-            payload.min_area_ratio,
-            payload.max_area_ratio,
-        )
-        scene_type = scene_info["scene_type"]
-        scene_hint = normalize_scene_hint(payload.scene_hint)
-        effective_scene = scene_hint if scene_hint != "auto" else scene_type
-
-        adaptive_plan = build_adaptive_plan(effective_scene, payload.priority, payload.exterior_target)
-
-        label_map_arr = cv2.imread(str(masks_dir / f"{label_owner_name}_labels.png"), cv2.IMREAD_GRAYSCALE)
-        suggestions: list[dict[str, Any]] = []
-        if label_map_arr is not None:
-            if effective_scene == "exterior":
-                suggestions = rank_exterior_candidates(
-                    label_map_arr, payload.top_k,
-                    target=payload.exterior_target,
-                    min_area_ratio=payload.min_area_ratio,
-                    max_area_ratio=payload.max_area_ratio,
-                )
-            else:
-                suggestions = rank_interior_candidates(label_map_arr, payload.top_k)
-
-        return {
-            "message": "Scene analysis completed",
-            "filename": safe_name,
-            "original_filename_for_apply": label_owner_name,
-            "scene_type": scene_type,
-            "effective_scene": effective_scene,
-            "confidence": scene_info["confidence"],
-            "signals": scene_info["signals"],
-            "adaptive_plan": adaptive_plan,
-            "suggestions": suggestions,
-            "priority": normalize_priority(payload.priority),
-        }
-    finally:
-        log_timing_end("ANALYZE_SCENE", started)
-        try:
-            release_resources()
-        except Exception:
-            logger.exception("Error releasing resources after ANALYZE_SCENE")
-
-
-@router.post("/segment_adaptive")
-async def segment_adaptive(payload: SegmentAdaptiveRequest) -> dict[str, Any]:
-    started = log_timing_start("SEGMENT_ADAPTIVE")
-    try:
-        from services.image_service import load_image_rgb_for_edit
-        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
-
-        scene_info = await asyncio.to_thread(
-            infer_scene_type,
-            image_rgb,
-            payload.semantic_keywords,
-            payload.exterior_target,
-        )
-        scene_hint = normalize_scene_hint(payload.scene_hint)
-        effective_scene = scene_hint if scene_hint != "auto" else scene_info["scene_type"]
-        priority = normalize_priority(payload.priority)
-        adaptive_plan = build_adaptive_plan(effective_scene, priority, payload.exterior_target)
-
-        label_owner_name = Path(payload.original_filename).name if payload.original_filename else safe_name
-
-        if effective_scene == "exterior":
-            from services.segmentation_service import segment_exterior_depth_sync as seg_depth
-            from models.schemas import ExteriorDepthRequest as DepthReq
-
-            depth_payload = DepthReq(
-                filename=payload.filename,
-                exterior_target=payload.exterior_target,
-                rect_xywh=payload.rect_xywh,
-                smooth_strength=1,
-                sam2_merge_top_k=12,
-                iterations=6,
-                use_semantic_hint=True,
-                use_depth_hint=True,
-                semantic_keywords=payload.semantic_keywords,
-            )
-            result = await asyncio.to_thread(seg_depth, depth_payload)
-        else:
-            label_map, _ = await asyncio.to_thread(generate_label_map, image_rgb)
-            label_owner_name = await asyncio.to_thread(save_label_map_for_owner, label_owner_name, label_map)
-            top_k = 4 if priority == "speed" else (10 if priority == "quality" else 6)
-            candidates = rank_interior_candidates(label_map, top_k)
-            result = {
-                "message": "Interior adaptive segmentation completed",
-                "filename": safe_name,
-                "original_filename_for_apply": label_owner_name,
-                "scene_type": effective_scene,
-                "suggestions": candidates,
-            }
-
-        result["adaptive_plan"] = adaptive_plan
-        result["detected_scene_type"] = scene_info["scene_type"]
-        result["effective_scene"] = effective_scene
-        result["scene_confidence"] = scene_info["confidence"]
-        return result
-    finally:
-        log_timing_end("SEGMENT_ADAPTIVE", started)
-        try:
-            release_resources()
-        except Exception:
-            logger.exception("Error releasing resources after SEGMENT_ADAPTIVE")
-
-
-@router.post("/segment_video")
-async def segment_video(payload: SegmentVideoRequest) -> dict[str, Any]:
-    try:
-        return await asyncio.to_thread(segment_video_sync, payload)
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Video segmentation failed: {exc}") from exc
-
-
-@router.post("/segment_exterior_grabcut")
-async def segment_exterior_grabcut(payload: ExteriorGrabCutRequest) -> dict[str, Any]:
-    try:
-        return await asyncio.to_thread(segment_exterior_grabcut_sync, payload)
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"GrabCut segmentation failed: {exc}") from exc
-
-
-@router.post("/segment_exterior_hybrid")
-async def segment_exterior_hybrid(payload: ExteriorHybridRequest) -> dict[str, Any]:
-    try:
-        return await asyncio.to_thread(segment_exterior_hybrid_sync, payload)
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Hybrid exterior segmentation failed: {exc}") from exc
-
-
-@router.post("/segment_exterior_brick")
-async def segment_exterior_brick(payload: ExteriorBrickRequest) -> dict[str, Any]:
-    try:
-        return await asyncio.to_thread(segment_exterior_brick_sync, payload)
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Brick segmentation failed: {exc}") from exc
-
-
-@router.post("/segment_exterior_depth")
-async def segment_exterior_depth(payload: ExteriorDepthRequest) -> dict[str, Any]:
-    try:
-        return await asyncio.to_thread(segment_exterior_depth_sync, payload)
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Depth exterior segmentation failed: {exc}") from exc
-
-
-@router.post("/apply_texture_ai")
-async def apply_texture_ai(
-    payload: ApplyTextureAIRequest,
-    background_tasks: BackgroundTasks,
-) -> dict[str, Any]:
-    started = log_timing_start("APPLY_TEXTURE_AI")
-    try:
-        result = await asyncio.wait_for(
-            asyncio.to_thread(run_inpainting_sync, payload),
-            timeout=SD_QUICK_TIMEOUT_SECONDS,
-        )
-        log_timing_end("APPLY_TEXTURE_AI", started)
-        try:
-            release_resources()
-        except Exception:
-            logger.exception("Error releasing resources after APPLY_TEXTURE_AI")
-        result["processing"] = False
-        return result
-    except asyncio.TimeoutError:
-        job_id = uuid.uuid4().hex
-        with jobs_lock:
-            jobs[job_id] = {"status": "processing", "created_at": utc_now_iso(), "updated_at": utc_now_iso()}
-        background_tasks.add_task(run_inpainting_job, job_id, payload)
-        log_timing_end("APPLY_TEXTURE_AI", started)
-        try:
-            release_resources()
-        except Exception:
-            pass
-        return {
-            "processing": True,
-            "job_id": job_id,
-            "message": "Inpainting is taking longer than expected and continues in background.",
-            "status_url": f"/seg/jobs/{job_id}",
-        }
-    except HTTPException:
-        log_timing_end("APPLY_TEXTURE_AI", started)
-        try:
-            release_resources()
-        except Exception:
-            pass
-        raise
-    except Exception as exc:
-        log_timing_end("APPLY_TEXTURE_AI", started)
-        try:
-            release_resources()
-        except Exception:
-            pass
-        raise HTTPException(status_code=500, detail=f"Inpainting failed: {exc}") from exc
-
-
-@router.get("/jobs/{job_id}")
-async def get_job_status(job_id: str) -> dict[str, Any]:
-    with jobs_lock:
-        job = jobs.get(job_id)
-
-    if job is None:
-        raise HTTPException(status_code=404, detail="Job not found")
-
-    if job.get("status") == "processing":
-        kind = str(job.get("kind", "generic"))
-        stage = str(job.get("stage", "processing"))
-        progress = int(job.get("progress", 0) or 0)
-        eta_seconds: int | None = None
-
-        if kind == "upload" and stage == "segmenting_with_sam2":
-            stage_started_at_text = job.get("stage_started_at")
-            estimated_seconds = float(job.get("estimated_seconds", 0.0) or 0.0)
-            if stage_started_at_text and estimated_seconds > 0:
-                try:
-                    stage_started_at = datetime.fromisoformat(str(stage_started_at_text))
-                    elapsed = (datetime.now(timezone.utc) - stage_started_at).total_seconds()
-                    eta_seconds = max(0, int(estimated_seconds - elapsed))
-                    estimated_progress = int(min(95, 30 + (max(0.0, elapsed) / estimated_seconds) * 60))
-                    progress = max(progress, estimated_progress)
-                except ValueError:
-                    pass
-
-        stale_limit_seconds = UPLOAD_JOB_STALE_SECONDS if kind == "upload" else SD_JOB_STALE_SECONDS
-        created_at_text = job.get("created_at")
-        if created_at_text:
-            try:
-                created_at = datetime.fromisoformat(str(created_at_text))
-                age_seconds = (datetime.now(timezone.utc) - created_at).total_seconds()
-                if age_seconds > stale_limit_seconds:
-                    return {
-                        "processing": False,
-                        "status": "timeout",
-                        "message": "The process is taking too long. Please retry.",
-                        "job_id": job_id,
-                    }
-            except ValueError:
-                pass
-
-        response: dict[str, Any] = {
-            "processing": True,
-            "status": "processing",
-            "job_id": job_id,
-            "kind": kind,
-            "stage": stage,
-            "progress": progress,
-            "message": str(job.get("message", "Still processing.")),
-        }
-        if eta_seconds is not None:
-            response["eta_seconds"] = eta_seconds
-        return response
-
-    if job.get("status") == "done":
-        result = cast(dict[str, Any], job.get("result", {}))
-        result["processing"] = False
-        result["job_id"] = job_id
-        result["status"] = "done"
-        return result
-
-    if job.get("status") == "failed":
-        return {
-            "processing": False,
-            "status": "failed",
-            "job_id": job_id,
-            "message": job.get("error", "Background task failed"),
-        }
-
-    return {"processing": True, "status": "processing", "job_id": job_id, "message": "Still processing."}
-
-
-@router.post("/apply_color")
-async def apply_color(payload: ApplyColorRequest) -> dict[str, Any]:
-    started = log_timing_start("APPLY_COLOR")
-    try:
-        safe_name = Path(payload.filename).name
-        if not safe_name:
-            raise HTTPException(status_code=400, detail="Invalid filename")
-
-        label_safe_name = Path(payload.original_filename).name if payload.original_filename else safe_name
-
-        image_path = UPLOAD_DIR / safe_name
-        if not image_path.exists():
-            image_path = OUTPUT_DIR / safe_name
-        if not image_path.exists() or not image_path.is_file():
-            raise HTTPException(status_code=404, detail=f"Image not found: {safe_name}")
-
-        image_bgr = cv2.imread(str(image_path))
-        if image_bgr is None:
-            raise HTTPException(status_code=400, detail="Image could not be read")
-
-        mask_index = parse_mask_index(payload.mask_filename)
-        red, green, blue = parse_rgb_color(payload.color)
-
-        label_path = UPLOAD_DIR / "masks" / f"{label_safe_name}_labels.png"
-        label_map = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
-        if label_map is None:
-            raise HTTPException(
-                status_code=404,
-                detail="Label map not found. Upload the image first to generate segments.",
-            )
-
-        segmentation = label_map == mask_index
-        if not segmentation.any():
-            raise HTTPException(status_code=400, detail=f"Segment index {mask_index} not found in label map.")
-
-        edited_image = image_bgr.copy()
-        edited_image[segmentation] = (blue, green, red)
-
-        original_stem = Path(label_safe_name).stem
-        out_filename = f"{original_stem}_edit.jpg"
-        out_path = UPLOAD_DIR / out_filename
-        if not cv2.imwrite(str(out_path), edited_image):
-            raise HTTPException(status_code=500, detail="Failed to save edited image")
-
-        return {
-            "message": "Color applied successfully",
-            "output_filename": out_filename,
-            "output_url": f"/seg/image/{out_filename}",
-        }
-    finally:
-        log_timing_end("APPLY_COLOR", started)
-        try:
-            release_resources()
-        except Exception:
-            logger.exception("Error releasing resources after APPLY_COLOR")
-
-
-@router.post("/apply_texture")
-async def apply_texture(payload: ApplyTextureRequest) -> dict[str, Any]:
-    try:
-        result = await asyncio.to_thread(apply_local_texture_sync, payload)
-        result["processing"] = False
-        return result
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Texture apply failed: {exc}") from exc
-
-
-@router.get("/textures")
-async def get_textures() -> dict[str, Any]:
-    return {"textures": list_available_textures()}
-
-
-class _GenerateVariationsRequest(BaseModel):
-    texture_name: str
-
-    class Config:
-        extra = "ignore"
-
-
-@router.post("/textures/generate")
-async def generate_variations(payload: _GenerateVariationsRequest) -> dict[str, Any]:
-    if not payload.texture_name:
-        raise HTTPException(status_code=400, detail="texture_name is required")
-    try:
-        variations = await asyncio.to_thread(generate_texture_variations, payload.texture_name)
-        return {"variations": variations}
-    except HTTPException:
-        raise
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Variation generation failed: {exc}") from exc
-
-
-@router.get("/texture-preview/{filename:path}")
-async def get_texture_preview(filename: str) -> Response:
-    texture_path = resolve_texture_path(filename)
-    jpeg = await asyncio.to_thread(build_texture_preview_jpeg, texture_path)
-    return Response(content=jpeg, media_type="image/jpeg", headers={"Cache-Control": "public, max-age=3600"})
-
-
-@router.get("/video/{filename}")
-async def get_video(filename: str) -> FileResponse:
-    if Path(filename).name != filename:
-        raise HTTPException(status_code=400, detail="Invalid file name")
-    video_path = VIDEO_UPLOAD_DIR / filename
-    if not video_path.exists() or not video_path.is_file():
-        raise HTTPException(status_code=404, detail="Video not found")
-    return FileResponse(video_path)
-
-
-@router.get("/output-video/{filename}")
-async def get_output_video(filename: str) -> FileResponse:
-    if Path(filename).name != filename:
-        raise HTTPException(status_code=400, detail="Invalid file name")
-    video_path = VIDEO_OUTPUT_DIR / filename
-    if not video_path.exists() or not video_path.is_file():
-        raise HTTPException(status_code=404, detail="Output video not found")
-    return FileResponse(video_path)
-
-
-@router.get("/image/{filename}")
-async def get_image(filename: str) -> FileResponse:
-    if Path(filename).name != filename:
-        raise HTTPException(status_code=400, detail="Invalid file name")
-    image_path = UPLOAD_DIR / filename
-    if not image_path.exists() or not image_path.is_file():
-        raise HTTPException(status_code=404, detail="Image not found")
-    return FileResponse(image_path)
-
-
-@router.post("/masks/reclassify/{filename}")
-async def reclassify_mask_metadata(filename: str) -> dict[str, Any]:
-    """Re-run semantic classification on an already-segmented image and overwrite its metadata JSON."""
-    import json as _json
-    safe = Path(filename).name
-    if not safe:
-        raise HTTPException(status_code=400, detail="Invalid filename")
-
-    masks_dir = UPLOAD_DIR / "masks"
-    label_path = masks_dir / f"{safe}_labels.png"
-    if not label_path.exists():
-        raise HTTPException(status_code=404, detail="Label map not found — upload the image first")
-
-    label_map = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
-    if label_map is None:
-        raise HTTPException(status_code=500, detail="Could not read label map")
-
-    image_path = UPLOAD_DIR / safe
-    image_rgb: Any = None
-    if image_path.exists():
-        img_bgr = cv2.imread(str(image_path))
-        if img_bgr is not None:
-            image_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
-
-    from services.scene_service import classify_all_label_map_segments
-    h, w = label_map.shape[:2]
-    segments_meta = await asyncio.to_thread(
-        classify_all_label_map_segments, label_map, w, h, image_rgb
-    )
-    meta_path = masks_dir / f"{safe}_labels_meta.json"
-    meta_path.write_text(_json.dumps({"segments": segments_meta}, ensure_ascii=False), encoding="utf-8")
-
-    return {"segments": segments_meta, "count": len(segments_meta)}
-
-
-@router.get("/masks/meta/{filename}")
-async def get_mask_metadata(filename: str) -> dict:
-    import json as _json
-    safe = Path(filename).name
-    if not safe:
-        raise HTTPException(status_code=400, detail="Invalid filename")
-    meta_path = UPLOAD_DIR / "masks" / f"{safe}_labels_meta.json"
-    if not meta_path.exists() or not meta_path.is_file():
-        raise HTTPException(status_code=404, detail="Segment metadata not found")
-    try:
-        return _json.loads(meta_path.read_text(encoding="utf-8"))
-    except Exception as exc:
-        raise HTTPException(status_code=500, detail=f"Failed to read metadata: {exc}") from exc
-
-
-@router.get("/masks/{filename}")
-async def get_mask_labels(filename: str) -> FileResponse:
-    if Path(filename).name != filename:
-        raise HTTPException(status_code=400, detail="Invalid file name")
-    label_path = UPLOAD_DIR / "masks" / f"{filename}_labels.png"
-    if not label_path.exists() or not label_path.is_file():
-        raise HTTPException(status_code=404, detail="Label map not found")
-    return FileResponse(label_path)
-
-
-@router.get("/ai/{filename}")
-async def get_ai_image(filename: str) -> FileResponse:
-    if Path(filename).name != filename:
-        raise HTTPException(status_code=400, detail="Invalid file name")
-    out_path = OUTPUT_DIR / filename
-    if not out_path.exists() or not out_path.is_file():
-        raise HTTPException(status_code=404, detail="AI output image not found")
-    return FileResponse(out_path)
+"""
+Segmentation router - todos los endpoints del editor de texturas con SAM2.
+Prefijo: /seg
+"""
+import asyncio
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, cast
+
+from fastapi import APIRouter, BackgroundTasks, File, HTTPException, UploadFile
+from fastapi.responses import FileResponse, HTMLResponse, Response
+
+from core.config import (
+    FRONTEND_DEBUG,
+    OUTPUT_DIR,
+    SD_JOB_STALE_SECONDS,
+    SD_QUICK_TIMEOUT_SECONDS,
+    UPLOAD_DIR,
+    UPLOAD_JOB_STALE_SECONDS,
+    VIDEO_OUTPUT_DIR,
+    VIDEO_UPLOAD_DIR,
+    load_classic_dashboard_html,
+    log_timing_end,
+    log_timing_start,
+    logger,
+    utc_now_iso,
+)
+from pydantic import BaseModel
+
+from models.schemas import (
+    ApplyColorRequest,
+    ApplyTextureAIRequest,
+    ApplyTextureRequest,
+    ExteriorBrickRequest,
+    ExteriorDepthRequest,
+    ExteriorGrabCutRequest,
+    ExteriorHybridRequest,
+    ExteriorSuggestRequest,
+    GuidedSegmentRequest,
+    SceneAnalyzeRequest,
+    SegmentAdaptiveRequest,
+    SegmentVideoRequest,
+)
+from services.image_service import (
+    prepare_and_store_upload,
+    run_upload_job,
+    save_label_map_for_owner,
+)
+from services.inpainting_service import run_inpainting_job, run_inpainting_sync
+from services.sam2_service import jobs, jobs_lock, release_resources
+from services.openai_service import generate_image_with_openai
+from PIL import Image
+from services.scene_service import (
+    build_adaptive_plan,
+    generate_label_map,
+    infer_scene_type,
+    normalize_priority,
+    normalize_scene_hint,
+    rank_exterior_candidates,
+    rank_interior_candidates,
+)
+from services.segmentation_service import (
+    generate_guided_label_map,
+    parse_mask_index,
+    parse_rgb_color,
+    segment_exterior_brick_sync,
+    segment_exterior_depth_sync,
+    segment_exterior_grabcut_sync,
+    segment_exterior_hybrid_sync,
+    segment_video_sync,
+)
+from services.texture_service import (
+    apply_local_texture_sync,
+    build_texture_preview_jpeg,
+    generate_texture_variations,
+    list_available_textures,
+    resolve_texture_path,
+)
+
+import cv2
+
+router = APIRouter(prefix="/seg")
+
+
+@router.get("/", response_class=HTMLResponse)
+async def home() -> HTMLResponse:
+    dashboard_html = load_classic_dashboard_html().replace(
+        "__FRONTEND_DEBUG_ENABLED__",
+        "true" if FRONTEND_DEBUG else "false",
+    )
+    return HTMLResponse(content=dashboard_html)
+
+
+@router.post("/upload_video")
+async def upload_video(file: UploadFile = File(...)) -> dict[str, Any]:
+    if not file.content_type or not file.content_type.startswith("video/"):
+        raise HTTPException(status_code=400, detail="Only video files are allowed")
+
+    safe_name = Path(file.filename or "uploaded_video").name
+    if not safe_name:
+        raise HTTPException(status_code=400, detail="Invalid filename")
+
+    destination = VIDEO_UPLOAD_DIR / safe_name
+    content = await file.read()
+    if not content:
+        raise HTTPException(status_code=400, detail="Uploaded video is empty")
+
+    destination.write_bytes(content)
+    return {
+        "message": "Video uploaded successfully",
+        "filename": safe_name,
+        "url": f"/seg/video/{safe_name}",
+    }
+
+
+@router.post("/upload_async")
+async def upload_image_async(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+) -> dict[str, Any]:
+    if not file.content_type or not file.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="Only image files are allowed")
+
+    content = await file.read()
+    job_id = uuid.uuid4().hex
+    with jobs_lock:
+        jobs[job_id] = {
+            "kind": "upload",
+            "status": "processing",
+            "stage": "queued",
+            "progress": 2,
+            "message": "Queued for segmentation",
+            "created_at": utc_now_iso(),
+            "updated_at": utc_now_iso(),
+        }
+
+    background_tasks.add_task(run_upload_job, job_id, content, file.filename or "uploaded_image")
+    return {
+        "processing": True,
+        "job_id": job_id,
+        "status": "processing",
+        "stage": "queued",
+        "progress": 2,
+        "message": "Upload accepted. Segmentation started in background.",
+        "status_url": f"/seg/jobs/{job_id}",
+    }
+
+
+@router.post("/segment_guided")
+async def segment_guided(payload: GuidedSegmentRequest) -> dict[str, Any]:
+    started = log_timing_start("SEGMENT_GUIDED")
+    try:
+        from services.image_service import load_image_rgb_for_edit
+        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
+        label_map, ranked_scores = await asyncio.to_thread(
+            generate_guided_label_map,
+            image_rgb,
+            [list(point) for point in payload.point_coords],
+            list(payload.point_labels),
+            list(payload.box_xyxy) if payload.box_xyxy is not None else [],
+            payload.multimask_output,
+        )
+
+        guided_owner = f"{Path(safe_name).stem}_guided.jpg"
+        label_owner = await asyncio.to_thread(save_label_map_for_owner, guided_owner, label_map)
+        available_indices = list(range(1, len(ranked_scores) + 1))
+
+        return {
+            "message": "Guided segmentation completed",
+            "filename": safe_name,
+            "original_filename_for_apply": label_owner,
+            "mask_count": len(ranked_scores),
+            "available_mask_indices": available_indices,
+            "recommended_mask_index": 1,
+            "scores": [round(score, 6) for score in ranked_scores],
+        }
+    finally:
+        log_timing_end("SEGMENT_GUIDED", started)
+        try:
+            release_resources()
+        except Exception:
+            logger.exception("Error releasing resources after SEGMENT_GUIDED")
+
+
+@router.post("/suggest_exterior_masks")
+async def suggest_exterior_masks(payload: ExteriorSuggestRequest) -> dict[str, Any]:
+    started = log_timing_start("EXTERIOR_SUGGEST")
+    try:
+        from services.image_service import load_image_rgb_for_edit
+        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
+
+        label_owner_name = Path(payload.original_filename).name if payload.original_filename else safe_name
+
+        masks_dir = UPLOAD_DIR / "masks"
+        label_path = masks_dir / f"{label_owner_name}_labels.png"
+        if not label_path.exists():
+            label_map, _ = await asyncio.to_thread(generate_label_map, image_rgb)
+            label_owner_name = await asyncio.to_thread(save_label_map_for_owner, label_owner_name, label_map)
+            label_path = masks_dir / f"{label_owner_name}_labels.png"
+
+        label_map_arr = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
+        if label_map_arr is None:
+            raise HTTPException(status_code=404, detail="Label map not found")
+
+        candidates = rank_exterior_candidates(
+            label_map_arr,
+            payload.top_k,
+            target=payload.target,
+            min_area_ratio=payload.min_area_ratio,
+            max_area_ratio=payload.max_area_ratio,
+        )
+
+        return {
+            "message": "Exterior mask suggestions generated",
+            "filename": safe_name,
+            "original_filename_for_apply": label_owner_name,
+            "suggestions": candidates,
+            "target": payload.target,
+        }
+    finally:
+        log_timing_end("EXTERIOR_SUGGEST", started)
+        try:
+            release_resources()
+        except Exception:
+            logger.exception("Error releasing resources after EXTERIOR_SUGGEST")
+
+
+@router.post("/analyze_scene")
+async def analyze_scene(payload: SceneAnalyzeRequest) -> dict[str, Any]:
+    started = log_timing_start("ANALYZE_SCENE")
+    try:
+        from services.image_service import load_image_rgb_for_edit
+        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
+
+        label_owner_name = Path(payload.original_filename).name if payload.original_filename else safe_name
+        masks_dir = UPLOAD_DIR / "masks"
+        label_path = masks_dir / f"{label_owner_name}_labels.png"
+
+        if not label_path.exists():
+            label_map, _ = await asyncio.to_thread(generate_label_map, image_rgb)
+            label_owner_name = await asyncio.to_thread(save_label_map_for_owner, label_owner_name, label_map)
+
+        scene_info = await asyncio.to_thread(
+            infer_scene_type,
+            image_rgb,
+            payload.semantic_keywords,
+            payload.exterior_target,
+            payload.min_area_ratio,
+            payload.max_area_ratio,
+        )
+        scene_type = scene_info["scene_type"]
+        scene_hint = normalize_scene_hint(payload.scene_hint)
+        effective_scene = scene_hint if scene_hint != "auto" else scene_type
+
+        adaptive_plan = build_adaptive_plan(effective_scene, payload.priority, payload.exterior_target)
+
+        label_map_arr = cv2.imread(str(masks_dir / f"{label_owner_name}_labels.png"), cv2.IMREAD_GRAYSCALE)
+        suggestions: list[dict[str, Any]] = []
+        if label_map_arr is not None:
+            if effective_scene == "exterior":
+                suggestions = rank_exterior_candidates(
+                    label_map_arr, payload.top_k,
+                    target=payload.exterior_target,
+                    min_area_ratio=payload.min_area_ratio,
+                    max_area_ratio=payload.max_area_ratio,
+                )
+            else:
+                suggestions = rank_interior_candidates(label_map_arr, payload.top_k)
+
+        return {
+            "message": "Scene analysis completed",
+            "filename": safe_name,
+            "original_filename_for_apply": label_owner_name,
+            "scene_type": scene_type,
+            "effective_scene": effective_scene,
+            "confidence": scene_info["confidence"],
+            "signals": scene_info["signals"],
+            "adaptive_plan": adaptive_plan,
+            "suggestions": suggestions,
+            "priority": normalize_priority(payload.priority),
+        }
+    finally:
+        log_timing_end("ANALYZE_SCENE", started)
+        try:
+            release_resources()
+        except Exception:
+            logger.exception("Error releasing resources after ANALYZE_SCENE")
+
+
+@router.post("/segment_adaptive")
+async def segment_adaptive(payload: SegmentAdaptiveRequest) -> dict[str, Any]:
+    started = log_timing_start("SEGMENT_ADAPTIVE")
+    try:
+        from services.image_service import load_image_rgb_for_edit
+        safe_name, image_rgb = await asyncio.to_thread(load_image_rgb_for_edit, payload.filename)
+
+        scene_info = await asyncio.to_thread(
+            infer_scene_type,
+            image_rgb,
+            payload.semantic_keywords,
+            payload.exterior_target,
+        )
+        scene_hint = normalize_scene_hint(payload.scene_hint)
+        effective_scene = scene_hint if scene_hint != "auto" else scene_info["scene_type"]
+        priority = normalize_priority(payload.priority)
+        adaptive_plan = build_adaptive_plan(effective_scene, priority, payload.exterior_target)
+
+        label_owner_name = Path(payload.original_filename).name if payload.original_filename else safe_name
+
+        if effective_scene == "exterior":
+            from services.segmentation_service import segment_exterior_depth_sync as seg_depth
+            from models.schemas import ExteriorDepthRequest as DepthReq
+
+            depth_payload = DepthReq(
+                filename=payload.filename,
+                exterior_target=payload.exterior_target,
+                rect_xywh=payload.rect_xywh,
+                smooth_strength=1,
+                sam2_merge_top_k=12,
+                iterations=6,
+                use_semantic_hint=True,
+                use_depth_hint=True,
+                semantic_keywords=payload.semantic_keywords,
+            )
+            result = await asyncio.to_thread(seg_depth, depth_payload)
+        else:
+            label_map, _ = await asyncio.to_thread(generate_label_map, image_rgb)
+            label_owner_name = await asyncio.to_thread(save_label_map_for_owner, label_owner_name, label_map)
+            top_k = 4 if priority == "speed" else (10 if priority == "quality" else 6)
+            candidates = rank_interior_candidates(label_map, top_k)
+            result = {
+                "message": "Interior adaptive segmentation completed",
+                "filename": safe_name,
+                "original_filename_for_apply": label_owner_name,
+                "scene_type": effective_scene,
+                "suggestions": candidates,
+            }
+
+        result["adaptive_plan"] = adaptive_plan
+        result["detected_scene_type"] = scene_info["scene_type"]
+        result["effective_scene"] = effective_scene
+        result["scene_confidence"] = scene_info["confidence"]
+        return result
+    finally:
+        log_timing_end("SEGMENT_ADAPTIVE", started)
+        try:
+            release_resources()
+        except Exception:
+            logger.exception("Error releasing resources after SEGMENT_ADAPTIVE")
+
+
+@router.post("/segment_video")
+async def segment_video(payload: SegmentVideoRequest) -> dict[str, Any]:
+    try:
+        return await asyncio.to_thread(segment_video_sync, payload)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Video segmentation failed: {exc}") from exc
+
+
+@router.post("/segment_exterior_grabcut")
+async def segment_exterior_grabcut(payload: ExteriorGrabCutRequest) -> dict[str, Any]:
+    try:
+        return await asyncio.to_thread(segment_exterior_grabcut_sync, payload)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"GrabCut segmentation failed: {exc}") from exc
+
+
+@router.post("/segment_exterior_hybrid")
+async def segment_exterior_hybrid(payload: ExteriorHybridRequest) -> dict[str, Any]:
+    try:
+        return await asyncio.to_thread(segment_exterior_hybrid_sync, payload)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Hybrid exterior segmentation failed: {exc}") from exc
+
+
+@router.post("/segment_exterior_brick")
+async def segment_exterior_brick(payload: ExteriorBrickRequest) -> dict[str, Any]:
+    try:
+        return await asyncio.to_thread(segment_exterior_brick_sync, payload)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Brick segmentation failed: {exc}") from exc
+
+
+@router.post("/segment_exterior_depth")
+async def segment_exterior_depth(payload: ExteriorDepthRequest) -> dict[str, Any]:
+    try:
+        return await asyncio.to_thread(segment_exterior_depth_sync, payload)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Depth exterior segmentation failed: {exc}") from exc
+
+
+@router.post("/apply_texture_ai")
+async def apply_texture_ai(
+    payload: ApplyTextureAIRequest,
+    background_tasks: BackgroundTasks,
+) -> dict[str, Any]:
+    started = log_timing_start("APPLY_TEXTURE_AI")
+    try:
+        # Try to run OpenAI generation synchronously within the quick timeout
+        def _run_openai():
+            safe_name = Path(payload.filename).name
+            image_path = UPLOAD_DIR / safe_name
+            if not image_path.exists():
+                image_path = OUTPUT_DIR / safe_name
+
+            if not image_path.exists():
+                return {"error": f"Image not found: {payload.filename}"}
+
+            try:
+                pil = Image.open(str(image_path)).convert("RGBA")
+            except Exception as e:
+                return {"error": f"Cannot open image: {e}"}
+
+            texture = payload.texture_name or payload.prompt or ""
+            png_bytes, msg = generate_image_with_openai(None, pil, texture)
+            if png_bytes is None:
+                return {"error": msg}
+
+            out_name = f"{Path(safe_name).stem}_ai_{uuid.uuid4().hex}.png"
+            out_path = OUTPUT_DIR / out_name
+            out_path.write_bytes(png_bytes)
+            return {"message": msg, "filename": out_name, "url": f"/seg/ai/{out_name}", "processing": False}
+
+        result = await asyncio.wait_for(asyncio.to_thread(_run_openai), timeout=SD_QUICK_TIMEOUT_SECONDS)
+        log_timing_end("APPLY_TEXTURE_AI", started)
+        try:
+            release_resources()
+        except Exception:
+            logger.exception("Error releasing resources after APPLY_TEXTURE_AI")
+        result["processing"] = False
+        return result
+    except asyncio.TimeoutError:
+        job_id = uuid.uuid4().hex
+        with jobs_lock:
+            jobs[job_id] = {"status": "processing", "created_at": utc_now_iso(), "updated_at": utc_now_iso()}
+        # enqueue background job that runs the OpenAI generation
+        def _run_openai_job(job_id_inner: str, payload_inner: ApplyTextureAIRequest) -> None:
+            try:
+                res = _run_openai()
+                with jobs_lock:
+                    if "error" in res:
+                        jobs[job_id_inner] = {"status": "failed", "error": res.get("error"), "updated_at": utc_now_iso()}
+                    else:
+                        jobs[job_id_inner] = {"status": "done", "result": res, "updated_at": utc_now_iso()}
+            except Exception as exc:
+                with jobs_lock:
+                    jobs[job_id_inner] = {"status": "failed", "error": str(exc), "updated_at": utc_now_iso()}
+
+        background_tasks.add_task(_run_openai_job, job_id, payload)
+        log_timing_end("APPLY_TEXTURE_AI", started)
+        try:
+            release_resources()
+        except Exception:
+            pass
+        return {
+            "processing": True,
+            "job_id": job_id,
+            "message": "Inpainting is taking longer than expected and continues in background.",
+            "status_url": f"/seg/jobs/{job_id}",
+        }
+    except HTTPException:
+        log_timing_end("APPLY_TEXTURE_AI", started)
+        try:
+            release_resources()
+        except Exception:
+            pass
+        raise
+    except Exception as exc:
+        log_timing_end("APPLY_TEXTURE_AI", started)
+        try:
+            release_resources()
+        except Exception:
+            pass
+        raise HTTPException(status_code=500, detail=f"Inpainting failed: {exc}") from exc
+
+
+@router.get("/jobs/{job_id}")
+async def get_job_status(job_id: str) -> dict[str, Any]:
+    with jobs_lock:
+        job = jobs.get(job_id)
+
+    if job is None:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+    if job.get("status") == "processing":
+        kind = str(job.get("kind", "generic"))
+        stage = str(job.get("stage", "processing"))
+        progress = int(job.get("progress", 0) or 0)
+        eta_seconds: int | None = None
+
+        if kind == "upload" and stage == "segmenting_with_sam2":
+            stage_started_at_text = job.get("stage_started_at")
+            estimated_seconds = float(job.get("estimated_seconds", 0.0) or 0.0)
+            if stage_started_at_text and estimated_seconds > 0:
+                try:
+                    stage_started_at = datetime.fromisoformat(str(stage_started_at_text))
+                    elapsed = (datetime.now(timezone.utc) - stage_started_at).total_seconds()
+                    eta_seconds = max(0, int(estimated_seconds - elapsed))
+                    estimated_progress = int(min(95, 30 + (max(0.0, elapsed) / estimated_seconds) * 60))
+                    progress = max(progress, estimated_progress)
+                except ValueError:
+                    pass
+
+        stale_limit_seconds = UPLOAD_JOB_STALE_SECONDS if kind == "upload" else SD_JOB_STALE_SECONDS
+        created_at_text = job.get("created_at")
+        if created_at_text:
+            try:
+                created_at = datetime.fromisoformat(str(created_at_text))
+                age_seconds = (datetime.now(timezone.utc) - created_at).total_seconds()
+                if age_seconds > stale_limit_seconds:
+                    return {
+                        "processing": False,
+                        "status": "timeout",
+                        "message": "The process is taking too long. Please retry.",
+                        "job_id": job_id,
+                    }
+            except ValueError:
+                pass
+
+        response: dict[str, Any] = {
+            "processing": True,
+            "status": "processing",
+            "job_id": job_id,
+            "kind": kind,
+            "stage": stage,
+            "progress": progress,
+            "message": str(job.get("message", "Still processing.")),
+        }
+        if eta_seconds is not None:
+            response["eta_seconds"] = eta_seconds
+        return response
+
+    if job.get("status") == "done":
+        result = cast(dict[str, Any], job.get("result", {}))
+        result["processing"] = False
+        result["job_id"] = job_id
+        result["status"] = "done"
+        return result
+
+    if job.get("status") == "failed":
+        return {
+            "processing": False,
+            "status": "failed",
+            "job_id": job_id,
+            "message": job.get("error", "Background task failed"),
+        }
+
+    return {"processing": True, "status": "processing", "job_id": job_id, "message": "Still processing."}
+
+
+@router.post("/apply_color")
+async def apply_color(payload: ApplyColorRequest) -> dict[str, Any]:
+    started = log_timing_start("APPLY_COLOR")
+    try:
+        safe_name = Path(payload.filename).name
+        if not safe_name:
+            raise HTTPException(status_code=400, detail="Invalid filename")
+
+        label_safe_name = Path(payload.original_filename).name if payload.original_filename else safe_name
+
+        image_path = UPLOAD_DIR / safe_name
+        if not image_path.exists():
+            image_path = OUTPUT_DIR / safe_name
+        if not image_path.exists() or not image_path.is_file():
+            raise HTTPException(status_code=404, detail=f"Image not found: {safe_name}")
+
+        image_bgr = cv2.imread(str(image_path))
+        if image_bgr is None:
+            raise HTTPException(status_code=400, detail="Image could not be read")
+
+        mask_index = parse_mask_index(payload.mask_filename)
+        red, green, blue = parse_rgb_color(payload.color)
+
+        label_path = UPLOAD_DIR / "masks" / f"{label_safe_name}_labels.png"
+        label_map = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
+        if label_map is None:
+            raise HTTPException(
+                status_code=404,
+                detail="Label map not found. Upload the image first to generate segments.",
+            )
+
+        segmentation = label_map == mask_index
+        if not segmentation.any():
+            raise HTTPException(status_code=400, detail=f"Segment index {mask_index} not found in label map.")
+
+        edited_image = image_bgr.copy()
+        edited_image[segmentation] = (blue, green, red)
+
+        original_stem = Path(label_safe_name).stem
+        out_filename = f"{original_stem}_edit.jpg"
+        out_path = UPLOAD_DIR / out_filename
+        if not cv2.imwrite(str(out_path), edited_image):
+            raise HTTPException(status_code=500, detail="Failed to save edited image")
+
+        return {
+            "message": "Color applied successfully",
+            "output_filename": out_filename,
+            "output_url": f"/seg/image/{out_filename}",
+        }
+    finally:
+        log_timing_end("APPLY_COLOR", started)
+        try:
+            release_resources()
+        except Exception:
+            logger.exception("Error releasing resources after APPLY_COLOR")
+
+
+@router.post("/apply_texture")
+async def apply_texture(payload: ApplyTextureRequest) -> dict[str, Any]:
+    try:
+        result = await asyncio.to_thread(apply_local_texture_sync, payload)
+        result["processing"] = False
+        return result
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Texture apply failed: {exc}") from exc
+
+
+@router.get("/textures")
+async def get_textures() -> dict[str, Any]:
+    return {"textures": list_available_textures()}
+
+
+class _GenerateVariationsRequest(BaseModel):
+    texture_name: str
+
+    class Config:
+        extra = "ignore"
+
+
+@router.post("/textures/generate")
+async def generate_variations(payload: _GenerateVariationsRequest) -> dict[str, Any]:
+    if not payload.texture_name:
+        raise HTTPException(status_code=400, detail="texture_name is required")
+    try:
+        variations = await asyncio.to_thread(generate_texture_variations, payload.texture_name)
+        return {"variations": variations}
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Variation generation failed: {exc}") from exc
+
+
+@router.get("/texture-preview/{filename:path}")
+async def get_texture_preview(filename: str) -> Response:
+    texture_path = resolve_texture_path(filename)
+    jpeg = await asyncio.to_thread(build_texture_preview_jpeg, texture_path)
+    return Response(content=jpeg, media_type="image/jpeg", headers={"Cache-Control": "public, max-age=3600"})
+
+
+@router.get("/video/{filename}")
+async def get_video(filename: str) -> FileResponse:
+    if Path(filename).name != filename:
+        raise HTTPException(status_code=400, detail="Invalid file name")
+    video_path = VIDEO_UPLOAD_DIR / filename
+    if not video_path.exists() or not video_path.is_file():
+        raise HTTPException(status_code=404, detail="Video not found")
+    return FileResponse(video_path)
+
+
+@router.get("/output-video/{filename}")
+async def get_output_video(filename: str) -> FileResponse:
+    if Path(filename).name != filename:
+        raise HTTPException(status_code=400, detail="Invalid file name")
+    video_path = VIDEO_OUTPUT_DIR / filename
+    if not video_path.exists() or not video_path.is_file():
+        raise HTTPException(status_code=404, detail="Output video not found")
+    return FileResponse(video_path)
+
+
+@router.get("/image/{filename}")
+async def get_image(filename: str) -> FileResponse:
+    if Path(filename).name != filename:
+        raise HTTPException(status_code=400, detail="Invalid file name")
+    image_path = UPLOAD_DIR / filename
+    if not image_path.exists() or not image_path.is_file():
+        raise HTTPException(status_code=404, detail="Image not found")
+    return FileResponse(image_path)
+
+
+@router.post("/masks/reclassify/{filename}")
+async def reclassify_mask_metadata(filename: str) -> dict[str, Any]:
+    """Re-run semantic classification on an already-segmented image and overwrite its metadata JSON."""
+    import json as _json
+    safe = Path(filename).name
+    if not safe:
+        raise HTTPException(status_code=400, detail="Invalid filename")
+
+    masks_dir = UPLOAD_DIR / "masks"
+    label_path = masks_dir / f"{safe}_labels.png"
+    if not label_path.exists():
+        raise HTTPException(status_code=404, detail="Label map not found — upload the image first")
+
+    label_map = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
+    if label_map is None:
+        raise HTTPException(status_code=500, detail="Could not read label map")
+
+    image_path = UPLOAD_DIR / safe
+    image_rgb: Any = None
+    if image_path.exists():
+        img_bgr = cv2.imread(str(image_path))
+        if img_bgr is not None:
+            image_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+
+    from services.scene_service import classify_all_label_map_segments
+    h, w = label_map.shape[:2]
+    segments_meta = await asyncio.to_thread(
+        classify_all_label_map_segments, label_map, w, h, image_rgb
+    )
+    meta_path = masks_dir / f"{safe}_labels_meta.json"
+    meta_path.write_text(_json.dumps({"segments": segments_meta}, ensure_ascii=False), encoding="utf-8")
+
+    return {"segments": segments_meta, "count": len(segments_meta)}
+
+
+@router.get("/masks/meta/{filename}")
+async def get_mask_metadata(filename: str) -> dict:
+    import json as _json
+    safe = Path(filename).name
+    if not safe:
+        raise HTTPException(status_code=400, detail="Invalid filename")
+    meta_path = UPLOAD_DIR / "masks" / f"{safe}_labels_meta.json"
+    if not meta_path.exists() or not meta_path.is_file():
+        raise HTTPException(status_code=404, detail="Segment metadata not found")
+    try:
+        return _json.loads(meta_path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Failed to read metadata: {exc}") from exc
+
+
+@router.get("/masks/{filename}")
+async def get_mask_labels(filename: str) -> FileResponse:
+    if Path(filename).name != filename:
+        raise HTTPException(status_code=400, detail="Invalid file name")
+    label_path = UPLOAD_DIR / "masks" / f"{filename}_labels.png"
+    if not label_path.exists() or not label_path.is_file():
+        raise HTTPException(status_code=404, detail="Label map not found")
+    return FileResponse(label_path)
+
+
+@router.get("/ai/{filename}")
+async def get_ai_image(filename: str) -> FileResponse:
+    if Path(filename).name != filename:
+        raise HTTPException(status_code=400, detail="Invalid file name")
+    out_path = OUTPUT_DIR / filename
+    if not out_path.exists() or not out_path.is_file():
+        raise HTTPException(status_code=404, detail="AI output image not found")
+    return FileResponse(out_path)

backend/services/gradio_client_service.py

@@ -1,176 +1,108 @@
-"""
-Cliente para llamar al Gradio Space de ZeroGPU (SAM2 + SegFormer + DINO).
-Se activa solo si GRADIO_SPACE_URL está definido en el entorno.
-"""
-import asyncio
-import base64
-import io
-import json
-import logging
-from pathlib import Path
-
-import numpy as np
-from PIL import Image
-
-from core.config import GRADIO_CPU_FALLBACK_URL, GRADIO_SPACE_URL
-
-logger = logging.getLogger(__name__)
-
-
-def is_gradio_enabled() -> bool:
-    return bool(GRADIO_SPACE_URL)
-
-
-def _call_gradio_sync(image_path: Path, space_url: str) -> tuple[np.ndarray, int]:
-    """
-    Synchronous Gradio call — safe to invoke from a background thread.
-    Returns (label_map, mask_count).
-    Raises on any error so the caller can handle fallback.
-    """
-    from gradio_client import Client, file  # type: ignore
-
-    # 300s timeout: ZeroGPU cold start + SAM2+DINO inference can take 60-120s
-    client = Client(space_url, httpx_kwargs={"timeout": 300.0})
-
-    # segment_for_backend returns (overlay_image, combined_json_str)
-    _overlay_file, combined_json_str = client.predict(
-        file(str(image_path)),
-        api_name="/segment",
-    )
-
-    if not isinstance(combined_json_str, str):
-        raise ValueError(f"Unexpected response type from Gradio Space: {type(combined_json_str)}")
-
-    combined: dict = json.loads(combined_json_str)
-
-    if "error" in combined:
-        raise RuntimeError(f"Gradio Space error: {combined['error'][:500]}")
-
-    label_map_b64: str = combined.get("label_map_b64", "")
-    if not label_map_b64:
-        return np.zeros((1, 1), dtype=np.uint8), 0
-
-    # Decode PNG-encoded label map (lossless uint8 grayscale)
-    label_map_bytes = base64.b64decode(label_map_b64)
-    pil_label = Image.open(io.BytesIO(label_map_bytes))
-    label_map = np.array(pil_label, dtype=np.uint8)
-    mask_count = int(label_map.max())
-
-    entorno = combined.get("entorno", "?")
-    motor = combined.get("motor", "?")
-    logger.info(
-        "Gradio Space segmentation: entorno=%s motor=%s mask_count=%d",
-        entorno, motor, mask_count,
-    )
-
-    return label_map, mask_count
-
-
-def segment_via_gradio_sync(image_path: Path) -> tuple[np.ndarray, int]:
-    """
-    Blocking call to the Gradio Space from a sync context (background task thread).
-    Tries the GPU Space first; if it fails, falls back to the CPU Space.
-    Raises RuntimeError if both fail or neither is configured.
-    """
-    if not is_gradio_enabled():
-        raise RuntimeError("GRADIO_SPACE_URL is not configured")
-
-    gpu_error: Exception | None = None
-    try:
-        logger.info("Calling GPU Gradio Space: %s", GRADIO_SPACE_URL)
-        return _call_gradio_sync(image_path, GRADIO_SPACE_URL)
-    except Exception as e:
-        gpu_error = e
-        logger.warning("GPU Space failed (%s), trying CPU fallback...", gpu_error)
-
-    if not GRADIO_CPU_FALLBACK_URL:
-        raise RuntimeError(f"GPU Gradio Space failed and no CPU fallback configured. Error: {gpu_error}")
-
-    try:
-        logger.info("Calling CPU fallback Space: %s", GRADIO_CPU_FALLBACK_URL)
-        return _call_gradio_sync(image_path, GRADIO_CPU_FALLBACK_URL)
-    except Exception as exc_cpu:
-        raise RuntimeError(
-            f"Both Gradio Spaces failed.\n"
-            f"  GPU ({GRADIO_SPACE_URL}): {gpu_error}\n"
-            f"  CPU ({GRADIO_CPU_FALLBACK_URL}): {exc_cpu}"
-        ) from exc_cpu
-
-
-async def segment_via_gradio(image_path: Path) -> tuple[np.ndarray, int]:
-    """
-    Async wrapper — offloads the blocking call (with GPU→CPU fallback) to a thread.
-    """
-    return await asyncio.to_thread(segment_via_gradio_sync, image_path)
-
-
-def _call_gradio_render_sync(
-    image_path: Path,
-    label_map_b64: str,
-    mask_index: int,
-    texture_name: str | None,
-    texture_b64: str | None,
-    params_json: str,
-    space_url: str,
-) -> tuple[np.ndarray, dict]:
-    """
-    Synchronous call to the Gradio Space render endpoint.
-    Returns (rendered_image_np, combined_dict)
-    """
-    from gradio_client import Client, file  # type: ignore
-
-    client = Client(space_url, httpx_kwargs={"timeout": 300.0})
-
-    # Prepare args: image file + other strings/values
-    inputs = [file(str(image_path)), label_map_b64 or "", int(mask_index or 1), texture_name or "", texture_b64 or "", params_json or "{}"]
-
-    rendered_img, combined_json_str = client.predict(*inputs, api_name="/render")
-
-    if not isinstance(combined_json_str, str):
-        raise ValueError(f"Unexpected response type from Gradio Space render: {type(combined_json_str)}")
-
-    combined = json.loads(combined_json_str)
-    if "error" in combined:
-        raise RuntimeError(f"Gradio Space render error: {combined['error'][:500]}")
-
-    return rendered_img, combined
-
-
-def render_via_gradio_sync(
-    image_path: Path,
-    label_map_b64: str,
-    mask_index: int = 1,
-    texture_name: str | None = None,
-    texture_b64: str | None = None,
-    params_json: str = "{}",
-) -> tuple[np.ndarray, dict]:
-    if not is_gradio_enabled():
-        raise RuntimeError("GRADIO_SPACE_URL is not configured")
-
-    gpu_error: Exception | None = None
-    try:
-        return _call_gradio_render_sync(image_path, label_map_b64, mask_index, texture_name, texture_b64, params_json, GRADIO_SPACE_URL)
-    except Exception as e:
-        gpu_error = e
-        logger.warning("GPU Space render failed (%s), trying CPU fallback...", gpu_error)
-
-    if not GRADIO_CPU_FALLBACK_URL:
-        raise RuntimeError(f"GPU Gradio Space render failed and no CPU fallback configured. Error: {gpu_error}")
-
-    try:
-        return _call_gradio_render_sync(image_path, label_map_b64, mask_index, texture_name, texture_b64, params_json, GRADIO_CPU_FALLBACK_URL)
-    except Exception as exc_cpu:
-        raise RuntimeError(
-            f"Both Gradio Spaces render failed.\n  GPU ({GRADIO_SPACE_URL}): {gpu_error}\n  CPU ({GRADIO_CPU_FALLBACK_URL}): {exc_cpu}"
-        ) from exc_cpu
-
-
-async def render_via_gradio(
-    image_path: Path,
-    label_map_b64: str,
-    mask_index: int = 1,
-    texture_name: str | None = None,
-    texture_b64: str | None = None,
-    params_json: str = "{}",
-) -> tuple[np.ndarray, dict]:
-    return await asyncio.to_thread(render_via_gradio_sync, image_path, label_map_b64, mask_index, texture_name, texture_b64, params_json)
+"""
+Cliente para llamar al Gradio Space de ZeroGPU (SAM2 + SegFormer + DINO).
+Se activa solo si GRADIO_SPACE_URL está definido en el entorno.
+"""
+import asyncio
+import base64
+import io
+import json
+import logging
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+from core.config import GRADIO_CPU_FALLBACK_URL, GRADIO_SPACE_URL
+
+logger = logging.getLogger(__name__)
+
+
+def is_gradio_enabled() -> bool:
+    # Desactivado por petición del usuario para usar el nuevo flujo simplificado con OpenAI
+    return False
+
+
+
+def _call_gradio_sync(image_path: Path, space_url: str) -> tuple[np.ndarray, int]:
+    """
+    Synchronous Gradio call — safe to invoke from a background thread.
+    Returns (label_map, mask_count).
+    Raises on any error so the caller can handle fallback.
+    """
+    from gradio_client import Client, file  # type: ignore
+
+    # 300s timeout: ZeroGPU cold start + SAM2+DINO inference can take 60-120s
+    # client = Client(space_url, httpx_kwargs={"timeout": 300.0})
+    client = Client(space_url) # httpx_kwargs no es compatible con todas las versiones
+
+
+    # segment_for_backend returns (overlay_image, combined_json_str)
+    _overlay_file, combined_json_str = client.predict(
+        file(str(image_path)),
+        api_name="/segment",
+    )
+
+    if not isinstance(combined_json_str, str):
+        raise ValueError(f"Unexpected response type from Gradio Space: {type(combined_json_str)}")
+
+    combined: dict = json.loads(combined_json_str)
+
+    if "error" in combined:
+        raise RuntimeError(f"Gradio Space error: {combined['error'][:500]}")
+
+    label_map_b64: str = combined.get("label_map_b64", "")
+    if not label_map_b64:
+        return np.zeros((1, 1), dtype=np.uint8), 0
+
+    # Decode PNG-encoded label map (lossless uint8 grayscale)
+    label_map_bytes = base64.b64decode(label_map_b64)
+    pil_label = Image.open(io.BytesIO(label_map_bytes))
+    label_map = np.array(pil_label, dtype=np.uint8)
+    mask_count = int(label_map.max())
+
+    entorno = combined.get("entorno", "?")
+    motor = combined.get("motor", "?")
+    logger.info(
+        "Gradio Space segmentation: entorno=%s motor=%s mask_count=%d",
+        entorno, motor, mask_count,
+    )
+
+    return label_map, mask_count
+
+
+def segment_via_gradio_sync(image_path: Path) -> tuple[np.ndarray, int]:
+    """
+    Blocking call to the Gradio Space from a sync context (background task thread).
+    Tries the GPU Space first; if it fails, falls back to the CPU Space.
+    Raises RuntimeError if both fail or neither is configured.
+    """
+    if not is_gradio_enabled():
+        raise RuntimeError("GRADIO_SPACE_URL is not configured")
+
+    gpu_error: Exception | None = None
+    try:
+        logger.info("Calling GPU Gradio Space: %s", GRADIO_SPACE_URL)
+        return _call_gradio_sync(image_path, GRADIO_SPACE_URL)
+    except Exception as e:
+        gpu_error = e
+        logger.warning("GPU Space failed (%s), trying CPU fallback...", gpu_error)
+
+    if not GRADIO_CPU_FALLBACK_URL:
+        raise RuntimeError(f"GPU Gradio Space failed and no CPU fallback configured. Error: {gpu_error}")
+
+    try:
+        logger.info("Calling CPU fallback Space: %s", GRADIO_CPU_FALLBACK_URL)
+        return _call_gradio_sync(image_path, GRADIO_CPU_FALLBACK_URL)
+    except Exception as exc_cpu:
+        raise RuntimeError(
+            f"Both Gradio Spaces failed.\n"
+            f"  GPU ({GRADIO_SPACE_URL}): {gpu_error}\n"
+            f"  CPU ({GRADIO_CPU_FALLBACK_URL}): {exc_cpu}"
+        ) from exc_cpu
+
+
+async def segment_via_gradio(image_path: Path) -> tuple[np.ndarray, int]:
+    """
+    Async wrapper — offloads the blocking call (with GPU→CPU fallback) to a thread.
+    """
+    return await asyncio.to_thread(segment_via_gradio_sync, image_path)

backend/services/image_service.py

@@ -18,13 +18,13 @@ from core.config import (
     logger,
     utc_now_iso,
 )
-from services.gradio_client_service import is_gradio_enabled, segment_via_gradio_sync
 from services.sam2_service import (
     jobs,
     jobs_lock,
     release_resources,
 )
 
+
 # Imported lazily to avoid circular imports
 def _get_generate_label_map():
     from services.scene_service import generate_label_map
@@ -134,47 +134,15 @@ def run_upload_job(job_id: str, content: bytes, original_name: str) -> None:
         logger.info(f"[JOB {job_id}] segmenting_with_sam2 progress=30 estimated_seconds={estimated_seconds}")
 
         image_path = UPLOAD_DIR / safe_name
-        if is_gradio_enabled():
-            label_map, mask_count = segment_via_gradio_sync(image_path)
-        else:
-            generate_label_map = _get_generate_label_map()
-            label_map, mask_count = generate_label_map(image_rgb)
-
-        with jobs_lock:
-            job = jobs.setdefault(job_id, {})
-            job.update({
-                "stage": "saving_masks",
-                "progress": 92,
-                "message": "Saving mask map",
-                "updated_at": utc_now_iso(),
-            })
-        logger.info(f"[JOB {job_id}] saving_masks progress=92")
-
-        masks_dir = UPLOAD_DIR / "masks"
-        masks_dir.mkdir(exist_ok=True)
-        label_path = masks_dir / f"{safe_name}_labels.png"
-        if not cv2.imwrite(str(label_path), label_map):
-            raise HTTPException(status_code=500, detail="Failed to save label map")
-
-        # Classify each segment and save metadata
-        try:
-            from services.scene_service import classify_all_label_map_segments
-            h, w = image_rgb.shape[:2]
-            segments_meta = classify_all_label_map_segments(label_map, w, h, image_rgb)
-            meta_path = masks_dir / f"{safe_name}_labels_meta.json"
-            meta_path.write_text(
-                json.dumps({"segments": segments_meta}, ensure_ascii=False),
-                encoding="utf-8",
-            )
-            logger.info(f"[JOB {job_id}] segments_meta saved ({len(segments_meta)} segments)")
-        except Exception:
-            logger.exception(f"[JOB {job_id}] Failed to save segment metadata")
-
+        
+        # We are simplifying the flow: skipping SAM 2 segmentation.
+        # The result will have 0 masks.
+        
         result: dict[str, Any] = {
             "message": "Image uploaded successfully",
             "filename": safe_name,
             "url": f"/seg/image/{safe_name}",
-            "mask_count": mask_count,
+            "mask_count": 0,
         }
 
         with jobs_lock:
@@ -183,11 +151,15 @@ def run_upload_job(job_id: str, content: bytes, original_name: str) -> None:
                 "status": "done",
                 "stage": "done",
                 "progress": 100,
-                "message": "Segmentation complete",
+                "message": "Upload complete (Simplified flow)",
                 "result": result,
                 "updated_at": utc_now_iso(),
             }
-        logger.info(f"[JOB {job_id}] done mask_count={mask_count}")
+        logger.info(f"[JOB {job_id}] done (simplified, 0 masks)")
+
+        # Segmentation-related files (masks, metadata) are skipped in the simplified flow.
+        pass
+
 
     except Exception as exc:
         logger.exception(f"[JOB {job_id}] failed: {exc}")

backend/services/inpainting_service.py

@@ -1,28 +1,220 @@
+import io
+import os
+import base64
+import openai
+from pathlib import Path
+from PIL import Image, ImageOps
 from typing import Any
+import numpy as np
 
-from core.config import utc_now_iso
+from core.config import UPLOAD_DIR, OUTPUT_DIR, logger, utc_now_iso
+from services.openai_service import _get_texture_hex
 from models.schemas import ApplyTextureAIRequest
 from services.sam2_service import jobs, jobs_lock
 
+# ─── Descripciones en inglés para el prompt de DALL-E ─────────────────────────
+TEXTURE_DESCRIPTIONS = {
+    "ACM_Amarillo":          "bright yellow smooth aluminum composite panel exterior cladding",
+    "ACM_Azul":              "blue aluminum composite panel exterior cladding",
+    "ACM_Glossy_Black":      "glossy black aluminum composite panel exterior cladding",
+    "ACM_Glossy_Red":        "glossy red aluminum composite panel exterior cladding",
+    "ACM_Grafito":           "graphite dark grey aluminum composite panel exterior cladding",
+    "ACM_Light_Blue":        "light sky blue aluminum composite panel exterior cladding",
+    "ACM_Madera_Clara":      "light wood grain aluminum composite panel exterior cladding",
+    "ACM_Matteblack":        "matte black aluminum composite panel exterior cladding",
+    "ACM_Metalic":           "metallic silver brushed aluminum composite panel exterior cladding",
+    "ACM_MouseGrey":         "mouse grey aluminum composite panel exterior cladding",
+    "ACM_Orange":            "orange aluminum composite panel exterior cladding",
+    "ACM_ROBLE(OAK)":        "oak wood grain aluminum composite panel exterior cladding",
+    "ACM_Verde":             "green aluminum composite panel exterior cladding",
+    "ACM_Verde_HN":          "dark forest green aluminum composite panel exterior cladding",
+    "ACM_Verde_Lima":        "lime yellow-green aluminum composite panel exterior cladding",
+    "ACM_White":             "white aluminum composite panel exterior cladding",
+    "DECK_gris":             "grey WPC wood-plastic composite deck boards",
+    "DECK_madera":           "natural wood-look WPC composite deck boards",
+    "DECK_madera_oscuro":    "dark brown WPC composite deck boards",
+    "WPC_madera_claro":      "light beige wood-grain WPC exterior wall cladding",
+    "WPC_madera_gris":       "grey weathered wood-look WPC exterior wall cladding",
+    "WPC_madera_oscuro":     "dark espresso wood-grain WPC exterior wall cladding",
+    "WPC_negro":             "black WPC exterior wall cladding",
+}
+
+def prepare_image_square(pil_img, size=1024):
+    """
+    Ajusta la imagen a un cuadrado de 1024x1024 añadiendo padding 
+    para no deformar la imagen original.
+    """
+    orig_w, orig_h = pil_img.size
+    ratio = orig_w / orig_h
+    
+    if ratio > 1: # Es más ancha que alta (Horizontal)
+        new_w = size
+        new_h = int(size / ratio)
+        padding = (0, (size - new_h) // 2)
+    else: # Es más alta que ancha (Vertical)
+        new_h = size
+        new_w = int(size * ratio)
+        padding = ((size - new_w) // 2, 0)
+        
+    # Redimensionar manteniendo proporción
+    resized_img = pil_img.resize((new_w, new_h), Image.LANCZOS)
+    
+    # Crear fondo cuadrado con transparencia
+    new_img = Image.new("RGBA", (size, size), (255, 255, 255, 0))
+    new_img.paste(resized_img, padding)
+    
+    return new_img, padding, (new_w, new_h)
 
 def run_inpainting_sync(payload: ApplyTextureAIRequest) -> dict[str, Any]:
-    return {
-        "message": "Inpainting not configured",
-        "filename": payload.filename,
-        "prompt": payload.prompt,
-        "processing": False,
-    }
+    """
+    Usa DALL-E 2 para editar la imagen de la casa reemplazando las texturas.
+    Inspirado en la lógica de 'imagneConaI/app.py'.
+    """
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        return {"error": "OpenAI API Key not found in environment"}
+
+    safe_name = Path(payload.filename).name
+    image_path = UPLOAD_DIR / safe_name
+    if not image_path.exists():
+        image_path = OUTPUT_DIR / safe_name
+    
+    if not image_path.exists():
+        return {"error": f"Image not found: {payload.filename}"}
+
+    # Determinar descripción de textura
+    texture_name = payload.texture_name or "ACM_White"
+    texture_stem = Path(texture_name).stem
+    texture_desc = TEXTURE_DESCRIPTIONS.get(texture_stem, texture_name)
+
+    # Specs técnicas para el prompt
+    acm_specs = ""
+    if texture_stem.startswith("ACM"):
+        acm_specs = (
+            "ACM aluminum composite panel 4mm thick, 0.40mm aluminum layers, "
+            "panels sized 1.22m x 2.44m, clean precision-cut joints between panels, "
+        )
+    elif "WPC" in texture_stem or "DECK" in texture_stem:
+        acm_specs = "WPC wood-plastic composite profile boards, "
+
+    try:
+        client = openai.OpenAI(api_key=api_key)
+
+        pil_img_orig = Image.open(str(image_path)).convert("RGBA")
+        orig_size = pil_img_orig.size
+        
+        square_img, padding, resized_dims = prepare_image_square(pil_img_orig)
+        
+        buf = io.BytesIO()
+        square_img.save(buf, format="PNG")
+        buf.seek(0)
+
+        # Usar el prompt enviado o generar uno por defecto
+        prompt = payload.prompt or (
+            f"Edit ONLY the exterior wall cladding material of this house. "
+            f"Replace all facade wall surfaces with {acm_specs}{texture_desc}. "
+            f"Keep EVERYTHING ELSE exactly the same: the house structure, shape, proportions, "
+            f"roof, windows, doors, garage, balcony railings, garden, plants, sky and lighting. "
+            f"Only change the wall surface material. "
+            f"Result must look like a photorealistic architectural photo. "
+            f"CRITICAL: Do NOT stylize, do NOT apply artistic filters, do NOT add painterly or CGI effects. "
+            f"Preserve photographic grain, camera exposure, highlights and shadows, and match original lighting and perspective. "
+            f"Avoid oversmoothing — keep realistic texture detail and crisp panel edges."
+        )
+
+        # If texture file exists, compute representative hex and request exact color match
+        tex_hex = _get_texture_hex(texture_name or "") if texture_name else None
+        if tex_hex:
+            prompt += f" Use the exact color sample {tex_hex} from the reference texture and match its hue, saturation and brightness precisely. Do not alter the color tone."
 
+        # gpt-image-1 solo acepta 1024x1024
+        # If a texture file exists, attach it as a reference image when possible
+        tex_path = None
+        if texture_name:
+            try:
+                from services.texture_service import resolve_texture_path as _resolve
+                tex_path = _resolve(texture_name)
+            except Exception:
+                tex_path = None
+
+        if tex_path:
+            try:
+                with open(tex_path, "rb") as tf:
+                    tex_buf = io.BytesIO(tf.read())
+                    tex_buf.seek(0)
+                    response = client.images.edit(
+                        model="gpt-image-1",
+                        image=("house.png", buf, "image/png"),
+                        reference_image=(Path(tex_path).name, tex_buf, "image/png"),
+                        prompt=prompt,
+                        n=1,
+                        size="1024x1024",
+                        response_format="b64_json",
+                    )
+            except Exception:
+                response = client.images.edit(
+                    model="gpt-image-1",
+                    image=("house.png", buf, "image/png"),
+                    prompt=prompt,
+                    n=1,
+                    size="1024x1024",
+                    response_format="b64_json",
+                )
+        else:
+            response = client.images.edit(
+                model="gpt-image-1",
+                image=("house.png", buf, "image/png"),
+                prompt=prompt,
+                n=1,
+                size="1024x1024",
+                response_format="b64_json",
+            )
+
+        img_data = base64.b64decode(response.data[0].b64_json)
+        result_square = Image.open(io.BytesIO(img_data)).convert("RGBA")
+        
+        # 2. Recortar el resultado para volver al aspecto original (quitar padding)
+        left, top = padding
+        right, bottom = left + resized_dims[0], top + resized_dims[1]
+        result_cropped = result_square.crop((left, top, right, bottom))
+        
+        # 3. Redimensionar al tamaño original exacto
+        result = result_cropped.resize(orig_size, Image.LANCZOS).convert("RGB")
+
+        # Return generated result without blending with original image
+        final = result
+
+        out_filename = f"{Path(safe_name).stem}_ai_{texture_stem}.jpg"
+        out_path = OUTPUT_DIR / out_filename
+        final.save(str(out_path), "JPEG", quality=90)
+
+        return {
+            "message": f"AI Texture applied: {texture_name}",
+            "filename": out_filename,
+            "url": f"/seg/ai/{out_filename}",
+            "processing": False
+        }
+
+    except Exception as e:
+        logger.error(f"DALL-E Error: {e}")
+        return {"error": str(e)}
 
 def run_inpainting_job(job_id: str, payload: ApplyTextureAIRequest) -> None:
     try:
         result = run_inpainting_sync(payload)
         with jobs_lock:
-            jobs[job_id] = {
-                "status": "done",
-                "result": result,
-                "updated_at": utc_now_iso(),
-            }
+            if "error" in result:
+                jobs[job_id] = {
+                    "status": "failed",
+                    "error": result["error"],
+                    "updated_at": utc_now_iso(),
+                }
+            else:
+                jobs[job_id] = {
+                    "status": "done",
+                    "result": result,
+                    "updated_at": utc_now_iso(),
+                }
     except Exception as exc:
         with jobs_lock:
             jobs[job_id] = {

backend/services/openai_service.py

@@ -0,0 +1,251 @@
+import io
+import os
+import base64
+from pathlib import Path
+from typing import Any, Tuple
+
+import openai
+from PIL import Image
+
+from core.config import TEXTURE_DIR
+
+
+TEXTURE_DESCRIPTIONS = {
+    # Copiado desde imagneConaI/app.py (reducido a los usados más adelante)
+    "ACM_Amarillo": "bright yellow smooth aluminum composite panel exterior cladding",
+    "ACM_Azul": "blue aluminum composite panel exterior cladding",
+    "ACM_White": "white aluminum composite panel exterior cladding",
+}
+
+
+def _resolve_texture_path(name_or_path: str) -> Tuple[str | None, str]:
+    if not name_or_path:
+        return None, ""
+    p = Path(name_or_path)
+    if p.exists():
+        return str(p), p.stem
+    # buscar en TEXTURE_DIR
+    for folder in TEXTURE_DIR.iterdir():
+        if not folder.is_dir():
+            continue
+        for it in folder.glob("*.png"):
+            if it.stem.lower() == name_or_path.lower() or it.name.lower() == name_or_path.lower():
+                return str(it), it.stem.replace("_", " ")
+    return None, name_or_path
+
+
+def _get_texture_hex(name_or_path: str) -> str | None:
+    """Return average color hex for a texture file if available."""
+    path, _ = _resolve_texture_path(name_or_path)
+    if not path:
+        return None
+    try:
+        img = Image.open(path).convert("RGB")
+        # downsize for speed
+        img = img.resize((64, 64))
+        pixels = list(img.getdata())
+        r = sum(p[0] for p in pixels) // len(pixels)
+        g = sum(p[1] for p in pixels) // len(pixels)
+        b = sum(p[2] for p in pixels) // len(pixels)
+        return f"#{r:02X}{g:02X}{b:02X}"
+    except Exception:
+        return None
+
+
+def prepare_image_square(pil_img: Image.Image, size: int = 1024):
+    orig_w, orig_h = pil_img.size
+    ratio = orig_w / orig_h
+    if ratio > 1:
+        new_w = size
+        new_h = int(size / ratio)
+        padding = (0, (size - new_h) // 2)
+    else:
+        new_h = size
+        new_w = int(size * ratio)
+        padding = ((size - new_w) // 2, 0)
+    resized_img = pil_img.resize((new_w, new_h), Image.LANCZOS)
+    new_img = Image.new("RGBA", (size, size), (255, 255, 255, 0))
+    new_img.paste(resized_img, padding)
+    return new_img, padding, (new_w, new_h)
+
+
+def generate_image_with_openai(
+    api_key: str | None,
+    pil_img: Image.Image,
+    texture: str,
+    preserve_percent: int = 0,
+    use_vision: bool = False,
+) -> Tuple[bytes | None, str]:
+    """
+    Genera/edita una imagen usando la API de OpenAI (gpt-image-1 edit).
+    Retorna (png_bytes, message) o (None, error_message).
+    """
+    key = api_key.strip() if api_key and isinstance(api_key, str) and api_key.strip() else os.getenv("OPENAI_API_KEY")
+    if not key:
+        return None, "OpenAI API key not provided"
+
+    texture_path, texture_display = _resolve_texture_path(texture)
+    if not texture_path:
+        # intentar usar descripción simple
+        texture_desc = TEXTURE_DESCRIPTIONS.get(texture, texture)
+    else:
+        texture_desc = Path(texture_path).stem
+
+    # Build specialized specs for ACM / WPC / DECK
+    acm_specs = ""
+    if texture_display and texture_display.upper().startswith("ACM"):
+        acm_specs = (
+            "ACM aluminum composite panel 4mm thick, 0.40mm aluminum layers, "
+            "panels sized 1.22m x 2.44m, clean precision-cut joints between panels, "
+        )
+
+    deck_specs = ""
+    if Path(texture).stem.startswith("DECK") or ("DECK" in Path(texture).stem):
+        deck_specs = (
+            "WPC deck boards (ash / \"ceniza\" color), plank dimensions 2.5 cm thick x 14 cm wide x 220 cm long, "
+            "installed as horizontal planks with 3-5 mm spacing and hidden fasteners, realistic wood grain, slight bevel on plank edges."
+        )
+
+    wpc_panel_specs = ""
+    if ("WPC" in Path(texture).stem) and ("DECK" not in Path(texture).stem):
+        wpc_panel_specs = (
+            "WPC wall panels, each panel sized 0.16 m x 2.90 m (16 cm x 290 cm), realistic ash tone when appropriate, "
+            "installed with narrow vertical joints matching panel width and clean aligned seams."
+        )
+
+    # If we have a texture file, attempt to compute its representative color and ask model to match it
+    tex_hex = _get_texture_hex(texture)
+
+    # Build prompt depending on type
+    if deck_specs:
+        prompt = (
+            f"Edit ONLY the HORIZONTAL floor/deck surfaces (decks, terraces, balcony floors, wooden walkways). "
+            f"Replace all decking/floor surfaces with {deck_specs} {texture_desc}. "
+            f"Do NOT apply this material to vertical wall cladding or facades. "
+            f"Keep EVERYTHING ELSE exactly the same: the house structure, shape, proportions, roof, windows, doors, garage, balcony railings, garden, plants, sky and lighting. "
+            f"Result must look like a photorealistic architectural photo."
+        )
+    elif wpc_panel_specs:
+        prompt = (
+            f"Edit ONLY the VERTICAL wall cladding surfaces (exterior and interior wall panels where visible). "
+            f"Replace all vertical wall panels with {wpc_panel_specs} {texture_desc}. "
+            f"Do NOT apply this material to horizontal floor or deck surfaces. "
+            f"Keep EVERYTHING ELSE exactly the same: the house structure, shape, proportions, roof, windows, doors, garage, balcony railings, garden, plants, sky and lighting. "
+            f"Result must look like a photorealistic architectural photo."
+        )
+    else:
+        prompt = (
+            f"Edit ONLY the exterior wall cladding material of this house. "
+            f"Replace all facade wall surfaces with {acm_specs}{texture_desc}. "
+            f"Keep EVERYTHING ELSE exactly the same: the house structure, shape, proportions, "
+            f"roof, windows, doors, garage, balcony railings, garden, plants, sky and lighting. "
+            f"Only change the wall surface material. Result must look like a photorealistic architectural photo."
+        )
+
+    if tex_hex:
+        prompt += f" Use the exact color sample {tex_hex} from the reference texture and match its hue, saturation and brightness precisely. Do not alter the color tone."
+
+    try:
+        client = openai.OpenAI(api_key=key)
+
+        pil_img_orig = pil_img.convert("RGBA")
+        orig_size = pil_img_orig.size
+        square_img, padding, resized_dims = prepare_image_square(pil_img_orig)
+
+        buf = io.BytesIO()
+        square_img.save(buf, format="PNG")
+        buf.seek(0)
+
+        # Optionally run vision analysis to enrich prompt
+        house_desc = ""
+        if use_vision:
+            try:
+                bb = io.BytesIO()
+                pil_img_orig.convert("RGB").save(bb, format="JPEG", quality=85)
+                bb.seek(0)
+                b64 = base64.b64encode(bb.getvalue()).decode("ascii")
+
+                vision_prompt = (
+                    "You are an architectural photographer. Describe exactly what is visible in this house photo: "
+                    "number of floors, roof shape, main materials, prominent features (garage, balconies, large windows), "
+                    "lighting conditions, and anything that affects how to apply a facade material. "
+                    "Return a concise English description (max 200 words)."
+                )
+
+                vision_resp = client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=[{"role": "user", "content": f"data:image/jpeg;base64,{b64}\n\n{vision_prompt}"}],
+                    max_tokens=300,
+                )
+
+                try:
+                    house_desc = vision_resp.choices[0].message.content.strip()
+                except Exception:
+                    house_desc = str(vision_resp)
+            except Exception:
+                house_desc = ""
+
+        if house_desc:
+            prompt = f"House description: {house_desc}. " + prompt
+
+        # If a texture file exists, try to attach it as a reference image to the API call.
+        tex_path, _ = _resolve_texture_path(texture)
+        try:
+            if tex_path:
+                with open(tex_path, "rb") as tf:
+                    tex_buf = io.BytesIO(tf.read())
+                    tex_buf.seek(0)
+                    response = client.images.edit(
+                        model="gpt-image-1",
+                        image=("image.png", buf, "image/png"),
+                        reference_image=(Path(tex_path).name, tex_buf, "image/png"),
+                        prompt=prompt,
+                        n=1,
+                        size="1024x1024",
+                        quality="medium",
+                    )
+            else:
+                response = client.images.edit(
+                    model="gpt-image-1",
+                    image=("image.png", buf, "image/png"),
+                    prompt=prompt,
+                    n=1,
+                    size="1024x1024",
+                    quality="medium",
+                )
+        except Exception:
+            # Fallback: try without reference_image if SDK rejected the param
+            response = client.images.edit(
+                model="gpt-image-1",
+                image=("image.png", buf, "image/png"),
+                prompt=prompt,
+                n=1,
+                size="1024x1024",
+                quality="medium",
+            )
+
+        img_data = base64.b64decode(response.data[0].b64_json)
+        result_square = Image.open(io.BytesIO(img_data)).convert("RGBA")
+        left, top = padding
+        right, bottom = left + resized_dims[0], top + resized_dims[1]
+        result_cropped = result_square.crop((left, top, right, bottom))
+        result = result_cropped.resize(orig_size, Image.LANCZOS).convert("RGB")
+
+        # Apply optional blending/preserve percent (0-100)
+        try:
+            preserve = max(0.0, min(1.0, float(preserve_percent) / 100.0))
+        except Exception:
+            preserve = 0.0
+
+        if preserve > 0:
+            pil_img_rgb = pil_img_orig.convert("RGB")
+            final = Image.blend(result, pil_img_rgb, preserve)
+        else:
+            final = result
+
+        out_buf = io.BytesIO()
+        final.save(out_buf, format="PNG")
+        return out_buf.getvalue(), f"Generated with texture {texture_display if texture_display else texture_desc}"
+
+    except Exception as exc:
+        return None, f"Error generating image: {exc}"

backend/services/sam2_service.py

@@ -112,6 +112,9 @@ def find_sam2_model_path() -> Path:
 
 def load_sam2_model() -> None:
     global sam2_mask_generator, sam2_image_predictor, sam2_load_error
+    sam2_load_error = "SAM2 disabled (using Simplified OpenAI flow)"
+    logger.info(f"[SAM2] {sam2_load_error}")
+    return
 
     if not _TORCH_AVAILABLE:
         sam2_load_error = "torch not installed — SAM2 unavailable (using Gradio Space)"

backend/services/texture_service.py

@@ -1,981 +1,851 @@
-import io
-import shutil
-import uuid
-from pathlib import Path
-from typing import Any
-
-import cv2
-import numpy as np
-from fastapi import HTTPException
-from PIL import Image
-
-from core.config import (
-    OUTPUT_DIR,
-    TEXTURE_DIR,
-    UPLOAD_DIR,
-    UPLOAD_JPEG_QUALITY,
-    log_timing_end,
-    log_timing_start,
-    logger,
-)
-from models.schemas import ApplyTextureRequest
-
-
-def generate_texture_variations(texture_name: str) -> list[dict[str, str]]:
-    """
-    Genera variaciones de color/brillo/saturación de una textura de referencia usando HSV.
-    Los archivos se cachean en TEXTURE_DIR/generated/ — si ya existen no se regeneran.
-    Devuelve lista de {ref, label, preview_url}.
-    """
-    texture_path = resolve_texture_path(texture_name)
-    generated_dir = TEXTURE_DIR / "generated"
-    generated_dir.mkdir(parents=True, exist_ok=True)
-
-    tex_pil = load_texture_pil_rgb(texture_path)
-    tex_bgr = cv2.cvtColor(np.array(tex_pil, dtype=np.uint8), cv2.COLOR_RGB2BGR)
-    tex_hsv = cv2.cvtColor(tex_bgr, cv2.COLOR_BGR2HSV).astype(np.int32)
-
-    base_stem = Path(texture_name).stem
-    results: list[dict[str, str]] = []
-
-    def _save(hsv: np.ndarray, suffix: str, label: str) -> None:
-        fname = f"{base_stem}__{suffix}.jpg"
-        out_path = generated_dir / fname
-        if not out_path.exists():
-            bgr = cv2.cvtColor(np.clip(hsv, 0, 255).astype(np.uint8), cv2.COLOR_HSV2BGR)
-            rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
-            Image.fromarray(rgb).save(str(out_path), format="JPEG", quality=92, optimize=True)
-        ref = f"generated/{fname}"
-        results.append({"ref": ref, "label": label, "preview_url": f"/seg/texture-preview/{ref}"})
-
-    # Rotaciones de tono: 12 pasos de 30° recorriendo el círculo cromático
-    # En OpenCV HSV, H ∈ [0,179] → shift en grados / 2
-    for deg, label in [
-        (30,  "Naranja"),
-        (60,  "Amarillo"),
-        (90,  "Verde lima"),
-        (120, "Verde"),
-        (150, "Verde agua"),
-        (165, "Cyan"),
-        (180, "Azul cielo"),
-        (210, "Azul"),
-        (240, "Índigo"),
-        (270, "Violeta"),
-        (300, "Magenta"),
-        (330, "Rosa"),
-    ]:
-        v = tex_hsv.copy()
-        v[:, :, 0] = (v[:, :, 0] + deg // 2) % 180
-        _save(v, f"hue{deg}", label)
-
-    # Variaciones de brillo
-    for factor, label, suffix in [
-        (0.45, "Oscuro",  "dark"),
-        (1.55, "Claro",   "light"),
-    ]:
-        v = tex_hsv.copy()
-        v[:, :, 2] = np.clip(v[:, :, 2] * factor, 0, 255)
-        _save(v, suffix, label)
-
-    # Variaciones de saturación
-    for factor, label, suffix in [
-        (0.0,  "Gris",    "gray"),
-        (0.45, "Apagado", "muted"),
-        (1.75, "Vívido",  "vivid"),
-    ]:
-        v = tex_hsv.copy()
-        v[:, :, 1] = np.clip(v[:, :, 1] * factor, 0, 255)
-        _save(v, suffix, label)
-
-    return results
-
-
-def list_available_textures() -> list[str]:
-    allowed = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff", ".exr"}
-    return [
-        str(path.relative_to(TEXTURE_DIR)).replace("\\", "/")
-        for path in sorted(TEXTURE_DIR.rglob("*"))
-        if path.is_file() and path.suffix.lower() in allowed
-    ]
-
-
-def resolve_texture_path(texture_name: str) -> Path:
-    if not texture_name:
-        raise HTTPException(status_code=400, detail="Invalid texture_name")
-
-    normalized = texture_name.replace("\\", "/").strip("/")
-    candidate = (TEXTURE_DIR / normalized).resolve()
-    base = TEXTURE_DIR.resolve()
-
-    try:
-        candidate.relative_to(base)
-    except ValueError as exc:
-        raise HTTPException(status_code=400, detail="Invalid texture_name") from exc
-
-    if not candidate.exists() or not candidate.is_file():
-        raise HTTPException(status_code=404, detail=f"Texture not found: {normalized}")
-
-    return candidate
-
-
-def build_texture_preview_jpeg(texture_path: Path, max_size: int = 320) -> bytes:
-    pil_img = load_texture_pil_rgb(texture_path)
-    pil_img.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
-    out = io.BytesIO()
-    pil_img.save(out, format="JPEG", quality=88, optimize=True)
-    return out.getvalue()
-
-
-def load_texture_pil_rgb(texture_path: Path) -> Image.Image:
-    suffix = texture_path.suffix.lower()
-
-    if suffix != ".exr":
-        try:
-            return Image.open(str(texture_path)).convert("RGB")
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=f"Could not read texture file: {exc}") from exc
-
-    exr = cv2.imread(str(texture_path), cv2.IMREAD_UNCHANGED)
-    if exr is None:
-        raise HTTPException(status_code=500, detail="Could not decode EXR texture")
-
-    if exr.ndim == 2:
-        exr = np.stack([exr, exr, exr], axis=-1)
-    if exr.ndim != 3:
-        raise HTTPException(status_code=500, detail="EXR texture has unsupported shape")
-    if exr.shape[2] > 3:
-        exr = exr[:, :, :3]
-
-    exr = np.nan_to_num(exr, nan=0.0, posinf=0.0, neginf=0.0)
-    exr = np.maximum(exr, 0)
-
-    if np.issubdtype(exr.dtype, np.floating):
-        scale = float(np.percentile(exr, 99.0))
-        if scale <= 1e-8:
-            scale = float(np.max(exr))
-        if scale <= 1e-8:
-            scale = 1.0
-        img = np.clip(exr / scale, 0.0, 1.0)
-        img = np.power(img, 1.0 / 2.2)
-        img_u8 = (img * 255.0).astype(np.uint8)
-    elif exr.dtype == np.uint16:
-        img_u8 = (exr / 257.0).astype(np.uint8)
-    else:
-        img_u8 = np.clip(exr, 0, 255).astype(np.uint8)
-
-    img_rgb = cv2.cvtColor(img_u8, cv2.COLOR_BGR2RGB)
-    return Image.fromarray(img_rgb).convert("RGB")
-
-
-def estimate_mask_orientation_degrees(binary_mask: np.ndarray) -> float:
-    mask_u8 = (binary_mask > 0).astype(np.uint8)
-    contours, _ = cv2.findContours(mask_u8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return 0.0
-
-    largest = max(contours, key=cv2.contourArea)
-    if cv2.contourArea(largest) < 25.0:
-        return 0.0
-
-    rect = cv2.minAreaRect(largest)
-    (_, _), (width, height), angle = rect
-
-    dominant_angle = float(angle)
-    if width < height:
-        dominant_angle += 90.0
-
-    dominant_angle %= 180.0
-    return dominant_angle
-
-
-def _compute_trapezoid_score_from_mask(
-    binary_mask: np.ndarray,
-    ys: np.ndarray,
-    xs: np.ndarray,
-    min_y: int,
-    max_y: int,
-    bbox_h: int,
-) -> float:
-    """Return 0..1 indicating how floor-like (wider at bottom) the mask shape is."""
-    quarter = max(1, bbox_h // 4)
-    top_xs = xs[ys <= (min_y + quarter)]
-    bot_xs = xs[ys >= (max_y - quarter)]
-    if len(top_xs) < 3 or len(bot_xs) < 3:
-        return 0.0
-    top_w = float(top_xs.max() - top_xs.min())
-    bot_w = float(bot_xs.max() - bot_xs.min())
-    if top_w < 5.0:
-        return 1.0 if bot_w > 20.0 else 0.0
-    ratio = bot_w / top_w
-    return float(np.clip((ratio - 1.0) / 1.8, 0.0, 1.0))
-
-
-def _sort_quad_corners(pts: np.ndarray) -> np.ndarray:
-    """Sort 4 points into [TL, TR, BR, BL] order."""
-    result = np.zeros((4, 2), dtype=np.float32)
-    s = pts[:, 0] + pts[:, 1]
-    d = pts[:, 0] - pts[:, 1]
-    result[0] = pts[np.argmin(s)]
-    result[1] = pts[np.argmax(d)]
-    result[2] = pts[np.argmax(s)]
-    result[3] = pts[np.argmin(d)]
-    return result
-
-
-def _extract_mask_quad(binary_mask: np.ndarray) -> np.ndarray | None:
-    """Approximate mask as 4-corner polygon sorted [TL, TR, BR, BL], or None."""
-    mask_u8 = (binary_mask > 0).astype(np.uint8)
-    contours, _ = cv2.findContours(mask_u8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    if not contours:
-        return None
-    largest = max(contours, key=cv2.contourArea)
-    if cv2.contourArea(largest) < 400.0:
-        return None
-    hull = cv2.convexHull(largest)
-    peri = cv2.arcLength(hull, True)
-    for eps_frac in (0.03, 0.05, 0.08, 0.10, 0.13):
-        approx = cv2.approxPolyDP(hull, eps_frac * peri, True)
-        if len(approx) == 4:
-            return _sort_quad_corners(approx.reshape(4, 2).astype(np.float32))
-    return None
-
-
-def _tile_texture_perspective(
-    tex_pil: Image.Image,
-    quad: np.ndarray,
-    image_width: int,
-    image_height: int,
-) -> Image.Image | None:
-    """
-    Tile texture with perspective correction for a floor surface.
-    quad: [TL, TR, BR, BL] in image coordinates.
-    Returns full-image-size PIL image with warped tiled texture, or None on failure.
-    Pixels outside the perspective quad are filled with regular tiling to avoid black gaps.
-    """
-    tl, tr, br, bl = quad
-    bot_w = float(np.linalg.norm(br.astype(float) - bl.astype(float)))
-    top_w = float(np.linalg.norm(tr.astype(float) - tl.astype(float)))
-    left_h = float(np.linalg.norm(bl.astype(float) - tl.astype(float)))
-    right_h = float(np.linalg.norm(br.astype(float) - tr.astype(float)))
-    rect_w = min(int(max(bot_w, top_w)) + 1, image_width * 2)
-    rect_h = min(int(max(left_h, right_h)) + 1, image_height * 2)
-    if rect_w < 8 or rect_h < 8:
-        return None
-    tex_arr = np.array(tex_pil.convert("RGB"), dtype=np.uint8)
-    th, tw = tex_arr.shape[:2]
-    if tw < 1 or th < 1:
-        return None
-    rect_tiled = np.zeros((rect_h, rect_w, 3), dtype=np.uint8)
-    for ry in range(0, rect_h, th):
-        for rx in range(0, rect_w, tw):
-            py = min(th, rect_h - ry)
-            px = min(tw, rect_w - rx)
-            rect_tiled[ry : ry + py, rx : rx + px] = tex_arr[:py, :px]
-    src_pts = np.array(
-        [[0.0, 0.0], [float(rect_w - 1), 0.0], [float(rect_w - 1), float(rect_h - 1)], [0.0, float(rect_h - 1)]],
-        dtype=np.float32,
-    )
-    dst_pts = quad.astype(np.float32)
-    try:
-        H = cv2.getPerspectiveTransform(src_pts, dst_pts)
-        warped = cv2.warpPerspective(rect_tiled, H, (image_width, image_height))
-        # Mapa de cobertura: píxeles realmente cubiertos por el warp
-        cov_src = np.ones((rect_h, rect_w), dtype=np.uint8) * 255
-        coverage = cv2.warpPerspective(cov_src, H, (image_width, image_height))
-    except cv2.error:
-        return None
-
-    # Rellenar píxeles sin cobertura (fuera del quad) con tiling regular
-    # para evitar espacios negros donde la máscara supera el quad aproximado
-    regular = np.zeros((image_height, image_width, 3), dtype=np.uint8)
-    for ry in range(0, image_height, th):
-        for rx in range(0, image_width, tw):
-            py = min(th, image_height - ry)
-            px = min(tw, image_width - rx)
-            regular[ry : ry + py, rx : rx + px] = tex_arr[:py, :px]
-
-    uncovered = coverage < 128
-    warped[uncovered] = regular[uncovered]
-
-    return Image.fromarray(warped)
-
-
-def classify_texture_material(texture_name: str) -> str:
-    texture_key = texture_name.lower()
-    if "deck" in texture_key:
-        return "deck"
-    if "acm" in texture_key or "wpc" in texture_key:
-        return "acm"
-    if any(hint in texture_key for hint in ("wood", "plank", "laminate", "floor")):
-        return "wood"
-    if any(hint in texture_key for hint in ("marble", "granite", "tile", "brick", "cobblestone", "stone", "cartago", "riverbed")):
-        return "stone"
-    if any(hint in texture_key for hint in ("metal", "rust", "iron", "steel")):
-        return "metal"
-    return "generic"
-
-
-def infer_surface_type_and_direction(
-    binary_mask: np.ndarray,
-    image_width: int,
-    image_height: int,
-    texture_name: str,
-) -> tuple[str, float, float, int]:
-    mask_u8 = (binary_mask > 0).astype(np.uint8)
-    ys, xs = np.where(mask_u8 > 0)
-    if ys.size == 0 or xs.size == 0:
-        return ("wall", 0.0, 0.78, max(180, image_width // 4))
-
-    min_x, max_x = int(xs.min()), int(xs.max())
-    min_y, max_y = int(ys.min()), int(ys.max())
-    bbox_w = max(1, max_x - min_x + 1)
-    bbox_h = max(1, max_y - min_y + 1)
-    aspect = bbox_w / max(1.0, float(bbox_h))
-    center_y = float(ys.mean()) / max(1.0, float(image_height))
-    dominant_angle = estimate_mask_orientation_degrees(binary_mask)
-    material = classify_texture_material(texture_name)
-
-    # Trapezoid score: floor in perspective is wider at the bottom than the top
-    trapezoid_score = _compute_trapezoid_score_from_mask(binary_mask, ys, xs, min_y, max_y, bbox_h)
-
-    is_ceiling = center_y < 0.26 and aspect > 1.35
-    # Floor: low center + trapezoidal shape, OR clearly low + wide
-    is_floor = (
-        (center_y > 0.55 and aspect >= 0.9 and trapezoid_score > 0.30)
-        or (center_y > 0.68 and aspect > 1.15)
-    )
-
-    if is_ceiling:
-        surface_type = "ceiling"
-        angle = 0.0
-        blend_alpha = 0.58
-        tile_width = max(128, image_width // 5)
-    elif is_floor:
-        if material in ("deck", "wood"):
-            surface_type = "deck"
-            angle = 0.0  # Always straight, no perspective distortion for deck
-            blend_alpha = 0.82
-            tile_width = max(240, int(bbox_w * 0.55), image_width // 3)
-        else:
-            surface_type = "floor"
-            angle = 0.0
-            blend_alpha = 0.80
-            # ACM floor: ~3 large-format panels visible on the near edge
-            tile_width = max(200, int(bbox_w * 0.35)) if material == "acm" else max(144, image_width // 3)
-    else:
-        surface_type = "wall"
-        angle = 0.0
-        if material == "acm":
-            blend_alpha = 0.78
-            # ACM wall panels: ~3 panels across the surface width
-            tile_width = max(180, int(bbox_w * 0.33))
-        elif material == "wood":
-            blend_alpha = 0.70
-            tile_width = max(220, int(bbox_w * 0.55), image_width // 4)
-        elif material == "stone":
-            blend_alpha = 0.84
-            tile_width = max(128, image_width // 4)
-        else:
-            blend_alpha = 0.66
-            tile_width = max(128, image_width // 4)
-
-    return (surface_type, float(angle % 180.0), float(blend_alpha), int(tile_width))
-
-
-def choose_auto_texture_settings(material: str, surface_type: str) -> tuple[float, float, float]:
-    strength_map = {"acm": 0.98, "stone": 0.96, "wood": 0.88, "deck": 0.88, "metal": 0.91, "generic": 0.9}
-    intensity_map = {"acm": 0.08, "stone": 0.36, "wood": 0.3, "deck": 0.3, "metal": 0.34, "generic": 0.32}
-
-    strength = float(strength_map.get(material, 0.9))
-    intensity = float(intensity_map.get(material, 0.32))
-
-    if surface_type in {"wall", "facade"}:
-        strength += 0.02
-        angle = 28.0
-    elif surface_type in {"roof"}:
-        angle = 42.0
-        intensity += 0.03
-    elif surface_type in {"floor", "deck"}:
-        angle = 24.0
-        intensity += 0.02
-    else:
-        angle = 35.0
-
-    return (
-        float(np.clip(strength, 0.55, 0.99)),
-        float(angle % 360.0),
-        float(np.clip(intensity, 0.0, 1.0)),
-    )
-
-
-def build_feather_mask(binary_mask: np.ndarray, sigma: float = 2.2) -> np.ndarray:
-    mask = (binary_mask > 0).astype(np.float32)
-    if mask.max() <= 0:
-        return mask
-    feather = cv2.GaussianBlur(mask, (0, 0), sigmaX=sigma, sigmaY=sigma)
-    return np.clip(feather, 0.0, 1.0)
-
-
-def build_scene_luminance_map(orig_rgb: np.ndarray) -> np.ndarray:
-    orig_u8 = orig_rgb.astype(np.uint8)
-    orig_lab = cv2.cvtColor(orig_u8, cv2.COLOR_RGB2LAB).astype(np.float32)
-    l_channel = orig_lab[:, :, 0] / 255.0
-    broad_light = cv2.GaussianBlur(l_channel, (0, 0), sigmaX=18.0, sigmaY=18.0)
-    local_detail = l_channel - cv2.GaussianBlur(l_channel, (0, 0), sigmaX=4.0, sigmaY=4.0)
-    light_map = 0.82 + (broad_light * 0.36) + (local_detail * 0.18)
-    return np.clip(light_map, 0.72, 1.22)
-
-
-def build_texture_relief_map(tex_rgb: np.ndarray, material: str = "generic") -> np.ndarray:
-    tex_u8 = tex_rgb.astype(np.uint8)
-    tex_gray = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
-    micro_relief = tex_gray - cv2.GaussianBlur(tex_gray, (0, 0), sigmaX=3.0, sigmaY=3.0)
-
-    relief_scale = {"acm": 0.35, "stone": 2.8, "wood": 2.2, "deck": 2.2, "metal": 1.8}.get(material, 2.0)
-    return np.clip(micro_relief * relief_scale, -1.0, 1.0)
-
-
-def build_directional_light_map(
-    tex_rgb: np.ndarray,
-    material: str,
-    light_angle_degrees: float,
-    light_intensity: float,
-) -> np.ndarray:
-    tex_u8 = tex_rgb.astype(np.uint8)
-    tex_gray = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
-    height_map = cv2.GaussianBlur(tex_gray, (0, 0), sigmaX=1.4, sigmaY=1.4)
-    grad_x = cv2.Sobel(height_map, cv2.CV_32F, 1, 0, ksize=3)
-    grad_y = cv2.Sobel(height_map, cv2.CV_32F, 0, 1, ksize=3)
-
-    relief_scale = {"acm": 0.45, "stone": 3.0, "wood": 2.4, "deck": 2.4, "metal": 1.6}.get(material, 2.0)
-
-    nx = -grad_x * relief_scale
-    ny = -grad_y * relief_scale
-    nz = np.ones_like(nx, dtype=np.float32)
-    norm = np.sqrt((nx * nx) + (ny * ny) + (nz * nz)) + 1e-6
-    nx = nx / norm
-    ny = ny / norm
-    nz = nz / norm
-
-    theta = np.deg2rad(float(light_angle_degrees))
-    lx = float(np.cos(theta))
-    ly = float(-np.sin(theta))
-    lz = 0.82
-    light_norm = max(1e-6, float(np.sqrt((lx * lx) + (ly * ly) + (lz * lz))))
-    lx /= light_norm
-    ly /= light_norm
-    lz /= light_norm
-
-    diffuse = np.clip((nx * lx) + (ny * ly) + (nz * lz), 0.0, 1.0)
-    strength = float(np.clip(light_intensity, 0.0, 1.0))
-    if material == "acm":
-        return np.clip(0.97 + (diffuse * (0.03 + (0.12 * strength))), 0.95, 1.12)
-    if material == "deck":
-        return np.clip(0.88 + (diffuse * (0.12 + (0.50 * strength))), 0.76, 1.28)
-    return np.clip(0.86 + (diffuse * (0.14 + (0.60 * strength))), 0.72, 1.35)
-
-
-def build_mask_edge_occlusion(binary_mask: np.ndarray, light_intensity: float) -> np.ndarray:
-    mask_u8 = (binary_mask > 0).astype(np.uint8)
-    if mask_u8.max() == 0:
-        return np.ones(mask_u8.shape, dtype=np.float32)
-
-    distance = cv2.distanceTransform(mask_u8, cv2.DIST_L2, 5).astype(np.float32)
-    inner_values = distance[mask_u8 > 0]
-    if inner_values.size == 0:
-        return np.ones(mask_u8.shape, dtype=np.float32)
-
-    max_distance = max(1.0, float(np.percentile(inner_values, 95)))
-    normalized = np.clip(distance / (max_distance * 0.16), 0.0, 1.0)
-    edge_strength = 1.0 - normalized
-    occlusion = 1.0 - (edge_strength * (0.04 + (0.08 * float(np.clip(light_intensity, 0.0, 1.0)))))
-    occlusion[mask_u8 == 0] = 1.0
-    return np.clip(occlusion, 0.88, 1.0)
-
-
-def apply_surface_lighting(
-    tex_rgb: np.ndarray,
-    orig_rgb: np.ndarray,
-    binary_mask: np.ndarray,
-    material: str,
-    lighting_mode: str,
-    light_angle_degrees: float,
-    light_intensity: float,
-) -> np.ndarray:
-    scene_light = build_scene_luminance_map(orig_rgb)
-    directional_light = build_directional_light_map(tex_rgb, material, light_angle_degrees, light_intensity)
-    relief_map = build_texture_relief_map(tex_rgb, material)
-    edge_occlusion = build_mask_edge_occlusion(binary_mask, light_intensity)
-
-    if material == "acm":
-        if lighting_mode == "directional":
-            light_map = directional_light
-        elif lighting_mode == "flat":
-            light_map = np.ones(scene_light.shape, dtype=np.float32)
-        else:
-            # 45 % scene luminance so ACM panels inherit shadows/gradients from photo
-            light_map = (scene_light * 0.45) + (directional_light * 0.55)
-    elif lighting_mode == "directional":
-        light_map = directional_light
-    elif lighting_mode == "flat":
-        light_map = np.ones(scene_light.shape, dtype=np.float32)
-    else:
-        light_map = (scene_light * 0.78) + (directional_light * 0.22)
-
-    detail_scale = 0.02 + (0.05 * float(np.clip(light_intensity, 0.0, 1.0))) if material == "acm" else 0.08 + (0.18 * float(np.clip(light_intensity, 0.0, 1.0)))
-    detail_boost = 1.0 + (relief_map * detail_scale)
-    enhanced = tex_rgb.astype(np.float32)
-    enhanced *= light_map[:, :, None]
-    enhanced *= detail_boost[:, :, None]
-    enhanced *= edge_occlusion[:, :, None]
-    return np.clip(enhanced, 0, 255).astype(np.uint8)
-
-
-def blend_texture_preserve_shading(
-    orig_rgb: np.ndarray,
-    tex_rgb: np.ndarray,
-    alpha_mask: np.ndarray,
-    blend_alpha: float,
-    material: str = "generic",
-) -> np.ndarray:
-    orig_u8 = orig_rgb.astype(np.uint8)
-    tex_u8 = tex_rgb.astype(np.uint8)
-
-    orig_lab = cv2.cvtColor(orig_u8, cv2.COLOR_RGB2LAB).astype(np.float32)
-    tex_lab = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2LAB).astype(np.float32)
-
-    mixed_lab = tex_lab.copy()
-    if material == "acm":
-        # 30 % original luminance → panels inherit scene shadows while keeping panel colour
-        mixed_lab[:, :, 0] = (0.30 * orig_lab[:, :, 0]) + (0.70 * tex_lab[:, :, 0])
-        mixed_lab[:, :, 1] = (0.97 * tex_lab[:, :, 1]) + (0.03 * orig_lab[:, :, 1])
-        mixed_lab[:, :, 2] = (0.97 * tex_lab[:, :, 2]) + (0.03 * orig_lab[:, :, 2])
-    elif material in ("wood", "deck"):
-        mixed_lab[:, :, 0] = (0.78 * orig_lab[:, :, 0]) + (0.22 * tex_lab[:, :, 0])
-        mixed_lab[:, :, 1] = (0.9 * tex_lab[:, :, 1]) + (0.1 * orig_lab[:, :, 1])
-        mixed_lab[:, :, 2] = (0.9 * tex_lab[:, :, 2]) + (0.1 * orig_lab[:, :, 2])
-    elif material == "stone":
-        orig_l_base = cv2.GaussianBlur(orig_lab[:, :, 0], (0, 0), sigmaX=11.0, sigmaY=11.0)
-        mixed_lab[:, :, 0] = (0.18 * orig_l_base) + (0.82 * tex_lab[:, :, 0])
-        mixed_lab[:, :, 1] = (0.95 * tex_lab[:, :, 1]) + (0.05 * orig_lab[:, :, 1])
-        mixed_lab[:, :, 2] = (0.95 * tex_lab[:, :, 2]) + (0.05 * orig_lab[:, :, 2])
-    else:
-        mixed_lab[:, :, 0] = orig_lab[:, :, 0]
-        mixed_lab[:, :, 1] = (0.8 * tex_lab[:, :, 1]) + (0.2 * orig_lab[:, :, 1])
-        mixed_lab[:, :, 2] = (0.8 * tex_lab[:, :, 2]) + (0.2 * orig_lab[:, :, 2])
-
-    shaded_tex = cv2.cvtColor(np.clip(mixed_lab, 0, 255).astype(np.uint8), cv2.COLOR_LAB2RGB).astype(np.float32)
-    if material in ("wood", "deck"):
-        tex_gray = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2GRAY).astype(np.float32)
-        tex_base = cv2.GaussianBlur(tex_gray, (0, 0), sigmaX=9.0, sigmaY=9.0)
-        tex_detail = np.clip((tex_gray - tex_base) / 255.0, -0.35, 0.35)
-        shaded_tex *= (1.0 + (tex_detail[:, :, None] * 0.28))
-
-    alpha = np.clip(alpha_mask[:, :, None] * float(blend_alpha), 0.0, 1.0)
-    composite = (orig_rgb * (1.0 - alpha)) + (shaded_tex * alpha)
-    return np.clip(composite, 0, 255).astype(np.uint8)
-
-
-def blend_texture_direct(
-    orig_rgb: np.ndarray,
-    tex_rgb: np.ndarray,
-    alpha_mask: np.ndarray,
-    blend_alpha: float,
-) -> np.ndarray:
-    alpha = np.clip(alpha_mask[:, :, None] * float(blend_alpha), 0.0, 1.0)
-    composite = (orig_rgb * (1.0 - alpha)) + (tex_rgb * alpha)
-    return np.clip(composite, 0, 255).astype(np.uint8)
-
-
-def apply_local_texture_sync(payload: ApplyTextureRequest) -> dict[str, Any]:
-    step = "APPLY_TEXTURE"
-    started = log_timing_start(step)
-    try:
-        safe_name = Path(payload.filename).name
-        if not safe_name:
-            raise HTTPException(status_code=400, detail="Invalid filename")
-
-        label_safe_name = Path(payload.original_filename).name if payload.original_filename else safe_name
-
-        image_path = UPLOAD_DIR / safe_name
-        if not image_path.exists() or not image_path.is_file():
-            image_path = OUTPUT_DIR / safe_name
-
-        if (not image_path.exists() or not image_path.is_file()) and payload.original_filename:
-            orig_name = Path(payload.original_filename).name
-            image_path = UPLOAD_DIR / orig_name
-            if not image_path.exists() or not image_path.is_file():
-                image_path = OUTPUT_DIR / orig_name
-
-        if not image_path.exists() or not image_path.is_file():
-            raise HTTPException(
-                status_code=404,
-                detail=f"Image not found: {safe_name} (also tried original: {payload.original_filename or 'n/a'})",
-            )
-
-        masks_dir = UPLOAD_DIR / "masks"
-        masks_dir.mkdir(exist_ok=True)
-        label_owner = Path(image_path).stem
-        label_path = masks_dir / f"{label_owner}_labels.png"
-        if not label_path.exists() and payload.original_filename:
-            alt_owner = Path(payload.original_filename).name
-            alt_label = masks_dir / f"{alt_owner}_labels.png"
-            if alt_label.exists():
-                label_path = alt_label
-
-        if not label_path.exists():
-            raise HTTPException(
-                status_code=404,
-                detail=f"Label map not found for {label_owner}. Upload/segment the image first.",
-            )
-
-        if not payload.mask_indices:
-            raise HTTPException(status_code=400, detail="No mask indices provided")
-
-        texture_path = resolve_texture_path(payload.texture_name)
-        orig_pil = Image.open(str(image_path)).convert("RGB")
-        width, height = orig_pil.size
-
-        label_map = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
-        if label_map is None:
-            raise HTTPException(status_code=500, detail="Could not read label map")
-
-        binary_mask = np.zeros((label_map.shape[0], label_map.shape[1]), dtype=np.uint8)
-        for idx in payload.mask_indices:
-            binary_mask |= (label_map == idx).astype(np.uint8)
-
-        if binary_mask.max() == 0:
-            raise HTTPException(status_code=400, detail="None of the selected segments were found in the label map.")
-
-        direction_mode = str(payload.direction_mode or "auto").strip().lower()
-        if direction_mode not in {"auto", "manual", "none"}:
-            raise HTTPException(status_code=400, detail="Invalid direction_mode. Use auto, manual, or none.")
-
-        replace_mode = str(getattr(payload, "replace_mode", "realistic") or "realistic").strip().lower()
-        lighting_mode = str(getattr(payload, "lighting_mode", "scene") or "scene").strip().lower()
-
-        material = classify_texture_material(payload.texture_name)
-
-        # Integración: si la textura es 'acm' y hay un Gradio Space configurado,
-        # delegar el render al Space usando el preset 'ACM' (si existe).
-        # Construimos un label_map reducido (1 = unión de máscaras seleccionadas)
-        # y enviamos la textura como base64 para evitar dependencias de archivos.
-        try:
-            import json as _json
-            import base64 as _base64
-            from services.gradio_client_service import is_gradio_enabled, render_via_gradio_sync
-            from services.presets_service import get_preset
-
-            try:
-                # Activar render remoto para ACM y también para materiales 'deck'
-                _use_remote = is_gradio_enabled() and material in {"acm", "deck"}
-            except Exception:
-                _use_remote = False
-
-            if _use_remote:
-                # Preparar label_map de unión
-                lm = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
-                if lm is None:
-                    raise HTTPException(status_code=500, detail="Could not read label map for remote render")
-
-                union = np.zeros_like(lm, dtype=np.uint8)
-                for idx in payload.mask_indices:
-                    union[lm == int(idx)] = 1
-
-                # Encode label_map (PNG) -> base64
-                buf = io.BytesIO()
-                Image.fromarray(union, mode="L").save(buf, format="PNG")
-                label_map_b64 = _base64.b64encode(buf.getvalue()).decode("utf-8")
-
-                # Encodear textura como base64
-                tex_path = resolve_texture_path(payload.texture_name)
-                tex_pil = load_texture_pil_rgb(tex_path)
-                tbuf = io.BytesIO()
-                tex_pil.save(tbuf, format="PNG")
-                texture_b64 = _base64.b64encode(tbuf.getvalue()).decode("utf-8")
-
-                # Intentar obtener preset correspondiente:
-                # - Si el nombre contiene 'wpc' + 'deck' -> 'WPC_DECK'
-                # - Si contiene solo 'wpc' -> 'WPC'
-                # - En otro caso -> 'ACM'
-                preset = {}
-                try:
-                    _tex_key = (payload.texture_name or "").lower()
-                    if "wpc" in _tex_key:
-                        if "deck" in _tex_key:
-                            preset = get_preset("WPC_DECK")
-                        else:
-                            preset = get_preset("WPC")
-                    else:
-                        preset = get_preset("ACM")
-                except Exception:
-                    preset = {}
-
-                # Detectar tipo de superficie para que el Space oriente correctamente
-                # la textura (piso=horizontal, pared=vertical)
-                try:
-                    _surface_type, _, _, _ = infer_surface_type_and_direction(
-                        binary_mask, width, height, payload.texture_name
-                    )
-                except Exception:
-                    _surface_type = "wall"
-
-                # Merge: preset base + surface_type (surface_type tiene prioridad
-                # sobre la orientacion del preset cuando es piso o deck)
-                params_dict = dict(preset or {})
-                params_dict["surface_type"] = _surface_type
-                params_json = _json.dumps(params_dict)
-
-                try:
-                    rendered_img_np, meta = render_via_gradio_sync(
-                        image_path, label_map_b64, 1, None, texture_b64, params_json
-                    )
-                except Exception as _e:
-                    logger.warning("Remote render via Gradio failed, falling back to local: %s", _e)
-                    rendered_img_np = None
-
-                if rendered_img_np is not None:
-                    # Guardar resultado remoto con mismo formato de salida
-                    input_stem = Path(image_path).stem
-                    edit_suffix = uuid.uuid4().hex[:8]
-                    out_filename = f"{input_stem}_edit_{edit_suffix}.jpg"
-                    out_path = UPLOAD_DIR / out_filename
-                    # Aceptar tanto np.ndarray como PIL.Image devueltos por el Space
-                    try:
-                        if isinstance(rendered_img_np, np.ndarray):
-                            img_to_save = Image.fromarray(rendered_img_np)
-                        elif isinstance(rendered_img_np, Image.Image):
-                            img_to_save = rendered_img_np
-                        else:
-                            # manejar strings: pueden ser rutas locales, URLs o base64
-                            if isinstance(rendered_img_np, str):
-                                s = rendered_img_np.strip()
-                                # 1) ruta local descargada por gradio_client
-                                try:
-                                    p = Path(s)
-                                    if p.exists():
-                                        img_to_save = Image.open(str(p))
-                                    else:
-                                        # 2) intentar descargar si es URL
-                                        if s.startswith("http://") or s.startswith("https://") or "/gradio_api/file=" in s:
-                                            try:
-                                                from urllib.request import urlopen as _urlopen
-
-                                                with _urlopen(s) as resp:
-                                                    data = resp.read()
-                                                img_to_save = Image.open(io.BytesIO(data))
-                                            except Exception:
-                                                # 3) fallback: intentar decodificar base64
-                                                try:
-                                                    b = _base64.b64decode(s)
-                                                    img_to_save = Image.open(io.BytesIO(b))
-                                                except Exception:
-                                                    raise RuntimeError("Unsupported rendered image string from Gradio Space")
-                                        else:
-                                            # 3) fallback: intentar decodificar base64
-                                            try:
-                                                b = _base64.b64decode(s)
-                                                img_to_save = Image.open(io.BytesIO(b))
-                                            except Exception:
-                                                raise RuntimeError("Unsupported rendered image string from Gradio Space")
-                                except Exception:
-                                    raise RuntimeError("Unsupported rendered image string from Gradio Space")
-                            else:
-                                # intentar convertir bytes -> Image
-                                try:
-                                    img_to_save = Image.open(io.BytesIO(rendered_img_np))
-                                except Exception:
-                                    raise RuntimeError("Unsupported rendered image type from Gradio Space")
-
-                        img_to_save.convert("RGB").save(str(out_path), format="JPEG", quality=UPLOAD_JPEG_QUALITY, optimize=True)
-                    except Exception:
-                        logger.exception("Failed to save rendered image from Gradio Space")
-                        raise
-
-                    try:
-                        out_label_path = masks_dir / f"{Path(out_filename).stem}_labels.png"
-                        if label_path.exists():
-                            shutil.copyfile(str(label_path), str(out_label_path))
-                    except Exception:
-                        logger.exception("Failed to copy label map for remote output image")
-
-                    return {
-                        "message": "Texture applied successfully (remote)",
-                        "original": safe_name,
-                        "mask_indices": payload.mask_indices,
-                        "texture_name": payload.texture_name,
-                        "material": material,
-                        "direction_mode": direction_mode,
-                        "surface_type": None,
-                        "replace_mode": replace_mode,
-                        "replace_strength": None,
-                        "lighting_mode": lighting_mode,
-                        "light_angle_degrees": None,
-                        "light_intensity": None,
-                        "blend_alpha": None,
-                        "applied_angle_degrees": None,
-                        "output_filename": out_filename,
-                        "output_url": f"/seg/image/{out_filename}",
-                    }
-        except HTTPException:
-            raise
-        except Exception:
-            logger.exception("Error during remote render integration (continuing local flow)")
-
-        surface_type, inferred_angle, blend_alpha, target_w = infer_surface_type_and_direction(
-            binary_mask, width, height, payload.texture_name,
-        )
-        replace_strength, light_angle_degrees, light_intensity = choose_auto_texture_settings(material, surface_type)
-        effective_alpha = float(np.clip(blend_alpha * (0.55 + (0.75 * replace_strength)), 0.0, 0.98))
-        if material == "acm":
-            effective_alpha = float(max(effective_alpha, 0.92))
-
-        applied_angle = 0.0
-        if direction_mode == "auto":
-            applied_angle = inferred_angle
-        elif direction_mode == "manual":
-            applied_angle = float(payload.angle_degrees)
-
-        tex_pil = load_texture_pil_rgb(texture_path)
-
-        # Escalar al tamaño de tile deseado ANTES de rotar
-        tex_w, tex_h = tex_pil.size
-        scale = target_w / max(1, tex_w)
-        if abs(scale - 1.0) > 0.05:
-            tex_pil = tex_pil.resize(
-                (max(1, int(tex_w * scale)), max(1, int(tex_h * scale))),
-                Image.Resampling.LANCZOS,
-            )
-            tex_w, tex_h = tex_pil.size
-
-        tiled: Image.Image | None = None
-
-        if tiled is None:
-            if abs(applied_angle) > 0.01:
-                # Tile on a large canvas first, then rotate the full canvas to avoid black corners
-                diag = int(np.ceil(np.sqrt(width ** 2 + height ** 2))) + max(tex_w, tex_h)
-                large_w = width + diag
-                large_h = height + diag
-                large = Image.new("RGB", (large_w, large_h))
-                for y in range(0, large_h, tex_h):
-                    for x in range(0, large_w, tex_w):
-                        large.paste(tex_pil, (x, y))
-                large = large.rotate(-applied_angle, resample=Image.Resampling.BICUBIC, expand=False)
-                cx = (large_w - width) // 2
-                cy = (large_h - height) // 2
-                tiled = large.crop((cx, cy, cx + width, cy + height))
-            else:
-                tiled = Image.new("RGB", (width, height))
-                for y in range(0, height, tex_h):
-                    for x in range(0, width, tex_w):
-                        tiled.paste(tex_pil, (x, y))
-
-        orig_u8 = np.array(orig_pil, dtype=np.uint8)
-
-        try:
-            if bool(getattr(payload, "clear_mask_before_apply", False)):
-                orig_candidate = None
-                if payload.original_filename:
-                    cand = UPLOAD_DIR / Path(payload.original_filename).name
-                    if cand.exists() and cand.is_file():
-                        orig_candidate = cand
-                    else:
-                        cand2 = OUTPUT_DIR / Path(payload.original_filename).name
-                        if cand2.exists() and cand2.is_file():
-                            orig_candidate = cand2
-                if orig_candidate is None:
-                    stem = Path(image_path).stem
-                    if "_edit_" in stem:
-                        base_name = stem.split("_edit_")[0] + ".jpg"
-                        cand = UPLOAD_DIR / base_name
-                        if cand.exists() and cand.is_file():
-                            orig_candidate = cand
-                        else:
-                            cand2 = OUTPUT_DIR / base_name
-                            if cand2.exists() and cand2.is_file():
-                                orig_candidate = cand2
-
-                if orig_candidate is not None:
-                    try:
-                        base_pil = Image.open(str(orig_candidate)).convert("RGB")
-                        if base_pil.size != (width, height):
-                            base_pil = base_pil.resize((width, height), Image.Resampling.LANCZOS)
-                        base_arr = np.array(base_pil, dtype=np.uint8)
-                        mask_bool = (binary_mask > 0)
-                        orig_u8[mask_bool] = base_arr[mask_bool]
-                        logger.info(f"[APPLY_TEXTURE] cleared mask from original source: {orig_candidate}")
-                    except Exception:
-                        logger.exception("Failed to restore original pixels for clear_mask_before_apply")
-        except Exception:
-            logger.exception("Error handling clear_mask_before_apply")
-
-        tiled_arr = np.array(tiled, dtype=np.uint8)
-
-        # Parchar píxeles muy oscuros (suma R+G+B < 20) dentro de la máscara.
-        # Cubren tanto negro exacto (0,0,0) como píxeles casi negros que el warp
-        # de perspectiva puede generar en bordes del quad o zonas sin cobertura.
-        mask_bool = binary_mask > 0
-        dark_in_mask = mask_bool & (tiled_arr.sum(axis=2) < 20)
-        if dark_in_mask.any():
-            th_f, tw_f = tex_pil.size[1], tex_pil.size[0]
-            tex_np = np.array(tex_pil, dtype=np.uint8)
-            ys_b, xs_b = np.where(dark_in_mask)
-            tiled_arr[ys_b, xs_b] = tex_np[ys_b % th_f, xs_b % tw_f]
-
-        lit_tex = apply_surface_lighting(
-            tiled_arr,
-            orig_u8,
-            binary_mask,
-            material,
-            lighting_mode,
-            light_angle_degrees,
-            light_intensity,
-        )
-
-        orig_arr = orig_u8.astype(np.float32)
-        tex_arr = lit_tex.astype(np.float32)
-
-        if replace_mode in {"hard", "absolute", "force", "replace"}:
-            mask_bool = (binary_mask > 0).astype(bool)
-            composite_arr = orig_arr.copy()
-            composite_arr[mask_bool] = tex_arr[mask_bool]
-            composite = np.clip(composite_arr, 0, 255).astype(np.uint8)
-        else:
-            feather_mask = build_feather_mask(binary_mask)
-            # All materials use shading-preservation so scene luminance (shadows/highlights)
-            # from the original photo is transferred onto the texture.
-            composite = blend_texture_preserve_shading(orig_arr, tex_arr, feather_mask, effective_alpha, material)
-
-        input_stem = Path(image_path).stem
-        edit_suffix = uuid.uuid4().hex[:8]
-        out_filename = f"{input_stem}_edit_{edit_suffix}.jpg"
-        out_path = UPLOAD_DIR / out_filename
-        Image.fromarray(composite).save(str(out_path), format="JPEG", quality=UPLOAD_JPEG_QUALITY, optimize=True)
-
-        try:
-            out_label_path = masks_dir / f"{Path(out_filename).stem}_labels.png"
-            if label_path.exists():
-                shutil.copyfile(str(label_path), str(out_label_path))
-        except Exception:
-            logger.exception("Failed to copy label map for output image")
-
-        return {
-            "message": "Texture applied successfully",
-            "original": safe_name,
-            "mask_indices": payload.mask_indices,
-            "texture_name": payload.texture_name,
-            "material": material,
-            "direction_mode": direction_mode,
-            "surface_type": surface_type,
-            "replace_mode": replace_mode,
-            "replace_strength": round(replace_strength, 3),
-            "lighting_mode": lighting_mode,
-            "light_angle_degrees": round(light_angle_degrees, 2),
-            "light_intensity": round(light_intensity, 3),
-            "blend_alpha": round(effective_alpha, 3),
-            "applied_angle_degrees": round(applied_angle, 2),
-            "output_filename": out_filename,
-            "output_url": f"/seg/image/{out_filename}",
-        }
-    finally:
-        log_timing_end(step, started)
+import io
+import shutil
+import uuid
+from pathlib import Path
+from typing import Any
+
+import cv2
+import numpy as np
+from fastapi import HTTPException
+from PIL import Image
+
+from core.config import (
+    OUTPUT_DIR,
+    TEXTURE_DIR,
+    UPLOAD_DIR,
+    UPLOAD_JPEG_QUALITY,
+    log_timing_end,
+    log_timing_start,
+    logger,
+)
+from models.schemas import ApplyTextureRequest
+
+
+def generate_texture_variations(texture_name: str) -> list[dict[str, str]]:
+    """
+    Genera variaciones de color/brillo/saturación de una textura de referencia usando HSV.
+    Los archivos se cachean en TEXTURE_DIR/generated/ — si ya existen no se regeneran.
+    Devuelve lista de {ref, label, preview_url}.
+    """
+    texture_path = resolve_texture_path(texture_name)
+    generated_dir = TEXTURE_DIR / "generated"
+    generated_dir.mkdir(parents=True, exist_ok=True)
+
+    tex_pil = load_texture_pil_rgb(texture_path)
+    tex_bgr = cv2.cvtColor(np.array(tex_pil, dtype=np.uint8), cv2.COLOR_RGB2BGR)
+    tex_hsv = cv2.cvtColor(tex_bgr, cv2.COLOR_BGR2HSV).astype(np.int32)
+
+    base_stem = Path(texture_name).stem
+    results: list[dict[str, str]] = []
+
+    def _save(hsv: np.ndarray, suffix: str, label: str) -> None:
+        fname = f"{base_stem}__{suffix}.jpg"
+        out_path = generated_dir / fname
+        if not out_path.exists():
+            bgr = cv2.cvtColor(np.clip(hsv, 0, 255).astype(np.uint8), cv2.COLOR_HSV2BGR)
+            rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB)
+            Image.fromarray(rgb).save(str(out_path), format="JPEG", quality=92, optimize=True)
+        ref = f"generated/{fname}"
+        results.append({"ref": ref, "label": label, "preview_url": f"/seg/texture-preview/{ref}"})
+
+    # Rotaciones de tono: 12 pasos de 30° recorriendo el círculo cromático
+    # En OpenCV HSV, H ∈ [0,179] → shift en grados / 2
+    for deg, label in [
+        (30,  "Naranja"),
+        (60,  "Amarillo"),
+        (90,  "Verde lima"),
+        (120, "Verde"),
+        (150, "Verde agua"),
+        (165, "Cyan"),
+        (180, "Azul cielo"),
+        (210, "Azul"),
+        (240, "Índigo"),
+        (270, "Violeta"),
+        (300, "Magenta"),
+        (330, "Rosa"),
+    ]:
+        v = tex_hsv.copy()
+        v[:, :, 0] = (v[:, :, 0] + deg // 2) % 180
+        _save(v, f"hue{deg}", label)
+
+    # Variaciones de brillo
+    for factor, label, suffix in [
+        (0.45, "Oscuro",  "dark"),
+        (1.55, "Claro",   "light"),
+    ]:
+        v = tex_hsv.copy()
+        v[:, :, 2] = np.clip(v[:, :, 2] * factor, 0, 255)
+        _save(v, suffix, label)
+
+    # Variaciones de saturación
+    for factor, label, suffix in [
+        (0.0,  "Gris",    "gray"),
+        (0.45, "Apagado", "muted"),
+        (1.75, "Vívido",  "vivid"),
+    ]:
+        v = tex_hsv.copy()
+        v[:, :, 1] = np.clip(v[:, :, 1] * factor, 0, 255)
+        _save(v, suffix, label)
+
+    return results
+
+
+def list_available_textures() -> list[str]:
+    allowed = {".jpg", ".jpeg", ".png", ".webp", ".bmp", ".tif", ".tiff", ".exr"}
+    return [
+        str(path.relative_to(TEXTURE_DIR)).replace("\\", "/")
+        for path in sorted(TEXTURE_DIR.rglob("*"))
+        if path.is_file() and path.suffix.lower() in allowed
+    ]
+
+
+def resolve_texture_path(texture_name: str) -> Path:
+    if not texture_name:
+        raise HTTPException(status_code=400, detail="Invalid texture_name")
+
+    normalized = texture_name.replace("\\", "/").strip("/")
+    candidate = (TEXTURE_DIR / normalized).resolve()
+    base = TEXTURE_DIR.resolve()
+
+    try:
+        candidate.relative_to(base)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail="Invalid texture_name") from exc
+
+    if not candidate.exists() or not candidate.is_file():
+        raise HTTPException(status_code=404, detail=f"Texture not found: {normalized}")
+
+    return candidate
+
+
+def build_texture_preview_jpeg(texture_path: Path, max_size: int = 320) -> bytes:
+    pil_img = load_texture_pil_rgb(texture_path)
+    pil_img.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+    out = io.BytesIO()
+    pil_img.save(out, format="JPEG", quality=88, optimize=True)
+    return out.getvalue()
+
+
+def load_texture_pil_rgb(texture_path: Path) -> Image.Image:
+    suffix = texture_path.suffix.lower()
+
+    if suffix != ".exr":
+        try:
+            return Image.open(str(texture_path)).convert("RGB")
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=f"Could not read texture file: {exc}") from exc
+
+    exr = cv2.imread(str(texture_path), cv2.IMREAD_UNCHANGED)
+    if exr is None:
+        raise HTTPException(status_code=500, detail="Could not decode EXR texture")
+
+    if exr.ndim == 2:
+        exr = np.stack([exr, exr, exr], axis=-1)
+    if exr.ndim != 3:
+        raise HTTPException(status_code=500, detail="EXR texture has unsupported shape")
+    if exr.shape[2] > 3:
+        exr = exr[:, :, :3]
+
+    exr = np.nan_to_num(exr, nan=0.0, posinf=0.0, neginf=0.0)
+    exr = np.maximum(exr, 0)
+
+    if np.issubdtype(exr.dtype, np.floating):
+        scale = float(np.percentile(exr, 99.0))
+        if scale <= 1e-8:
+            scale = float(np.max(exr))
+        if scale <= 1e-8:
+            scale = 1.0
+        img = np.clip(exr / scale, 0.0, 1.0)
+        img = np.power(img, 1.0 / 2.2)
+        img_u8 = (img * 255.0).astype(np.uint8)
+    elif exr.dtype == np.uint16:
+        img_u8 = (exr / 257.0).astype(np.uint8)
+    else:
+        img_u8 = np.clip(exr, 0, 255).astype(np.uint8)
+
+    img_rgb = cv2.cvtColor(img_u8, cv2.COLOR_BGR2RGB)
+    return Image.fromarray(img_rgb).convert("RGB")
+
+
+def estimate_mask_orientation_degrees(binary_mask: np.ndarray) -> float:
+    mask_u8 = (binary_mask > 0).astype(np.uint8)
+    contours, _ = cv2.findContours(mask_u8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return 0.0
+
+    largest = max(contours, key=cv2.contourArea)
+    if cv2.contourArea(largest) < 25.0:
+        return 0.0
+
+    rect = cv2.minAreaRect(largest)
+    (_, _), (width, height), angle = rect
+
+    dominant_angle = float(angle)
+    if width < height:
+        dominant_angle += 90.0
+
+    dominant_angle %= 180.0
+    return dominant_angle
+
+
+def _compute_trapezoid_score_from_mask(
+    binary_mask: np.ndarray,
+    ys: np.ndarray,
+    xs: np.ndarray,
+    min_y: int,
+    max_y: int,
+    bbox_h: int,
+) -> float:
+    """Return 0..1 indicating how floor-like (wider at bottom) the mask shape is."""
+    quarter = max(1, bbox_h // 4)
+    top_xs = xs[ys <= (min_y + quarter)]
+    bot_xs = xs[ys >= (max_y - quarter)]
+    if len(top_xs) < 3 or len(bot_xs) < 3:
+        return 0.0
+    top_w = float(top_xs.max() - top_xs.min())
+    bot_w = float(bot_xs.max() - bot_xs.min())
+    if top_w < 5.0:
+        return 1.0 if bot_w > 20.0 else 0.0
+    ratio = bot_w / top_w
+    return float(np.clip((ratio - 1.0) / 1.8, 0.0, 1.0))
+
+
+def _sort_quad_corners(pts: np.ndarray) -> np.ndarray:
+    """Sort 4 points into [TL, TR, BR, BL] order."""
+    result = np.zeros((4, 2), dtype=np.float32)
+    s = pts[:, 0] + pts[:, 1]
+    d = pts[:, 0] - pts[:, 1]
+    result[0] = pts[np.argmin(s)]
+    result[1] = pts[np.argmax(d)]
+    result[2] = pts[np.argmax(s)]
+    result[3] = pts[np.argmin(d)]
+    return result
+
+
+def _extract_mask_quad(binary_mask: np.ndarray) -> np.ndarray | None:
+    """Approximate mask as 4-corner polygon sorted [TL, TR, BR, BL], or None."""
+    mask_u8 = (binary_mask > 0).astype(np.uint8)
+    contours, _ = cv2.findContours(mask_u8, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not contours:
+        return None
+    largest = max(contours, key=cv2.contourArea)
+    if cv2.contourArea(largest) < 400.0:
+        return None
+    hull = cv2.convexHull(largest)
+    peri = cv2.arcLength(hull, True)
+    for eps_frac in (0.03, 0.05, 0.08, 0.10, 0.13):
+        approx = cv2.approxPolyDP(hull, eps_frac * peri, True)
+        if len(approx) == 4:
+            return _sort_quad_corners(approx.reshape(4, 2).astype(np.float32))
+    return None
+
+
+def _tile_texture_perspective(
+    tex_pil: Image.Image,
+    quad: np.ndarray,
+    image_width: int,
+    image_height: int,
+) -> Image.Image | None:
+    """
+    Tile texture with perspective correction for a floor surface.
+    quad: [TL, TR, BR, BL] in image coordinates.
+    Returns full-image-size PIL image with warped tiled texture, or None on failure.
+    Pixels outside the perspective quad are filled with regular tiling to avoid black gaps.
+    """
+    tl, tr, br, bl = quad
+    bot_w = float(np.linalg.norm(br.astype(float) - bl.astype(float)))
+    top_w = float(np.linalg.norm(tr.astype(float) - tl.astype(float)))
+    left_h = float(np.linalg.norm(bl.astype(float) - tl.astype(float)))
+    right_h = float(np.linalg.norm(br.astype(float) - tr.astype(float)))
+    rect_w = min(int(max(bot_w, top_w)) + 1, image_width * 2)
+    rect_h = min(int(max(left_h, right_h)) + 1, image_height * 2)
+    if rect_w < 8 or rect_h < 8:
+        return None
+    tex_arr = np.array(tex_pil.convert("RGB"), dtype=np.uint8)
+    th, tw = tex_arr.shape[:2]
+    if tw < 1 or th < 1:
+        return None
+    rect_tiled = np.zeros((rect_h, rect_w, 3), dtype=np.uint8)
+    for ry in range(0, rect_h, th):
+        for rx in range(0, rect_w, tw):
+            py = min(th, rect_h - ry)
+            px = min(tw, rect_w - rx)
+            rect_tiled[ry : ry + py, rx : rx + px] = tex_arr[:py, :px]
+    src_pts = np.array(
+        [[0.0, 0.0], [float(rect_w - 1), 0.0], [float(rect_w - 1), float(rect_h - 1)], [0.0, float(rect_h - 1)]],
+        dtype=np.float32,
+    )
+    dst_pts = quad.astype(np.float32)
+    try:
+        H = cv2.getPerspectiveTransform(src_pts, dst_pts)
+        warped = cv2.warpPerspective(rect_tiled, H, (image_width, image_height))
+        # Mapa de cobertura: píxeles realmente cubiertos por el warp
+        cov_src = np.ones((rect_h, rect_w), dtype=np.uint8) * 255
+        coverage = cv2.warpPerspective(cov_src, H, (image_width, image_height))
+    except cv2.error:
+        return None
+
+    # Rellenar píxeles sin cobertura (fuera del quad) con tiling regular
+    # para evitar espacios negros donde la máscara supera el quad aproximado
+    regular = np.zeros((image_height, image_width, 3), dtype=np.uint8)
+    for ry in range(0, image_height, th):
+        for rx in range(0, image_width, tw):
+            py = min(th, image_height - ry)
+            px = min(tw, image_width - rx)
+            regular[ry : ry + py, rx : rx + px] = tex_arr[:py, :px]
+
+    uncovered = coverage < 128
+    warped[uncovered] = regular[uncovered]
+
+    return Image.fromarray(warped)
+
+
+def classify_texture_material(texture_name: str) -> str:
+    texture_key = texture_name.lower()
+    if "acm" in texture_key or "wpc" in texture_key:
+        return "acm"
+    if any(hint in texture_key for hint in ("deck", "wood", "plank", "laminate", "floor")):
+        return "wood"
+    if any(hint in texture_key for hint in ("marble", "granite", "tile", "brick", "cobblestone", "stone", "cartago", "riverbed")):
+        return "stone"
+    if any(hint in texture_key for hint in ("metal", "rust", "iron", "steel")):
+        return "metal"
+    return "generic"
+
+
+def infer_surface_type_and_direction(
+    binary_mask: np.ndarray,
+    image_width: int,
+    image_height: int,
+    texture_name: str,
+) -> tuple[str, float, float, int]:
+    mask_u8 = (binary_mask > 0).astype(np.uint8)
+    ys, xs = np.where(mask_u8 > 0)
+    if ys.size == 0 or xs.size == 0:
+        return ("wall", 0.0, 0.78, max(180, image_width // 4))
+
+    min_x, max_x = int(xs.min()), int(xs.max())
+    min_y, max_y = int(ys.min()), int(ys.max())
+    bbox_w = max(1, max_x - min_x + 1)
+    bbox_h = max(1, max_y - min_y + 1)
+    aspect = bbox_w / max(1.0, float(bbox_h))
+    center_y = float(ys.mean()) / max(1.0, float(image_height))
+    dominant_angle = estimate_mask_orientation_degrees(binary_mask)
+    material = classify_texture_material(texture_name)
+
+    # Trapezoid score: floor in perspective is wider at the bottom than the top
+    trapezoid_score = _compute_trapezoid_score_from_mask(binary_mask, ys, xs, min_y, max_y, bbox_h)
+
+    is_ceiling = center_y < 0.26 and aspect > 1.35
+    # Floor: low center + trapezoidal shape, OR clearly low + wide
+    is_floor = (
+        (center_y > 0.55 and aspect >= 0.9 and trapezoid_score > 0.30)
+        or (center_y > 0.68 and aspect > 1.15)
+    )
+
+    if is_ceiling:
+        surface_type = "ceiling"
+        angle = 0.0
+        blend_alpha = 0.58
+        tile_width = max(128, image_width // 5)
+    elif is_floor:
+        if material == "wood":
+            surface_type = "deck"
+            angle = dominant_angle if 8.0 <= dominant_angle <= 172.0 else 0.0
+            blend_alpha = 0.82
+            tile_width = max(320, int(bbox_w * 0.95), image_width // 2)
+        else:
+            surface_type = "floor"
+            angle = 0.0
+            blend_alpha = 0.80
+            # ACM floor: ~3 large-format panels visible on the near edge
+            tile_width = max(200, int(bbox_w * 0.35)) if material == "acm" else max(144, image_width // 3)
+    else:
+        surface_type = "wall"
+        angle = 0.0
+        if material == "acm":
+            blend_alpha = 0.78
+            # ACM wall panels: ~3 panels across the surface width
+            tile_width = max(180, int(bbox_w * 0.33))
+        elif material == "wood":
+            blend_alpha = 0.70
+            tile_width = max(220, int(bbox_w * 0.55), image_width // 4)
+        elif material == "stone":
+            blend_alpha = 0.84
+            tile_width = max(128, image_width // 4)
+        else:
+            blend_alpha = 0.66
+            tile_width = max(128, image_width // 4)
+
+    return (surface_type, float(angle % 180.0), float(blend_alpha), int(tile_width))
+
+
+def choose_auto_texture_settings(material: str, surface_type: str) -> tuple[float, float, float]:
+    strength_map = {"acm": 0.98, "stone": 0.96, "wood": 0.88, "metal": 0.91, "generic": 0.9}
+    intensity_map = {"acm": 0.08, "stone": 0.36, "wood": 0.3, "metal": 0.34, "generic": 0.32}
+
+    strength = float(strength_map.get(material, 0.9))
+    intensity = float(intensity_map.get(material, 0.32))
+
+    if surface_type in {"wall", "facade"}:
+        strength += 0.02
+        angle = 28.0
+    elif surface_type in {"roof"}:
+        angle = 42.0
+        intensity += 0.03
+    elif surface_type in {"floor", "deck"}:
+        angle = 24.0
+        intensity += 0.02
+    else:
+        angle = 35.0
+
+    return (
+        float(np.clip(strength, 0.55, 0.99)),
+        float(angle % 360.0),
+        float(np.clip(intensity, 0.0, 1.0)),
+    )
+
+
+def build_feather_mask(binary_mask: np.ndarray, sigma: float = 2.2) -> np.ndarray:
+    mask = (binary_mask > 0).astype(np.float32)
+    if mask.max() <= 0:
+        return mask
+    feather = cv2.GaussianBlur(mask, (0, 0), sigmaX=sigma, sigmaY=sigma)
+    return np.clip(feather, 0.0, 1.0)
+
+
+def build_scene_luminance_map(orig_rgb: np.ndarray) -> np.ndarray:
+    orig_u8 = orig_rgb.astype(np.uint8)
+    orig_lab = cv2.cvtColor(orig_u8, cv2.COLOR_RGB2LAB).astype(np.float32)
+    l_channel = orig_lab[:, :, 0] / 255.0
+    broad_light = cv2.GaussianBlur(l_channel, (0, 0), sigmaX=18.0, sigmaY=18.0)
+    local_detail = l_channel - cv2.GaussianBlur(l_channel, (0, 0), sigmaX=4.0, sigmaY=4.0)
+    light_map = 0.82 + (broad_light * 0.36) + (local_detail * 0.18)
+    return np.clip(light_map, 0.72, 1.22)
+
+
+def build_texture_relief_map(tex_rgb: np.ndarray, material: str = "generic") -> np.ndarray:
+    tex_u8 = tex_rgb.astype(np.uint8)
+    tex_gray = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
+    micro_relief = tex_gray - cv2.GaussianBlur(tex_gray, (0, 0), sigmaX=3.0, sigmaY=3.0)
+
+    relief_scale = {"acm": 0.35, "stone": 2.8, "wood": 2.2, "metal": 1.8}.get(material, 2.0)
+    return np.clip(micro_relief * relief_scale, -1.0, 1.0)
+
+
+def build_directional_light_map(
+    tex_rgb: np.ndarray,
+    material: str,
+    light_angle_degrees: float,
+    light_intensity: float,
+) -> np.ndarray:
+    tex_u8 = tex_rgb.astype(np.uint8)
+    tex_gray = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
+    height_map = cv2.GaussianBlur(tex_gray, (0, 0), sigmaX=1.4, sigmaY=1.4)
+    grad_x = cv2.Sobel(height_map, cv2.CV_32F, 1, 0, ksize=3)
+    grad_y = cv2.Sobel(height_map, cv2.CV_32F, 0, 1, ksize=3)
+
+    relief_scale = {"acm": 0.45, "stone": 3.0, "wood": 2.4, "metal": 1.6}.get(material, 2.0)
+
+    nx = -grad_x * relief_scale
+    ny = -grad_y * relief_scale
+    nz = np.ones_like(nx, dtype=np.float32)
+    norm = np.sqrt((nx * nx) + (ny * ny) + (nz * nz)) + 1e-6
+    nx = nx / norm
+    ny = ny / norm
+    nz = nz / norm
+
+    theta = np.deg2rad(float(light_angle_degrees))
+    lx = float(np.cos(theta))
+    ly = float(-np.sin(theta))
+    lz = 0.82
+    light_norm = max(1e-6, float(np.sqrt((lx * lx) + (ly * ly) + (lz * lz))))
+    lx /= light_norm
+    ly /= light_norm
+    lz /= light_norm
+
+    diffuse = np.clip((nx * lx) + (ny * ly) + (nz * lz), 0.0, 1.0)
+    strength = float(np.clip(light_intensity, 0.0, 1.0))
+    if material == "acm":
+        return np.clip(0.97 + (diffuse * (0.03 + (0.12 * strength))), 0.95, 1.12)
+    return np.clip(0.86 + (diffuse * (0.14 + (0.60 * strength))), 0.72, 1.35)
+
+
+def build_mask_edge_occlusion(binary_mask: np.ndarray, light_intensity: float) -> np.ndarray:
+    mask_u8 = (binary_mask > 0).astype(np.uint8)
+    if mask_u8.max() == 0:
+        return np.ones(mask_u8.shape, dtype=np.float32)
+
+    distance = cv2.distanceTransform(mask_u8, cv2.DIST_L2, 5).astype(np.float32)
+    inner_values = distance[mask_u8 > 0]
+    if inner_values.size == 0:
+        return np.ones(mask_u8.shape, dtype=np.float32)
+
+    max_distance = max(1.0, float(np.percentile(inner_values, 95)))
+    normalized = np.clip(distance / (max_distance * 0.16), 0.0, 1.0)
+    edge_strength = 1.0 - normalized
+    occlusion = 1.0 - (edge_strength * (0.04 + (0.08 * float(np.clip(light_intensity, 0.0, 1.0)))))
+    occlusion[mask_u8 == 0] = 1.0
+    return np.clip(occlusion, 0.88, 1.0)
+
+
+def apply_surface_lighting(
+    tex_rgb: np.ndarray,
+    orig_rgb: np.ndarray,
+    binary_mask: np.ndarray,
+    material: str,
+    lighting_mode: str,
+    light_angle_degrees: float,
+    light_intensity: float,
+) -> np.ndarray:
+    scene_light = build_scene_luminance_map(orig_rgb)
+    directional_light = build_directional_light_map(tex_rgb, material, light_angle_degrees, light_intensity)
+    relief_map = build_texture_relief_map(tex_rgb, material)
+    edge_occlusion = build_mask_edge_occlusion(binary_mask, light_intensity)
+
+    if material == "acm":
+        if lighting_mode == "directional":
+            light_map = directional_light
+        elif lighting_mode == "flat":
+            light_map = np.ones(scene_light.shape, dtype=np.float32)
+        else:
+            # 45 % scene luminance so ACM panels inherit shadows/gradients from photo
+            light_map = (scene_light * 0.45) + (directional_light * 0.55)
+    elif lighting_mode == "directional":
+        light_map = directional_light
+    elif lighting_mode == "flat":
+        light_map = np.ones(scene_light.shape, dtype=np.float32)
+    else:
+        light_map = (scene_light * 0.78) + (directional_light * 0.22)
+
+    detail_scale = 0.02 + (0.05 * float(np.clip(light_intensity, 0.0, 1.0))) if material == "acm" else 0.08 + (0.18 * float(np.clip(light_intensity, 0.0, 1.0)))
+    detail_boost = 1.0 + (relief_map * detail_scale)
+    enhanced = tex_rgb.astype(np.float32)
+    enhanced *= light_map[:, :, None]
+    enhanced *= detail_boost[:, :, None]
+    enhanced *= edge_occlusion[:, :, None]
+    return np.clip(enhanced, 0, 255).astype(np.uint8)
+
+
+def blend_texture_preserve_shading(
+    orig_rgb: np.ndarray,
+    tex_rgb: np.ndarray,
+    alpha_mask: np.ndarray,
+    blend_alpha: float,
+    material: str = "generic",
+) -> np.ndarray:
+    orig_u8 = orig_rgb.astype(np.uint8)
+    tex_u8 = tex_rgb.astype(np.uint8)
+
+    orig_lab = cv2.cvtColor(orig_u8, cv2.COLOR_RGB2LAB).astype(np.float32)
+    tex_lab = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2LAB).astype(np.float32)
+
+    mixed_lab = tex_lab.copy()
+    if material == "acm":
+        # 30 % original luminance → panels inherit scene shadows while keeping panel colour
+        mixed_lab[:, :, 0] = (0.30 * orig_lab[:, :, 0]) + (0.70 * tex_lab[:, :, 0])
+        mixed_lab[:, :, 1] = (0.97 * tex_lab[:, :, 1]) + (0.03 * orig_lab[:, :, 1])
+        mixed_lab[:, :, 2] = (0.97 * tex_lab[:, :, 2]) + (0.03 * orig_lab[:, :, 2])
+    elif material == "wood":
+        mixed_lab[:, :, 0] = (0.78 * orig_lab[:, :, 0]) + (0.22 * tex_lab[:, :, 0])
+        mixed_lab[:, :, 1] = (0.9 * tex_lab[:, :, 1]) + (0.1 * orig_lab[:, :, 1])
+        mixed_lab[:, :, 2] = (0.9 * tex_lab[:, :, 2]) + (0.1 * orig_lab[:, :, 2])
+    elif material == "stone":
+        orig_l_base = cv2.GaussianBlur(orig_lab[:, :, 0], (0, 0), sigmaX=11.0, sigmaY=11.0)
+        mixed_lab[:, :, 0] = (0.18 * orig_l_base) + (0.82 * tex_lab[:, :, 0])
+        mixed_lab[:, :, 1] = (0.95 * tex_lab[:, :, 1]) + (0.05 * orig_lab[:, :, 1])
+        mixed_lab[:, :, 2] = (0.95 * tex_lab[:, :, 2]) + (0.05 * orig_lab[:, :, 2])
+    else:
+        mixed_lab[:, :, 0] = orig_lab[:, :, 0]
+        mixed_lab[:, :, 1] = (0.8 * tex_lab[:, :, 1]) + (0.2 * orig_lab[:, :, 1])
+        mixed_lab[:, :, 2] = (0.8 * tex_lab[:, :, 2]) + (0.2 * orig_lab[:, :, 2])
+
+    shaded_tex = cv2.cvtColor(np.clip(mixed_lab, 0, 255).astype(np.uint8), cv2.COLOR_LAB2RGB).astype(np.float32)
+    if material == "wood":
+        tex_gray = cv2.cvtColor(tex_u8, cv2.COLOR_RGB2GRAY).astype(np.float32)
+        tex_base = cv2.GaussianBlur(tex_gray, (0, 0), sigmaX=9.0, sigmaY=9.0)
+        tex_detail = np.clip((tex_gray - tex_base) / 255.0, -0.35, 0.35)
+        shaded_tex *= (1.0 + (tex_detail[:, :, None] * 0.28))
+
+    alpha = np.clip(alpha_mask[:, :, None] * float(blend_alpha), 0.0, 1.0)
+    composite = (orig_rgb * (1.0 - alpha)) + (shaded_tex * alpha)
+    return np.clip(composite, 0, 255).astype(np.uint8)
+
+
+def blend_texture_direct(
+    orig_rgb: np.ndarray,
+    tex_rgb: np.ndarray,
+    alpha_mask: np.ndarray,
+    blend_alpha: float,
+) -> np.ndarray:
+    alpha = np.clip(alpha_mask[:, :, None] * float(blend_alpha), 0.0, 1.0)
+    composite = (orig_rgb * (1.0 - alpha)) + (tex_rgb * alpha)
+    return np.clip(composite, 0, 255).astype(np.uint8)
+
+
+def apply_local_texture_sync(payload: ApplyTextureRequest) -> dict[str, Any]:
+    step = "APPLY_TEXTURE"
+    started = log_timing_start(step)
+    try:
+        safe_name = Path(payload.filename).name
+        if not safe_name:
+            raise HTTPException(status_code=400, detail="Invalid filename")
+
+        label_safe_name = Path(payload.original_filename).name if payload.original_filename else safe_name
+
+        image_path = UPLOAD_DIR / safe_name
+        if not image_path.exists() or not image_path.is_file():
+            image_path = OUTPUT_DIR / safe_name
+
+        if (not image_path.exists() or not image_path.is_file()) and payload.original_filename:
+            orig_name = Path(payload.original_filename).name
+            image_path = UPLOAD_DIR / orig_name
+            if not image_path.exists() or not image_path.is_file():
+                image_path = OUTPUT_DIR / orig_name
+
+        if not image_path.exists() or not image_path.is_file():
+            raise HTTPException(
+                status_code=404,
+                detail=f"Image not found: {safe_name} (also tried original: {payload.original_filename or 'n/a'})",
+            )
+
+        masks_dir = UPLOAD_DIR / "masks"
+        masks_dir.mkdir(exist_ok=True)
+        label_owner = Path(image_path).stem
+        label_path = masks_dir / f"{label_owner}_labels.png"
+        if not label_path.exists() and payload.original_filename:
+            alt_owner = Path(payload.original_filename).name
+            alt_label = masks_dir / f"{alt_owner}_labels.png"
+            if alt_label.exists():
+                label_path = alt_label
+
+        if not label_path.exists():
+            raise HTTPException(
+                status_code=404,
+                detail=f"Label map not found for {label_owner}. Upload/segment the image first.",
+            )
+
+        if not payload.mask_indices:
+            raise HTTPException(status_code=400, detail="No mask indices provided")
+
+        texture_path = resolve_texture_path(payload.texture_name)
+        orig_pil = Image.open(str(image_path)).convert("RGB")
+        width, height = orig_pil.size
+
+        label_map = cv2.imread(str(label_path), cv2.IMREAD_GRAYSCALE)
+        if label_map is None:
+            raise HTTPException(status_code=500, detail="Could not read label map")
+
+        binary_mask = np.zeros((label_map.shape[0], label_map.shape[1]), dtype=np.uint8)
+        for idx in payload.mask_indices:
+            binary_mask |= (label_map == idx).astype(np.uint8)
+
+        if binary_mask.max() == 0:
+            raise HTTPException(status_code=400, detail="None of the selected segments were found in the label map.")
+
+        direction_mode = str(payload.direction_mode or "auto").strip().lower()
+        if direction_mode not in {"auto", "manual", "none"}:
+            raise HTTPException(status_code=400, detail="Invalid direction_mode. Use auto, manual, or none.")
+
+        replace_mode = str(getattr(payload, "replace_mode", "realistic") or "realistic").strip().lower()
+        lighting_mode = str(getattr(payload, "lighting_mode", "scene") or "scene").strip().lower()
+
+        material = classify_texture_material(payload.texture_name)
+        surface_type, inferred_angle, blend_alpha, target_w = infer_surface_type_and_direction(
+            binary_mask, width, height, payload.texture_name,
+        )
+        replace_strength, light_angle_degrees, light_intensity = choose_auto_texture_settings(material, surface_type)
+        effective_alpha = float(np.clip(blend_alpha * (0.55 + (0.75 * replace_strength)), 0.0, 0.98))
+        if material == "acm":
+            effective_alpha = float(max(effective_alpha, 0.92))
+
+        applied_angle = 0.0
+        if direction_mode == "auto":
+            applied_angle = inferred_angle
+        elif direction_mode == "manual":
+            applied_angle = float(payload.angle_degrees)
+
+        tex_pil = load_texture_pil_rgb(texture_path)
+
+        # Escalar al tamaño de tile deseado ANTES de rotar
+        tex_w, tex_h = tex_pil.size
+        scale = target_w / max(1, tex_w)
+        if abs(scale - 1.0) > 0.05:
+            tex_pil = tex_pil.resize(
+                (max(1, int(tex_w * scale)), max(1, int(tex_h * scale))),
+                Image.Resampling.LANCZOS,
+            )
+            tex_w, tex_h = tex_pil.size
+
+        tiled: Image.Image | None = None
+
+        # Floor surfaces: perspective tiling solo cuando la perspectiva es fuerte.
+        # Para pisos de dormitorio/habitación (perspectiva suave) el quad aproximado
+        # no cubre bien el mask irregular → produce negro. Se usa tiling regular en esos casos.
+        if surface_type == "floor" and direction_mode in {"auto", "none"}:
+            ys_m, xs_m = np.where(binary_mask > 0)
+            if ys_m.size > 0:
+                min_y_m, max_y_m = int(ys_m.min()), int(ys_m.max())
+                bbox_h_m = max(1, max_y_m - min_y_m + 1)
+                trap_score = _compute_trapezoid_score_from_mask(
+                    binary_mask, ys_m, xs_m, min_y_m, max_y_m, bbox_h_m
+                )
+                if trap_score > 0.35:
+                    quad = _extract_mask_quad(binary_mask)
+                    if quad is not None:
+                        tiled = _tile_texture_perspective(tex_pil, quad, width, height)
+                        if tiled is not None:
+                            logger.info(f"[APPLY_TEXTURE] perspective floor tiling applied (trap={trap_score:.2f})")
+                else:
+                    logger.info(f"[APPLY_TEXTURE] flat floor tiling (trap={trap_score:.2f} < 0.35, skip perspective)")
+
+        # Wall / ceiling surfaces: perspective tiling cuando el quad es significativamente
+        # no-rectangular (pared fotografiada en ángulo). Un ratio > 1.20 entre lado mayor
+        # y lado menor indica distorsión perspectiva visible.
+        if surface_type in {"wall", "ceiling"} and tiled is None and direction_mode in {"auto", "none"}:
+            quad = _extract_mask_quad(binary_mask)
+            if quad is not None:
+                tl, tr, br, bl = quad
+                top_w   = float(np.linalg.norm(tr.astype(float) - tl.astype(float)))
+                bot_w   = float(np.linalg.norm(br.astype(float) - bl.astype(float)))
+                left_h  = float(np.linalg.norm(bl.astype(float) - tl.astype(float)))
+                right_h = float(np.linalg.norm(br.astype(float) - tr.astype(float)))
+                w_ratio = max(top_w, bot_w) / max(1.0, min(top_w, bot_w))
+                h_ratio = max(left_h, right_h) / max(1.0, min(left_h, right_h))
+                if w_ratio > 1.20 or h_ratio > 1.20:
+                    tiled = _tile_texture_perspective(tex_pil, quad, width, height)
+                    if tiled is not None:
+                        logger.info(
+                            f"[APPLY_TEXTURE] perspective wall tiling applied "
+                            f"(w_ratio={w_ratio:.2f}, h_ratio={h_ratio:.2f})"
+                        )
+
+        if tiled is None:
+            if abs(applied_angle) > 0.01:
+                # Tile on a large canvas first, then rotate the full canvas to avoid black corners
+                diag = int(np.ceil(np.sqrt(width ** 2 + height ** 2))) + max(tex_w, tex_h)
+                large_w = width + diag
+                large_h = height + diag
+                large = Image.new("RGB", (large_w, large_h))
+                for y in range(0, large_h, tex_h):
+                    for x in range(0, large_w, tex_w):
+                        large.paste(tex_pil, (x, y))
+                large = large.rotate(-applied_angle, resample=Image.Resampling.BICUBIC, expand=False)
+                cx = (large_w - width) // 2
+                cy = (large_h - height) // 2
+                tiled = large.crop((cx, cy, cx + width, cy + height))
+            else:
+                tiled = Image.new("RGB", (width, height))
+                for y in range(0, height, tex_h):
+                    for x in range(0, width, tex_w):
+                        tiled.paste(tex_pil, (x, y))
+
+        orig_u8 = np.array(orig_pil, dtype=np.uint8)
+
+        try:
+            if bool(getattr(payload, "clear_mask_before_apply", False)):
+                orig_candidate = None
+                if payload.original_filename:
+                    cand = UPLOAD_DIR / Path(payload.original_filename).name
+                    if cand.exists() and cand.is_file():
+                        orig_candidate = cand
+                    else:
+                        cand2 = OUTPUT_DIR / Path(payload.original_filename).name
+                        if cand2.exists() and cand2.is_file():
+                            orig_candidate = cand2
+                if orig_candidate is None:
+                    stem = Path(image_path).stem
+                    if "_edit_" in stem:
+                        base_name = stem.split("_edit_")[0] + ".jpg"
+                        cand = UPLOAD_DIR / base_name
+                        if cand.exists() and cand.is_file():
+                            orig_candidate = cand
+                        else:
+                            cand2 = OUTPUT_DIR / base_name
+                            if cand2.exists() and cand2.is_file():
+                                orig_candidate = cand2
+
+                if orig_candidate is not None:
+                    try:
+                        base_pil = Image.open(str(orig_candidate)).convert("RGB")
+                        if base_pil.size != (width, height):
+                            base_pil = base_pil.resize((width, height), Image.Resampling.LANCZOS)
+                        base_arr = np.array(base_pil, dtype=np.uint8)
+                        mask_bool = (binary_mask > 0)
+                        orig_u8[mask_bool] = base_arr[mask_bool]
+                        logger.info(f"[APPLY_TEXTURE] cleared mask from original source: {orig_candidate}")
+                    except Exception:
+                        logger.exception("Failed to restore original pixels for clear_mask_before_apply")
+        except Exception:
+            logger.exception("Error handling clear_mask_before_apply")
+
+        tiled_arr = np.array(tiled, dtype=np.uint8)
+
+        # Parchar píxeles muy oscuros (suma R+G+B < 20) dentro de la máscara.
+        # Cubren tanto negro exacto (0,0,0) como píxeles casi negros que el warp
+        # de perspectiva puede generar en bordes del quad o zonas sin cobertura.
+        mask_bool = binary_mask > 0
+        dark_in_mask = mask_bool & (tiled_arr.sum(axis=2) < 20)
+        if dark_in_mask.any():
+            th_f, tw_f = tex_pil.size[1], tex_pil.size[0]
+            tex_np = np.array(tex_pil, dtype=np.uint8)
+            ys_b, xs_b = np.where(dark_in_mask)
+            tiled_arr[ys_b, xs_b] = tex_np[ys_b % th_f, xs_b % tw_f]
+
+        lit_tex = apply_surface_lighting(
+            tiled_arr,
+            orig_u8,
+            binary_mask,
+            material,
+            lighting_mode,
+            light_angle_degrees,
+            light_intensity,
+        )
+
+        orig_arr = orig_u8.astype(np.float32)
+        tex_arr = lit_tex.astype(np.float32)
+
+        if replace_mode in {"hard", "absolute", "force", "replace"}:
+            mask_bool = (binary_mask > 0).astype(bool)
+            composite_arr = orig_arr.copy()
+            composite_arr[mask_bool] = tex_arr[mask_bool]
+            composite = np.clip(composite_arr, 0, 255).astype(np.uint8)
+        else:
+            feather_mask = build_feather_mask(binary_mask)
+            # All materials use shading-preservation so scene luminance (shadows/highlights)
+            # from the original photo is transferred onto the texture.
+            composite = blend_texture_preserve_shading(orig_arr, tex_arr, feather_mask, effective_alpha, material)
+
+        input_stem = Path(image_path).stem
+        edit_suffix = uuid.uuid4().hex[:8]
+        out_filename = f"{input_stem}_edit_{edit_suffix}.jpg"
+        out_path = UPLOAD_DIR / out_filename
+        Image.fromarray(composite).save(str(out_path), format="JPEG", quality=UPLOAD_JPEG_QUALITY, optimize=True)
+
+        try:
+            out_label_path = masks_dir / f"{Path(out_filename).stem}_labels.png"
+            if label_path.exists():
+                shutil.copyfile(str(label_path), str(out_label_path))
+        except Exception:
+            logger.exception("Failed to copy label map for output image")
+
+        return {
+            "message": "Texture applied successfully",
+            "original": safe_name,
+            "mask_indices": payload.mask_indices,
+            "texture_name": payload.texture_name,
+            "material": material,
+            "direction_mode": direction_mode,
+            "surface_type": surface_type,
+            "replace_mode": replace_mode,
+            "replace_strength": round(replace_strength, 3),
+            "lighting_mode": lighting_mode,
+            "light_angle_degrees": round(light_angle_degrees, 2),
+            "light_intensity": round(light_intensity, 3),
+            "blend_alpha": round(effective_alpha, 3),
+            "applied_angle_degrees": round(applied_angle, 2),
+            "output_filename": out_filename,
+            "output_url": f"/seg/image/{out_filename}",
+        }
+    finally:
+        log_timing_end(step, started)