IQ.Pilot Prebuilt Release @ 27f668a
This commit is contained in:
IQ.Lvbs CI [bot]
257
iqpilot/ui/onroad/offline_tiles.py
Normal file
257
iqpilot/ui/onroad/offline_tiles.py
Normal file
@@ -0,0 +1,257 @@
|
||||
import os
|
||||
import json
|
||||
import time
|
||||
from typing import Any
|
||||
from pathlib import Path
|
||||
|
||||
try:
|
||||
import sqlite3
|
||||
except Exception:
|
||||
sqlite3 = None
|
||||
|
||||
OFFLINE_MBTILES_ENV = "IQPILOT_OFFLINE_MBTILES"
|
||||
OFFLINE_TILE_ROOT_ENV = "IQPILOT_OFFLINE_TILE_ROOT"
|
||||
DEFAULT_OFFLINE_TILE_ROOT = Path("/data/offline_maps/tiles" if Path("/data").exists() else "/tmp/offline_maps/tiles")
|
||||
DEFAULT_OFFLINE_MAP_ROOT = Path("/data/offline_maps" if Path("/data").exists() else "/tmp/offline_maps")
|
||||
SQLITE_ERRORS = (sqlite3.Error,) if sqlite3 is not None else (Exception,)
|
||||
SQLiteConnection = Any
|
||||
|
||||
def offline_tile_root() -> Path:
|
||||
override = os.getenv(OFFLINE_TILE_ROOT_ENV)
|
||||
return Path(override) if override else DEFAULT_OFFLINE_TILE_ROOT
|
||||
|
||||
def offline_map_root() -> Path:
|
||||
root = offline_tile_root()
|
||||
if root.name == "tiles":
|
||||
return root.parent
|
||||
if root.name == "xyz":
|
||||
return root.parent.parent if root.parent.name == "tiles" else root.parent
|
||||
return DEFAULT_OFFLINE_MAP_ROOT
|
||||
|
||||
def _parse_bounds(bounds: str) -> tuple[float, float, float, float] | None:
|
||||
try:
|
||||
min_lon, min_lat, max_lon, max_lat = [float(part) for part in bounds.split(",")]
|
||||
except (ValueError, AttributeError):
|
||||
return None
|
||||
return min_lat, min_lon, max_lat, max_lon
|
||||
|
||||
def _bounds_contains(bounds: tuple[float, float, float, float], latitude: float, longitude: float) -> bool:
|
||||
min_lat, min_lon, max_lat, max_lon = bounds
|
||||
return min_lat <= latitude <= max_lat and min_lon <= longitude <= max_lon
|
||||
|
||||
def _bounds_area(bounds: tuple[float, float, float, float]) -> float:
|
||||
min_lat, min_lon, max_lat, max_lon = bounds
|
||||
return max(max_lat - min_lat, 0.0) * max(max_lon - min_lon, 0.0)
|
||||
|
||||
_region_bounds_cache: dict[Path, tuple[float, float, float, float]] = {}
|
||||
|
||||
def _load_region_bounds(region_root: Path) -> tuple[float, float, float, float] | None:
|
||||
cached = _region_bounds_cache.get(region_root)
|
||||
if cached is not None:
|
||||
return cached
|
||||
bounds = _load_region_bounds_uncached(region_root)
|
||||
if bounds is not None:
|
||||
if len(_region_bounds_cache) > 64:
|
||||
_region_bounds_cache.clear()
|
||||
_region_bounds_cache[region_root] = bounds
|
||||
return bounds
|
||||
|
||||
def _load_region_bounds_uncached(region_root: Path) -> tuple[float, float, float, float] | None:
|
||||
manifest_path = region_root / "manifest.json"
|
||||
if manifest_path.exists():
|
||||
try:
|
||||
manifest = json.loads(manifest_path.read_text())
|
||||
bounds = manifest.get("mbtiles", {}).get("bounds")
|
||||
parsed = _parse_bounds(bounds) if bounds else None
|
||||
if parsed is not None:
|
||||
return parsed
|
||||
except (OSError, json.JSONDecodeError):
|
||||
pass
|
||||
|
||||
mbtiles_path = region_root / "tiles" / "offline.mbtiles"
|
||||
if not mbtiles_path.exists():
|
||||
return None
|
||||
|
||||
try:
|
||||
conn = open_mbtiles(mbtiles_path)
|
||||
row = conn.execute("SELECT value FROM metadata WHERE name = 'bounds'").fetchone()
|
||||
conn.close()
|
||||
except SQLITE_ERRORS:
|
||||
return None
|
||||
|
||||
return _parse_bounds(row["value"]) if row is not None else None
|
||||
|
||||
_REGION_ROOTS_TTL_S = 15.0
|
||||
_region_roots_cache: tuple[float, Path, tuple[Path, ...]] | None = None
|
||||
|
||||
def _candidate_region_roots() -> tuple[Path, ...]:
|
||||
global _region_roots_cache
|
||||
root = offline_map_root()
|
||||
now = time.monotonic()
|
||||
if _region_roots_cache is not None:
|
||||
cached_at, cached_root, cached = _region_roots_cache
|
||||
if cached_root == root and now - cached_at < _REGION_ROOTS_TTL_S:
|
||||
return cached
|
||||
|
||||
candidates: list[Path] = []
|
||||
if (root / "tiles").exists():
|
||||
candidates.append(root)
|
||||
|
||||
regions_root = root / "regions"
|
||||
if regions_root.exists():
|
||||
for child in sorted(regions_root.iterdir()):
|
||||
if child.is_dir() and (child / "tiles").exists():
|
||||
candidates.append(child)
|
||||
|
||||
result = tuple(candidates)
|
||||
_region_roots_cache = (now, root, result)
|
||||
return result
|
||||
|
||||
def _region_covers_point(region_root: Path, latitude: float, longitude: float) -> bool:
|
||||
mb = region_root / "tiles" / "offline.mbtiles"
|
||||
if not mb.exists():
|
||||
return True
|
||||
try:
|
||||
conn = open_mbtiles(mb)
|
||||
try:
|
||||
_, max_zoom = mbtiles_zoom_bounds(conn)
|
||||
z = max_zoom if max_zoom is not None else 14
|
||||
import math
|
||||
n = 2 ** z
|
||||
lat_r = math.radians(max(min(latitude, 85.05112878), -85.05112878))
|
||||
x = int((longitude + 180.0) / 360.0 * n)
|
||||
y = int((1.0 - math.asinh(math.tan(lat_r)) / math.pi) / 2.0 * n)
|
||||
for dx in (-1, 0, 1):
|
||||
for dy in (-1, 0, 1):
|
||||
if load_raster_tile_blob(conn, z, x + dx, y + dy) is not None:
|
||||
return True
|
||||
return False
|
||||
finally:
|
||||
conn.close()
|
||||
except SQLITE_ERRORS:
|
||||
return True
|
||||
|
||||
def find_offline_region_root(latitude: float | None = None, longitude: float | None = None) -> Path | None:
|
||||
candidates = _candidate_region_roots()
|
||||
if not candidates:
|
||||
return None
|
||||
|
||||
if latitude is None or longitude is None:
|
||||
return candidates[0]
|
||||
|
||||
bounded: list[tuple[float, Path]] = []
|
||||
for candidate in candidates:
|
||||
bounds = _load_region_bounds(candidate)
|
||||
if bounds is None:
|
||||
continue
|
||||
if _bounds_contains(bounds, latitude, longitude):
|
||||
bounded.append((_bounds_area(bounds), candidate))
|
||||
|
||||
if bounded:
|
||||
if len(bounded) == 1:
|
||||
return bounded[0][1]
|
||||
bounded.sort(key=lambda item: item[0])
|
||||
for _, candidate in bounded:
|
||||
if _region_covers_point(candidate, latitude, longitude):
|
||||
return candidate
|
||||
return bounded[0][1]
|
||||
|
||||
return candidates[0]
|
||||
|
||||
def find_offline_mbtiles_path(latitude: float | None = None, longitude: float | None = None,
|
||||
day: bool = False) -> Path | None:
|
||||
explicit = os.getenv(OFFLINE_MBTILES_ENV)
|
||||
if explicit:
|
||||
path = Path(explicit)
|
||||
if day:
|
||||
day_path = path.with_name("offline_day.mbtiles")
|
||||
if day_path.exists():
|
||||
return day_path
|
||||
return path if path.exists() else None
|
||||
|
||||
region_root = find_offline_region_root(latitude, longitude)
|
||||
if region_root is None:
|
||||
return None
|
||||
|
||||
if day:
|
||||
day_preferred = region_root / "tiles" / "offline_day.mbtiles"
|
||||
if day_preferred.exists():
|
||||
return day_preferred
|
||||
|
||||
preferred = region_root / "tiles" / "offline.mbtiles"
|
||||
if preferred.exists():
|
||||
return preferred
|
||||
|
||||
matches = sorted(p for p in (region_root / "tiles").glob("*.mbtiles") if "_day" not in p.name or day)
|
||||
return matches[0] if matches else None
|
||||
|
||||
def find_offline_xyz_root(latitude: float | None = None, longitude: float | None = None) -> Path | None:
|
||||
root = offline_tile_root()
|
||||
if not root.exists():
|
||||
region_root = find_offline_region_root(latitude, longitude)
|
||||
if region_root is None:
|
||||
return None
|
||||
root = region_root / "tiles"
|
||||
|
||||
if any(child.is_dir() and child.name.isdigit() for child in root.iterdir()):
|
||||
return root
|
||||
|
||||
xyz_dir = root / "xyz"
|
||||
if xyz_dir.exists() and any(child.is_dir() and child.name.isdigit() for child in xyz_dir.iterdir()):
|
||||
return xyz_dir
|
||||
|
||||
return None
|
||||
|
||||
def xyz_to_tms_y(z: int, y: int) -> int:
|
||||
return (2 ** z - 1) - y
|
||||
|
||||
def open_mbtiles(path: Path) -> SQLiteConnection:
|
||||
if sqlite3 is None:
|
||||
raise RuntimeError("sqlite3 unavailable")
|
||||
conn = sqlite3.connect(f"file:{path}?mode=ro", uri=True, check_same_thread=False)
|
||||
conn.row_factory = sqlite3.Row
|
||||
return conn
|
||||
|
||||
def mbtiles_is_raster(conn: SQLiteConnection) -> bool:
|
||||
row = conn.execute("SELECT value FROM metadata WHERE name = 'format'").fetchone()
|
||||
if row is None:
|
||||
return False
|
||||
return row["value"] in {"png", "jpg", "jpeg", "webp"}
|
||||
|
||||
def mbtiles_zoom_bounds(conn: SQLiteConnection) -> tuple[int | None, int | None]:
|
||||
rows = {
|
||||
row["name"]: row["value"]
|
||||
for row in conn.execute("SELECT name, value FROM metadata WHERE name IN ('minzoom', 'maxzoom')")
|
||||
}
|
||||
min_zoom = int(rows["minzoom"]) if "minzoom" in rows else None
|
||||
max_zoom = int(rows["maxzoom"]) if "maxzoom" in rows else None
|
||||
return min_zoom, max_zoom
|
||||
|
||||
def xyz_zoom_bounds(root: Path) -> tuple[int | None, int | None]:
|
||||
zoom_dirs = sorted(
|
||||
int(child.name)
|
||||
for child in root.iterdir()
|
||||
if child.is_dir() and child.name.isdigit()
|
||||
)
|
||||
if not zoom_dirs:
|
||||
return None, None
|
||||
return zoom_dirs[0], zoom_dirs[-1]
|
||||
|
||||
def load_raster_tile_blob(conn: SQLiteConnection, z: int, x: int, y: int) -> bytes | None:
|
||||
row = conn.execute(
|
||||
"""
|
||||
SELECT tile_data
|
||||
FROM tiles
|
||||
WHERE zoom_level = ? AND tile_column = ? AND tile_row = ?
|
||||
""",
|
||||
(z, x, xyz_to_tms_y(z, y)),
|
||||
).fetchone()
|
||||
return bytes(row["tile_data"]) if row is not None else None
|
||||
|
||||
def load_raster_xyz_tile_blob(root: Path, z: int, x: int, y: int) -> bytes | None:
|
||||
for suffix in ("png", "webp", "jpg", "jpeg"):
|
||||
for filename in (f"{y}.{suffix}", f"{y}@2x.{suffix}"):
|
||||
tile_path = root / str(z) / str(x) / filename
|
||||
if tile_path.exists():
|
||||
return tile_path.read_bytes()
|
||||
return None
|
||||
Reference in New Issue
Block a user