tile_source, coord: Add support for quadkeys

src/coord.rs

 
 }
 
-#[test]
-fn test_normalize() {
-    {
-        let a = MapCoord::new(0.0, 0.0);
-        let mut b = a.clone();
-        assert_eq!(a, b);
-        b.normalize_x();
-        assert_eq!(a, b);
-    }
-    {
-        let mut a = MapCoord::new(1.0, 1.0);
-        let b = MapCoord::new(0.0, 1.0);
-        a.normalize_x();
-        assert_eq!(a, b);
-    }
-}
-
+/// A position on the screen in pixels. Top-left corner is (0.0, 0.0).
 #[derive(Copy, Clone, Debug)]
 pub struct ScreenCoord {
     pub x: f64,
     }
 }
 
+/// A rectangle in screen coordinates.
 #[derive(Copy, Clone, Debug)]
 pub struct ScreenRect {
     pub x: f64,
     }
 }
 
+/// A rectangle in texture coordinates.
+/// Top-left corner is (0.0, 0.0).
+/// Bottom-right corner is (1.0, 1.0).
 #[derive(Copy, Clone, Debug)]
 pub struct TextureRect {
     pub x1: f64,
     }
 }
 
+/// A subdivision of a tile. `x` and `y` are in the interval [0, `size` - 1].
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct SubTileCoord {
     pub size: u32,
     }
 }
 
+/// A tile position in a tile pyramid.
+/// Each zoom level has 2^zoom by 2^zoom tiles.
+/// `x` and `y` are allowed to be negative or >= 2^zoom but then they will not correspond to a tile
+/// and `is_on_planet` will return false.
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TileCoord {
     pub zoom: u32,
         //TODO throw error when zoom too big
         i32::pow(2, zoom)
     }
+
+    pub fn to_quadkey(&self) -> Option<String> {
+        if self.zoom == 0 || self.zoom > 30 || self.x < 0 || self.y < 0 {
+            return None;
+        }
+
+        let mut quadkey = String::with_capacity(self.zoom as usize);
+
+        let len = self.zoom;
+
+        for i in (0..len).rev() {
+            let mask: u32 = 1 << i;
+
+            match ((self.x as u32 & mask) != 0, (self.y as u32 & mask) != 0) {
+                (false, false) => quadkey.push('0'),
+                (true, false) => quadkey.push('1'),
+                (false, true) => quadkey.push('2'),
+                (true, true) => quadkey.push('3'),
+            }
+        }
+
+        Some(quadkey)
+    }
 }
 
 //TODO include width and height of view rect to determine visibility
     pub zoom: u32,
     pub center: MapCoord,
 }
+
+#[cfg(test)]
+mod tests {
+    use coord::*;
+
+    #[test]
+    fn normalize_mapcoord() {
+        {
+            let a = MapCoord::new(0.0, 0.0);
+            let mut b = a.clone();
+            assert_eq!(a, b);
+            b.normalize_x();
+            assert_eq!(a, b);
+        }
+        {
+            let mut a = MapCoord::new(1.0, 1.0);
+            let b = MapCoord::new(0.0, 1.0);
+            a.normalize_x();
+            assert_eq!(a, b);
+        }
+    }
+
+    #[test]
+    fn quadkey() {
+        assert_eq!(TileCoord::new(0, 0, 0).to_quadkey(), None);
+        assert_eq!(TileCoord::new(1, 0, 0).to_quadkey(), Some("0".to_string()));
+        assert_eq!(TileCoord::new(1, 1, 0).to_quadkey(), Some("1".to_string()));
+        assert_eq!(TileCoord::new(1, 0, 1).to_quadkey(), Some("2".to_string()));
+        assert_eq!(TileCoord::new(1, 1, 1).to_quadkey(), Some("3".to_string()));
+        assert_eq!(TileCoord::new(3, 1, 0).to_quadkey(), Some("001".to_string()));
+        assert_eq!(TileCoord::new(30, 0, 1).to_quadkey(), Some("000000000000000000000000000002".to_string()));
+    }
+}

src/tile_loader.rs

 
         let tile = Tile::new(tile_coord, source.id());
 
-        if !self.pending.contains(&tile) &&
-            self.request_tx.send(LoaderMessage::GetTile(
-                TileRequest {
-                    tile: tile,
-                    url: source.remote_tile_url(tile_coord),
-                    path: source.local_tile_path(tile_coord),
-                    write_to_file: write_to_file,
+        if !self.pending.contains(&tile) {
+            if let Some(url) = source.remote_tile_url(tile_coord) {
+                if self.request_tx.send(LoaderMessage::GetTile(
+                        TileRequest {
+                            tile: tile,
+                            url: url,
+                            path: source.local_tile_path(tile_coord),
+                            write_to_file: write_to_file,
+                        }
+                    )).is_ok()
+                {
+                    self.pending.insert(tile);
                 }
-            )).is_ok()
-        {
-            self.pending.insert(tile);
+            }
         }
     }
 
                     self.client = Client::builder().build().ok();
                 }
 
-                if let Some(ref client) = self.client {
-                    if let Ok(mut response) = client.get(&source.remote_tile_url(tile)).send() {
+                if let (Some(client), Some(url)) = (self.client.as_ref(), source.remote_tile_url(tile)) {
+                    if let Ok(mut response) = client.get(&url).send() {
                         let mut buf: Vec<u8> = vec![];
                         if response.copy_to(&mut buf).is_ok() {
                             if let Ok(img) = image::load_from_memory(&buf) {

src/tile_source.rs

         path
     }
 
-    pub fn remote_tile_url(&self, tile_coord: TileCoord) -> String {
+    pub fn remote_tile_url(&self, tile_coord: TileCoord) -> Option<String> {
         Self::fill_template(&self.url_template, tile_coord)
     }
 
         self.max_zoom
     }
 
-    fn fill_template(template: &str, tile_coord: TileCoord) -> String {
+    fn fill_template(template: &str, tile_coord: TileCoord) -> Option<String> {
         let x_str = tile_coord.x.to_string();
         let y_str = tile_coord.y.to_string();
         let z_str = tile_coord.zoom.to_string();
 
         //TODO use the regex crate for templates or some other more elegant method
-        template.replacen("{x}", &x_str, 1)
-                .replacen("{y}", &y_str, 1)
-                .replacen("{z}", &z_str, 1)
+        if template.contains("{quadkey}") {
+            tile_coord.to_quadkey().map(|qk| template.replacen("{quadkey}", &qk, 1))
+        } else {
+            Some(template.replacen("{x}", &x_str, 1)
+                    .replacen("{y}", &y_str, 1)
+                    .replacen("{z}", &z_str, 1)
+                )
+        }
     }
 }