Rename Tile -> TileCoord

src/config.rs

@@ -1,4 +1,3 @@
-use serde_derive;
 use std::collections::BTreeMap;
 use std::fs::File;
 use std::io::Read;

src/coord.rs

@@ -29,7 +29,7 @@ impl MapCoord {
     }
 
     //TODO differ between normalized and not normalized tiles
-    pub fn on_tile_at_zoom(&self, zoom: u32) -> Tile {
+    pub fn on_tile_at_zoom(&self, zoom: u32) -> TileCoord {
         let zoom_factor = f64::powi(2.0, zoom as i32);
         let ix = (self.x * zoom_factor).floor() as i32;
         let iy = (self.y * zoom_factor).floor() as i32;
@@ -37,10 +37,10 @@ impl MapCoord {
         let x = ix;
         let y = iy;
 
-        Tile {
+        TileCoord {
             zoom: zoom,
-            tile_x: x,
-            tile_y: y,
+            x: x,
+            y: y,
         }
     }
 
@@ -102,3 +102,71 @@ pub struct ScreenRect {
     pub width: f64,
     pub height: f64,
 }
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TileCoord {
+    pub zoom: u32,
+    pub x: i32,
+    pub y: i32,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct SubTileCoord {
+    pub size: u32,
+    pub x: u32,
+    pub y: u32,
+}
+
+impl TileCoord {
+    pub fn new(zoom: u32, x: i32, y: i32) -> TileCoord {
+        TileCoord {
+            zoom: zoom,
+            x: Self::normalize_coord(x, zoom),
+            y: y,
+        }
+    }
+
+    pub fn is_on_planet(&self) -> bool {
+        let num_tiles = Self::get_zoom_level_tiles(self.zoom);
+        self.y >= 0 && self.y < num_tiles &&
+        self.x >= 0 && self.x < num_tiles
+    }
+
+    pub fn map_coord(&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)
+    }
+
+    pub fn parent(&self, distance: u32) -> Option<(TileCoord, SubTileCoord)> {
+        if distance > self.zoom {
+            None
+        } else {
+            let scale = u32::pow(2, distance);
+
+            Some((
+                TileCoord {
+                    zoom: self.zoom - distance,
+                    x: self.x / scale as i32,
+                    y: self.y / scale as i32,
+                },
+                SubTileCoord {
+                    size: scale,
+                    x: (Self::normalize_coord(self.x, self.zoom) as u32) % scale,
+                    y: (Self::normalize_coord(self.y, self.zoom) as u32) % scale,
+                },
+            ))
+        }
+    }
+
+    #[inline]
+    fn normalize_coord(coord: i32, zoom: u32) -> i32 {
+        let max = Self::get_zoom_level_tiles(zoom);
+        ((coord % max) + max) % max
+    }
+
+    #[inline]
+    pub fn get_zoom_level_tiles(zoom: u32) -> i32 {
+        //TODO throw error when zoom too big
+        i32::pow(2, zoom)
+    }
+}

src/map_view.rs

@@ -1,5 +1,4 @@
-use coord::{MapCoord, ScreenCoord, ScreenRect};
-use tile::Tile;
+use coord::{MapCoord, ScreenCoord, ScreenRect, TileCoord};
 
 
 #[derive(Clone, Debug)]
@@ -13,7 +12,7 @@ pub struct MapView {
 
 #[derive(Clone, Debug)]
 pub struct VisibleTile {
-    pub tile: Tile,
+    pub tile: TileCoord,
     pub rect: ScreenRect,
 }
 
@@ -49,7 +48,7 @@ impl MapView {
         }
     }
 
-    pub fn tile_screen_position(&self, tile: &Tile) -> ScreenCoord {
+    pub fn tile_screen_position(&self, tile: &TileCoord) -> ScreenCoord {
         self.map_to_screen_coord(tile.map_coord())
     }
 
@@ -63,8 +62,8 @@ impl MapView {
             top_left_tile_screen_coord.snap_to_pixel();
         }
 
-        let start_tile_x = top_left_tile.tile_x;
-        let start_tile_y = top_left_tile.tile_y;
+        let start_tile_x = top_left_tile.x;
+        let start_tile_y = top_left_tile.y;
         let num_tiles_x = ((self.width - top_left_tile_screen_coord.x) / tile_screen_size).ceil().max(0.0) as i32;
         let num_tiles_y = ((self.height - top_left_tile_screen_coord.y) / tile_screen_size).ceil().max(0.0) as i32;
 
@@ -72,7 +71,7 @@ impl MapView {
 
         for y in 0..num_tiles_y {
             for x in 0..num_tiles_x {
-                let t = Tile::new(uzoom, start_tile_x + x, start_tile_y + y);
+                let t = TileCoord::new(uzoom, start_tile_x + x, start_tile_y + y);
                 if t.is_on_planet() {
                     visible_tiles.push(
                         VisibleTile {

src/tile.rs

@@ -1,70 +1,9 @@
-use coord::MapCoord;
+use coord::TileCoord;
+use tile_source::TileSourceId;
 
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Tile {
-    pub zoom: u32,
-    pub tile_x: i32,
-    pub tile_y: i32,
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct SubTileCoord {
-    pub size: u32,
-    pub x: u32,
-    pub y: u32,
-}
-
-impl Tile {
-    pub fn new(zoom: u32, tile_x: i32, tile_y: i32) -> Tile {
-        Tile {
-            zoom: zoom,
-            tile_x: Self::normalize_coord(tile_x, zoom),
-            tile_y: tile_y,
-        }
-    }
-
-    pub fn is_on_planet(&self) -> bool {
-        let num_tiles = Self::get_zoom_level_tiles(self.zoom);
-        self.tile_y >= 0 && self.tile_y < num_tiles &&
-        self.tile_x >= 0 && self.tile_x < num_tiles
-    }
-
-    pub fn map_coord(&self) -> MapCoord {
-        let inv_zoom_factor = f64::powi(2.0, -(self.zoom as i32));
-        MapCoord::new(f64::from(self.tile_x) * inv_zoom_factor, f64::from(self.tile_y) * inv_zoom_factor)
-    }
-
-    pub fn parent(&self, distance: u32) -> Option<(Tile, SubTileCoord)> {
-        if distance > self.zoom {
-            None
-        } else {
-            let scale = u32::pow(2, distance);
-
-            Some((
-                Tile {
-                    zoom: self.zoom - distance,
-                    tile_x: self.tile_x / scale as i32,
-                    tile_y: self.tile_y / scale as i32,
-                },
-                SubTileCoord {
-                    size: scale,
-                    x: (Self::normalize_coord(self.tile_x, self.zoom) as u32) % scale,
-                    y: (Self::normalize_coord(self.tile_y, self.zoom) as u32) % scale,
-                },
-            ))
-        }
-    }
-
-    #[inline]
-    fn normalize_coord(coord: i32, zoom: u32) -> i32 {
-        let max = Self::get_zoom_level_tiles(zoom);
-        ((coord % max) + max) % max
-    }
-
-    #[inline]
-    pub fn get_zoom_level_tiles(zoom: u32) -> i32 {
-        //TODO throw error when zoom too big
-        i32::pow(2, zoom)
-    }
+    pub coord: TileCoord,
+    pub source_id: TileSourceId,
 }

src/tile_cache.rs

@@ -1,19 +1,19 @@
 use image;
 use linked_hash_map::{Entry, LinkedHashMap};
-use tile::Tile;
+use coord::TileCoord;
 use tile_loader::TileLoader;
 use tile_source::TileSource;
 
 
 pub struct TileCache {
     loader: TileLoader,
-    map: LinkedHashMap<Tile, image::DynamicImage>,
+    map: LinkedHashMap<TileCoord, image::DynamicImage>,
     max_tiles: usize,
 }
 
 impl TileCache {
     pub fn new<F>(new_tile_func: F) -> Self
-        where F: Fn(Tile) + Sync + Send + 'static,
+        where F: Fn(TileCoord) + Sync + Send + 'static,
     {
         TileCache {
             loader: TileLoader::new(move |tile| {
@@ -26,7 +26,7 @@ impl TileCache {
 
     pub fn get_sync(
         &mut self,
-        tile: Tile,
+        tile: TileCoord,
         source: &TileSource,
         write_to_file: bool,
         ) -> Option<&image::DynamicImage>
@@ -51,7 +51,7 @@ impl TileCache {
 
     pub fn get_async(
         &mut self,
-        tile: Tile,
+        tile: TileCoord,
         source: &TileSource,
         write_to_file: bool,
         ) -> Option<&image::DynamicImage>
@@ -79,7 +79,7 @@ impl TileCache {
     }
 
     // Return a tile from the cache but do not use TileLoader.
-    pub fn lookup(&mut self, tile: Tile, source: &TileSource) -> Option<&image::DynamicImage> {
+    pub fn lookup(&mut self, tile: TileCoord, source: &TileSource) -> Option<&image::DynamicImage> {
         //TODO Return the value from get_refresh with borrowck agreeing that this is OK.
         self.map.get_refresh(&tile);
 

src/tile_cache_gl.rs

@@ -1,10 +1,9 @@
-use coord::ScreenRect;
+use coord::{ScreenRect, SubTileCoord, TileCoord};
 use linked_hash_map::LinkedHashMap;
 use map_view::VisibleTile;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use texture::Texture;
-use tile::{Tile, SubTileCoord};
 use tile_cache::TileCache;
 use tile_source::TileSource;
 
@@ -38,8 +37,8 @@ pub struct TexturedVisibleTile {
 pub struct TileCacheGl<'a> {
     texture: Texture<'a>,
     tile_size: u32,
-    slots_lru: LinkedHashMap<CacheSlot, Option<Tile>>, // LRU cache of slots
-    tile_to_slot: HashMap<Tile, CacheSlot>,
+    slots_lru: LinkedHashMap<CacheSlot, Option<TileCoord>>, // LRU cache of slots
+    tile_to_slot: HashMap<TileCoord, CacheSlot>,
 }
 
 impl<'a> TileCacheGl<'a> {
@@ -70,7 +69,7 @@ impl<'a> TileCacheGl<'a> {
         CacheSlot { x: 0, y: 0 }
     }
 
-    pub fn store(&mut self, tile: Tile, source: &TileSource, cache: &mut TileCache, load: bool) -> Option<CacheSlot> {
+    pub fn store(&mut self, tile: TileCoord, source: &TileSource, cache: &mut TileCache, load: bool) -> Option<CacheSlot> {
         let mut remove_tile = None;
 
         let slot = match self.tile_to_slot.entry(tile) {

src/tile_loader.rs

@@ -1,3 +1,4 @@
+use coord::TileCoord;
 use image::DynamicImage;
 use image;
 use reqwest::Client;
@@ -7,8 +8,7 @@ use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::sync::mpsc;
 use std::thread;
-use tile::Tile;
-use tile_source::TileSource;
+use tile_source::{TileSource, TileSourceId};
 
 
 //TODO remember failed loading attempts
@@ -17,15 +17,14 @@ use tile_source::TileSource;
 pub struct TileLoader {
     client: Option<Client>,
     join_handle: thread::JoinHandle<()>,
-    request_tx: mpsc::Sender<(Tile, String, PathBuf, bool)>,
-    result_rx: mpsc::Receiver<(Tile, Option<DynamicImage>)>,
-    //TODO store source together with tile in pending
-    pending: HashSet<Tile>,
+    request_tx: mpsc::Sender<(TileCoord, TileSourceId, String, PathBuf, bool)>,
+    result_rx: mpsc::Receiver<(TileCoord, TileSourceId, Option<DynamicImage>)>,
+    pending: HashSet<(TileCoord, TileSourceId)>,
 }
 
 impl TileLoader {
     pub fn new<F>(notice_func: F) -> Self
-        where F: Fn(Tile) + Sync + Send + 'static,
+        where F: Fn(TileCoord) + Sync + Send + 'static,
     {
         let (request_tx, request_rx) = mpsc::channel();
         let (result_tx, result_rx) = mpsc::channel();
@@ -40,18 +39,18 @@ impl TileLoader {
     }
 
     fn work<F>(
-        request_rx: mpsc::Receiver<(Tile, String, PathBuf, bool)>,
-        result_tx: mpsc::Sender<(Tile, Option<DynamicImage>)>,
+        request_rx: mpsc::Receiver<(TileCoord, TileSourceId, String, PathBuf, bool)>,
+        result_tx: mpsc::Sender<(TileCoord, TileSourceId, Option<DynamicImage>)>,
         notice_func: F,
     )
-        where F: Fn(Tile) + Sync + Send + 'static,
+        where F: Fn(TileCoord) + Sync + Send + 'static,
     {
         let mut client_opt = None;
-        while let Ok((tile, url, path, write_to_file)) = request_rx.recv() {
+        while let Ok((tile, source_id, url, path, write_to_file)) = request_rx.recv() {
             println!("work {:?}", tile);
             match image::open(&path) {
                 Ok(img) => {
-                    result_tx.send((tile, Some(img))).unwrap();
+                    result_tx.send((tile, source_id, Some(img))).unwrap();
                     notice_func(tile);
                     continue;
                 },
@@ -67,7 +66,7 @@ impl TileLoader {
                             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();
+                                result_tx.send((tile, source_id, Some(img))).unwrap();
                                 notice_func(tile);
 
                                 if write_to_file {
@@ -81,19 +80,20 @@ impl TileLoader {
                     }
                 },
             }
-            result_tx.send((tile, None)).unwrap();
+            result_tx.send((tile, source_id, None)).unwrap();
         }
     }
 
-    pub fn async_request(&mut self, tile: Tile, source: &TileSource, write_to_file: bool) {
+    pub fn async_request(&mut self, tile: TileCoord, source: &TileSource, write_to_file: bool) {
         if tile.zoom > source.max_tile_zoom() {
             return;
         }
 
-        if !self.pending.contains(&tile) {
-            self.pending.insert(tile);
+        if !self.pending.contains(&(tile, source.id())) {
+            self.pending.insert((tile, source.id()));
             self.request_tx.send((
                 tile,
+                source.id(),
                 source.remote_tile_url(tile),
                 source.local_tile_path(tile),
                 write_to_file
@@ -101,21 +101,21 @@ impl TileLoader {
         }
     }
 
-    pub fn async_result(&mut self) -> Option<(Tile, DynamicImage)> {
+    pub fn async_result(&mut self) -> Option<(TileCoord, DynamicImage)> {
         match self.result_rx.try_recv() {
             Err(_) => None,
-            Ok((tile, None)) => {
-                self.pending.remove(&tile);
+            Ok((tile, source_id, None)) => {
+                self.pending.remove(&(tile, source_id));
                 None
             },
-            Ok((tile, Some(img))) => {
-                self.pending.remove(&tile);
+            Ok((tile, source_id, Some(img))) => {
+                self.pending.remove(&(tile, source_id));
                 Some((tile, img))
             },
         }
     }
 
-    pub fn get_sync(&mut self, tile: Tile, source: &TileSource, write_to_file: bool) -> Option<DynamicImage> {
+    pub fn get_sync(&mut self, tile: TileCoord, source: &TileSource, write_to_file: bool) -> Option<DynamicImage> {
         match image::open(source.local_tile_path(tile)) {
             Ok(img) => {
                 Some(img)

src/tile_source.rs

@@ -1,4 +1,4 @@
-use tile::Tile;
+use coord::TileCoord;
 use std::path::{Path, PathBuf};
 
 
@@ -10,7 +10,7 @@ pub struct TileSource {
     max_zoom: u32,
 }
 
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TileSourceId {
     id: u32,
 }
@@ -36,17 +36,16 @@ impl TileSource {
         }
     }
 
-    pub fn local_tile_path(&self, tile: Tile) -> PathBuf {
-
+    pub fn local_tile_path(&self, tile: TileCoord) -> PathBuf {
         let mut path = PathBuf::from(&self.directory);
         path.push(tile.zoom.to_string());
-        path.push(tile.tile_x.to_string());
-        path.push(tile.tile_y.to_string() + ".png");
+        path.push(tile.x.to_string());
+        path.push(tile.y.to_string() + ".png");
 
         path
     }
 
-    pub fn remote_tile_url(&self, tile: Tile) -> String {
+    pub fn remote_tile_url(&self, tile: TileCoord) -> String {
         Self::fill_template(&self.url_template, tile)
     }
 
@@ -54,9 +53,9 @@ impl TileSource {
         self.max_zoom
     }
 
-    fn fill_template(template: &str, tile: Tile) -> String {
-        let x_str = tile.tile_x.to_string();
-        let y_str = tile.tile_y.to_string();
+    fn fill_template(template: &str, tile: TileCoord) -> String {
+        let x_str = tile.x.to_string();
+        let y_str = tile.y.to_string();
         let z_str = tile.zoom.to_string();
 
         //let len = (template.len() + x_str.len() + y_str.len() + z_str.len()).saturating_sub(9);