Emi Griffith
e819079bda
Remove the US+Canada bounding box so every endpoint accepts any lat/lon. The grading pipeline was already global-ready (ERA5 archive, timezone=auto, day-of-year climatology), so opening it up is mostly deleting the guard — plus the edge cases that only exist once the whole globe is in play: - grid.py: snap() wraps longitude into [-180, 180) and clamps latitude, and cell centers are normalized so the polar row and the cells straddling the antimeridian always report valid coordinates to the weather/geocoding APIs. snap() and from_id() now share one _cell() builder, making id round-trips exact by construction (verified with a 300k-point global sweep). - nav.js: neighbor-cell prefetch skips rows past the poles and wraps longitudes across the dateline instead of sending out-of-range queries. - Nominatim reverse geocoding requests accept-language=en so place labels render in one script worldwide (matching the forward geocoder). - mappicker: search suggestions are no longer filtered to US/CA, the placeholder and default map view are worldwide. - calendar: season filter labels flip for southern-hemisphere locations (Dec-Feb shows as Summer); the underlying month groups are unchanged, so saved filter selections keep meaning the same months. Verified end-to-end on a scratch server: Tokyo and Sydney grade with real labels, a Fiji cell on the antimeridian's east edge builds and serves warm hits from the derived store, and prefetch=1 on a cold cell still answers 204 without spending weather-API quota.
72 lines
2.8 KiB
Python
72 lines
2.8 KiB
Python
"""Snap an arbitrary lat/lon to a stable ~4-square-mile grid cell.
|
|
|
|
The grid is defined by fixed latitude rows (~2 miles tall). Within each row the
|
|
longitude step is scaled by cos(latitude) so cells stay roughly square (~4 sq mi)
|
|
at every latitude instead of getting skinny toward the poles. Cell ids are
|
|
deterministic, so the same physical location always maps to the same cache file.
|
|
Coverage is worldwide: any lat in [-90, 90] and any longitude (wrapped into
|
|
[-180, 180)) maps to a cell.
|
|
"""
|
|
import math
|
|
|
|
# 1 degree of latitude ~= 69 miles. ~2 miles -> ~0.029 deg gives a ~4 sq mi cell.
|
|
LAT_STEP = 1.0 / 34.5 # ~= 0.02899 deg (~2.0 miles)
|
|
|
|
|
|
def _lon_step(center_lat: float) -> float:
|
|
"""Longitude degrees that span ~2 miles at the given latitude."""
|
|
c = math.cos(math.radians(center_lat))
|
|
c = max(c, 0.05) # clamp near the poles to avoid a blow-up
|
|
return LAT_STEP / c
|
|
|
|
|
|
def _cell(i: int, j: int) -> dict:
|
|
"""Build the cell dict for grid indices (i, j). Shared by snap()/from_id()
|
|
so an id always rebuilds to the exact same cell."""
|
|
center_lat = (i + 0.5) * LAT_STEP
|
|
lon_step = _lon_step(center_lat)
|
|
center_lon = (j + 0.5) * lon_step
|
|
# Keep the reported center a valid coordinate for the upstream weather and
|
|
# geocoding APIs: the topmost row's center overshoots the pole, and a row's
|
|
# outermost cells can have centers just past the antimeridian on either side.
|
|
center_lat = min(max(center_lat, -90.0), 90.0)
|
|
if center_lon > 180.0:
|
|
center_lon -= 360.0
|
|
elif center_lon < -180.0:
|
|
center_lon += 360.0
|
|
|
|
# Approximate cell dimensions in miles for display.
|
|
height_mi = LAT_STEP * 69.0
|
|
width_mi = lon_step * 69.0 * math.cos(math.radians(center_lat))
|
|
|
|
return {
|
|
"id": f"{i}_{j}",
|
|
"center_lat": round(center_lat, 5),
|
|
"center_lon": round(center_lon, 5),
|
|
"lat_step": LAT_STEP,
|
|
"lon_step": lon_step,
|
|
"bounds": {
|
|
"south": round(i * LAT_STEP, 5),
|
|
"north": round((i + 1) * LAT_STEP, 5),
|
|
"west": round(j * lon_step, 5),
|
|
"east": round((j + 1) * lon_step, 5),
|
|
},
|
|
"area_sq_mi": round(height_mi * width_mi, 2),
|
|
}
|
|
|
|
|
|
def snap(lat: float, lon: float) -> dict:
|
|
"""Return the grid cell (id + center + span) containing (lat, lon)."""
|
|
lat = min(max(lat, -90.0), 90.0)
|
|
lon = ((lon + 180.0) % 360.0) - 180.0 # wrap into [-180, 180)
|
|
i = math.floor(lat / LAT_STEP)
|
|
j = math.floor(lon / _lon_step((i + 0.5) * LAT_STEP))
|
|
return _cell(i, j)
|
|
|
|
|
|
def from_id(cell_id: str) -> dict:
|
|
"""Rebuild the full cell dict from a cache id ("i_j") — the inverse of snap().
|
|
Lets offline tooling (the migrate script) recover a cell from its parquet
|
|
filename alone. Raises ValueError on a malformed id."""
|
|
i, j = (int(p) for p in cell_id.split("_"))
|
|
return _cell(i, j)
|