Upload 217 files

backend/.env

@@ -1,6 +1,6 @@
 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:

backend/data/presets.json

@@ -0,0 +1,35 @@
+{
+  "ACM": {
+    "ancho_panel_m": 0.3,
+    "alto_panel_m": 0.3,
+    "intensidad_textura": 0.85,
+    "separacion_vertical_px": 0.3,
+    "separacion_horizontal_px": 0.3,
+    "orientacion": "vertical",
+    "perspectiva_horizontal": 0.5,
+    "perspectiva_vertical": 0.7,
+    "modo_fusion": "luz suave"
+  },
+  "WPC": {
+    "ancho_panel_m": 0.3,
+    "alto_panel_m": 1.0,
+    "intensidad_textura": 0.85,
+    "separacion_vertical_px": 0.3,
+    "separacion_horizontal_px": 0.3,
+    "orientacion": "vertical",
+    "perspectiva_horizontal": 0.5,
+    "perspectiva_vertical": 0.7,
+    "modo_fusion": "luz suave"
+  },
+  "WPC_DECK": {
+    "ancho_panel_m": 0.25,
+    "alto_panel_m": 0.05,
+    "intensidad_textura": 0.85,
+    "separacion_vertical_px": 0,
+    "separacion_horizontal_px": 5,
+    "orientacion": "horizontal",
+    "perspectiva_horizontal": 0.5,
+    "perspectiva_vertical": 0.5,
+    "modo_fusion": "luz suave"
+  }
+}

backend/main.py

@@ -13,7 +13,7 @@ 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
+from routers import auth, catalog, media, pages, segmentation, sessions, share, presets
 from routers.catalog import seed_catalog
 from services.sam2_service import lifespan
 
@@ -51,6 +51,7 @@ 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

backend/routers/presets.py

@@ -0,0 +1,34 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Any
+
+from services.presets_service import save_preset, get_preset, list_presets, delete_preset
+
+router = APIRouter(prefix="/api/presets")
+
+
+class PresetPayload(BaseModel):
+    name: str
+    params: dict
+
+
+@router.get("/")
+async def api_list_presets() -> dict:
+    return list_presets()
+
+
+@router.get("/{name}")
+async def api_get_preset(name: str) -> dict:
+    return get_preset(name)
+
+
+@router.post("/")
+async def api_save_preset(payload: PresetPayload) -> dict:
+    saved = save_preset(payload.name, payload.params)
+    return {"message": "saved", "preset": saved}
+
+
+@router.delete("/{name}")
+async def api_delete_preset(name: str) -> dict:
+    delete_preset(name)
+    return {"message": "deleted", "name": name}

backend/services/gradio_client_service.py

@@ -102,3 +102,75 @@ 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)

backend/services/presets_service.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+import json
+from typing import Any, Dict
+
+from fastapi import HTTPException
+
+DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+PRESETS_PATH = DATA_DIR / "presets.json"
+if not PRESETS_PATH.exists():
+    PRESETS_PATH.write_text(json.dumps({}), encoding="utf-8")
+
+
+def _read_all() -> Dict[str, Any]:
+    try:
+        text = PRESETS_PATH.read_text(encoding="utf-8")
+        return json.loads(text) if text.strip() else {}
+    except Exception:
+        return {}
+
+
+def list_presets() -> Dict[str, Any]:
+    return _read_all()
+
+
+def get_preset(name: str) -> Dict[str, Any]:
+    presets = _read_all()
+    if name not in presets:
+        raise HTTPException(status_code=404, detail=f"Preset not found: {name}")
+    return presets[name]
+
+
+def save_preset(name: str, params: Dict[str, Any]) -> Dict[str, Any]:
+    if not name or not isinstance(params, dict):
+        raise HTTPException(status_code=400, detail="Invalid preset payload")
+    presets = _read_all()
+    presets[name] = params
+    PRESETS_PATH.write_text(json.dumps(presets, ensure_ascii=False, indent=2), encoding="utf-8")
+    return presets[name]
+
+
+def delete_preset(name: str) -> None:
+    presets = _read_all()
+    if name in presets:
+        del presets[name]
+        PRESETS_PATH.write_text(json.dumps(presets, ensure_ascii=False, indent=2), encoding="utf-8")
+    else:
+        raise HTTPException(status_code=404, detail=f"Preset not found: {name}")

backend/services/texture_service.py

@@ -655,6 +655,173 @@ def apply_local_texture_sync(payload: ApplyTextureRequest) -> dict[str, Any]:
         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,
         )

frontend/src/version.ts

@@ -1 +1 @@
-export const appVersion = "0.1.0-dev.20260508T144158";
+export const appVersion = "0.1.0-dev.20260511T131335";