fix: Fix min/max tile index calculation for some bounds

Add a method to the tile schema builder to set the bounds for which the
tiles exist. This method when tested revieled a bug in the min/max tile
index calcultion which resulted in wrong tiles being selected for the
specified bounding box.

Author: Maximkaaa

galileo/src/tile_schema/builder.rs

@@ -14,7 +14,8 @@ use super::schema::{TileSchema, VerticalDirection};
 #[derive(Debug)]
 pub struct TileSchemaBuilder {
     origin: Point2,
-    bounds: Rect,
+    world_bounds: Rect,
+    tile_bounds: Rect,
     lods: Lods,
     tile_width: u32,
     tile_height: u32,
@@ -75,8 +76,8 @@ impl TileSchemaBuilder {
     pub fn build(self) -> Result<TileSchema, TileSchemaError> {
         // Resolution is bound by the maximum tile index that can be represented
         let min_resolution = f64::min(
-            self.bounds.width() / self.tile_width as f64 / u64::MAX as f64,
-            self.bounds.height() / self.tile_height as f64 / u64::MAX as f64,
+            self.world_bounds.width() / self.tile_width as f64 / u64::MAX as f64,
+            self.world_bounds.height() / self.tile_height as f64 / u64::MAX as f64,
         );
 
         let lods = match self.lods {
@@ -85,7 +86,7 @@ impl TileSchemaBuilder {
                     return Err(TileSchemaError::NoZLevelsProvided);
                 }
 
-                let top_resolution = self.bounds.width() / self.tile_width as f64;
+                let top_resolution = self.world_bounds.width() / self.tile_width as f64;
 
                 let max_z_level = *z_levels.iter().max().unwrap_or(&0);
                 let mut lods = vec![f64::MAX; max_z_level as usize + 1];
@@ -161,7 +162,7 @@ impl TileSchemaBuilder {
 
         Ok(TileSchema {
             origin: self.origin,
-            bounds: self.bounds,
+            bounds: self.tile_bounds,
             lods: Arc::new(lods),
             tile_width: self.tile_width,
             tile_height: self.tile_height,
@@ -184,7 +185,13 @@ impl TileSchemaBuilder {
 
         Self {
             origin: Point2::new(-MAX_COORD_VALUE, MAX_COORD_VALUE),
-            bounds: Rect::new(
+            world_bounds: Rect::new(
+                -MAX_COORD_VALUE,
+                -MAX_COORD_VALUE,
+                MAX_COORD_VALUE,
+                MAX_COORD_VALUE,
+            ),
+            tile_bounds: Rect::new(
                 -MAX_COORD_VALUE,
                 -MAX_COORD_VALUE,
                 MAX_COORD_VALUE,
@@ -238,14 +245,14 @@ impl TileSchemaBuilder {
     }
 
     /// Sets the origin point of the tiles.
-    /// 
+    ///
     /// Origin point is set in projection coordinates (for example, in Mercator meters for Mercator projection).
-    /// 
+    ///
     /// It is the point where the tile with index `(X: 0, Y: 0)` is located (for every Z index). If the schema
     /// uses direction of Y indices from top to bottom, the origin point will be at the left top angle of the
     /// tile. If the direction of Y indices is from bottom to top, the origin point will be at the left bottom
     /// point of the tile.
-    /// 
+    ///
     /// ```
     /// # use galileo::tile_schema::TileSchemaBuilder;
     /// # use galileo::galileo_types::cartesian::Point2;
@@ -254,14 +261,37 @@ impl TileSchemaBuilder {
     ///     .build()
     ///     .expect("tile schema is properly defined");
     /// ```
-    /// 
+    ///
     /// Note that origin point doesn't have to be inside the schema bounds. For example, the origin may point to
     /// the top left angle of the world map, but tiles might only be available for a specific region, and the
-    /// bounds will only contain that region. In this case tiles may have indicies starting not from 0.
+    /// bounds will only contain that region. In this case tiles may have indices starting not from 0.
     pub fn origin(mut self, origin: Point2) -> Self {
         self.origin = origin;
         self
     }
+
+    /// Sets a rectangle in projected coordinates for which tiles are available.
+    ///
+    /// Tiles that lies outside of the bounds will not be requested from the source.
+    ///
+    /// ```
+    /// # use galileo::tile_schema::TileSchemaBuilder;
+    /// # use galileo::galileo_types::cartesian::Rect;
+    /// let tile_schema = TileSchemaBuilder::web_mercator(0..23)
+    ///     // only show tiles for Angola
+    ///     .bounds(Rect::new(1282761., -1975899., 2674573., -590691.))
+    ///     .build()
+    ///     .expect("tile schema is properly defined");
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// If either width or height of the bounds rectangle is `0`, `NaN` or `Infinity`, building the tile schema
+    /// will return an error `TileSchemaError::InvalidBounds`.
+    pub fn bounds(mut self, bounds: Rect) -> Self {
+        self.tile_bounds = bounds;
+        self
+    }
 }
 
 #[cfg(test)]

galileo/src/tile_schema/schema.rs

@@ -203,16 +203,16 @@ impl TileSchema {
         let pix_bound = (self.bounds.x_max() - self.origin.x()) / resolution;
         let floored = pix_bound.floor();
         if (pix_bound - floored).abs() < 0.1 {
-            (floored / self.tile_width as f64) as i32 - 1
+            (pix_bound / self.tile_width as f64) as i32 - 1
         } else {
-            (floored / self.tile_width as f64) as i32
+            (pix_bound / self.tile_width as f64) as i32
         }
     }
 
     fn min_y_index(&self, resolution: f64) -> i32 {
         match self.y_direction {
             VerticalDirection::TopToBottom => {
-                ((self.bounds.y_min() + self.origin.y()) / resolution / self.tile_height as f64)
+                ((self.origin.y() - self.bounds.y_max()) / resolution / self.tile_height as f64)
                     .floor() as i32
             }
             VerticalDirection::BottomToTop => {
@@ -224,14 +224,15 @@ impl TileSchema {
 
     fn max_y_index(&self, resolution: f64) -> i32 {
         let pix_bound = match self.y_direction {
-            VerticalDirection::TopToBottom => (self.bounds.y_max() + self.origin.y()) / resolution,
+            VerticalDirection::TopToBottom => (self.origin.y() - self.bounds.y_min()) / resolution,
             VerticalDirection::BottomToTop => (self.bounds.y_max() - self.origin.y()) / resolution,
         };
+
         let floored = pix_bound.floor();
         if (pix_bound - floored).abs() < 0.1 {
-            (floored / self.tile_height as f64) as i32 - 1
+            (pix_bound / self.tile_width as f64) as i32 - 1
         } else {
-            (floored / self.tile_height as f64) as i32
+            (pix_bound / self.tile_width as f64) as i32
         }
     }
 }
@@ -397,4 +398,97 @@ mod tests {
             4
         );
     }
+
+    #[test]
+    fn iter_tiles_origin_out_of_bounds() {
+        let schema = TileSchema {
+            origin: Point2::new(0.0, 0.0),
+            bounds: Rect::new(1000.0, 1000.0, 2000.0, 2000.0),
+            lods: Arc::new(vec![30.0, 10.0, 1.0]),
+            tile_width: 10,
+            tile_height: 10,
+            y_direction: VerticalDirection::BottomToTop,
+            wrap_x: false,
+        };
+
+        let tiles: Vec<_> = schema
+            .iter_tiles_over_bbox(10.0, Rect::new(0.0, 0.0, 500.0, 500.0))
+            .unwrap()
+            .collect();
+        assert!(
+            tiles.is_empty(),
+            "Expected empty tiles iter, but got: {tiles:?}"
+        );
+
+        let tiles: Vec<_> = schema
+            .iter_tiles_over_bbox(10.0, Rect::new(900.0, 900.0, 1100.0, 1100.0))
+            .unwrap()
+            .collect();
+
+        assert_eq!(tiles.len(), 1);
+        assert_eq!(tiles[0], WrappingTileIndex::new(10, 10, 1));
+
+        let tiles: Vec<_> = schema
+            .iter_tiles_over_bbox(30.0, Rect::new(900.0, 900.0, 950.0, 950.0))
+            .unwrap()
+            .collect();
+
+        assert_eq!(tiles.len(), 1);
+        assert_eq!(tiles[0], WrappingTileIndex::new(3, 3, 0));
+    }
+
+    #[test]
+    fn iter_tiles_origin_out_of_bounds_top_to_bottom() {
+        let schema = TileSchema {
+            origin: Point2::new(0.0, 3000.0),
+            bounds: Rect::new(1000.0, 1000.0, 2000.0, 2000.0),
+            lods: Arc::new(vec![30.0, 10.0, 1.0]),
+            tile_width: 10,
+            tile_height: 10,
+            y_direction: VerticalDirection::TopToBottom,
+            wrap_x: false,
+        };
+
+        let tiles: Vec<_> = schema
+            .iter_tiles_over_bbox(10.0, Rect::new(0.0, 0.0, 500.0, 500.0))
+            .unwrap()
+            .collect();
+        assert!(
+            tiles.is_empty(),
+            "Expected empty tiles iter, but got: {tiles:?}"
+        );
+
+        let tiles: Vec<_> = schema
+            .iter_tiles_over_bbox(10.0, Rect::new(900.0, 900.0, 1099.0, 1099.0))
+            .unwrap()
+            .collect();
+
+        println!("{tiles:?}");
+        assert_eq!(tiles.len(), 1);
+        assert_eq!(tiles[0], WrappingTileIndex::new(10, 19, 1));
+
+        let tiles: Vec<_> = schema
+            .iter_tiles_over_bbox(30.0, Rect::new(900.0, 900.0, 950.0, 950.0))
+            .unwrap()
+            .collect();
+
+        assert_eq!(tiles.len(), 1);
+        assert_eq!(tiles[0], WrappingTileIndex::new(3, 6, 0));
+    }
+
+    #[test]
+    fn tile_bbox_origin_out_of_bounds() {
+        let schema = TileSchema {
+            origin: Point2::new(0.0, 0.0),
+            bounds: Rect::new(1000.0, 1000.0, 2000.0, 2000.0),
+            lods: Arc::new(vec![300.0, 100.0, 10.0, 1.0]),
+            tile_width: 10,
+            tile_height: 10,
+            y_direction: VerticalDirection::BottomToTop,
+            wrap_x: false,
+        };
+
+        let bbox = schema.tile_bbox(WrappingTileIndex::new(10, 10, 2)).unwrap();
+        assert_eq!(bbox, Rect::new(1000.0, 1000.0, 1100.0, 1100.0));
+    }
 }