Update app.py

app.py

@@ -1,8 +1,9 @@
-# app.py (versión con logging, manejo de TileOutsideBounds y endpoint debug hillshade)
+# app.py (versión optimizada)
 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
@@ -10,14 +11,13 @@ from rio_tiler.errors import TileOutsideBounds
 from PIL import Image
 
 COG_URL = os.environ.get("COG_URL", "https://huggingface.co/datasets/Pingul/mexico-dem/resolve/main/Mexico_DEM_COG.tif")
-# COG_URL = os.environ.get("COG_URL", "https://huggingface.co/datasets/Pingul/mexico-dem/resolve/main/CEM_15m_COG.tif")
 TILE_SIZE = 256
+CACHE_SIZE = 512  # Cachear últimas 512 tiles
 
-# Logging simple
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("dem-tiler")
 
-app = FastAPI(title="Mexico DEM TerrainRGB API (debuggable)")
+app = FastAPI(title="Mexico DEM TerrainRGB API (optimizado)")
 
 app.add_middleware(
     CORSMiddleware,
@@ -27,70 +27,147 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-def encode_terrainrgb(arr: np.ndarray) -> np.ndarray:
+# ============================================================================
+# OPTIMIZACIÓN 1: COGReader global reutilizable
+# ============================================================================
+_cog_reader = None
+
+def get_cog_reader():
+    """Reutiliza la misma conexión COG en lugar de abrir/cerrar cada vez"""
+    global _cog_reader
+    if _cog_reader is None:
+        _cog_reader = COGReader(COG_URL)
+    return _cog_reader
+
+# ============================================================================
+# OPTIMIZACIÓN 2: Encoding Terrain-RGB más rápido (vectorizado eficiente)
+# ============================================================================
+def encode_terrainrgb_fast(arr: np.ndarray) -> np.ndarray:
     """
-    Convierte elevación en metros a Terrain-RGB (Mapbox spec).
+    Versión optimizada de Terrain-RGB encoding.
+    Usa operaciones in-place y evita copias innecesarias.
     """
-    arr = np.array(arr, dtype=np.float32)
-    arr = np.clip(arr, -10000, 9000)
-    arr = (arr + 10000.0) * 10.0  # mapbox scale
-
-    R = np.floor(arr / (256.0 * 256.0))
-    G = np.floor((arr - R * 256.0 * 256.0) / 256.0)
-    B = np.floor(arr - R * 256.0 * 256.0 - G * 256.0)
-
-    rgb = np.stack([R, G, B], axis=-1).astype(np.uint8)
-    return rgb
-
-def elev_to_grayscale(arr: np.ndarray) -> np.ndarray:
+    # Clamp valores
+    arr = np.clip(arr, -10000, 9000, out=arr)
+    
+    # Escala Mapbox
+    arr *= 10.0
+    arr += 100000.0  # (arr + 10000) * 10
+    
+    # Descomposición RGB más eficiente
+    arr_int = arr.astype(np.uint32)
+    
+    R = (arr_int >> 16) & 0xFF
+    G = (arr_int >> 8) & 0xFF
+    B = arr_int & 0xFF
+    
+    # Stack directo sin copies intermedias
+    return np.stack([R, G, B], axis=-1).astype(np.uint8)
+
+# Alternativa aún más rápida si numexpr está disponible:
+try:
+    import numexpr as ne
+    def encode_terrainrgb_fast(arr: np.ndarray) -> np.ndarray:
+        arr = np.clip(arr, -10000, 9000)
+        scaled = ne.evaluate("(arr + 10000.0) * 10.0")
+        
+        R = np.floor(scaled / 65536.0).astype(np.uint8)
+        G = np.floor((scaled % 65536.0) / 256.0).astype(np.uint8)
+        B = (scaled % 256.0).astype(np.uint8)
+        
+        return np.stack([R, G, B], axis=-1)
+except ImportError:
+    pass  # Usa la versión sin numexpr
+
+# ============================================================================
+# OPTIMIZACIÓN 3: Cache LRU para tiles
+# ============================================================================
+@lru_cache(maxsize=CACHE_SIZE)
+def get_tile_cached(z: int, x: int, y: int) -> bytes:
     """
-    Convierte elevación a imagen grayscale para debug: mapea min->0 max->255.
-    NaNs se convierten a 0 (transparente later).
+    Cachea tiles generadas. Retorna bytes directamente.
+    LRU cache guarda las tiles más solicitadas en memoria.
     """
-    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
+    try:
+        cog = get_cog_reader()
+        data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
+        elev = data[0].astype(np.float32)
+
+        # Aplicar mask si existe
+        if mask is not None:
+            invalid = (mask == 0)
+            elev[invalid] = np.nan
+
+        # Check si todo es nodata
+        if np.all(np.isnan(elev)):
+            raise TileOutsideBounds(f"All NaN for tile {z}/{x}/{y}")
+
+        # Reemplazar NaN con valor base
+        np.nan_to_num(elev, copy=False, nan=-10000.0)
+        
+        # Encode a Terrain-RGB
+        rgb = encode_terrainrgb_fast(elev)
+        
+        # Convertir a PNG con compresión rápida
+        img = Image.fromarray(rgb, "RGB")
+        buf = io.BytesIO()
+        img.save(buf, format="PNG", compress_level=1)  # compress_level=1 es MUY importante
+        
+        return buf.getvalue()
+
+    except TileOutsideBounds:
+        # Tile transparente (cacheable también)
+        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
+# ============================================================================
 @app.get("/")
 def root():
-    return {"message": "Mexico DEM TerrainRGB API running", "cog_url": COG_URL}
+    return {"message": "Mexico DEM TerrainRGB API (optimizado)", "cog_url": COG_URL}
 
 @app.get("/health")
 def health():
     return {"status": "ok"}
 
+@app.get("/cache/stats")
+def cache_stats():
+    """Endpoint para ver estadísticas del cache"""
+    info = get_tile_cached.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.post("/cache/clear")
+def clear_cache():
+    """Limpia el cache de tiles"""
+    get_tile_cached.cache_clear()
+    return {"status": "cache cleared"}
+
 @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,      # [left, bottom, right, top] in CRS of dataset (EPSG:3857)
-                "minzoom": meta.minzoom,
-                "maxzoom": meta.maxzoom,
-                "band_descriptions": meta.band_descriptions,
-                "statistics": {
-                    "min": getattr(meta, "min", None),
-                    "max": getattr(meta, "max", None)
-                },
-                "crs": str(meta.crs)
-            }
-            return out
+        cog = get_cog_reader()
+        meta = cog.info()
+        out = {
+            "bounds": meta.bounds,
+            "minzoom": meta.minzoom,
+            "maxzoom": meta.maxzoom,
+            "band_descriptions": meta.band_descriptions,
+            "statistics": {
+                "min": getattr(meta, "min", None),
+                "max": getattr(meta, "max", None)
+            },
+            "crs": str(meta.crs)
+        }
+        return out
     except Exception as e:
         logger.exception("Error reading COG info")
         return {"error": str(e)}
@@ -98,77 +175,49 @@ def get_info():
 @app.get("/tiles/{z}/{x}/{y}.png")
 def get_tile(z: int, x: int, y: int):
     """
-    Tile endpoint: devuelve Terrain-RGB PNG (Mapbox spec).
-    Si el tile está fuera de bounds, devuelve PNG transparente.
+    Tile endpoint optimizado con cache.
     """
     try:
-        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")
-
+        tile_bytes = get_tile_cached(z, x, y)
+        return Response(tile_bytes, 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)}")
+        return Response(status_code=500, content=f"Server error: {str(e)}")
 
 @app.get("/debug/{z}/{x}/{y}.png")
 def debug_tile(z: int, x: int, y: int):
-    """
-    Endpoint de debug: devuelve una imagen en escala de grises (hillshade-like) para ver visualmente
-    si la tile solicitada coincide con tu DEM.
-    """
+    """Endpoint de debug (sin cache para ver cambios en tiempo real)"""
     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")
-            buf = io.BytesIO()
-            img.save(buf, format="PNG")
-            buf.seek(0)
-            return Response(buf.getvalue(), media_type="image/png")
+        cog = get_cog_reader()
+        data, mask = cog.tile(x, y, z, tilesize=TILE_SIZE)
+        elev = data[0].astype(np.float32)
+        
+        if mask is not None:
+            elev[mask == 0] = np.nan
+
+        if np.all(np.isnan(elev)):
+            raise TileOutsideBounds()
+
+        # Grayscale simple
+        a = np.where(np.isfinite(elev), elev, 0)
+        vmin, vmax = np.nanpercentile(a[a != 0], [2, 98]) if np.any(a != 0) else (0, 1)
+        norm = np.clip((a - vmin) / (vmax - vmin + 1e-8), 0, 1)
+        gray = (norm * 255).astype(np.uint8)
+        
+        rgb = np.stack([gray, gray, gray], axis=-1)
+        alpha = np.where(np.isfinite(elev), 255, 0).astype(np.uint8)
+        rgba = np.dstack([rgb, alpha])
+        
+        img = Image.fromarray(rgba, "RGBA")
+        buf = io.BytesIO()
+        img.save(buf, format="PNG", compress_level=1)
+        buf.seek(0)
+        return Response(buf.getvalue(), media_type="image/png")
 
     except TileOutsideBounds:
         blank = Image.new("RGBA", (TILE_SIZE, TILE_SIZE), (0, 0, 0, 0))
         buf = io.BytesIO()
-        blank.save(buf, format="PNG")
+        blank.save(buf, format="PNG", compress_level=1)
         buf.seek(0)
         return Response(buf.getvalue(), media_type="image/png")
     except Exception as e:
@@ -178,10 +227,18 @@ def debug_tile(z: int, x: int, y: int):
 @app.get("/point")
 def get_point(lon: float, lat: float):
     try:
-        with COGReader(COG_URL) as cog:
-            val = cog.point(lon, lat)
-            elevation = float(val.data[0])
-            return {"lon": lon, "lat": lat, "elevation_m": elevation}
+        cog = get_cog_reader()
+        val = cog.point(lon, lat)
+        elevation = float(val.data[0])
+        return {"lon": lon, "lat": lat, "elevation_m": elevation}
     except Exception as e:
         logger.exception("Error sampling point")
-        return Response(status_code=500, content=f"Error sampling point: {e}")
+        return Response(status_code=500, content=f"Error: {e}")
+
+# Cleanup al cerrar
+@app.on_event("shutdown")
+def shutdown_event():
+    global _cog_reader
+    if _cog_reader is not None:
+        _cog_reader.close()
+        _cog_reader = None