Add member min_zoom to TileSource

src/config.rs

                 let mut sources_vec: Vec<(String, TileSource)> = Vec::with_capacity(sources_table.len());
 
                 for (id, (name, source)) in sources_table.iter().enumerate() {
+                    let min_zoom = source.get("min_zoom")
+                        .unwrap_or_else(|| &Value::Integer(0))
+                        .as_integer()
+                        .ok_or_else(|| "min_zoom has to be an integer".to_string())
+                        .and_then(|m| {
+                            if m < 0 || m > 30 {
+                                Err(format!("min_zoom = {} is out of bounds, has to be in interval [0, 30]", m))
+                            } else {
+                                Ok(m)
+                            }
+                        })?;
+
                     let max_zoom = source.get("max_zoom")
                         .ok_or_else(|| format!("source {:?} is missing \"max_zoom\" entry", name))?
                         .as_integer()
                         .ok_or_else(|| "max_zoom has to be an integer".to_string())
                         .and_then(|m| {
-                            if m <= 0 || m > 30 {
-                                Err(format!("max_zoom = {} is out of bounds, has to be in interval [1, 30]", m))
+                            if m < 0 || m > 30 {
+                                Err(format!("max_zoom = {} is out of bounds, has to be in interval [0, 30]", m))
                             } else {
                                 Ok(m)
                             }
                         })?;
 
+                    if min_zoom > max_zoom {
+                        warn!("min_zoom ({}) and max_zoom ({}) allow no valid tiles", min_zoom, max_zoom);
+                    } else if min_zoom == max_zoom {
+                        warn!("min_zoom ({}) and max_zoom ({}) allow only one zoom level", min_zoom, max_zoom);
+                    }
+
                     let url_template = source.get("url_template")
                         .ok_or_else(|| format!("source {:?} is missing \"url_template\" entry", name))?
                         .as_str()
                             url_template.to_string(),
                             path,
                             extension.to_string(),
+                            min_zoom as u32,
                             max_zoom as u32,
                         ),
                     ));

src/main.rs

 
     let fps: f64 = matches.value_of("fps").map(|s| s.parse().unwrap()).unwrap_or_else(|| config.fps());
     let duration_per_frame = Duration::from_millis((1000.0 / fps - 0.5).max(0.0).floor() as u64);
-    info!("milliseconds per frame: {}", dur_to_sec(duration_per_frame) * 0.001);
+    info!("milliseconds per frame: {}", dur_to_sec(duration_per_frame) * 1000.0);
 
     // estimated draw duration
     let mut est_draw_dur = duration_per_frame;

src/tile_loader.rs

     }
 
     pub fn async_request(&mut self, tile_coord: TileCoord, source: &TileSource, write_to_file: bool) {
-        if tile_coord.zoom > source.max_tile_zoom() {
+        if tile_coord.zoom > source.max_tile_zoom() ||
+           tile_coord.zoom < source.min_tile_zoom()
+        {
             return;
         }
 
     }
 
     pub fn get_sync(&mut self, tile: TileCoord, source: &TileSource, write_to_file: bool) -> Option<DynamicImage> {
+        if tile.zoom > source.max_tile_zoom() ||
+           tile.zoom < source.min_tile_zoom()
+        {
+            return None;
+        }
+
         match image::open(source.local_tile_path(tile)) {
             Ok(img) => {
                 Some(img)

src/tile_source.rs

     url_template: String,
     directory: PathBuf,
     extension: String,
+    min_zoom: u32,
     max_zoom: u32,
 }
 
         url_template: S,
         directory: P,
         extension: String,
+        min_zoom: u32,
         max_zoom: u32,
     ) -> Self {
         TileSource {
             url_template: url_template.into(),
             directory: directory.into(),
             extension: extension,
+            min_zoom: min_zoom,
             max_zoom: max_zoom,
         }
     }
         Self::fill_template(&self.url_template, tile_coord)
     }
 
+    pub fn min_tile_zoom(&self) -> u32 {
+        self.min_zoom
+    }
+
     pub fn max_tile_zoom(&self) -> u32 {
         self.max_zoom
     }