Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py (versión optimizada)
+# app.py (versión optimizada - ARREGLADA)
 import io
 import os
 import logging
@@ -40,44 +40,22 @@ def get_cog_reader():
     return _cog_reader
 
 # ============================================================================
-# OPTIMIZACIÓN 2: Encoding Terrain-RGB más rápido (vectorizado eficiente)
+# OPTIMIZACIÓN 2: Encoding Terrain-RGB (tu versión original, funciona bien)
 # ============================================================================
-def encode_terrainrgb_fast(arr: np.ndarray) -> np.ndarray:
+def encode_terrainrgb(arr: np.ndarray) -> np.ndarray:
     """
-    Versión optimizada de Terrain-RGB encoding.
-    Usa operaciones in-place y evita copias innecesarias.
+    Convierte elevación en metros a Terrain-RGB (Mapbox spec).
     """
-    # 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
+    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
 
 # ============================================================================
 # OPTIMIZACIÓN 3: Cache LRU para tiles
@@ -103,15 +81,15 @@ def get_tile_cached(z: int, x: int, y: int) -> bytes:
             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)
+        elev = np.nan_to_num(elev, nan=-10000.0)
         
-        # Encode a Terrain-RGB
-        rgb = encode_terrainrgb_fast(elev)
+        # Encode a Terrain-RGB (tu función original)
+        rgb = encode_terrainrgb(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
+        img.save(buf, format="PNG", compress_level=1)  # compress_level=1 es clave
         
         return buf.getvalue()
 
@@ -200,8 +178,16 @@ def debug_tile(z: int, x: int, y: int):
 
         # 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)
+        if np.any(a != 0):
+            vmin = np.nanpercentile(a[a != 0], 2)
+            vmax = np.nanpercentile(a[a != 0], 98)
+        else:
+            vmin, vmax = 0, 1
+        
+        if vmin == vmax:
+            vmax = vmin + 1
+            
+        norm = np.clip((a - vmin) / (vmax - vmin), 0, 1)
         gray = (norm * 255).astype(np.uint8)
         
         rgb = np.stack([gray, gray, gray], axis=-1)