1use crate::error::Error;
2use crate::store::Store;
3use jismeshcode::{coord_to_mesh, haversine_distance, Coordinate, MeshLevel};
4use std::io::Read;
5use std::path::Path;
6
7#[derive(Debug, Clone, Copy, PartialEq)]
11pub struct Address<'a> {
12 pub prefecture: &'a str,
14 pub prefecture_code: u8,
16 pub city: &'a str,
18 pub city_code: u32,
20 pub town: &'a str,
22 pub town_code: u64,
24 pub lat: f64,
26 pub lon: f64,
28}
29
30#[derive(Debug, Clone, Copy, PartialEq)]
32pub struct ReverseGeocodeResult<'a> {
33 pub address: Address<'a>,
35 pub distance_meters: f64,
37}
38
39pub struct Geocoder {
50 store: Store,
51}
52
53const MAX_RING: i32 = 400;
55
56const LAT_DEG_METERS_MIN: f64 = 110_000.0;
58
59const LON_DEG_METERS_MIN: f64 = 77_000.0;
61
62const CELL_LAT_DEG: f64 = 1.0 / 12.0;
64
65const CELL_LON_DEG: f64 = 1.0 / 8.0;
67
68fn min_unexplored_distance(query: Coordinate, row0: i32, col0: i32, ring: i32) -> f64 {
74 let south_gap = query.lat() - (row0 - ring) as f64 * CELL_LAT_DEG;
75 let north_gap = ((row0 + ring + 1) as f64) * CELL_LAT_DEG - query.lat();
76 let west_gap = query.lon() - (100.0 + (col0 - ring) as f64 * CELL_LON_DEG);
77 let east_gap = (100.0 + (col0 + ring + 1) as f64 * CELL_LON_DEG) - query.lon();
78
79 let lat_bound = south_gap.min(north_gap).max(0.0) * LAT_DEG_METERS_MIN;
80 let lon_bound = west_gap.min(east_gap).max(0.0) * LON_DEG_METERS_MIN;
81 lat_bound.min(lon_bound)
82}
83
84impl Geocoder {
85 #[cfg(feature = "embedded-data")]
90 #[allow(clippy::new_without_default)]
91 pub fn new() -> Self {
92 static DATA: &[u8] = include_bytes!("../data/isj.bin");
93 let store = Store::from_compressed(DATA).expect("embedded data must be valid");
94 Geocoder { store }
95 }
96
97 pub fn from_path(path: impl AsRef<Path>) -> Result<Self, Error> {
102 let bytes = std::fs::read(path)?;
103 Self::from_bytes(&bytes)
104 }
105
106 pub fn from_reader(mut reader: impl Read) -> Result<Self, Error> {
108 let mut bytes = Vec::new();
109 reader.read_to_end(&mut bytes)?;
110 Self::from_bytes(&bytes)
111 }
112
113 pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
115 Ok(Geocoder {
116 store: Store::from_compressed(bytes)?,
117 })
118 }
119
120 pub fn reverse_geocode(&self, lat: f64, lon: f64) -> Result<ReverseGeocodeResult<'_>, Error> {
141 let results = self.nearest(lat, lon, 1)?;
142 results
143 .into_iter()
144 .next()
145 .ok_or_else(|| Error::InvalidData("no records loaded".into()))
146 }
147
148 pub fn nearest(
152 &self,
153 lat: f64,
154 lon: f64,
155 k: usize,
156 ) -> Result<Vec<ReverseGeocodeResult<'_>>, Error> {
157 let query = self.validate(lat, lon)?;
158 if k == 0 {
159 return Ok(Vec::new());
160 }
161 let k = k.min(self.store.records.len());
162
163 let mut candidates: Vec<(f64, u32)> = Vec::new();
164 let (row0, col0) = self.query_cell(query);
165 for ring in 0..=MAX_RING {
166 self.collect_ring(query, row0, col0, ring, &mut candidates);
167
168 if candidates.len() >= k {
169 candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
170 if candidates[k - 1].0 <= min_unexplored_distance(query, row0, col0, ring) {
172 break;
173 }
174 }
175 }
176
177 candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
178 candidates.truncate(k);
179 Ok(self.to_results(candidates))
180 }
181
182 pub fn within_radius(
186 &self,
187 lat: f64,
188 lon: f64,
189 radius_meters: f64,
190 ) -> Result<Vec<ReverseGeocodeResult<'_>>, Error> {
191 let query = self.validate(lat, lon)?;
192 if radius_meters.is_nan() || radius_meters < 0.0 {
193 return Ok(Vec::new());
194 }
195
196 let mut candidates: Vec<(f64, u32)> = Vec::new();
197 let (row0, col0) = self.query_cell(query);
198 for ring in 0..=MAX_RING {
199 if ring > 0 && min_unexplored_distance(query, row0, col0, ring - 1) > radius_meters {
201 break;
202 }
203 self.collect_ring(query, row0, col0, ring, &mut candidates);
204 }
205
206 candidates.retain(|&(d, _)| d <= radius_meters);
207 candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
208 Ok(self.to_results(candidates))
209 }
210
211 pub fn data_version(&self) -> &str {
213 &self.store.data_version
214 }
215
216 pub fn len(&self) -> usize {
218 self.store.records.len()
219 }
220
221 pub fn is_empty(&self) -> bool {
223 self.store.records.is_empty()
224 }
225
226 fn validate(&self, lat: f64, lon: f64) -> Result<Coordinate, Error> {
227 Coordinate::new(lat, lon).map_err(|_| Error::OutOfJapanRange { lat, lon })
228 }
229
230 fn query_cell(&self, query: Coordinate) -> (i32, i32) {
236 let mesh = coord_to_mesh(query, MeshLevel::Second)
237 .expect("validated coordinate is convertible")
238 .code() as u32;
239 mesh_to_cell(mesh)
240 }
241
242 fn collect_ring(
244 &self,
245 query: Coordinate,
246 row0: i32,
247 col0: i32,
248 ring: i32,
249 out: &mut Vec<(f64, u32)>,
250 ) {
251 if ring == 0 {
252 self.collect_cell(query, row0, col0, out);
253 return;
254 }
255 for dc in -ring..=ring {
256 self.collect_cell(query, row0 - ring, col0 + dc, out);
257 self.collect_cell(query, row0 + ring, col0 + dc, out);
258 }
259 for dr in (-ring + 1)..ring {
260 self.collect_cell(query, row0 + dr, col0 - ring, out);
261 self.collect_cell(query, row0 + dr, col0 + ring, out);
262 }
263 }
264
265 fn collect_cell(&self, query: Coordinate, row: i32, col: i32, out: &mut Vec<(f64, u32)>) {
266 let Some(mesh) = cell_to_mesh(row, col) else {
267 return;
268 };
269 let Ok(pos) = self
270 .store
271 .mesh_index
272 .binary_search_by_key(&mesh, |e| e.mesh)
273 else {
274 return;
275 };
276 let entry = &self.store.mesh_index[pos];
277 for i in entry.start..entry.start + entry.len {
278 let record = &self.store.records[i as usize];
279 let coord = Coordinate::new_unchecked(record.lat(), record.lon());
280 let distance = haversine_distance(query, coord);
281 out.push((distance, i));
282 }
283 }
284
285 fn to_results(&self, candidates: Vec<(f64, u32)>) -> Vec<ReverseGeocodeResult<'_>> {
286 candidates
287 .into_iter()
288 .map(|(distance_meters, i)| {
289 let record = &self.store.records[i as usize];
290 let city = &self.store.cities[record.city_idx as usize];
291 let pref = &self.store.prefs[city.pref_idx as usize];
292 ReverseGeocodeResult {
293 address: Address {
294 prefecture: &pref.name,
295 prefecture_code: pref.code,
296 city: &city.name,
297 city_code: city.code,
298 town: &self.store.town_names[record.town_name_idx as usize],
299 town_code: record.town_code,
300 lat: record.lat(),
301 lon: record.lon(),
302 },
303 distance_meters,
304 }
305 })
306 .collect()
307 }
308}
309
310fn mesh_to_cell(mesh: u32) -> (i32, i32) {
312 let pq = (mesh / 10_000) as i32;
313 let rs = ((mesh / 100) % 100) as i32;
314 let t = ((mesh / 10) % 10) as i32;
315 let u = (mesh % 10) as i32;
316 (pq * 8 + t, rs * 8 + u)
317}
318
319fn cell_to_mesh(row: i32, col: i32) -> Option<u32> {
323 if !(0..800).contains(&row) || !(0..800).contains(&col) {
324 return None;
325 }
326 let pq = (row / 8) as u32;
327 let t = (row % 8) as u32;
328 let rs = (col / 8) as u32;
329 let u = (col % 8) as u32;
330 Some(pq * 10_000 + rs * 100 + t * 10 + u)
331}
332
333#[cfg(test)]
334mod tests {
335 use super::*;
336
337 #[test]
338 fn test_mesh_cell_roundtrip() {
339 let (row, col) = mesh_to_cell(533946);
341 assert_eq!((row, col), (53 * 8 + 4, 39 * 8 + 6));
342 assert_eq!(cell_to_mesh(row, col), Some(533946));
343 }
344
345 #[test]
346 fn test_cell_to_mesh_out_of_range() {
347 assert_eq!(cell_to_mesh(-1, 100), None);
348 assert_eq!(cell_to_mesh(100, -1), None);
349 assert_eq!(cell_to_mesh(800, 100), None);
350 assert_eq!(cell_to_mesh(100, 800), None);
351 }
352
353 #[test]
354 fn test_cell_neighbors_cross_first_mesh_boundary() {
355 let (row, col) = mesh_to_cell(533977);
357 assert_eq!(cell_to_mesh(row + 1, col), Some(543907));
358 let (row, col) = mesh_to_cell(533947);
360 assert_eq!(cell_to_mesh(row, col + 1), Some(534040));
361 }
362}