Skip to content

LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust

Reverse geocoding: fill City / State / Country from GPS (offline GeoNames)

Andrew Frahnb28b05c47519
diff --git a/Cargo.lock b/Cargo.lock
index 700f386fb..6f432b266 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3210,6 +3210,7 @@ dependencies = [
"lightcraft-develop",
"lightcraft-faces",
"lightcraft-fetch",
+ "lightcraft-geocode",
"lightcraft-geom",
"lightcraft-gpu",
"lightcraft-heif",
@@ -3257,6 +3258,14 @@ dependencies = [
"webpki-roots",
]
+[[package]]
+name = "lightcraft-geocode"
+version = "0.6.0"
+dependencies = [
+ "miniz_oxide 0.8.9",
+ "serde",
+]
+
[[package]]
name = "lightcraft-geom"
version = "0.6.0"
diff --git a/Cargo.toml b/Cargo.toml
index b9a511e26..7bcc0004d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,6 +36,7 @@ lightcraft-mcp = { path = "crates/mcp" }
lightcraft-fetch = { path = "crates/fetch" }
lightcraft-heif = { path = "crates/heif" }
lightcraft-segment = { path = "crates/segment" }
+lightcraft-geocode = { path = "crates/geocode" }
# foundation
thiserror = "2"
diff --git a/NOTICE b/NOTICE
index 5fd60227f..f3adeff84 100644
--- a/NOTICE
+++ b/NOTICE
@@ -48,3 +48,10 @@ also embed the fonts listed in https://github.com/storytold/craft-fonts/blob/mai
(the Japanese fonts BIZ UDPGothic, BIZ UDMincho and Shippori Mincho; the web build embeds only BIZ
UDPGothic Regular), under the SIL Open Font License 1.1. Release packages include each font's
licence as OFL-<family>.txt.
+
+Place names for reverse geocoding (Photo > Fill Location from GPS) are not part of LightCraft and
+are never distributed with it. On the user's request (Photo > Download Place Names) the app
+downloads cities15000.zip, admin1CodesASCII.txt and countryInfo.txt from GeoNames
+(https://download.geonames.org/export/dump/) into the settings folder. GeoNames data is licensed
+under Creative Commons Attribution 4.0 (https://creativecommons.org/licenses/by/4.0/);
+attribution: "GeoNames, geonames.org". The lookup code (crates/geocode) is our own.
diff --git a/crates/engine/Cargo.toml b/crates/engine/Cargo.toml
index 4036a5c94..2fb403cec 100644
--- a/crates/engine/Cargo.toml
+++ b/crates/engine/Cargo.toml
@@ -27,6 +27,7 @@ lightcraft-meta = { workspace = true }
lightcraft-faces = { workspace = true }
miniz_oxide = { workspace = true }
lightcraft-merge = { workspace = true }
+lightcraft-geocode = { workspace = true }
rayon = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
diff --git a/crates/engine/src/cmd/geocode.rs b/crates/engine/src/cmd/geocode.rs
new file mode 100644
index 000000000..bf9389adf
--- /dev/null
+++ b/crates/engine/src/cmd/geocode.rs
@@ -0,0 +1,272 @@
+//! Reverse geocoding (issue #582): fill City / State / Country from a photo's GPS position, offline, with the
+//! GeoNames place names ([`lightcraft_geocode`]). The place names (CC-BY 4.0) are not shipped with the app: the user
+//! downloads them once (`metadata.downloadPlaceNames`, ~3 MB from download.geonames.org) into the settings folder;
+//! after that every lookup is local and no position ever leaves the machine.
+//!
+//! Sources: GeoNames dump readme (prose); own design.
+
+use std::path::PathBuf;
+
+use serde_json::{Value, json};
+
+use lightcraft_catalog::{Op, PhotoId};
+use lightcraft_geocode::{GEONAMES_ATTRIBUTION, GEONAMES_FILES, GeoNames, LatLon};
+
+use super::{CommandSpec, always, bad, bool_or, cmd, has_selection, str_param};
+use crate::activity::Cancel;
+use crate::{Result, Session};
+
+/// Where the place names live: `dataset` (a folder) or `<settings>/geonames`.
+fn dataset_dir(p: &Value) -> Option<PathBuf> {
+ str_param(p, "dataset").map(PathBuf::from).or_else(|| crate::config::config_dir().map(|d| d.join("geonames")))
+}
+
+fn status(_s: &mut Session, p: &Value) -> Result<Value> {
+ let dir = dataset_dir(p);
+ let size = dir.as_ref().and_then(|d| std::fs::metadata(d.join(GEONAMES_FILES[0])).ok()).map(|m| m.len());
+ Ok(
+ json!({"downloaded": size.is_some(), "bytes": size, "path": dir, "attribution": GEONAMES_ATTRIBUTION, "source": lightcraft_geocode::GEONAMES_BASE}),
+ )
+}
+
+/// Which place fields to write: a field is filled when it is empty, or always with `overwrite`.
+fn fill(meta: &mut lightcraft_catalog::Meta, place: &lightcraft_geocode::Place, overwrite: bool) {
+ for (field, value) in [
+ (&mut meta.location, &place.sublocation),
+ (&mut meta.city, &place.city),
+ (&mut meta.state, &place.state),
+ (&mut meta.country, &place.country),
+ ] {
+ if !value.is_empty() && (overwrite || field.trim().is_empty()) {
+ *field = value.clone();
+ }
+ }
+}
+
+fn reverse(s: &mut Session, p: &Value) -> Result<Value> {
+ const C: &str = "metadata.reverseGeocode";
+ let overwrite = bool_or(p, "overwrite", false);
+ let ids = s.targets(p);
+ let todo: Vec<(PhotoId, LatLon)> = ids
+ .iter()
+ .filter_map(|id| {
+ let (la, lo) = s.catalog.photo(*id)?.meta.gps?;
+ let at = LatLon::new(la, lo);
+ at.is_valid().then_some((*id, at))
+ })
+ .collect();
+ if todo.is_empty() {
+ return Err(bad(C, "none of these photos has a GPS position"));
+ }
+ let dir = dataset_dir(p).ok_or_else(|| bad(C, "no settings folder: give `dataset`"))?;
+ let names = GeoNames::load(&dir).map_err(|e| bad(C, format!("{e}: download the place names first (Photo ▸ Download Place Names)")))?;
+ // a large selection shows in the activity stack and can be stopped
+ let task = (todo.len() > 1).then(|| s.activity.start("geocode", "Looking up places", Cancel::Yes));
+ let mut ops = Vec::new();
+ let mut found = Vec::new();
+ for (n, (id, at)) in todo.iter().enumerate() {
+ if let Some(t) = &task {
+ if t.cancel_flag().is_some_and(|f| f.load(std::sync::atomic::Ordering::Relaxed)) {
+ return Err(bad(C, "cancelled"));
+ }
+ t.progress(n as u64, todo.len() as u64);
+ }
+ let Some(place) = names.reverse(*at) else { continue };
+ let Some(ph) = s.catalog.photo(*id) else { continue };
+ let mut meta = ph.meta.clone();
+ fill(&mut meta, &place, overwrite);
+ if meta != ph.meta {
+ ops.push(Op::SetMeta { id: *id, meta: Box::new(meta) });
+ }
+ found.push(json!({"id": id.0, "place": place}));
+ }
+ drop(task);
+ let changed = ops.len();
+ if !bool_or(p, "dryRun", false) && changed > 0 {
+ s.commit("Reverse Geocode", Op::Batch { ops })?;
+ }
+ Ok(json!({"looked": todo.len(), "found": found.len(), "changed": changed, "photos": found, "attribution": GEONAMES_ATTRIBUTION}))
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+mod download {
+ use std::path::Path;
+ use std::sync::Arc;
+ use std::sync::atomic::AtomicBool;
+
+ use lightcraft_geocode::{GEONAMES_BASE, GEONAMES_ZIP};
+
+ use super::*;
+ use crate::activity::Unit;
+
+ const MAX_ZIP: u64 = 64 * 1024 * 1024;
+ const MAX_TEXT: usize = 256 * 1024 * 1024;
+
+ fn get(name: &str, base: &str, dir: &Path, cancel: &AtomicBool, task: &crate::activity::TaskHandle) -> std::result::Result<(), String> {
+ let _ = std::fs::remove_file(dir.join(name));
+ let file = lightcraft_fetch::FileSpec { name, size: None, sha256: None, max: MAX_ZIP };
+ lightcraft_fetch::download_url(&file, &format!("{base}{name}"), dir, &lightcraft_fetch::Options::default(), cancel, &mut |pr| {
+ task.progress(pr.done, pr.total.max(pr.done))
+ })
+ .map_err(|e| e.to_string())
+ }
+
+ /// Fetch and unpack the place names into `dir`; the new files replace the old ones only when complete.
+ pub(super) fn run(base: &str, dir: &Path, cancel: &AtomicBool, task: &crate::activity::TaskHandle) -> std::result::Result<usize, String> {
+ let staging = dir.join(".download");
+ std::fs::create_dir_all(&staging).map_err(|e| format!("could not create {}: {e}", staging.display()))?;
+ get(GEONAMES_ZIP, base, &staging, cancel, task)?;
+ let zip = std::fs::read(staging.join(GEONAMES_ZIP)).map_err(|e| e.to_string())?;
+ let cities = lightcraft_geocode::unzip::extract(&zip, GEONAMES_FILES[0], MAX_TEXT).map_err(|e| e.to_string())?;
+ let places = GeoNames::parse(&String::from_utf8_lossy(&cities), None, None).len();
+ if places == 0 {
+ return Err("the downloaded place list is empty".into());
+ }
+ let _ = std::fs::remove_file(staging.join(GEONAMES_ZIP));
+ let write = |name: &str, data: &[u8]| std::fs::write(dir.join(name), data).map_err(|e| format!("could not save {name}: {e}"));
+ for name in &GEONAMES_FILES[1..] {
+ // optional: without them states stay blank and countries are ISO codes
+ match get(name, base, &staging, cancel, task).and_then(|()| std::fs::read(staging.join(name)).map_err(|e| e.to_string())) {
+ Ok(b) => write(name, &b)?,
+ Err(e) => log::warn!("place names: {name}: {e}"),
+ }
+ let _ = std::fs::remove_file(staging.join(name));
+ }
+ write(GEONAMES_FILES[0], &cities)?;
+ let _ = std::fs::remove_dir(&staging);
+ Ok(places)
+ }
+
+ /// `metadata.downloadPlaceNames`: starts a background download (shown in the activity stack, cancellable).
+ pub(super) fn start(s: &mut Session, p: &Value) -> Result<Value> {
+ const C: &str = "metadata.downloadPlaceNames";
+ let dir = dataset_dir(p).ok_or_else(|| bad(C, "no settings folder: give `dataset`"))?;
+ let base = str_param(p, "base").unwrap_or(GEONAMES_BASE).to_string();
+ if !(base.starts_with("https://") || base.starts_with("http://127.0.0.1")) {
+ return Err(bad(C, "`base` must be an https:// address"));
+ }
+ let cancel = Arc::new(AtomicBool::new(false));
+ let task = s.activity.start("download", "Downloading place names", Cancel::Flag(cancel.clone()));
+ task.set_unit(Unit::Bytes);
+ task.detail("GeoNames");
+ let handle = task.handle();
+ let thread_dir = dir.clone();
+ std::thread::Builder::new()
+ .name("place-names-download".into())
+ .spawn(move || {
+ // the activity row goes when the thread ends, however it ends
+ let _task = task;
+ let outcome = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| run(&base, &thread_dir, &cancel, &handle)));
+ match outcome {
+ Ok(Ok(n)) => log::info!("place names: {n} places downloaded"),
+ Ok(Err(e)) => log::warn!("place names download failed: {e}"),
+ Err(_) => log::warn!("place names download stopped unexpectedly"),
+ }
+ })
+ .map_err(|e| bad(C, format!("could not start the download: {e}")))?;
+ Ok(json!({"started": true, "path": dir, "attribution": GEONAMES_ATTRIBUTION}))
+ }
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+ #[allow(unused_mut)]
+ let mut v = vec![
+ cmd!(
+ "metadata.reverseGeocode",
+ "Fill Location from GPS",
+ ["Photo"],
+ None,
+ "{ids?, overwrite?: bool (also replace place fields that already have text; default false: only empty ones are filled), dryRun?, dataset?: folder} → {looked, found, changed, photos: [{id, place: {sublocation, city, state, country, iso, distance}}], attribution} — fills City / State / Country (and Sublocation when known) from GPS with the offline GeoNames place names (download them first); one undo step",
+ has_selection,
+ reverse
+ ),
+ cmd!(query "metadata.placeNamesStatus", "Place Names Status", [], None, "{dataset?: folder} → {downloaded, bytes, path, attribution, source}", always, status),
+ ];
+ #[cfg(not(target_arch = "wasm32"))]
+ v.push(cmd!(
+ "metadata.downloadPlaceNames",
+ "Download Place Names (GeoNames)",
+ ["Photo"],
+ None,
+ "{dataset?: folder} → {started, path, attribution} — downloads the GeoNames cities list (CC-BY 4.0, ~3 MB, from download.geonames.org) in the background for Fill Location from GPS; no photo data is sent",
+ always,
+ download::start
+ ));
+ v
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const CITIES: &str = "2988507\tParis\tParis\t\t48.85341\t2.3488\tP\tPPLC\tFR\t\t11\t75\t\t\t2138551\t\t42\tEurope/Paris\t2024-01-01\n\
+ 2643743\tLondon\tLondon\t\t51.50853\t-0.12574\tP\tPPLC\tGB\t\tENG\t\t\t\t8961989\t\t25\tEurope/London\t2024-01-01\n";
+
+ fn dataset(tag: &str) -> PathBuf {
+ let dir = std::env::temp_dir().join(format!("lightcraft-geocode-cmd-{tag}-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&dir);
+ std::fs::create_dir_all(&dir).unwrap();
+ std::fs::write(dir.join(GEONAMES_FILES[0]), CITIES).unwrap();
+ std::fs::write(dir.join(GEONAMES_FILES[1]), "FR.11\tÎle-de-France\nGB.ENG\tEngland\n").unwrap();
+ std::fs::write(dir.join(GEONAMES_FILES[2]), "#c\nFR\tFRA\t250\tFR\tFrance\nGB\tGBR\t826\tUK\tUnited Kingdom\n").unwrap();
+ dir
+ }
+
+ fn set_gps(s: &mut Session, id: PhotoId, gps: Option<(f64, f64)>, city: &str) {
+ let mut meta = s.catalog.photo(id).unwrap().meta.clone();
+ meta.gps = gps;
+ meta.city = city.into();
+ meta.state.clear();
+ meta.country.clear();
+ meta.location.clear();
+ s.commit("test", Op::SetMeta { id, meta: Box::new(meta) }).unwrap();
+ }
+
+ #[test]
+ fn fills_empty_fields_keeps_typed_ones_and_undoes() {
+ let mut s = Session::with_demo();
+ let ids = s.visible_cloned();
+ let dir = dataset("fill");
+ set_gps(&mut s, ids[0], Some((48.86, 2.34)), "");
+ set_gps(&mut s, ids[1], Some((51.5, -0.1)), "Westminster");
+ set_gps(&mut s, ids[2], Some((f64::NAN, 0.0)), "");
+ set_gps(&mut s, ids[3], Some((0.0, 0.0)), "");
+ let r = s.execute("metadata.reverseGeocode", &json!({"ids": [ids[0].0, ids[1].0, ids[2].0, ids[3].0], "dataset": dir})).unwrap();
+ assert_eq!((r["looked"].as_u64(), r["found"].as_u64(), r["changed"].as_u64()), (Some(3), Some(2), Some(2)), "{r}");
+ let m0 = s.catalog.photo(ids[0]).unwrap().meta.clone();
+ assert_eq!((m0.city.as_str(), m0.state.as_str(), m0.country.as_str()), ("Paris", "Île-de-France", "France"));
+ let m1 = s.catalog.photo(ids[1]).unwrap().meta.clone();
+ assert_eq!((m1.city.as_str(), m1.state.as_str(), m1.country.as_str()), ("Westminster", "England", "United Kingdom"));
+ assert!(s.activity.list().is_empty(), "the activity row ends with the command");
+ // one undo step
+ s.undo_step().unwrap();
+ assert!(s.catalog.photo(ids[0]).unwrap().meta.city.is_empty());
+ assert_eq!(s.catalog.photo(ids[1]).unwrap().meta.city, "Westminster");
+ // overwrite replaces typed text
+ s.execute("metadata.reverseGeocode", &json!({"ids": [ids[1].0], "dataset": dir, "overwrite": true})).unwrap();
+ assert_eq!(s.catalog.photo(ids[1]).unwrap().meta.city, "London");
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+
+ #[test]
+ fn explains_missing_data_and_gps() {
+ let mut s = Session::with_demo();
+ let ids = s.visible_cloned();
+ set_gps(&mut s, ids[0], None, "");
+ let e = s.execute("metadata.reverseGeocode", &json!({"ids": [ids[0].0]})).unwrap_err();
+ assert!(e.to_string().contains("GPS"), "{e}");
+ set_gps(&mut s, ids[0], Some((48.86, 2.34)), "");
+ let missing = std::env::temp_dir().join(format!("lightcraft-geocode-none-{}", std::process::id()));
+ let e = s.execute("metadata.reverseGeocode", &json!({"ids": [ids[0].0], "dataset": missing})).unwrap_err();
+ assert!(e.to_string().contains("download"), "{e}");
+ let st = s.execute("metadata.placeNamesStatus", &json!({"dataset": missing})).unwrap();
+ assert_eq!(st["downloaded"], false);
+ }
+
+ #[cfg(not(target_arch = "wasm32"))]
+ #[test]
+ fn download_refuses_plain_http() {
+ let mut s = Session::with_demo();
+ assert!(s.execute("metadata.downloadPlaceNames", &json!({"dataset": "/nonexistent", "base": "http://example.com/"})).is_err());
+ }
+}
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index e7def13d3..9ecc9008b 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -19,6 +19,7 @@ pub(crate) mod face_detect;
mod face_models;
mod face_recognize;
pub mod filters;
+mod geocode;
pub mod keywords;
pub mod library;
pub mod lut_profiles;
@@ -150,6 +151,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
v.extend(missing::specs());
v.extend(sync::specs());
v.extend(metadata::specs());
+ v.extend(geocode::specs());
v.extend(filters::specs());
v.extend(denoise::specs());
v.extend(face_models::specs());
diff --git a/crates/geocode/Cargo.toml b/crates/geocode/Cargo.toml
new file mode 100644
index 000000000..0d30af762
--- /dev/null
+++ b/crates/geocode/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "lightcraft-geocode"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+description = "LightCraft offline reverse geocoding: GPS position to sublocation / city / state / country from a GeoNames dump (L1)"
+
+[lints]
+workspace = true
+
+[dependencies]
+miniz_oxide = { workspace = true }
+serde = { workspace = true }
diff --git a/crates/geocode/README.md b/crates/geocode/README.md
new file mode 100644
index 000000000..9e0376b0c
--- /dev/null
+++ b/crates/geocode/README.md
@@ -0,0 +1,17 @@
+# lightcraft-geocode (L1)
+
+Offline reverse geocoding: a GPS position becomes Sublocation / City / State / Country.
+
+- **Data:** the GeoNames dump (<https://download.geonames.org/export/dump/>), licensed CC-BY 4.0
+ (attribution: "GeoNames, geonames.org"). Nothing is bundled: the engine
+ (`metadata.downloadPlaceNames`) downloads `cities15000.zip`, `admin1CodesASCII.txt` and
+ `countryInfo.txt` on the user's request into the settings folder. This crate only parses and
+ searches; it never touches the network.
+- **Lookup:** the nearest populated place within `MAX_KM` (great-circle distance), searched in the
+ 1° cells around the position, so one lookup looks at a few dozen places, not all of them.
+- **unzip:** just enough ZIP to read one file out of `cities15000.zip` (stored or deflated).
+- **Never panics on hostile input:** bad lines are skipped, NaN / out-of-range positions find
+ nothing, sizes and counts are capped.
+
+Sources: GeoNames dump readme (file layout, prose); haversine distance (textbook); PKWARE APPNOTE
+(ZIP, prose spec); the cell index is own design.
diff --git a/crates/geocode/src/lib.rs b/crates/geocode/src/lib.rs
new file mode 100644
index 000000000..3acb6b5f6
--- /dev/null
+++ b/crates/geocode/src/lib.rs
@@ -0,0 +1,273 @@
+//! Offline reverse geocoding: a GPS position → Sublocation / City / State / Country, from the
+//! GeoNames dump (CC-BY 4.0, "GeoNames, geonames.org"). See README.md.
+//!
+//! Sources: GeoNames dump readme (prose); haversine (textbook); cell index own design.
+#![forbid(unsafe_code)]
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+
+pub mod unzip;
+
+use std::collections::HashMap;
+use std::path::Path;
+
+use serde::Serialize;
+
+/// Lookups farther than this from any place find nothing.
+pub const MAX_KM: f64 = 50.0;
+/// The files the engine downloads (the first comes zipped as `cities15000.zip`).
+pub const GEONAMES_FILES: [&str; 3] = ["cities15000.txt", "admin1CodesASCII.txt", "countryInfo.txt"];
+/// The zip holding [`GEONAMES_FILES`]`[0]`.
+pub const GEONAMES_ZIP: &str = "cities15000.zip";
+pub const GEONAMES_BASE: &str = "https://download.geonames.org/export/dump/";
+pub const GEONAMES_ATTRIBUTION: &str = "Place names: GeoNames (geonames.org), CC-BY 4.0";
+/// Places kept from a dataset (cities15000 has ~33 000; cities500 ~200 000).
+const MAX_PLACES: usize = 2_000_000;
+/// Largest name kept (GeoNames names are short; anything longer is junk).
+const MAX_NAME: usize = 200;
+const EARTH_RADIUS_M: f64 = 6_371_008.8;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum GeocodeError {
+ /// The place names aren't there (not downloaded yet) or can't be read.
+ Missing(String),
+ /// The data is not what it should be.
+ Invalid(String),
+}
+
+impl std::fmt::Display for GeocodeError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ GeocodeError::Missing(e) | GeocodeError::Invalid(e) => f.write_str(e),
+ }
+ }
+}
+
+impl std::error::Error for GeocodeError {}
+
+/// A position in degrees.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct LatLon {
+ pub lat: f64,
+ pub lon: f64,
+}
+
+impl LatLon {
+ pub fn new(lat: f64, lon: f64) -> LatLon {
+ LatLon { lat, lon }
+ }
+
+ /// Finite and on the globe.
+ pub fn is_valid(self) -> bool {
+ self.lat.is_finite() && self.lon.is_finite() && self.lat.abs() <= 90.0 && self.lon.abs() <= 180.0
+ }
+}
+
+/// Great-circle distance in metres (haversine). NaN in, NaN out.
+pub fn distance_m(a: LatLon, b: LatLon) -> f64 {
+ let (p1, p2) = (a.lat.to_radians(), b.lat.to_radians());
+ let dp = p2 - p1;
+ let dl = (b.lon - a.lon).to_radians();
+ let h = (dp / 2.0).sin().powi(2) + p1.cos() * p2.cos() * (dl / 2.0).sin().powi(2);
+ 2.0 * EARTH_RADIUS_M * h.clamp(0.0, 1.0).sqrt().asin()
+}
+
+/// What a lookup fills in (empty strings: unknown).
+#[derive(Clone, Debug, Default, PartialEq, Serialize)]
+pub struct Place {
+ /// Below city level. GeoNames' city list has none, so offline lookups leave it empty.
+ pub sublocation: String,
+ pub city: String,
+ pub state: String,
+ pub country: String,
+ /// ISO 3166-1 alpha-2, upper case.
+ pub iso: String,
+ /// Metres from the position to the place.
+ pub distance: f64,
+}
+
+#[derive(Clone, Debug)]
+struct City {
+ name: String,
+ at: LatLon,
+ country: String,
+ admin1: String,
+}
+
+/// An offline GeoNames index: places bucketed by 1° cells.
+#[derive(Clone, Debug, Default)]
+pub struct GeoNames {
+ cities: Vec<City>,
+ cells: HashMap<(i32, i32), Vec<u32>>,
+ admin1: HashMap<String, String>,
+ countries: HashMap<String, String>,
+}
+
+fn cell(p: LatLon) -> (i32, i32) {
+ // valid positions only: |lat| ≤ 90, |lon| ≤ 180, so the casts are in range
+ (p.lat.floor() as i32, p.lon.floor() as i32)
+}
+
+fn short(s: &str) -> String {
+ s.trim().chars().take(MAX_NAME).collect()
+}
+
+impl GeoNames {
+ /// From the dump's text: `cities` (tab-separated, the `cities*.txt` layout), and optionally
+ /// `admin1CodesASCII.txt` and `countryInfo.txt`. Bad lines are skipped.
+ pub fn parse(cities: &str, admin1: Option<&str>, countries: Option<&str>) -> GeoNames {
+ let mut g = GeoNames::default();
+ for line in cities.lines() {
+ if g.cities.len() >= MAX_PLACES {
+ break;
+ }
+ let f: Vec<&str> = line.split('\t').collect();
+ // columns: 1 name, 4 latitude, 5 longitude, 8 country code, 10 admin1 code
+ let (Some(name), Some(lat), Some(lon), Some(cc)) = (f.get(1), f.get(4), f.get(5), f.get(8)) else { continue };
+ let (Ok(lat), Ok(lon)) = (lat.trim().parse::<f64>(), lon.trim().parse::<f64>()) else { continue };
+ let at = LatLon::new(lat, lon);
+ let name = short(name);
+ if !at.is_valid() || name.is_empty() {
+ continue;
+ }
+ let Ok(i) = u32::try_from(g.cities.len()) else { break };
+ g.cells.entry(cell(at)).or_default().push(i);
+ g.cities.push(City { name, at, country: short(cc).to_ascii_uppercase(), admin1: f.get(10).map(|s| short(s)).unwrap_or_default() });
+ }
+ for line in admin1.unwrap_or("").lines() {
+ let mut f = line.split('\t');
+ if let (Some(code), Some(name)) = (f.next(), f.next()) {
+ g.admin1.insert(short(code), short(name));
+ }
+ }
+ for line in countries.unwrap_or("").lines().filter(|l| !l.starts_with('#')) {
+ let f: Vec<&str> = line.split('\t').collect();
+ if let (Some(iso), Some(name)) = (f.first(), f.get(4)) {
+ g.countries.insert(short(iso).to_ascii_uppercase(), short(name));
+ }
+ }
+ g
+ }
+
+ /// Load from a folder holding [`GEONAMES_FILES`] (the last two are optional: without them
+ /// states stay blank and countries are ISO codes).
+ pub fn load(dir: &Path) -> Result<GeoNames, GeocodeError> {
+ let read = |n: &str| std::fs::read(dir.join(n)).map(|b| String::from_utf8_lossy(&b).into_owned());
+ let cities = read(GEONAMES_FILES[0]).map_err(|e| GeocodeError::Missing(format!("the place names aren't downloaded ({e})")))?;
+ let g = GeoNames::parse(&cities, read(GEONAMES_FILES[1]).ok().as_deref(), read(GEONAMES_FILES[2]).ok().as_deref());
+ if g.is_empty() {
+ return Err(GeocodeError::Invalid("the place names file holds no places".into()));
+ }
+ Ok(g)
+ }
+
+ pub fn len(&self) -> usize {
+ self.cities.len()
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.cities.is_empty()
+ }
+
+ /// The nearest place within [`MAX_KM`]; `None` for an invalid position or open country.
+ pub fn reverse(&self, p: LatLon) -> Option<Place> {
+ if !p.is_valid() {
+ return None;
+ }
+ let (cy, cx) = cell(p);
+ let mut best: Option<(f64, &City)> = None;
+ // ±1° covers 50 km everywhere except very near the poles (where there are no cities)
+ for dy in -1..=1 {
+ for dx in -1..=1 {
+ let mut x = cx + dx;
+ if x < -180 {
+ x += 360;
+ } else if x >= 180 {
+ x -= 360;
+ }
+ for &i in self.cells.get(&(cy + dy, x)).into_iter().flatten() {
+ let Some(c) = self.cities.get(i as usize) else { continue };
+ let d = distance_m(p, c.at);
+ if best.is_none_or(|(b, _)| d < b) {
+ best = Some((d, c));
+ }
+ }
+ }
+ }
+ let (d, c) = best?;
+ (d <= MAX_KM * 1000.0).then(|| Place {
+ sublocation: String::new(),
+ city: c.name.clone(),
+ state: self.admin1.get(&format!("{}.{}", c.country, c.admin1)).cloned().unwrap_or_default(),
+ country: self.countries.get(&c.country).cloned().unwrap_or_else(|| c.country.clone()),
+ iso: c.country.clone(),
+ distance: d.round(),
+ })
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ const CITIES: &str = "2988507\tParis\tParis\t\t48.85341\t2.3488\tP\tPPLC\tFR\t\t11\t75\t\t\t2138551\t\t42\tEurope/Paris\t2024-01-01\n\
+ 2643743\tLondon\tLondon\t\t51.50853\t-0.12574\tP\tPPLC\tGB\t\tENG\t\t\t\t8961989\t\t25\tEurope/London\t2024-01-01\n\
+ bad line\n\
+ 1\tNowhere\tx\t\tNaN\t0\tP\tP\tXX\n\
+ 2\tFar\tx\t\t500\t0\tP\tP\tXX\n\
+ 3\tInf\tx\t\tinf\t-inf\tP\tP\tXX\n";
+
+ #[test]
+ fn nearest_place() {
+ let g = GeoNames::parse(CITIES, Some("FR.11\tÎle-de-France\nGB.ENG\tEngland\n"), Some("#ISO\tx\nFR\tFRA\t250\tFR\tFrance\n"));
+ assert_eq!(g.len(), 2);
+ let p = g.reverse(LatLon::new(48.86, 2.34)).unwrap();
+ assert_eq!((p.city.as_str(), p.state.as_str(), p.country.as_str(), p.iso.as_str()), ("Paris", "Île-de-France", "France", "FR"));
+ assert!(p.distance > 0.0 && p.distance < 2000.0);
+ // no countryInfo row: the ISO code stands in
+ let l = g.reverse(LatLon::new(51.5, -0.1)).unwrap();
+ assert_eq!((l.city.as_str(), l.state.as_str(), l.country.as_str()), ("London", "England", "GB"));
+ // open sea
+ assert!(g.reverse(LatLon::new(0.0, 0.0)).is_none());
+ }
+
+ #[test]
+ fn hostile_positions_find_nothing() {
+ let g = GeoNames::parse(CITIES, None, None);
+ for (la, lo) in [(f64::NAN, 0.0), (0.0, f64::NAN), (f64::INFINITY, 0.0), (91.0, 0.0), (0.0, -180.5), (-1e300, 1e300)] {
+ assert!(g.reverse(LatLon::new(la, lo)).is_none(), "{la}, {lo}");
+ }
+ // the poles and the antimeridian are fine
+ assert!(g.reverse(LatLon::new(90.0, 180.0)).is_none());
+ assert!(g.reverse(LatLon::new(-90.0, -180.0)).is_none());
+ assert!(GeoNames::default().reverse(LatLon::new(48.86, 2.34)).is_none());
+ }
+
+ #[test]
+ fn across_the_antimeridian() {
+ let fiji = GeoNames::parse("1\tX\tX\t\t-17.0\t179.9\tP\tP\tFJ\t\t\n", None, None);
+ assert_eq!(fiji.reverse(LatLon::new(-17.0, -179.95)).unwrap().city, "X");
+ }
+
+ #[test]
+ fn junk_text_parses_to_nothing() {
+ let g = GeoNames::parse("\t\t\t\t\t\n\u{0}\t\u{feff}\n", Some("\n\t\n"), Some("x"));
+ assert!(g.is_empty());
+ let long = format!("1\t{}\tx\t\t1\t1\tP\tP\tXX\n", "a".repeat(10_000));
+ assert_eq!(GeoNames::parse(&long, None, None).reverse(LatLon::new(1.0, 1.0)).unwrap().city.len(), MAX_NAME);
+ }
+
+ #[test]
+ fn load_from_a_folder() {
+ let dir = std::env::temp_dir().join(format!("lightcraft-geocode-load-{}", std::process::id()));
+ let _ = std::fs::remove_dir_all(&dir);
+ assert!(matches!(GeoNames::load(&dir), Err(GeocodeError::Missing(_))));
+ std::fs::create_dir_all(&dir).unwrap();
+ std::fs::write(dir.join(GEONAMES_FILES[0]), "junk").unwrap();
+ assert!(matches!(GeoNames::load(&dir), Err(GeocodeError::Invalid(_))));
+ std::fs::write(dir.join(GEONAMES_FILES[0]), CITIES).unwrap();
+ std::fs::write(dir.join(GEONAMES_FILES[2]), "GB\tGBR\t826\tUK\tUnited Kingdom\n").unwrap();
+ let g = GeoNames::load(&dir).unwrap();
+ assert_eq!(g.reverse(LatLon::new(51.5, -0.1)).unwrap().country, "United Kingdom");
+ let _ = std::fs::remove_dir_all(&dir);
+ }
+}
diff --git a/crates/geocode/src/unzip.rs b/crates/geocode/src/unzip.rs
new file mode 100644
index 000000000..18e127181
--- /dev/null
+++ b/crates/geocode/src/unzip.rs
@@ -0,0 +1,122 @@
+//! Just enough ZIP to read one file out of a GeoNames dump (`cities15000.zip`): the central
+//! directory, stored or deflated entries, sizes capped.
+//!
+//! Sources: PKWARE APPNOTE (prose spec); own design.
+
+use crate::GeocodeError;
+
+fn u16_at(b: &[u8], i: usize) -> Option<u16> {
+ let s = b.get(i..i.checked_add(2)?)?;
+ Some(u16::from_le_bytes([*s.first()?, *s.get(1)?]))
+}
+
+fn u32_at(b: &[u8], i: usize) -> Option<u32> {
+ let s = b.get(i..i.checked_add(4)?)?;
+ Some(u32::from_le_bytes([*s.first()?, *s.get(1)?, *s.get(2)?, *s.get(3)?]))
+}
+
+fn bad(what: &str) -> GeocodeError {
+ GeocodeError::Invalid(format!("not a readable ZIP archive ({what})"))
+}
+
+/// The contents of the entry whose name ends with `name`, at most `max` bytes.
+pub fn extract(zip: &[u8], name: &str, max: usize) -> Result<Vec<u8>, GeocodeError> {
+ // end of central directory: the last "PK\x05\x06" within the final 64 KiB + 22 bytes
+ let from = zip.len().saturating_sub(65_557);
+ let eocd = (from..zip.len().saturating_sub(21))
+ .rev()
+ .find(|&i| zip.get(i..i.saturating_add(4)) == Some(b"PK\x05\x06"))
+ .ok_or_else(|| bad("no directory"))?;
+ let field16 = |at: usize, what: &str| u16_at(zip, at).map(usize::from).ok_or_else(|| bad(what));
+ let field32 = |at: usize, what: &str| u32_at(zip, at).and_then(|v| usize::try_from(v).ok()).ok_or_else(|| bad(what));
+ let count = field16(eocd.saturating_add(10), "directory")?;
+ let mut p = field32(eocd.saturating_add(16), "directory")?;
+ for _ in 0..count {
+ if zip.get(p..p.saturating_add(4)) != Some(b"PK\x01\x02") {
+ return Err(bad("directory entry"));
+ }
+ let method = field16(p.saturating_add(10), "entry")?;
+ let csize = field32(p.saturating_add(20), "entry")?;
+ let usize_ = field32(p.saturating_add(24), "entry")?;
+ let nlen = field16(p.saturating_add(28), "entry")?;
+ let xlen = field16(p.saturating_add(30), "entry")?;
+ let clen = field16(p.saturating_add(32), "entry")?;
+ let local = field32(p.saturating_add(42), "entry")?;
+ let name_at = p.saturating_add(46);
+ let entry = zip.get(name_at..name_at.saturating_add(nlen)).ok_or_else(|| bad("entry name"))?;
+ p = name_at.saturating_add(nlen).saturating_add(xlen).saturating_add(clen);
+ if !String::from_utf8_lossy(entry).ends_with(name) {
+ continue;
+ }
+ if usize_ > max {
+ return Err(GeocodeError::Invalid(format!("{name} is larger than {max} bytes")));
+ }
+ if zip.get(local..local.saturating_add(4)) != Some(b"PK\x03\x04") {
+ return Err(bad("local header"));
+ }
+ let lnlen = field16(local.saturating_add(26), "local header")?;
+ let lxlen = field16(local.saturating_add(28), "local header")?;
+ let start = local.saturating_add(30).saturating_add(lnlen).saturating_add(lxlen);
+ let data = zip.get(start..start.saturating_add(csize)).ok_or_else(|| bad("truncated"))?;
+ return match method {
+ 0 if data.len() <= max => Ok(data.to_vec()),
+ 0 => Err(GeocodeError::Invalid(format!("{name} is larger than {max} bytes"))),
+ 8 => miniz_oxide::inflate::decompress_to_vec_with_limit(data, max).map_err(|e| bad(&format!("deflate: {e:?}"))),
+ m => Err(bad(&format!("compression method {m}"))),
+ };
+ }
+ Err(GeocodeError::Invalid(format!("{name} is not in the archive")))
+}
+
+#[cfg(test)]
+pub(crate) fn make(name: &str, data: &[u8]) -> Vec<u8> {
+ let c = miniz_oxide::deflate::compress_to_vec(data, 6);
+ let mut z = Vec::new();
+ z.extend_from_slice(b"PK\x03\x04");
+ z.extend_from_slice(&[20, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+ z.extend_from_slice(&(c.len() as u32).to_le_bytes());
+ z.extend_from_slice(&(data.len() as u32).to_le_bytes());
+ z.extend_from_slice(&(name.len() as u16).to_le_bytes());
+ z.extend_from_slice(&[0, 0]);
+ z.extend_from_slice(name.as_bytes());
+ z.extend_from_slice(&c);
+ let cd = z.len();
+ z.extend_from_slice(b"PK\x01\x02");
+ z.extend_from_slice(&[20, 0, 20, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+ z.extend_from_slice(&(c.len() as u32).to_le_bytes());
+ z.extend_from_slice(&(data.len() as u32).to_le_bytes());
+ z.extend_from_slice(&(name.len() as u16).to_le_bytes());
+ z.extend_from_slice(&[0; 12]);
+ z.extend_from_slice(&0u32.to_le_bytes());
+ z.extend_from_slice(name.as_bytes());
+ let cdlen = z.len() - cd;
+ z.extend_from_slice(b"PK\x05\x06");
+ z.extend_from_slice(&[0, 0, 0, 0, 1, 0, 1, 0]);
+ z.extend_from_slice(&(cdlen as u32).to_le_bytes());
+ z.extend_from_slice(&(cd as u32).to_le_bytes());
+ z.extend_from_slice(&[0, 0]);
+ z
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn round_trip_and_junk() {
+ let z = make("cities15000.txt", b"hello world");
+ assert_eq!(extract(&z, "cities15000.txt", 100).unwrap(), b"hello world");
+ assert!(extract(&z, "cities15000.txt", 5).is_err());
+ assert!(extract(&z, "other.txt", 100).is_err());
+ assert!(extract(b"PK", "x", 10).is_err());
+ assert!(extract(b"", "x", 10).is_err());
+ for cut in 0..z.len() {
+ let _ = extract(&z[..cut], "cities15000.txt", 100);
+ }
+ for i in 0..z.len() {
+ let mut bad = z.clone();
+ bad[i] ^= 0xff;
+ let _ = extract(&bad, "cities15000.txt", 100);
+ }
+ }
+}
diff --git a/crates/ui-egui/locales/de.json b/crates/ui-egui/locales/de.json
index 6520fb3e3..fbecd6e68 100644
--- a/crates/ui-egui/locales/de.json
+++ b/crates/ui-egui/locales/de.json
@@ -2039,5 +2039,12 @@
"Downloading model": "Modell wird heruntergeladen",
"Finding faces": "Gesichter werden gesucht",
"Synchronizing folder": "Ordner wird synchronisiert",
- "Looking for changes": "Änderungen werden gesucht"
+ "Looking for changes": "Änderungen werden gesucht",
+ "Fill Location from GPS": "Ort aus GPS ausfüllen",
+ "Download Place Names (GeoNames)": "Ortsnamen herunterladen (GeoNames)",
+ "Place Names Status": "Status der Ortsnamen",
+ "Fill Location": "Ort ausfüllen",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "Leere Felder Stadt, Bundesland und Land aus GPS ausfüllen (GeoNames-Ortsnamen, offline)",
+ "Looking up places": "Orte werden nachgeschlagen",
+ "Downloading place names": "Ortsnamen werden heruntergeladen"
}
diff --git a/crates/ui-egui/locales/es.json b/crates/ui-egui/locales/es.json
index fc53b6392..36d041a73 100644
--- a/crates/ui-egui/locales/es.json
+++ b/crates/ui-egui/locales/es.json
@@ -1884,5 +1884,12 @@
"Downloading model": "Descargando modelo",
"Finding faces": "Buscando caras",
"Synchronizing folder": "Sincronizando carpeta",
- "Looking for changes": "Buscando cambios"
+ "Looking for changes": "Buscando cambios",
+ "Fill Location from GPS": "Rellenar ubicación desde GPS",
+ "Download Place Names (GeoNames)": "Descargar nombres de lugares (GeoNames)",
+ "Place Names Status": "Estado de los nombres de lugares",
+ "Fill Location": "Rellenar ubicación",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "Rellenar Ciudad, Estado y País vacíos desde el GPS (nombres de lugares de GeoNames, sin conexión)",
+ "Looking up places": "Buscando lugares",
+ "Downloading place names": "Descargando nombres de lugares"
}
diff --git a/crates/ui-egui/locales/fr.json b/crates/ui-egui/locales/fr.json
index 53509a503..16bbc30d6 100644
--- a/crates/ui-egui/locales/fr.json
+++ b/crates/ui-egui/locales/fr.json
@@ -1884,5 +1884,12 @@
"Panels": "Panels",
"Reset Panel Layout": "Reset Panel Layout",
"Resize panel window": "Resize panel window",
- "Resize panels": "Resize panels"
+ "Resize panels": "Resize panels",
+ "Fill Location from GPS": "Remplir le lieu depuis le GPS",
+ "Download Place Names (GeoNames)": "Télécharger les noms de lieux (GeoNames)",
+ "Place Names Status": "État des noms de lieux",
+ "Fill Location": "Remplir le lieu",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "Remplir Ville, État et Pays vides depuis le GPS (noms de lieux GeoNames, hors ligne)",
+ "Looking up places": "Recherche des lieux",
+ "Downloading place names": "Téléchargement des noms de lieux"
}
diff --git a/crates/ui-egui/locales/ja.json b/crates/ui-egui/locales/ja.json
index 2babd30b6..ce7bda184 100644
--- a/crates/ui-egui/locales/ja.json
+++ b/crates/ui-egui/locales/ja.json
@@ -1886,5 +1886,12 @@
"Downloading model": "モデルをダウンロード中",
"Finding faces": "顔を検索中",
"Synchronizing folder": "フォルダを同期中",
- "Looking for changes": "変更を確認中"
+ "Looking for changes": "変更を確認中",
+ "Fill Location from GPS": "GPS から場所を入力",
+ "Download Place Names (GeoNames)": "地名データをダウンロード (GeoNames)",
+ "Place Names Status": "地名データの状態",
+ "Fill Location": "場所を入力",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "空の市区町村・都道府県・国を GPS から入力 (GeoNames の地名、オフライン)",
+ "Looking up places": "場所を検索中",
+ "Downloading place names": "地名データをダウンロード中"
}
diff --git a/crates/ui-egui/locales/pt-br.json b/crates/ui-egui/locales/pt-br.json
index dfe472818..59d8b2c62 100644
--- a/crates/ui-egui/locales/pt-br.json
+++ b/crates/ui-egui/locales/pt-br.json
@@ -1884,5 +1884,12 @@
"Downloading model": "Baixando modelo",
"Finding faces": "Procurando rostos",
"Synchronizing folder": "Sincronizando pasta",
- "Looking for changes": "Procurando alterações"
+ "Looking for changes": "Procurando alterações",
+ "Fill Location from GPS": "Preencher local pelo GPS",
+ "Download Place Names (GeoNames)": "Baixar nomes de lugares (GeoNames)",
+ "Place Names Status": "Status dos nomes de lugares",
+ "Fill Location": "Preencher local",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "Preencher Cidade, Estado e País vazios pelo GPS (nomes de lugares GeoNames, offline)",
+ "Looking up places": "Procurando lugares",
+ "Downloading place names": "Baixando nomes de lugares"
}
diff --git a/crates/ui-egui/locales/ru.json b/crates/ui-egui/locales/ru.json
index fafb65a14..11a1878ef 100644
--- a/crates/ui-egui/locales/ru.json
+++ b/crates/ui-egui/locales/ru.json
@@ -1598,5 +1598,12 @@
"Finding faces": "Поиск лиц",
"Quit Anyway": "Всё равно выйти",
"Synchronizing folder": "Синхронизация папки",
- "Looking for changes": "Поиск изменений"
+ "Looking for changes": "Поиск изменений",
+ "Fill Location from GPS": "Заполнить место по GPS",
+ "Download Place Names (GeoNames)": "Загрузить названия мест (GeoNames)",
+ "Place Names Status": "Состояние названий мест",
+ "Fill Location": "Заполнить место",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "Заполнить пустые поля «Город», «Регион» и «Страна» по GPS (названия мест GeoNames, офлайн)",
+ "Looking up places": "Поиск мест",
+ "Downloading place names": "Загрузка названий мест"
}
diff --git a/crates/ui-egui/locales/uk.json b/crates/ui-egui/locales/uk.json
index 7ebad5b10..ce8713f69 100644
--- a/crates/ui-egui/locales/uk.json
+++ b/crates/ui-egui/locales/uk.json
@@ -2078,5 +2078,12 @@
"Panels": "Panels",
"Reset Panel Layout": "Reset Panel Layout",
"Resize panel window": "Resize panel window",
- "Resize panels": "Resize panels"
+ "Resize panels": "Resize panels",
+ "Fill Location from GPS": "Заповнити місце за GPS",
+ "Download Place Names (GeoNames)": "Завантажити назви місць (GeoNames)",
+ "Place Names Status": "Стан назв місць",
+ "Fill Location": "Заповнити місце",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "Заповнити порожні поля «Місто», «Регіон» і «Країна» за GPS (назви місць GeoNames, офлайн)",
+ "Looking up places": "Пошук місць",
+ "Downloading place names": "Завантаження назв місць"
}
diff --git a/crates/ui-egui/locales/zh-hans.json b/crates/ui-egui/locales/zh-hans.json
index 8a0e58b8e..805330bf6 100644
--- a/crates/ui-egui/locales/zh-hans.json
+++ b/crates/ui-egui/locales/zh-hans.json
@@ -1884,5 +1884,12 @@
"Downloading model": "正在下载模型",
"Finding faces": "正在查找人脸",
"Synchronizing folder": "正在同步文件夹",
- "Looking for changes": "正在查找更改"
+ "Looking for changes": "正在查找更改",
+ "Fill Location from GPS": "根据 GPS 填写位置",
+ "Download Place Names (GeoNames)": "下载地名数据 (GeoNames)",
+ "Place Names Status": "地名数据状态",
+ "Fill Location": "填写位置",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "根据 GPS 填写空白的城市、省/州和国家(GeoNames 地名,离线)",
+ "Looking up places": "正在查找地点",
+ "Downloading place names": "正在下载地名数据"
}
diff --git a/crates/ui-egui/locales/zh-hant.json b/crates/ui-egui/locales/zh-hant.json
index f1cbec3a0..0810fc2db 100644
--- a/crates/ui-egui/locales/zh-hant.json
+++ b/crates/ui-egui/locales/zh-hant.json
@@ -1884,5 +1884,12 @@
"Downloading model": "正在下載模型",
"Finding faces": "正在尋找臉孔",
"Synchronizing folder": "正在同步資料夾",
- "Looking for changes": "正在尋找變更"
+ "Looking for changes": "正在尋找變更",
+ "Fill Location from GPS": "根據 GPS 填寫位置",
+ "Download Place Names (GeoNames)": "下載地名資料 (GeoNames)",
+ "Place Names Status": "地名資料狀態",
+ "Fill Location": "填寫位置",
+ "Fill empty City, State and Country from GPS (offline GeoNames place names)": "根據 GPS 填寫空白的城市、州/省和國家(GeoNames 地名,離線)",
+ "Looking up places": "正在查找地點",
+ "Downloading place names": "正在下載地名資料"
}
diff --git a/crates/ui-egui/src/panels/right.rs b/crates/ui-egui/src/panels/right.rs
index 1c5a04ad9..6b49fd891 100644
--- a/crates/ui-egui/src/panels/right.rs
+++ b/crates/ui-egui/src/panels/right.rs
@@ -668,6 +668,13 @@ fn info(app: &mut LightcraftApp, ui: &mut egui::Ui, id: PhotoId) {
app.toast(ui.ctx(), e);
}
}
+ if text_button(ui, "fillLocation", crate::i18n::tr("Fill Location"), false)
+ .on_hover_text(crate::i18n::tr("Fill empty City, State and Country from GPS (offline GeoNames place names)"))
+ .clicked()
+ && let Err(e) = app.run("metadata.reverseGeocode", json!({}))
+ {
+ app.toast(ui.ctx(), e);
+ }
});
}
if let Some(a) = p.analysis {
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index 099411089..aac80c529 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -52,10 +52,10 @@ cited here still exists. Formerly docs/parity.md.
| X. Cross-cutting behaviours (BEHAV) | 18 | 6 | 1 | 1 | 8/8 (100%) | 6/9 (67%) |
| Y. Menus | 82 | 0 | 4 | 8 | 47/47 (100%) | 23/23 (100%) |
| Z. Keyboard shortcuts (desktop) | 75 | 3 | 3 | 1 | 49/52 (94%) | 23/24 (96%) |
-| Lightroom Classic extras | 33 | 15 | 35 | 9 | — | 23/25 (92%) |
-| **Total** | 397 | 49 | 73 | 36 | 192/200 (96%) | 143/155 (92%) |
+| Lightroom Classic extras | 33 | 16 | 35 | 8 | — | 23/25 (92%) |
+| **Total** | 397 | 50 | 73 | 35 | 192/200 (96%) | 143/155 (92%) |
-Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.2%** of 519 in-scope rows — P0 98.0% of 200 · P1 95.2% of 155 · P2 47.2% of 163.
+Weighted completion (✅ = 1, 🟡 = ½, 🚫 left out): **81.2%** of 520 in-scope rows — P0 98.0% of 200 · P1 95.2% of 155 · P2 47.3% of 164.
<!-- /parity:summary -->
## Top gaps and shortcut notes
@@ -164,7 +164,7 @@ differences and missing bindings are in [ui-parity.md](ui-parity.md#shortcuts).
|---|---|---|---|---|---|
| LR-META-INFO | Info panel | P0 | ✅ | `cmd:panel.info`, `cmd:photo.setMeta`, `crates/ui-egui/src/panels/right.rs` (`info`, `camera_card`) | camera card (camera, lens, size, format, focal length / shutter / aperture / ISO); title, caption, alt text, extended description, copyright, copyright status, rights usage terms, copyright info URL, creator; file name (rename), file path (reveal), capture time (edit); location, city, state, country; GPS. No flash, map snippet or people |
| LR-META-COPYRIGHT-DEFAULT | Default copyright on import | P1 | ✅ | `cmd:library.preferences` (`import.copyright`, `import.creator`), `crates/ui-egui/src/panels/settings.rs` | Settings → Import → Metadata; fills only photos without their own |
-| LR-META-LOCATION | Location editing | P2 | 🟡 | `cmd:photo.setMeta` (`location`, `city`, `state`, `country`, `gps`) | place fields and GPS (decimal or degrees / minutes / seconds) edited in Info, read/written as IPTC Core / Photoshop / EXIF XMP; Show on Map opens OpenStreetMap; no embedded map, no geocoding |
+| LR-META-LOCATION | Location editing | P2 | 🟡 | `cmd:photo.setMeta` (`location`, `city`, `state`, `country`, `gps`), `cmd:metadata.reverseGeocode` | place fields and GPS (decimal or degrees / minutes / seconds) edited in Info, read/written as IPTC Core / Photoshop / EXIF XMP; Show on Map opens OpenStreetMap; Fill Location fills empty City / State / Country from GPS offline (GeoNames, downloaded on request: `cmd:metadata.downloadPlaceNames`); no embedded map |
| LR-META-COPYPASTE | Copy / paste metadata | P2 | ✅ | `cmd:photo.copyMetadata`, `cmd:photo.pasteMetadata` | title, caption, alt text, extended description, copyright (notice, status, usage terms, info URL), creator, place fields, keywords; `fields` picks a subset |
| LR-META-XMP | XMP read/write | P0 | ✅ | `cmd:photo.saveMetadataToFile`, `cmd:photo.readMetadataFromFile`, `cmd:library.xmpPreferences`, `crates/engine/src/sidecar.rs`, `docs/xmp-interop.md` | sidecar wins for metadata; a sidecar capture time (`exif:DateTimeOriginal` / `photoshop:DateCreated` / `xmp:CreateDate`) fills in only when the file has none; saving merges into an existing sidecar (`crates/meta/src/xmp_merge.rs`): another app's `crs:`, `xmpMM:History` and unknown namespaces are kept byte for byte, an unreadable sidecar is backed up first; with stem naming, files sharing a stem (raw + JPEG) get separate sidecars (`<file>.xmp` for all but the raw); a `crs:` custom white balance on a relative-WB raw is shifted from `crs:AsShotTemperature` rather than read as Kelvin, or kept As Shot and reported when the packet has no as-shot white (issue #510) |
| LR-META-EXIF-FULL | Full EXIF/IPTC [Classic] | P1 | ✅ | `cmd:photo.allMetadata`, `cmd:dialog.allMetadata`, `crates/meta/src/tags.rs`, `crates/meta/src/exif.rs`, `crates/meta/src/iptc.rs` | read and written on export; Info ▸ All Metadata…: every TIFF / EXIF / GPS / interop tag (named, common values spelled out) and the XMP fields, searchable; metadata presets |
@@ -716,7 +716,7 @@ From `08-lightroom-classic-extras.md` (Classic-only features) and part 2 of `06-
| LRC-MAP-LOCATIONS | Saved locations | P2 | ⬜ | | |
| LRC-MAP-TRACKLOG | GPS track logs | P2 | ✅ | `cmd:photo.autoTagTracklog`, `cmd:photo.tagFromTracklog`, `crates/meta/src/gpx.rs` | Photo ▸ Auto-Tag from Tracklog…: a GPX 1.0 / 1.1 track log sets the GPS of the selected photos by capture time — interpolated between the points of a track segment, else the nearest point within `maxGap` (10 min); never across segment breaks. The camera's time zone comes from the photo (Exif offset) or is asked for; photos that already have a location keep it unless `replace`; `dryRun` previews; one undo step. No track drawn on a map (no Map module) |
| LRC-MAP-FILTER | Location filter bar | P2 | ⬜ | | |
-| LRC-MAP-REVGEO | Reverse geocoding | OOS | 🚫 | | |
+| LRC-MAP-REVGEO | Reverse geocoding | P2 | 🟡 | `cmd:metadata.reverseGeocode` | offline from GeoNames (City / State / Country, no sublocation); no online provider |
| LRC-BOOK-SETTINGS | Book settings | P2 | ⬜ | | |
| LRC-BOOK-AUTOLAYOUT | Book auto layout | P2 | ⬜ | | |
| LRC-BOOK-PAGE | Book pages & templates | P2 | ⬜ | | |
diff --git a/xtask/src/layers.rs b/xtask/src/layers.rs
index 4443cb230..365384f19 100644
--- a/xtask/src/layers.rs
+++ b/xtask/src/layers.rs
@@ -47,6 +47,7 @@ pub const TABLE: &[(&str, Class)] = &[
("meta", Class::Layer(1)),
("develop", Class::Layer(1)),
("faces", Class::Layer(1)),
+ ("geocode", Class::Layer(1)),
("scenes", Class::Layer(1)),
("pipeline", Class::Layer(2)),
("gpu", Class::Layer(3)),