refactor: Simplify TileQuadtree and Node methods to use BBox directly

Author: MichaelKreil

versatiles_core/src/types/tile_quadtree/constructors.rs

@@ -39,7 +39,7 @@ impl TileQuadtree {
 			return TileQuadtree::new_empty(level).unwrap();
 		};
 
-		let root = Node::build_node(level, (0, 0), 1u64 << level, &bbox);
+		let root = Node::build_node(&BBox::root(level), &bbox);
 		TileQuadtree { level, root }
 	}
 
@@ -73,8 +73,7 @@ impl TileQuadtree {
 		let mut codes: Vec<u64> = tiles.iter().map(|&(x, y)| morton(u64::from(x), u64::from(y))).collect();
 		codes.sort_unstable();
 		codes.dedup();
-		let size = 1u64 << level;
-		let root = Node::from_morton_sorted(&codes, 0, 0, size);
+		let root = Node::from_morton_sorted(&codes, &BBox::root(level));
 		Ok(TileQuadtree { level, root })
 	}
 
@@ -91,59 +90,44 @@ impl TileQuadtree {
 }
 
 impl Node {
-	/// Recursively build a quadtree node for the cell covering
-	/// `[x_off, x_off+size) × [y_off, y_off+size)` against the bbox
-	/// `[bbox.x_min, bbox.x_max) × [bbox.y_min, bbox.y_max)` (all exclusive on max side).
-	pub fn build_node(depth: u8, (x_off, y_off): (u64, u64), size: u64, bbox: &BBox) -> Node {
-		// Intersection of bbox with this cell
-		let ix_min = bbox.x_min.max(x_off);
-		let iy_min = bbox.y_min.max(y_off);
-		let ix_max = bbox.x_max.min(x_off + size);
-		let iy_max = bbox.y_max.min(y_off + size);
-
-		if ix_min >= ix_max || iy_min >= iy_max {
+	/// Recursively build a quadtree node for `cell` against `bbox` (both using
+	/// exclusive max coordinates).
+	pub fn build_node(cell: &BBox, bbox: &BBox) -> Node {
+		let Some(clip) = cell.intersection(bbox) else {
 			return Node::Empty;
-		}
-
-		if ix_min == x_off && iy_min == y_off && ix_max == x_off + size && iy_max == y_off + size {
+		};
+		if clip.covers(cell) {
 			return Node::Full;
 		}
-
-		if depth == 0 {
-			// We've reached leaf level — any intersection means Full
+		// At size == 1, overlap implies coverage for tile-aligned bboxes,
+		// so this branch is defensive — it should never fire in practice.
+		if cell.size() == 1 {
 			return Node::Full;
 		}
-
-		let half = size / 2;
-		let mid_x = x_off + half;
-		let mid_y = y_off + half;
-		Node::new_partial([
-			Node::build_node(depth - 1, (x_off, y_off), half, bbox),
-			Node::build_node(depth - 1, (mid_x, y_off), half, bbox),
-			Node::build_node(depth - 1, (x_off, mid_y), half, bbox),
-			Node::build_node(depth - 1, (mid_x, mid_y), half, bbox),
-		])
+		let quads = cell.quadrants();
+		Node::new_partial(std::array::from_fn(|i| Node::build_node(&quads[i], bbox)))
 	}
 
 	/// Build a `Node` from a sorted, deduplicated slice of Morton codes.
 	///
-	/// The slice must only contain codes for tiles within the cell
-	/// `[x_off, x_off+size) × [y_off, y_off+size)` and be sorted ascending.
-	/// Each quadrant split uses `partition_point` with a trivial `u64 <`
-	/// comparison — no Morton recomputation per tile.
-	pub(super) fn from_morton_sorted(codes: &[u64], x_off: u64, y_off: u64, size: u64) -> Node {
+	/// The slice must only contain codes for tiles within `cell` and be sorted
+	/// ascending. Each quadrant split uses `partition_point` with a trivial
+	/// `u64 <` comparison — no Morton recomputation per tile.
+	pub(super) fn from_morton_sorted(codes: &[u64], cell: &BBox) -> Node {
 		if codes.is_empty() {
 			return Node::Empty;
 		}
+		let size = cell.size();
 		if codes.len() as u64 == size * size {
 			return Node::Full;
 		}
 		if size == 1 {
 			return Node::Full;
 		}
-		let half = size / 2;
-		let mid_x = x_off + half;
-		let mid_y = y_off + half;
+		let quads = cell.quadrants();
+		let (x_off, y_off) = (cell.x_min, cell.y_min);
+		let mid_x = quads[0].x_max;
+		let mid_y = quads[0].y_max;
 		// Morton code of the first tile in each quadrant.
 		let ne_base = morton(mid_x, y_off);
 		let sw_base = morton(x_off, mid_y);
@@ -154,10 +138,10 @@ impl Node {
 		let se_start = codes.partition_point(|&c| c < se_base);
 
 		Node::new_partial([
-			Node::from_morton_sorted(&codes[..ne_start], x_off, y_off, half), // NW
-			Node::from_morton_sorted(&codes[ne_start..sw_start], mid_x, y_off, half), // NE
-			Node::from_morton_sorted(&codes[sw_start..se_start], x_off, mid_y, half), // SW
-			Node::from_morton_sorted(&codes[se_start..], mid_x, mid_y, half), // SE
+			Node::from_morton_sorted(&codes[..ne_start], &quads[0]),
+			Node::from_morton_sorted(&codes[ne_start..sw_start], &quads[1]),
+			Node::from_morton_sorted(&codes[sw_start..se_start], &quads[2]),
+			Node::from_morton_sorted(&codes[se_start..], &quads[3]),
 		])
 	}
 }

versatiles_core/src/types/tile_quadtree/convert.rs

@@ -8,7 +8,7 @@ impl TileQuadtree {
 	pub fn to_bbox(&self) -> TileBBox {
 		self
 			.root
-			.bounds((0, 0), 1u64 << self.level)
+			.bounds(&BBox::root(self.level))
 			.map_or_else(|| TileBBox::new_empty(self.level).unwrap(), |b| b.into_bbox(self.level))
 	}
 
@@ -20,27 +20,19 @@ impl TileQuadtree {
 }
 
 impl Node {
-	/// Returns the bounding box `(x_min, y_min, x_max_excl, y_max_excl)` of non-empty tiles.
-	pub fn bounds(&self, (x_off, y_off): (u64, u64), size: u64) -> Option<BBox> {
+	/// Returns the bounding box of non-empty tiles within `cell`, or `None` if
+	/// this subtree is empty.
+	pub fn bounds(&self, cell: &BBox) -> Option<BBox> {
 		match self {
 			Node::Empty => None,
-			Node::Full => Some(BBox::new(x_off, y_off, x_off + size, y_off + size)),
+			Node::Full => Some(*cell),
 			Node::Partial(children) => {
-				let half = size / 2;
-				let mid_x = x_off + half;
-				let mid_y = y_off + half;
-				let child_offsets = [(x_off, y_off), (mid_x, y_off), (x_off, mid_y), (mid_x, mid_y)];
-				let mut result: Option<BBox> = None;
-				for (i, child) in children.iter().enumerate() {
-					let (cx, cy) = child_offsets[i];
-					if let Some(b) = child.bounds((cx, cy), half) {
-						result = Some(match result {
-							None => b,
-							Some(r) => r.union(b),
-						});
-					}
-				}
-				result
+				let quads = cell.quadrants();
+				children
+					.iter()
+					.zip(&quads)
+					.filter_map(|(child, q)| child.bounds(q))
+					.reduce(BBox::union)
 			}
 		}
 	}

versatiles_core/src/types/tile_quadtree/include.rs

@@ -11,7 +11,7 @@ impl TileQuadtree {
 		assert_eq!(self.level, coord.level);
 		self
 			.root
-			.includes_coord((0, 0), 1u64 << self.level, (u64::from(coord.x), u64::from(coord.y)))
+			.includes_coord(&BBox::root(self.level), (u64::from(coord.x), u64::from(coord.y)))
 	}
 
 	/// Returns `true` if every tile in `bbox` is covered by this quadtree.
@@ -26,7 +26,7 @@ impl TileQuadtree {
 		let Some(bbox) = BBox::from_bbox(bbox) else {
 			return true;
 		};
-		self.root.includes_bbox((0, 0), 1u64 << self.level, bbox)
+		self.root.includes_bbox(&BBox::root(self.level), &bbox)
 	}
 
 	/// Returns `true` if every tile in `tree` is also covered by `self`.
@@ -61,54 +61,32 @@ impl Node {
 
 	/// Returns `true` if tile `(tx, ty)` is covered by this subtree.
 	///
-	/// `(x_off, y_off)` and `size` describe the tile-space region this node
-	/// covers.
-	pub fn includes_coord(&self, (x_off, y_off): (u64, u64), size: u64, (tx, ty): (u64, u64)) -> bool {
+	/// `cell` is the tile-space region this node covers.
+	pub fn includes_coord(&self, cell: &BBox, (tx, ty): (u64, u64)) -> bool {
 		match self {
 			Node::Empty => false,
 			Node::Full => true,
 			Node::Partial(children) => {
-				let (idx, cx, cy, half) = Node::child_quadrant((x_off, y_off), size, (tx, ty));
-				children[idx].includes_coord((cx, cy), half, (tx, ty))
+				let (idx, child_cell) = Node::child_quadrant(cell, (tx, ty));
+				children[idx].includes_coord(&child_cell, (tx, ty))
 			}
 		}
 	}
 
 	/// Returns `true` if every tile in `bbox` is covered by this subtree.
 	///
-	/// `(x_off, y_off)` and `size` describe this node's tile-space region;
-	/// `bbox` uses exclusive max coordinates.
-	pub fn includes_bbox(&self, (x_off, y_off): (u64, u64), size: u64, bbox: BBox) -> bool {
+	/// `cell` is this node's tile-space region; `bbox` uses exclusive max
+	/// coordinates.
+	pub fn includes_bbox(&self, cell: &BBox, bbox: &BBox) -> bool {
 		match self {
 			Node::Empty => false,
 			Node::Full => true,
 			Node::Partial(children) => {
-				let half = size / 2;
-				let mid_x = x_off + half;
-				let mid_y = y_off + half;
-				let child_offsets = [(x_off, y_off), (mid_x, y_off), (x_off, mid_y), (mid_x, mid_y)];
-				for (i, child) in children.iter().enumerate() {
-					let (cx, cy) = child_offsets[i];
-					let cx_max = cx + half;
-					let cy_max = cy + half;
-					// Clip bbox against this child's region
-					let ix_min = bbox.x_min.max(cx);
-					let iy_min = bbox.y_min.max(cy);
-					let ix_max = bbox.x_max.min(cx_max);
-					let iy_max = bbox.y_max.min(cy_max);
-					if ix_min < ix_max && iy_min < iy_max {
-						let child_bbox = BBox {
-							x_min: ix_min,
-							y_min: iy_min,
-							x_max: ix_max,
-							y_max: iy_max,
-						};
-						if !child.includes_bbox((cx, cy), half, child_bbox) {
-							return false;
-						}
-					}
-				}
-				true
+				let quads = cell.quadrants();
+				children
+					.iter()
+					.zip(&quads)
+					.all(|(child, q)| q.intersection(bbox).is_none() || child.includes_bbox(q, bbox))
 			}
 		}
 	}