Prioritize tile loading based on current view

src/coord.rs

@@ -1,4 +1,5 @@
 use std::f64::consts::PI;
+use tile_source::TileSourceId;
 
 /// A position in map coordinates.
 /// Valid values for x and y lie in the interval [0.0, 1.0].
@@ -131,11 +132,21 @@ impl TileCoord {
         self.x >= 0 && self.x < num_tiles
     }
 
-    pub fn map_coord(&self) -> MapCoord {
+    // Return the MapCoord of the top left corner of the current tile.
+    pub fn map_coord_north_west(&self) -> MapCoord {
         let inv_zoom_factor = f64::powi(2.0, -(self.zoom as i32));
         MapCoord::new(f64::from(self.x) * inv_zoom_factor, f64::from(self.y) * inv_zoom_factor)
     }
 
+    // Return the MapCoord of the center of the current tile.
+    pub fn map_coord_center(&self) -> MapCoord {
+        let inv_zoom_factor = f64::powi(2.0, -(self.zoom as i32));
+        MapCoord::new(
+            (f64::from(self.x) + 0.5) * inv_zoom_factor,
+            (f64::from(self.y) + 0.5) * inv_zoom_factor,
+        )
+    }
+
     pub fn parent(&self, distance: u32) -> Option<(TileCoord, SubTileCoord)> {
         if distance > self.zoom {
             None
@@ -169,3 +180,11 @@ impl TileCoord {
         i32::pow(2, zoom)
     }
 }
+
+//TODO include width and height of view rect to determine visibility
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct View {
+    pub source_id: TileSourceId,
+    pub zoom: u32,
+    pub center: MapCoord,
+}

src/map_view.rs

@@ -49,11 +49,11 @@ impl MapView {
     }
 
     pub fn tile_screen_position(&self, tile: &TileCoord) -> ScreenCoord {
-        self.map_to_screen_coord(tile.map_coord())
+        self.map_to_screen_coord(tile.map_coord_north_west())
     }
 
     pub fn visible_tiles(&self, snap_to_pixel: bool) -> Vec<VisibleTile> {
-        let uzoom = self.zoom2.floor().max(0.0) as u32;
+        let uzoom = self.zoom_level();
         let top_left_tile = self.top_left_coord().on_tile_at_zoom(uzoom);
         let mut top_left_tile_screen_coord = self.tile_screen_position(&top_left_tile);
         let tile_screen_size = f64::powf(2.0, self.zoom2 - f64::from(uzoom)) * f64::from(self.tile_size);
@@ -91,6 +91,11 @@ impl MapView {
         visible_tiles
     }
 
+    //TODO make zoom level configurable
+    pub fn zoom_level(&self) -> u32 {
+        self.zoom2.floor().max(0.0) as u32
+    }
+
     pub fn set_size(&mut self, width: f64, height: f64) {
         self.width = width;
         self.height = height;

src/map_view_gl.rs

@@ -2,7 +2,7 @@ use ::context;
 use ::std::ffi::CStr;
 use buffer::{Buffer, DrawMode};
 use context::Context;
-use coord::ScreenCoord;
+use coord::{ScreenCoord, View};
 use image;
 use map_view::MapView;
 use program::Program;
@@ -92,6 +92,12 @@ impl<'a> MapViewGl<'a> {
     }
 
     pub fn draw(&mut self, source: &TileSource) {
+        self.tile_cache.set_view_location(View {
+            source_id: source.id(),
+            zoom: self.map_view.zoom_level(),
+            center: self.map_view.center,
+        });
+
         {
             let visible_tiles = self.map_view.visible_tiles(true);
             let textured_visible_tiles = self.tile_cache_gl.textured_visible_tiles(

src/tile_cache.rs

@@ -1,6 +1,6 @@
 use image;
 use linked_hash_map::{Entry, LinkedHashMap};
-use coord::TileCoord;
+use coord::{TileCoord, View};
 use tile::Tile;
 use tile_loader::TileLoader;
 use tile_source::TileSource;
@@ -90,6 +90,10 @@ impl TileCache {
 
         self.map.get(&tile)
     }
+
+    pub fn set_view_location(&mut self, view: View) {
+        self.loader.set_view_location(view);
+    }
 }
 
 impl ::std::fmt::Debug for TileCache {

src/tile_loader.rs

@@ -1,11 +1,14 @@
-use coord::TileCoord;
+use coord::{TileCoord, View};
 use image::DynamicImage;
 use image;
 use reqwest::Client;
+use std::cmp::Ordering;
+use std::cmp;
 use std::collections::hash_set::HashSet;
 use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
+use std::sync::mpsc::TryRecvError;
 use std::sync::mpsc;
 use std::thread;
 use tile::Tile;
@@ -18,7 +21,7 @@ use tile_source::TileSource;
 pub struct TileLoader {
     client: Option<Client>,
     join_handle: thread::JoinHandle<()>,
-    request_tx: mpsc::Sender<(Tile, String, PathBuf, bool)>,
+    request_tx: mpsc::Sender<LoaderMessage>,
     result_rx: mpsc::Receiver<(Tile, Option<DynamicImage>)>,
     pending: HashSet<Tile>,
 }
@@ -40,48 +43,88 @@ impl TileLoader {
     }
 
     fn work<F>(
-        request_rx: mpsc::Receiver<(Tile, String, PathBuf, bool)>,
+        request_rx: mpsc::Receiver<LoaderMessage>,
         result_tx: mpsc::Sender<(Tile, Option<DynamicImage>)>,
         notice_func: F,
     )
         where F: Fn(Tile) + Sync + Send + 'static,
     {
         let mut client_opt = None;
-        while let Ok((tile, url, path, write_to_file)) = request_rx.recv() {
-            println!("work {:?} {:?}", tile, path);
-            match image::open(&path) {
-                Ok(img) => {
-                    result_tx.send((tile, Some(img))).unwrap();
-                    notice_func(tile);
-                    continue;
+        let mut queue: Vec<(Tile, String, PathBuf, bool)> = vec![];
+
+        'outer: while let Ok(message) = request_rx.recv() {
+            let mut view_opt: Option<View> = None;
+
+            match message {
+                LoaderMessage::SetViewLocation{view} => {
+                    view_opt = Some(view);
                 },
-                Err(_) => {
-                    //TODO do not try to create a client every time when it failed before
-                    if client_opt.is_none() {
-                        client_opt = Client::builder().build().ok();
+                LoaderMessage::GetTile{tile, url, path, write_to_file} => {
+                    queue.push((tile, url, path, write_to_file));
+                }
+            }
+
+            loop {
+                loop {
+                    match request_rx.try_recv() {
+                        Ok(LoaderMessage::SetViewLocation{view}) => {
+                            view_opt = Some(view);
+                        },
+                        Ok(LoaderMessage::GetTile{tile, url, path, write_to_file}) => {
+                            queue.push((tile, url, path, write_to_file));
+                        },
+                        Err(TryRecvError::Empty) => break,
+                        Err(TryRecvError::Disconnected) => break 'outer,
                     }
+                }
 
-                    if let Some(ref client) = client_opt {
-                        println!("use client {:?}", tile);
-                        if let Ok(mut response) = client.get(&url).send() {
-                            let mut buf: Vec<u8> = vec![];
-                            response.copy_to(&mut buf).unwrap();
-                            if let Ok(img) = image::load_from_memory(&buf) {
+                if let Some(view) = view_opt {
+                    //TODO sort queue
+                    queue.as_mut_slice().sort_by(|&(tile_a, _, _, _), &(tile_b, _, _, _)| {
+                        compare_tiles(tile_a, tile_b, view)
+                    });
+                }
+
+                match queue.pop() {
+                    None => break,
+                    Some((tile, url, path, write_to_file)) => {
+                        println!("queue {:?} {:?}", tile, path);
+                        match image::open(&path) {
+                            Ok(img) => {
                                 result_tx.send((tile, Some(img))).unwrap();
                                 notice_func(tile);
-
-                                if write_to_file {
-                                    //TODO do something on write errors
-                                    let _ = Self::write_to_file(&path, &buf);
+                                continue;
+                            },
+                            Err(_) => {
+                                //TODO do not try to create a client every time when it failed before
+                                if client_opt.is_none() {
+                                    client_opt = Client::builder().build().ok();
                                 }
 
-                                continue;
-                            }
+                                if let Some(ref client) = client_opt {
+                                    println!("use client {:?}", tile);
+                                    if let Ok(mut response) = client.get(&url).send() {
+                                        let mut buf: Vec<u8> = vec![];
+                                        response.copy_to(&mut buf).unwrap();
+                                        if let Ok(img) = image::load_from_memory(&buf) {
+                                            result_tx.send((tile, Some(img))).unwrap();
+                                            notice_func(tile);
+
+                                            if write_to_file {
+                                                //TODO do something on write errors
+                                                let _ = Self::write_to_file(&path, &buf);
+                                            }
+
+                                            continue;
+                                        }
+                                    }
+                                }
+                            },
                         }
-                    }
-                },
+                        result_tx.send((tile, None)).unwrap();
+                    },
+                }
             }
-            result_tx.send((tile, None)).unwrap();
         }
     }
 
@@ -94,12 +137,12 @@ impl TileLoader {
 
         if !self.pending.contains(&tile) {
             self.pending.insert(tile);
-            self.request_tx.send((
-                tile,
-                source.remote_tile_url(tile_coord),
-                source.local_tile_path(tile_coord),
-                write_to_file
-            )).unwrap();
+            self.request_tx.send(LoaderMessage::GetTile{
+                tile: tile,
+                url: source.remote_tile_url(tile_coord),
+                path: source.local_tile_path(tile_coord),
+                write_to_file: write_to_file,
+            }).unwrap();
         }
     }
 
@@ -152,6 +195,12 @@ impl TileLoader {
         }
     }
 
+    pub fn set_view_location(&mut self, view: View) {
+        self.request_tx.send(LoaderMessage::SetViewLocation{
+            view: view,
+        }).unwrap();
+    }
+
     fn write_to_file<P: AsRef<Path>>(path: P, img_data: &[u8]) -> ::std::io::Result<()> {
 
         if let Some(dir) = path.as_ref().parent() {
@@ -165,3 +214,35 @@ impl TileLoader {
         file.write_all(img_data)
     }
 }
+
+enum LoaderMessage {
+    GetTile{tile: Tile, url: String, path: PathBuf, write_to_file: bool},
+    SetViewLocation{view: View},
+}
+
+fn compare_tiles(a: Tile, b: Tile, view: View) -> Ordering {
+    let source_a = view.source_id == a.source_id;
+    let source_b = view.source_id == b.source_id;
+
+    match (source_a, source_b) {
+        (true, false) => Ordering::Greater,
+        (false, true) => Ordering::Less,
+        _ => {
+            let zoom_diff_a = cmp::max(a.coord.zoom, view.zoom) - cmp::min(a.coord.zoom, view.zoom);
+            let zoom_diff_b = cmp::max(b.coord.zoom, view.zoom) - cmp::min(b.coord.zoom, view.zoom);
+
+            if zoom_diff_a < zoom_diff_b {
+                Ordering::Greater
+            } else if zoom_diff_a > zoom_diff_b {
+                Ordering::Less
+            } else {
+                let map_a = a.coord.map_coord_center();
+                let map_b = b.coord.map_coord_center();
+                let center_diff_a = (view.center.x - map_a.x).hypot(view.center.y - map_a.y);
+                let center_diff_b = (view.center.x - map_b.x).hypot(view.center.y - map_b.y);
+
+                center_diff_b.partial_cmp(&center_diff_a).unwrap_or(Ordering::Equal)
+            }
+        },
+    }
+}