geolite 0.0.13

open source geocode solution
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use geo::{HaversineDistance, Point};

use super::value::{house_number, house_number_shape};

// house numbers are precise points; 50m is intentionally tighter than the 100m used for
// streets, which are lines with a broader snap area
const NEAREST_MAX_DISTANCE_IN_METERS: f64 = 50.0;

#[derive(Debug, PartialEq)]
pub enum house_number_resolution {
  exact(Point<f64>),
  interpolated(Point<f64>),
  absent,
}

pub fn resolve(
  wanted: &house_number,
  known: &[(house_number, Point<f64>)],
) -> house_number_resolution {
  if let Some((_, point)) = known.iter().find(|(number, _)| number == wanted) {
    return house_number_resolution::exact(*point);
  }
  if wanted.shape() == house_number_shape::compound {
    return house_number_resolution::absent;
  }
  match wanted
    .leading_value()
    .and_then(|target| interpolate(known, target))
  {
    Some(point) => house_number_resolution::interpolated(point),
    None => house_number_resolution::absent,
  }
}

fn interpolate(known: &[(house_number, Point<f64>)], target: u32) -> Option<Point<f64>> {
  let mut below: Option<(u32, Point<f64>)> = None;
  let mut above: Option<(u32, Point<f64>)> = None;

  for (number, point) in known {
    let Some(value) = number.leading_value() else {
      continue;
    };
    if value < target {
      if below.is_none_or(|(current, _)| value > current) {
        below = Some((value, *point));
      }
    } else if value > target && above.is_none_or(|(current, _)| value < current) {
      above = Some((value, *point));
    }
  }

  let ((low, low_point), (high, high_point)) = (below?, above?);
  let fraction = (target - low) as f64 / (high - low) as f64;
  Some(Point::new(
    low_point.x() + (high_point.x() - low_point.x()) * fraction,
    low_point.y() + (high_point.y() - low_point.y()) * fraction,
  ))
}

pub fn nearest(point: Point<f64>, known: &[(house_number, Point<f64>)]) -> Option<&house_number> {
  known
    .iter()
    .filter_map(|(number, at)| {
      let distance = point.haversine_distance(at);
      (distance <= NEAREST_MAX_DISTANCE_IN_METERS).then_some((number, distance))
    })
    .min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
    .map(|(number, _)| number)
}