Download app.py from Pingul/maps: direct link, hf CLI and curl.
- Browser
- Download file 6.81 kB
-
https://huggingface.co/spaces/Pingul/maps/resolve/main/app.py
- Command line
-
hf download hf://spaces/Pingul/maps/app.py
-
curl -L -o app.py https://huggingface.co/spaces/Pingul/maps/resolve/main/app.py
6.81 kB
| # app.py (versión con logging, manejo de TileOutsideBounds y endpoint debug hillshade) | |
| import io | |
| import os | |
| import logging | |
| import numpy as np | |
| from fastapi import FastAPI, Response | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from rio_tiler.io import COGReader | |
| 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 | |
| # Logging simple | |
| logging.basicConfig(level=logging.INFO) | |
| logger = logging.getLogger("dem-tiler") | |
| app = FastAPI(title="Mexico DEM TerrainRGB API (debuggable)") | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"], | |
| allow_credentials=True, | |
| allow_methods=["*"], | |
| allow_headers=["*"], | |
| ) | |
| def encode_terrainrgb(arr: np.ndarray) -> np.ndarray: | |
| """ | |
| Convierte elevación en metros a Terrain-RGB (Mapbox spec). | |
| """ | |
| 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: | |
| """ | |
| Convierte elevación a imagen grayscale para debug: mapea min->0 max->255. | |
| NaNs se convierten a 0 (transparente later). | |
| """ | |
| 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 | |
| def root(): | |
| return {"message": "Mexico DEM TerrainRGB API running", "cog_url": COG_URL} | |
| def health(): | |
| return {"status": "ok"} | |
| 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 | |
| except Exception as e: | |
| logger.exception("Error reading COG info") | |
| return {"error": str(e)} | |
| 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. | |
| """ | |
| 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") | |
| 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)}") | |
| 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. | |
| """ | |
| 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") | |
| except TileOutsideBounds: | |
| 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("Error in debug_tile") | |
| return Response(status_code=500, content=f"Error: {e}") | |
| 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} | |
| except Exception as e: | |
| logger.exception("Error sampling point") | |
| return Response(status_code=500, content=f"Error sampling point: {e}") |