Add coord::LatLon

src/coord.rs

 use std::f64::consts::PI;
 use tile_source::TileSourceId;
 
+
+/// A position in latitude, longitude.
+#[derive(Copy, Debug, PartialEq, Clone)]
+pub struct LatLon {
+    pub lat: f64,
+    pub lon: f64,
+}
+
+impl LatLon {
+    pub fn new(lat: f64, lon: f64) -> Self {
+        LatLon { lat, lon }
+    }
+}
+
 /// A position in map coordinates.
 /// Valid values for x and y lie in the interval [0.0, 1.0].
 #[derive(Copy, Debug, PartialEq, Clone)]
     pub y: f64,
 }
 
-impl MapCoord {
-    pub fn new(x: f64, y: f64) -> MapCoord {
+impl From<LatLon> for MapCoord
+{
+    fn from(pos: LatLon) -> MapCoord {
+        let x = pos.lon * (1.0 / 360.0) + 0.5;
+        let pi_lat = pos.lat * (PI / 180.0);
+        let y = f64::ln(f64::tan(pi_lat) + 1.0 / f64::cos(pi_lat)) * (-0.5 / PI) + 0.5;
+
         MapCoord { x, y }
     }
+}
 
-    pub fn from_latlon(latitude: f64, longitude: f64) -> MapCoord {
-        let x = longitude * (1.0 / 360.0) + 0.5;
-        let pi_lat = latitude * (PI / 180.0);
-        let y = f64::ln(f64::tan(pi_lat) + 1.0 / f64::cos(pi_lat)) * (-0.5 / PI) + 0.5;
-
+impl MapCoord {
+    pub fn new(x: f64, y: f64) -> MapCoord {
         MapCoord { x, y }
     }
 

src/main.rs

 pub mod url_template;
 pub mod vertex_attrib;
 
-use coord::ScreenCoord;
+use coord::{LatLon, ScreenCoord};
 use glutin::{ControlFlow, ElementState, Event, GlContext, MouseButton, MouseScrollDelta, VirtualKeyCode, WindowEvent};
 use map_view_gl::MapViewGl;
 use std::error::Error;
     map: &mut MapViewGl,
     input_state: &mut InputState,
     sources: &mut TileSources,
-    marker_rx: &mpsc::Receiver<(f64, f64)>,
+    marker_rx: &mpsc::Receiver<LatLon>,
 ) -> Action {
     match *event {
         Event::Awakened => {
-            for (lat, lon) in marker_rx.try_iter() {
-                map.add_marker(coord::MapCoord::from_latlon(lat, lon));
+            for pos in marker_rx.try_iter() {
+                map.add_marker(pos.into());
             }
             Action::Redraw
         },
         search::search_pbf(
             path,
             pattern,
-            move |lat, lon| {
-                if marker_tx.send((lat, lon)).is_err() {
+            move |latlon| {
+                if marker_tx.send(latlon).is_err() {
                     return search::ControlFlow::Break;
                 }
                 proxy.wakeup().into()

src/search.rs

 use regex::Regex;
 use std::path::{Path, PathBuf};
 use std::thread;
+use coord::LatLon;
+
 
 #[derive(Debug, Eq, PartialEq)]
 pub enum ControlFlow {
     update_func: F,
 ) -> Result<thread::JoinHandle<()>, String>
 where P: AsRef<Path>,
-      F: Fn(f64, f64) -> ControlFlow + Send + 'static,
+      F: Fn(LatLon) -> ControlFlow + Send + 'static,
 {
     let pathbuf = PathBuf::from(pbf_path.as_ref());
     let re = Regex::new(search_pattern)
                 Element::Node(node) => {
                     for (_key, val) in node.tags() {
                         if re.is_match(val) {
-                            if update_func(node.lat(), node.lon()) == ControlFlow::Break {
+                            let pos = LatLon::new(node.lat(), node.lon());
+                            if update_func(pos) == ControlFlow::Break {
                                 return;
                             }
                             break;
                         }
                     }
                 },
-                Element::DenseNode(dnode) => {
-                    for (_key, val) in dnode.tags() {
+                Element::DenseNode(node) => {
+                    for (_key, val) in node.tags() {
                         if re.is_match(val) {
-                            if update_func(dnode.lat(), dnode.lon()) == ControlFlow::Break {
+                            let pos = LatLon::new(node.lat(), node.lon());
+                            if update_func(pos) == ControlFlow::Break {
                                 return;
                             }
                             break;

src/tile_layer.rs

             program,
             buffer,
             cache: TileCache::new(update_func, use_network),
-            atlas: TileAtlas::new(cx, atlas_tex, 256, use_async),
+            atlas: TileAtlas::new(cx, atlas_tex, tile_size, use_async),
         }
     }