Update app.py

app.py

@@ -1,9 +1,8 @@
-# app.py (versión CONSERVADORA - solo cache, nada más)
+# app.py (versión con logging, manejo de TileOutsideBounds y endpoint debug hillshade)
 import io
 import os
 import logging
 import numpy as np
-from functools import lru_cache
 from fastapi import FastAPI, Response
 from fastapi.middleware.cors import CORSMiddleware
 from rio_tiler.io import COGReader
@@ -18,7 +17,7 @@ TILE_SIZE = 256
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("dem-tiler")
 
-app = FastAPI(title="Mexico DEM TerrainRGB API (con cache)")
+app = FastAPI(title="Mexico DEM TerrainRGB API (debuggable)")
 
 app.add_middleware(
     CORSMiddleware,
@@ -50,82 +49,38 @@ def elev_to_grayscale(arr: np.ndarray) -> np.ndarray:
     """
     a = np.array(arr, dtype=np.float32)
     a = np.where(np.isfinite(a), a, np.nan)
+    # clamp to sensible range (optional)
     vmin = np.nanpercentile(a, 2) if np.isfinite(np.nanpercentile(a, 2)) else np.nanmin(a)
     vmax = np.nanpercentile(a, 98) if np.isfinite(np.nanpercentile(a, 98)) else np.nanmax(a)
     if np.isnan(vmin) or np.isnan(vmax) or vmin == vmax:
         vmin, vmax = np.nanmin(a), np.nanmax(a)
+    # handle edge cases
     if np.isnan(vmin): vmin = 0.0
     if np.isnan(vmax): vmax = vmin + 1.0
 
     norm = (a - vmin) / (vmax - vmin)
     norm = np.clip(norm, 0.0, 1.0)
     img = (norm * 255).astype(np.uint8)
+    # convert to RGB
     rgb = np.stack([img, img, img], axis=-1)
     return rgb
 
-# ============================================================================
-# ÚNICA OPTIMIZACIÓN: Cache de tiles
-# ============================================================================
-@lru_cache(maxsize=512)
-def get_tile_data(z: int, x: int, y: int) -> bytes:
-    """
-    Genera y cachea tiles. Esta es la única optimización añadida.
-    """
-    try:
-        with COGReader(COG_URL) as cog:
-            data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
-            elev = data[0].astype(np.float32)
-
-            if mask is not None:
-                invalid = (mask == 0)
-                elev[invalid] = np.nan
-
-            if np.all(np.isnan(elev)):
-                raise TileOutsideBounds(f"All NaN for tile {z}/{x}/{y}")
-
-            rgb = encode_terrainrgb(np.nan_to_num(elev, nan=-10000.0))
-            img = Image.fromarray(rgb, "RGB")
-            buf = io.BytesIO()
-            # compress_level=1 hace PNG más rápido (vs default 6)
-            img.save(buf, format="PNG", compress_level=1)
-            return buf.getvalue()
-
-    except TileOutsideBounds:
-        blank = Image.new("RGBA", (TILE_SIZE, TILE_SIZE), (0, 0, 0, 0))
-        buf = io.BytesIO()
-        blank.save(buf, format="PNG", compress_level=1)
-        return buf.getvalue()
-
-# ============================================================================
-# ENDPOINTS (tu código original, sin cambios)
-# ============================================================================
 @app.get("/")
 def root():
-    return {"message": "Mexico DEM TerrainRGB API running (with cache)", "cog_url": COG_URL}
+    return {"message": "Mexico DEM TerrainRGB API running", "cog_url": COG_URL}
 
 @app.get("/health")
 def health():
     return {"status": "ok"}
 
-@app.get("/cache/stats")
-def cache_stats():
-    """Nuevo: Ver estadísticas del cache"""
-    info = get_tile_data.cache_info()
-    return {
-        "hits": info.hits,
-        "misses": info.misses,
-        "size": info.currsize,
-        "maxsize": info.maxsize,
-        "hit_rate": f"{info.hits / (info.hits + info.misses) * 100:.1f}%" if (info.hits + info.misses) > 0 else "0%"
-    }
-
 @app.get("/info")
 def get_info():
     try:
         with COGReader(COG_URL) as cog:
             meta = cog.info()
+            # return a small, JSON-serializable subset
             out = {
-                "bounds": meta.bounds,
+                "bounds": meta.bounds,      # [left, bottom, right, top] in CRS of dataset (EPSG:3857)
                 "minzoom": meta.minzoom,
                 "maxzoom": meta.maxzoom,
                 "band_descriptions": meta.band_descriptions,
@@ -143,31 +98,65 @@ def get_info():
 @app.get("/tiles/{z}/{x}/{y}.png")
 def get_tile(z: int, x: int, y: int):
     """
-    Tile endpoint con cache - LA ÚNICA DIFERENCIA con tu código original
+    Tile endpoint: devuelve Terrain-RGB PNG (Mapbox spec).
+    Si el tile está fuera de bounds, devuelve PNG transparente.
     """
     try:
-        tile_bytes = get_tile_data(z, x, y)
-        return Response(tile_bytes, media_type="image/png")
+        with COGReader(COG_URL) as cog:
+            data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
+            elev = data[0].astype(np.float32)
+
+            # Replace nodata values with NaN if mask indicates no-data
+            if mask is not None:
+                # rio-tiler mask: 255 valid, 0 invalid (varies), handle robustly
+                invalid = (mask == 0)
+                elev = elev.astype(np.float32)
+                elev[invalid] = np.nan
+
+            # Handle all-nodata -> return transparent
+            if np.all(np.isnan(elev)):
+                raise TileOutsideBounds(f"All NaN for tile {z}/{x}/{y}")
+
+            rgb = encode_terrainrgb(np.nan_to_num(elev, nan=-10000.0))
+            img = Image.fromarray(rgb, "RGB")
+            buf = io.BytesIO()
+            img.save(buf, format="PNG")
+            buf.seek(0)
+            return Response(buf.getvalue(), media_type="image/png")
+
+    except TileOutsideBounds:
+        # tile fuera de bounds: PNG transparente
+        blank = Image.new("RGBA", (TILE_SIZE, TILE_SIZE), (0, 0, 0, 0))
+        buf = io.BytesIO()
+        blank.save(buf, format="PNG")
+        buf.seek(0)
+        return Response(buf.getvalue(), media_type="image/png")
+
     except Exception as e:
         logger.exception(f"Unexpected error generating tile {z}/{x}/{y}")
+        # Devuelve 500 con mensaje corto (no stacktrace)
         return Response(status_code=500, content=f"Server error generating tile: {str(e)}")
 
 @app.get("/debug/{z}/{x}/{y}.png")
 def debug_tile(z: int, x: int, y: int):
     """
-    Endpoint de debug (sin cambios de tu código original)
+    Endpoint de debug: devuelve una imagen en escala de grises (hillshade-like) para ver visualmente
+    si la tile solicitada coincide con tu DEM.
     """
     try:
         with COGReader(COG_URL) as cog:
             data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
             elev = data[0].astype(np.float32)
+            # mask nodata
             if mask is not None:
                 elev[mask == 0] = np.nan
 
             if np.all(np.isnan(elev)):
                 raise TileOutsideBounds()
 
+            # convert elevation to grayscale RGB for debug
             rgb = elev_to_grayscale(elev)
+            # if any nodata, set those pixels transparent by returning RGBA
             alpha = np.where(np.isfinite(elev), 255, 0).astype(np.uint8)
             rgba = np.dstack([rgb, alpha])
             img = Image.fromarray(rgba, "RGBA")