use crate::error::Error;
use crate::store::Store;
use jismeshcode::{coord_to_mesh, haversine_distance, Coordinate, MeshLevel};
use std::io::Read;
use std::path::Path;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Address<'a> {
pub prefecture: &'a str,
pub prefecture_code: u8,
pub city: &'a str,
pub city_code: u32,
pub town: &'a str,
pub town_code: u64,
pub lat: f64,
pub lon: f64,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ReverseGeocodeResult<'a> {
pub address: Address<'a>,
pub distance_meters: f64,
}
pub struct Geocoder {
store: Store,
}
const MAX_RING: i32 = 400;
const LAT_DEG_METERS_MIN: f64 = 110_000.0;
const LON_DEG_METERS_MIN: f64 = 77_000.0;
const CELL_LAT_DEG: f64 = 1.0 / 12.0;
const CELL_LON_DEG: f64 = 1.0 / 8.0;
fn min_unexplored_distance(query: Coordinate, row0: i32, col0: i32, ring: i32) -> f64 {
let south_gap = query.lat() - (row0 - ring) as f64 * CELL_LAT_DEG;
let north_gap = ((row0 + ring + 1) as f64) * CELL_LAT_DEG - query.lat();
let west_gap = query.lon() - (100.0 + (col0 - ring) as f64 * CELL_LON_DEG);
let east_gap = (100.0 + (col0 + ring + 1) as f64 * CELL_LON_DEG) - query.lon();
let lat_bound = south_gap.min(north_gap).max(0.0) * LAT_DEG_METERS_MIN;
let lon_bound = west_gap.min(east_gap).max(0.0) * LON_DEG_METERS_MIN;
lat_bound.min(lon_bound)
}
impl Geocoder {
#[cfg(feature = "embedded-data")]
#[allow(clippy::new_without_default)]
pub fn new() -> Self {
static DATA: &[u8] = include_bytes!("../data/isj.bin");
let store = Store::from_compressed(DATA).expect("embedded data must be valid");
Geocoder { store }
}
pub fn from_path(path: impl AsRef<Path>) -> Result<Self, Error> {
let bytes = std::fs::read(path)?;
Self::from_bytes(&bytes)
}
pub fn from_reader(mut reader: impl Read) -> Result<Self, Error> {
let mut bytes = Vec::new();
reader.read_to_end(&mut bytes)?;
Self::from_bytes(&bytes)
}
pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error> {
Ok(Geocoder {
store: Store::from_compressed(bytes)?,
})
}
pub fn reverse_geocode(&self, lat: f64, lon: f64) -> Result<ReverseGeocodeResult<'_>, Error> {
let results = self.nearest(lat, lon, 1)?;
results
.into_iter()
.next()
.ok_or_else(|| Error::InvalidData("no records loaded".into()))
}
pub fn nearest(
&self,
lat: f64,
lon: f64,
k: usize,
) -> Result<Vec<ReverseGeocodeResult<'_>>, Error> {
let query = self.validate(lat, lon)?;
if k == 0 {
return Ok(Vec::new());
}
let k = k.min(self.store.records.len());
let mut candidates: Vec<(f64, u32)> = Vec::new();
let (row0, col0) = self.query_cell(query);
for ring in 0..=MAX_RING {
self.collect_ring(query, row0, col0, ring, &mut candidates);
if candidates.len() >= k {
candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
if candidates[k - 1].0 <= min_unexplored_distance(query, row0, col0, ring) {
break;
}
}
}
candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
candidates.truncate(k);
Ok(self.to_results(candidates))
}
pub fn within_radius(
&self,
lat: f64,
lon: f64,
radius_meters: f64,
) -> Result<Vec<ReverseGeocodeResult<'_>>, Error> {
let query = self.validate(lat, lon)?;
if radius_meters.is_nan() || radius_meters < 0.0 {
return Ok(Vec::new());
}
let mut candidates: Vec<(f64, u32)> = Vec::new();
let (row0, col0) = self.query_cell(query);
for ring in 0..=MAX_RING {
if ring > 0 && min_unexplored_distance(query, row0, col0, ring - 1) > radius_meters {
break;
}
self.collect_ring(query, row0, col0, ring, &mut candidates);
}
candidates.retain(|&(d, _)| d <= radius_meters);
candidates.sort_unstable_by(|a, b| a.0.total_cmp(&b.0));
Ok(self.to_results(candidates))
}
pub fn data_version(&self) -> &str {
&self.store.data_version
}
pub fn len(&self) -> usize {
self.store.records.len()
}
pub fn is_empty(&self) -> bool {
self.store.records.is_empty()
}
fn validate(&self, lat: f64, lon: f64) -> Result<Coordinate, Error> {
Coordinate::new(lat, lon).map_err(|_| Error::OutOfJapanRange { lat, lon })
}
fn query_cell(&self, query: Coordinate) -> (i32, i32) {
let mesh = coord_to_mesh(query, MeshLevel::Second)
.expect("validated coordinate is convertible")
.code() as u32;
mesh_to_cell(mesh)
}
fn collect_ring(
&self,
query: Coordinate,
row0: i32,
col0: i32,
ring: i32,
out: &mut Vec<(f64, u32)>,
) {
if ring == 0 {
self.collect_cell(query, row0, col0, out);
return;
}
for dc in -ring..=ring {
self.collect_cell(query, row0 - ring, col0 + dc, out);
self.collect_cell(query, row0 + ring, col0 + dc, out);
}
for dr in (-ring + 1)..ring {
self.collect_cell(query, row0 + dr, col0 - ring, out);
self.collect_cell(query, row0 + dr, col0 + ring, out);
}
}
fn collect_cell(&self, query: Coordinate, row: i32, col: i32, out: &mut Vec<(f64, u32)>) {
let Some(mesh) = cell_to_mesh(row, col) else {
return;
};
let Ok(pos) = self
.store
.mesh_index
.binary_search_by_key(&mesh, |e| e.mesh)
else {
return;
};
let entry = &self.store.mesh_index[pos];
for i in entry.start..entry.start + entry.len {
let record = &self.store.records[i as usize];
let coord = Coordinate::new_unchecked(record.lat(), record.lon());
let distance = haversine_distance(query, coord);
out.push((distance, i));
}
}
fn to_results(&self, candidates: Vec<(f64, u32)>) -> Vec<ReverseGeocodeResult<'_>> {
candidates
.into_iter()
.map(|(distance_meters, i)| {
let record = &self.store.records[i as usize];
let city = &self.store.cities[record.city_idx as usize];
let pref = &self.store.prefs[city.pref_idx as usize];
ReverseGeocodeResult {
address: Address {
prefecture: &pref.name,
prefecture_code: pref.code,
city: &city.name,
city_code: city.code,
town: &self.store.town_names[record.town_name_idx as usize],
town_code: record.town_code,
lat: record.lat(),
lon: record.lon(),
},
distance_meters,
}
})
.collect()
}
}
fn mesh_to_cell(mesh: u32) -> (i32, i32) {
let pq = (mesh / 10_000) as i32;
let rs = ((mesh / 100) % 100) as i32;
let t = ((mesh / 10) % 10) as i32;
let u = (mesh % 10) as i32;
(pq * 8 + t, rs * 8 + u)
}
fn cell_to_mesh(row: i32, col: i32) -> Option<u32> {
if !(0..800).contains(&row) || !(0..800).contains(&col) {
return None;
}
let pq = (row / 8) as u32;
let t = (row % 8) as u32;
let rs = (col / 8) as u32;
let u = (col % 8) as u32;
Some(pq * 10_000 + rs * 100 + t * 10 + u)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_mesh_cell_roundtrip() {
let (row, col) = mesh_to_cell(533946);
assert_eq!((row, col), (53 * 8 + 4, 39 * 8 + 6));
assert_eq!(cell_to_mesh(row, col), Some(533946));
}
#[test]
fn test_cell_to_mesh_out_of_range() {
assert_eq!(cell_to_mesh(-1, 100), None);
assert_eq!(cell_to_mesh(100, -1), None);
assert_eq!(cell_to_mesh(800, 100), None);
assert_eq!(cell_to_mesh(100, 800), None);
}
#[test]
fn test_cell_neighbors_cross_first_mesh_boundary() {
let (row, col) = mesh_to_cell(533977);
assert_eq!(cell_to_mesh(row + 1, col), Some(543907));
let (row, col) = mesh_to_cell(533947);
assert_eq!(cell_to_mesh(row, col + 1), Some(534040));
}
}