From a786eb8833a44b9b6121178671076f9fa3eba8c2 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Mon, 5 Aug 2024 14:34:02 +0800
Subject: [PATCH 01/21] include polars in requirements

---
 settings.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/settings.ini b/settings.ini
index 3338633..6bb9043 100644
--- a/settings.ini
+++ b/settings.ini
@@ -27,7 +27,7 @@ keywords = nbdev jupyter notebook python
 language = English
 status = 3
 user = thinkingmachines
-requirements = fastcore pandas numpy geopandas fastprogress h3 morecantile loguru rasterstats scikit-learn requests pyarrow exactextract
+requirements = fastcore pandas numpy geopandas fastprogress h3 morecantile loguru rasterstats scikit-learn requests pyarrow exactextract polars
 dev_requirements = nbdev jupyterlab matplotlib nbdime ipytest branca folium mapclassify pytest pytest-mock pytest-cov pytest-xdist black[jupyter]
 readme_nb = readme.ipynb
 allowed_metadata_keys = 

From 859a636783344eb12b3eedf6d4cdcbad2517dd29 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Mon, 5 Aug 2024 15:17:30 +0800
Subject: [PATCH 02/21] revert to not include polars

---
 settings.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/settings.ini b/settings.ini
index 6bb9043..3338633 100644
--- a/settings.ini
+++ b/settings.ini
@@ -27,7 +27,7 @@ keywords = nbdev jupyter notebook python
 language = English
 status = 3
 user = thinkingmachines
-requirements = fastcore pandas numpy geopandas fastprogress h3 morecantile loguru rasterstats scikit-learn requests pyarrow exactextract polars
+requirements = fastcore pandas numpy geopandas fastprogress h3 morecantile loguru rasterstats scikit-learn requests pyarrow exactextract
 dev_requirements = nbdev jupyterlab matplotlib nbdime ipytest branca folium mapclassify pytest pytest-mock pytest-cov pytest-xdist black[jupyter]
 readme_nb = readme.ipynb
 allowed_metadata_keys = 

From d820c09333f21177c2b07957c6efa8986ad84568 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Mon, 5 Aug 2024 15:19:14 +0800
Subject: [PATCH 03/21] add polars dependency

---
 settings.ini | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/settings.ini b/settings.ini
index 3338633..6bb9043 100644
--- a/settings.ini
+++ b/settings.ini
@@ -27,7 +27,7 @@ keywords = nbdev jupyter notebook python
 language = English
 status = 3
 user = thinkingmachines
-requirements = fastcore pandas numpy geopandas fastprogress h3 morecantile loguru rasterstats scikit-learn requests pyarrow exactextract
+requirements = fastcore pandas numpy geopandas fastprogress h3 morecantile loguru rasterstats scikit-learn requests pyarrow exactextract polars
 dev_requirements = nbdev jupyterlab matplotlib nbdime ipytest branca folium mapclassify pytest pytest-mock pytest-cov pytest-xdist black[jupyter]
 readme_nb = readme.ipynb
 allowed_metadata_keys = 

From b9d0f5755c7bcbce88a6cbaa7edde5d1e26be726 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Mon, 5 Aug 2024 18:57:22 +0800
Subject: [PATCH 04/21] add polygon_fill notebook and corresponding module

---
 geowrangler/_modidx.py                     |   9 +-
 geowrangler/gridding_utils/__init__.py     |   0
 geowrangler/gridding_utils/polygon_fill.py | 261 +++++++++
 notebooks/15_polygon_fill.ipynb            | 599 +++++++++++++++++++++
 4 files changed, 868 insertions(+), 1 deletion(-)
 create mode 100644 geowrangler/gridding_utils/__init__.py
 create mode 100644 geowrangler/gridding_utils/polygon_fill.py
 create mode 100644 notebooks/15_polygon_fill.ipynb

diff --git a/geowrangler/_modidx.py b/geowrangler/_modidx.py
index f236082..34c958a 100644
--- a/geowrangler/_modidx.py
+++ b/geowrangler/_modidx.py
@@ -109,6 +109,14 @@
                                                                                                                  'geowrangler/distance_zonal_stats.py'),
                                                   'geowrangler.distance_zonal_stats.create_distance_zonal_stats': ( 'distance_zonal_stats.html#create_distance_zonal_stats',
                                                                                                                     'geowrangler/distance_zonal_stats.py')},
+            'geowrangler.gridding_utils.polygon_fill': { 'geowrangler.gridding_utils.polygon_fill.interpolate_x': ( 'polygon_fill.html#interpolate_x',
+                                                                                                                    'geowrangler/gridding_utils/polygon_fill.py'),
+                                                         'geowrangler.gridding_utils.polygon_fill.polygon_fill': ( 'polygon_fill.html#polygon_fill',
+                                                                                                                   'geowrangler/gridding_utils/polygon_fill.py'),
+                                                         'geowrangler.gridding_utils.polygon_fill.scanline_fill': ( 'polygon_fill.html#scanline_fill',
+                                                                                                                    'geowrangler/gridding_utils/polygon_fill.py'),
+                                                         'geowrangler.gridding_utils.polygon_fill.voxel_traversal_2d': ( 'polygon_fill.html#voxel_traversal_2d',
+                                                                                                                         'geowrangler/gridding_utils/polygon_fill.py')},
             'geowrangler.grids': { 'geowrangler.grids.BingTileGridGenerator': ('grids.html#bingtilegridgenerator', 'geowrangler/grids.py'),
                                    'geowrangler.grids.BingTileGridGenerator.__init__': ( 'grids.html#bingtilegridgenerator.__init__',
                                                                                          'geowrangler/grids.py'),
@@ -165,7 +173,6 @@
                                                                                                               'geowrangler/raster_zonal_stats.py')},
             'geowrangler.spatialjoin_highest_intersection': { 'geowrangler.spatialjoin_highest_intersection.get_highest_intersection': ( 'spatialjoin_highest_intersection.html#get_highest_intersection',
                                                                                                                                          'geowrangler/spatialjoin_highest_intersection.py')},
-            'geowrangler.test_module': {},
             'geowrangler.tile_clustering': { 'geowrangler.tile_clustering.TileClustering': ( 'tile_clustering.html#tileclustering',
                                                                                              'geowrangler/tile_clustering.py'),
                                              'geowrangler.tile_clustering.TileClustering.__init__': ( 'tile_clustering.html#tileclustering.__init__',
diff --git a/geowrangler/gridding_utils/__init__.py b/geowrangler/gridding_utils/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/geowrangler/gridding_utils/polygon_fill.py b/geowrangler/gridding_utils/polygon_fill.py
new file mode 100644
index 0000000..002b9ba
--- /dev/null
+++ b/geowrangler/gridding_utils/polygon_fill.py
@@ -0,0 +1,261 @@
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../../notebooks/15_polygon_fill.ipynb.
+
+# %% auto 0
+__all__ = ['EPSILON', 'voxel_traversal_2d', 'scanline_fill', 'interpolate_x', 'polygon_fill']
+
+# %% ../../notebooks/15_polygon_fill.ipynb 3
+from typing import List, Tuple, Set, Optional, Dict, Union
+
+import numpy as np
+import pandas as pd
+import polars as pl
+
+# %% ../../notebooks/15_polygon_fill.ipynb 9
+# epsilon is a constant for correcting near-misses in voxel traversal
+EPSILON = 1e-14
+
+
+def voxel_traversal_2d(
+    start_vertex: Tuple[int, int],
+    end_vertex: Tuple[int, int],
+    debug: bool = False,  # if true, prints diagnostic info for the algorithm
+) -> List[Tuple[int, int]]:
+    """Returns all pixels between two points as inspired by Amanatides & Woo's “A Fast Voxel Traversal Algorithm For Ray Tracing”"""
+
+    # Setup initial conditions
+    x1, y1 = start_vertex
+    x2, y2 = end_vertex
+
+    direction_x = 1 if x2 > x1 else -1
+    direction_y = 1 if y2 > y1 else -1
+
+    if (x1 == x2) and (y1 == y2):
+        raise ValueError(
+            f"start_vertex {start_vertex} and end_vertex {end_vertex} are the same"
+        )
+
+    # Vertical line
+    elif x1 == x2:
+        pixels = [(x1, y) for y in range(y1, y2 + direction_y, direction_y)]
+        return pixels
+
+    # Horizontal line
+    elif y1 == y2:
+        pixels = [(x, y1) for x in range(x1, x2 + direction_x, direction_x)]
+        return pixels
+
+    dy = y2 - y1
+    dx = x2 - x1
+    slope = dy / dx
+    inv_slope = dx / dy
+
+    # reverse order if negative slope to preserve symmetry in floating point calculations
+    if slope < 0:
+        x1, y1 = end_vertex
+        x2, y2 = start_vertex
+
+        direction_x = 1 if x2 > x1 else -1
+        direction_y = 1 if y2 > y1 else -1
+
+    slope_multiplier = np.sqrt(1 + slope**2)
+    inv_slope_multiplier = np.sqrt(1 + inv_slope**2)
+
+    pixel_x, pixel_y = x1, y1
+    ray_x, ray_y = pixel_x, pixel_y
+    pixels = [(pixel_x, pixel_y)]
+
+    is_finished = False
+
+    if debug:
+        print(f"\nTraversing from ({x1},{y1}) to ({x2},{y2})")
+
+    # number of steps should not exceed the perimeter of the rectangle enclosing the line segment
+    max_steps = 2 * (abs(dx) + abs(dy))
+    n_steps = 0
+    while not is_finished:
+        # this prevents infinite loops
+        n_steps += 1
+        if n_steps > max_steps:
+            raise Exception(
+                f"Traversal has exceeded steps limit {max_steps:,}. Please recheck inputs"
+            )
+
+        # get the next x or y integer that the next ray would hit
+        if direction_x == 1:
+            next_ray_x = np.floor(ray_x) + 1
+        elif direction_x == -1:
+            next_ray_x = np.ceil(ray_x) - 1
+
+        if direction_y == 1:
+            next_ray_y = np.floor(ray_y) + 1
+        elif direction_y == -1:
+            next_ray_y = np.ceil(ray_y) - 1
+
+        # get distance between the 2 candidates and check which one is closer
+        # there is an epsilon to account near-misses due to floating point differences
+
+        # y coordinate line formula is next_ray_y = ray_y + slope*(next_ray_x-ray_x)
+        # squred distance is (next_ray_x - ray_x)**2 + (slope*(next_ray_x-ray_x))**2
+        # distance simplifies to abs(next_ray_x - ray_x)* sqrt(1+slope**2)
+
+        ray_candidate_1 = (
+            next_ray_x,
+            ray_y + slope * (next_ray_x - ray_x) + direction_y * EPSILON,
+        )
+        # unsimplified square distance
+        # dist_1 = (ray_candidate_1[0] - ray_x)**2 + (ray_candidate_1[1] - ray_y)**2
+        # simplified distance
+        dist_1 = abs(next_ray_x - ray_x) * slope_multiplier
+
+        # x coordinate line formula is next_ray_x = ray_x + inv_slope*(next_ray_y-y)
+        # squared distance is (inv_slope*(next_ray_y-ray_y))**2 + (next_ray_y-ray_y)**2
+        # distance simplifies to abs(next_ray_y-ray_y)* sqrt(1 + inv_slope**2)
+
+        ray_candidate_2 = (
+            ray_x + inv_slope * (next_ray_y - ray_y) + direction_x * EPSILON,
+            next_ray_y,
+        )
+        # unsimplified square distance
+        # dist_2 = (ray_candidate_2[0] - ray_x)**2 + (ray_candidate_2[1] - ray_y)**2
+        # simplified distance
+        dist_2 = abs(next_ray_y - ray_y) * inv_slope_multiplier
+
+        # candidate 1 is closer
+        if dist_1 < dist_2:
+            pixel_x += direction_x
+            ray_x, ray_y = ray_candidate_1
+
+        # candidate 2 is closer
+        elif dist_1 > dist_2:
+            pixel_y += direction_y
+            ray_x, ray_y = ray_candidate_2
+
+        # line passes exactly on the corner
+        elif dist_1 == dist_2:
+            pixel_x += direction_x
+            pixel_y += direction_y
+            ray_x, ray_y = pixel_x, pixel_y
+        else:
+            raise ValueError(f"Erroneous distances {dist_1}, {dist_2}")
+
+        if debug:
+            print(
+                f"Next ray coords are ({ray_x}, {ray_y}) and tile coords are ({pixel_x}, {pixel_y})"
+            )
+
+        pixels.append((pixel_x, pixel_y))
+
+        # checks to see if the loop is finished
+        if direction_x == 1:
+            is_x_finished = pixel_x >= x2
+        elif direction_x == -1:
+            is_x_finished = pixel_x <= x2
+
+        if direction_y == 1:
+            is_y_finished = pixel_y >= y2
+        elif direction_y == -1:
+            is_y_finished = pixel_y <= y2
+
+        if is_x_finished and is_y_finished:
+            break
+
+    return pixels
+
+# %% ../../notebooks/15_polygon_fill.ipynb 13
+def scanline_fill(
+    vertices: List[
+        Tuple[int, int]
+    ],  # list of polygon vertices in order (either clockwise or counterclockwise)
+    debug: bool = False,  # if true, prints diagnostic info for the algorithm
+) -> Set[Tuple[int, int]]:
+    """Returns all pixels within the interior of a polygon defined by vertices"""
+
+    offset_vertices = vertices[1:] + vertices[:1]
+
+    if not vertices:
+        return set()
+
+    if len(vertices) == 1:
+        return set(vertices)
+
+    # Calculate the bounding box for the polygon
+    min_y, max_y = min(y for x, y in vertices), max(y for x, y in vertices)
+
+    filled_pixels = set()
+    # Process each horizontal scanline within the bounding box
+    for scanline_y in range(min_y, max_y + 1):
+        intersection_points = []
+
+        # Find intersections of the polygon with the current scanline
+        for start_vertex, end_vertex in zip(vertices, offset_vertices):
+            start_x, start_y = start_vertex
+            end_x, end_y = end_vertex
+
+            if (end_y < scanline_y <= start_y) or (start_y < scanline_y <= end_y):
+                # Calculate x-coordinate of intersection
+                intersection_x = interpolate_x(start_vertex, end_vertex, scanline_y)
+                intersection_points.append(intersection_x)
+
+        # Fill pixels between pairs of intersections
+        if intersection_points:
+            intersection_points.sort()
+
+            filled_pixels_in_row = set()
+            for start_x, end_x in zip(
+                intersection_points[::2], intersection_points[1::2]
+            ):
+                start_x, end_x = int(round(start_x)), int(round(end_x))
+
+                _filled_pixels_in_row = [
+                    (x, scanline_y) for x in range(start_x, end_x + 1)
+                ]
+                filled_pixels_in_row.update(_filled_pixels_in_row)
+
+            filled_pixels.update(filled_pixels_in_row)
+
+        if debug:
+            print(f"Scanline y = {scanline_y}, Intersections: {intersection_points}")
+
+    return filled_pixels
+
+
+def interpolate_x(
+    start_vertex: Tuple[int, int],
+    end_vertex: Tuple[int, int],
+    y: int,
+) -> float:
+    """Interpolate x value for a given y along the line segment defined by start_vertex and end_vertex."""
+    x1, y1 = start_vertex
+    x2, y2 = end_vertex
+    if y1 == y2:
+        # case when there is a horizontal line segment
+        raise ValueError(f"The y value of the 2 vertices should not be the same")
+
+    inverse_slope = (x2 - x1) / (y2 - y1)
+    interpolated_x = x1 + (y - y1) * inverse_slope
+    return interpolated_x
+
+# %% ../../notebooks/15_polygon_fill.ipynb 17
+def polygon_fill(
+    vertices_df: Union[
+        pd.DataFrame, pl.DataFrame
+    ],  # dataframe with x_col and y_col for the polygon vertices
+    x_col: str = "x",
+    y_col: str = "y",
+    debug: bool = False,  # if true, prints diagnostic info for both voxel traversal and scanline fill algorithms
+) -> Set[Tuple[int, int]]:
+    """
+    Returns pixels that intersect a polygon
+    This uses voxel traversal to fill the boundary, and scanline fill for the interior. All coordinates are assumed to be nonnegative integers
+    """
+
+    vertices = list(zip(vertices_df[x_col].to_list(), vertices_df[y_col].to_list()))
+    offset_vertices = vertices[1:] + vertices[:1]
+
+    polygon_pixels = set()
+    for start_vertex, end_vertex in zip(vertices, offset_vertices):
+        polygon_pixels.update(voxel_traversal_2d(start_vertex, end_vertex, debug))
+
+    polygon_pixels.update(scanline_fill(vertices, debug))
+
+    return polygon_pixels
diff --git a/notebooks/15_polygon_fill.ipynb b/notebooks/15_polygon_fill.ipynb
new file mode 100644
index 0000000..d41afd7
--- /dev/null
+++ b/notebooks/15_polygon_fill.ipynb
@@ -0,0 +1,599 @@
+{
+ "cells": [
+  {
+   "cell_type": "raw",
+   "id": "f80c96fc-fd38-446b-94df-8b7a283c213e",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "description: polygon fill algorithms\n",
+    "output-file: polygon_fill.html\n",
+    "title: Polygon Fill\n",
+    "\n",
+    "---\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8a7ff4c-1763-4e17-86fe-7dd0aa78f64a",
+   "metadata": {},
+   "source": [
+    "[![](https://colab.research.google.com/assets/colab-badge.svg \"Open in Colab button\")]()\n",
+    "\n",
+    "### Colab link to follow"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4aa6e5ff-d0c0-4463-93d7-85a4855c63e1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| default_exp gridding_utils.polygon_fill"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "52b870c5-564a-40c0-8286-fdfe52f4fdc2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "from typing import List, Tuple, Set, Optional, Dict, Union\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import polars as pl"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "81fb9b86-f20c-455b-b4d2-c323263df245",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.patches as patches"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5160bd29-af21-4e8c-8a45-401042d5e96e",
+   "metadata": {},
+   "source": [
+    "## Overview\n",
+    "\n",
+    "We will use 2 separate algorithms for filling in pixels in polygons.\n",
+    "1. [Voxel Traversal Algorithm](https://github.com/cgyurgyik/fast-voxel-traversal-algorithm/blob/master/overview/FastVoxelTraversalOverview.md): We use this for filling in pixels along the polygon boundary. We implement 2D voxel traversal for every line segment of the polygon boundary.\n",
+    "2. [Scanline Fill Algorithm](https://www.educative.io/answers/what-is-scanline-fill-algorithm): We use this for filling in pixels in the polygon interior.\n",
+    "\n",
+    "All pixels and polygon vertices are assumed to have nonnegative integer coordinates"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "798c7c6b-ec87-4dac-8275-1d19dc4df9ae",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "polygon_test_cases = {\n",
+    "    \"Square\": [(0, 0), (10, 0), (10, 10), (0, 10)],\n",
+    "    \"Triangle\": [(0, 0), (10, 0), (5, 10)],\n",
+    "    \"Right Triangle\": [(0, 0), (10, 0), (0, 10)],\n",
+    "    \"Pentagon\": [(2, 0), (8, 0), (10, 6), (5, 10), (0, 6)],\n",
+    "    \"Star\": [\n",
+    "        (6, 2),\n",
+    "        (8, 8),\n",
+    "        (12, 8),\n",
+    "        (9, 12),\n",
+    "        (11, 18),\n",
+    "        (6, 14),\n",
+    "        (1, 18),\n",
+    "        (3, 12),\n",
+    "        (0, 8),\n",
+    "        (4, 8),\n",
+    "    ],\n",
+    "\n",
+    "    \"Complex Shape 1\": [(0, 0), (5, 2), (3, 5), (8, 8), (5, 10), (0, 7)],\n",
+    "    \"Complex Shape 2\": [\n",
+    "        (0, 0),\n",
+    "        (2, 6),\n",
+    "        (4, 10),\n",
+    "        (6, 8),\n",
+    "        (8, 12),\n",
+    "        (10, 4),\n",
+    "        (12, 2),\n",
+    "        (8, 0),\n",
+    "    ],\n",
+    "    \"Complex Shape 3\": [(2, 3), (5, 3), (6, 6), (3, 7), (1, 5)],\n",
+    "    \"Complex Shape 4\": [(1, 1), (2, 5), (4, 3), (6, 7)],\n",
+    "    \"Complex Shape 5\": [(1, 2), (3, 6), (5, 5), (7, 4), (9, 5), (11, 2)],\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "db03abe9-0d42-44f8-bdbc-9d22eac5fa14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| hide\n",
+    "def plot_polygon(\n",
+    "    ax: plt.Axes,\n",
+    "    vertices: List[Tuple[int,int]],\n",
+    "    pixels: Optional[set] = None,\n",
+    "    figsize: tuple = (4, 4),\n",
+    "):\n",
+    "    vertices_x = [x for (x,y) in vertices]\n",
+    "    vertices_y = [y for (x,y) in vertices]\n",
+    "    \n",
+    "    ax.plot(vertices_x, vertices_y, \"b-\", markersize=5)\n",
+    "    # to close off the polygon\n",
+    "    ax.plot([vertices_x[-1], vertices_x[0]], [vertices_y[-1], vertices_y[0]], \"b-\")\n",
+    "\n",
+    "    if pixels is not None:\n",
+    "        for x, y in pixels:\n",
+    "            rect = patches.Rectangle(\n",
+    "                xy=(x - 0.5, y - 0.5),\n",
+    "                width=1,\n",
+    "                height=1,\n",
+    "                linewidth=1,\n",
+    "                edgecolor=\"black\",\n",
+    "                facecolor=\"r\",\n",
+    "                alpha=0.6,\n",
+    "            )\n",
+    "            ax.add_patch(rect)\n",
+    "\n",
+    "def plot_all_polygons(\n",
+    "    polygon_vertices_dict: Dict[str, List[Tuple[int, int]]], \n",
+    "    polygon_pixels_dict: Dict[str, set], \n",
+    "    n_imgs_per_row: int = 3,\n",
+    "):\n",
+    "    n = len(polygon_vertices_dict)\n",
+    "    rows = (n + n_imgs_per_row - 1) // n_imgs_per_row  # Calculate the number of rows needed\n",
+    "    fig, axes = plt.subplots(nrows=rows, ncols=n_imgs_per_row, figsize=(4 * n_imgs_per_row, 4 * rows))\n",
+    "\n",
+    "    if n_imgs_per_row == 1:\n",
+    "        axes = [axes]  \n",
+    "    \n",
+    "    # Flattening the axes for easier iteration, especially for n_imgs_per_row = 1\n",
+    "    axes_flat = axes.flatten()\n",
+    "\n",
+    "    # Iterate over each polygon and its corresponding pixels\n",
+    "    for ax, (name, vertices) in zip(axes_flat, polygon_vertices_dict.items()):\n",
+    "        pixels = polygon_pixels_dict.get(name, set())  # Safely get pixels for the polygon\n",
+    "        plot_polygon(ax, vertices, pixels)\n",
+    "        ax.set_title(name)\n",
+    "        ax.axis('equal')  # Ensure the aspect ratio is equal to properly display polygons\n",
+    "    \n",
+    "    # Turn off any unused axes\n",
+    "    for ax in axes_flat[n:]:\n",
+    "        ax.axis('off')\n",
+    "    \n",
+    "    plt.tight_layout()\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f23e6134-b41d-44b9-a3c7-ce11ee1f14e4",
+   "metadata": {},
+   "source": [
+    "## Voxel Traversal\n",
+    "\n",
+    "We use the 2D voxel traversal algorithm to fill in pixels between two points."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e44a78ba-c885-4ab7-bcfa-104346df376a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "\n",
+    "# epsilon is a constant for correcting near-misses in voxel traversal\n",
+    "EPSILON = 1e-14\n",
+    "\n",
+    "def voxel_traversal_2d(\n",
+    "    start_vertex: Tuple[int, int], \n",
+    "    end_vertex: Tuple[int, int],\n",
+    "    debug: bool = False, # if true, prints diagnostic info for the algorithm  \n",
+    ") -> List[Tuple[int, int]]:\n",
+    "    \"\"\"Returns all pixels between two points as inspired by Amanatides & Woo's “A Fast Voxel Traversal Algorithm For Ray Tracing” \"\"\"\n",
+    "\n",
+    "    # Setup initial conditions\n",
+    "    x1, y1 = start_vertex\n",
+    "    x2, y2 = end_vertex\n",
+    "\n",
+    "    direction_x = 1 if x2 > x1 else -1\n",
+    "    direction_y = 1 if y2 > y1 else -1\n",
+    "\n",
+    "    if (x1 == x2) and (y1 == y2):\n",
+    "        raise ValueError(\n",
+    "            f\"start_vertex {start_vertex} and end_vertex {end_vertex} are the same\"\n",
+    "        )\n",
+    "\n",
+    "    # Vertical line\n",
+    "    elif x1 == x2:\n",
+    "        pixels = [(x1, y) for y in range(y1, y2 + direction_y, direction_y)]\n",
+    "        return pixels\n",
+    "\n",
+    "    # Horizontal line\n",
+    "    elif y1 == y2:\n",
+    "        pixels = [(x, y1) for x in range(x1, x2 + direction_x, direction_x)]\n",
+    "        return pixels\n",
+    "\n",
+    "    dy = y2 - y1\n",
+    "    dx = x2 - x1\n",
+    "    slope = dy / dx\n",
+    "    inv_slope = dx / dy\n",
+    "\n",
+    "    # reverse order if negative slope to preserve symmetry in floating point calculations\n",
+    "    if slope < 0:\n",
+    "        x1, y1 = end_vertex\n",
+    "        x2, y2 = start_vertex\n",
+    "\n",
+    "        direction_x = 1 if x2 > x1 else -1\n",
+    "        direction_y = 1 if y2 > y1 else -1\n",
+    "\n",
+    "    slope_multiplier = np.sqrt(1 + slope**2)\n",
+    "    inv_slope_multiplier = np.sqrt(1 + inv_slope**2)\n",
+    "\n",
+    "    pixel_x, pixel_y = x1, y1\n",
+    "    ray_x, ray_y = pixel_x, pixel_y\n",
+    "    pixels = [(pixel_x, pixel_y)]\n",
+    "\n",
+    "    is_finished = False\n",
+    "\n",
+    "    if debug:\n",
+    "        print(f\"\\nTraversing from ({x1},{y1}) to ({x2},{y2})\")\n",
+    "\n",
+    "    # number of steps should not exceed the perimeter of the rectangle enclosing the line segment\n",
+    "    max_steps = 2 * (abs(dx) + abs(dy))\n",
+    "    n_steps = 0\n",
+    "    while not is_finished:\n",
+    "        # this prevents infinite loops\n",
+    "        n_steps += 1\n",
+    "        if n_steps > max_steps:\n",
+    "            raise Exception(\n",
+    "                f\"Traversal has exceeded steps limit {max_steps:,}. Please recheck inputs\"\n",
+    "            )\n",
+    "\n",
+    "        # get the next x or y integer that the next ray would hit\n",
+    "        if direction_x == 1:\n",
+    "            next_ray_x = np.floor(ray_x) + 1\n",
+    "        elif direction_x == -1:\n",
+    "            next_ray_x = np.ceil(ray_x) - 1\n",
+    "\n",
+    "        if direction_y == 1:\n",
+    "            next_ray_y = np.floor(ray_y) + 1\n",
+    "        elif direction_y == -1:\n",
+    "            next_ray_y = np.ceil(ray_y) - 1\n",
+    "\n",
+    "        # get distance between the 2 candidates and check which one is closer\n",
+    "        # there is an epsilon to account near-misses due to floating point differences\n",
+    "\n",
+    "        # y coordinate line formula is next_ray_y = ray_y + slope*(next_ray_x-ray_x)\n",
+    "        # squred distance is (next_ray_x - ray_x)**2 + (slope*(next_ray_x-ray_x))**2\n",
+    "        # distance simplifies to abs(next_ray_x - ray_x)* sqrt(1+slope**2)\n",
+    "\n",
+    "        ray_candidate_1 = (\n",
+    "            next_ray_x,\n",
+    "            ray_y + slope * (next_ray_x - ray_x) + direction_y * EPSILON,\n",
+    "        )\n",
+    "        # unsimplified square distance\n",
+    "        # dist_1 = (ray_candidate_1[0] - ray_x)**2 + (ray_candidate_1[1] - ray_y)**2\n",
+    "        # simplified distance\n",
+    "        dist_1 = abs(next_ray_x - ray_x) * slope_multiplier\n",
+    "\n",
+    "        # x coordinate line formula is next_ray_x = ray_x + inv_slope*(next_ray_y-y)\n",
+    "        # squared distance is (inv_slope*(next_ray_y-ray_y))**2 + (next_ray_y-ray_y)**2\n",
+    "        # distance simplifies to abs(next_ray_y-ray_y)* sqrt(1 + inv_slope**2)\n",
+    "\n",
+    "        ray_candidate_2 = (\n",
+    "            ray_x + inv_slope * (next_ray_y - ray_y) + direction_x * EPSILON,\n",
+    "            next_ray_y,\n",
+    "        )\n",
+    "        # unsimplified square distance\n",
+    "        # dist_2 = (ray_candidate_2[0] - ray_x)**2 + (ray_candidate_2[1] - ray_y)**2\n",
+    "        # simplified distance\n",
+    "        dist_2 = abs(next_ray_y - ray_y) * inv_slope_multiplier\n",
+    "\n",
+    "        # candidate 1 is closer\n",
+    "        if dist_1 < dist_2:\n",
+    "            pixel_x += direction_x\n",
+    "            ray_x, ray_y = ray_candidate_1\n",
+    "\n",
+    "        # candidate 2 is closer\n",
+    "        elif dist_1 > dist_2:\n",
+    "            pixel_y += direction_y\n",
+    "            ray_x, ray_y = ray_candidate_2\n",
+    "\n",
+    "        # line passes exactly on the corner\n",
+    "        elif dist_1 == dist_2:\n",
+    "            pixel_x += direction_x\n",
+    "            pixel_y += direction_y\n",
+    "            ray_x, ray_y = pixel_x, pixel_y\n",
+    "        else:\n",
+    "            raise ValueError(f\"Erroneous distances {dist_1}, {dist_2}\")\n",
+    "\n",
+    "        if debug:\n",
+    "            print(\n",
+    "                f\"Next ray coords are ({ray_x}, {ray_y}) and tile coords are ({pixel_x}, {pixel_y})\"\n",
+    "            )\n",
+    "\n",
+    "        pixels.append((pixel_x, pixel_y))\n",
+    "\n",
+    "        # checks to see if the loop is finished\n",
+    "        if direction_x == 1:\n",
+    "            is_x_finished = pixel_x >= x2\n",
+    "        elif direction_x == -1:\n",
+    "            is_x_finished = pixel_x <= x2\n",
+    "\n",
+    "        if direction_y == 1:\n",
+    "            is_y_finished = pixel_y >= y2\n",
+    "        elif direction_y == -1:\n",
+    "            is_y_finished = pixel_y <= y2\n",
+    "\n",
+    "        if is_x_finished and is_y_finished:\n",
+    "            break\n",
+    "\n",
+    "    return pixels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2f06427e-157f-42d2-a332-e8fc69fb7d15",
+   "metadata": {},
+   "source": [
+    "We use voxel traversal on every line segment to fill the polygon boundary."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dc732d7e-91a6-4f0a-811a-cc9cc92a1df8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x1600 with 12 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "polygon_pixels = {}\n",
+    "for test_polygon_name, vertices in polygon_test_cases.items():\n",
+    "    offset_vertices = vertices[1:] + vertices[:1]\n",
+    "\n",
+    "    pixels = set()\n",
+    "    for start_vertex, end_vertex in zip(vertices, offset_vertices):\n",
+    "        pixels.update(voxel_traversal_2d(start_vertex, end_vertex))\n",
+    "\n",
+    "    polygon_pixels[test_polygon_name] = pixels\n",
+    "    \n",
+    "plot_all_polygons(polygon_test_cases, polygon_pixels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "df3d04d1-0b01-451a-b06a-152b7eeaa316",
+   "metadata": {},
+   "source": [
+    "## Scanline Fill Algorithm\n",
+    "\n",
+    "We use the scanline fill algorithm to fill in pixels within the polygon boundary."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29616c05-3a87-4952-a4f6-eb97c958599b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "def scanline_fill(\n",
+    "    vertices: List[Tuple[int,int]], # list of polygon vertices in order (either clockwise or counterclockwise)\n",
+    "    debug: bool = False, # if true, prints diagnostic info for the algorithm  \n",
+    ") -> Set[Tuple[int,int]]:\n",
+    "    \"\"\"Returns all pixels within the interior of a polygon defined by vertices\"\"\"\n",
+    "    \n",
+    "    offset_vertices = vertices[1:] + vertices[:1]\n",
+    "\n",
+    "    if not vertices:\n",
+    "        return set()\n",
+    "    \n",
+    "    if len(vertices) == 1:\n",
+    "        return set(vertices)\n",
+    "\n",
+    "    # Calculate the bounding box for the polygon\n",
+    "    min_y, max_y = min(y for x, y in vertices), max(y for x, y in vertices)\n",
+    "\n",
+    "    filled_pixels = set()\n",
+    "    # Process each horizontal scanline within the bounding box\n",
+    "    for scanline_y in range(min_y, max_y + 1):\n",
+    "        intersection_points = []\n",
+    "\n",
+    "        # Find intersections of the polygon with the current scanline\n",
+    "        for start_vertex, end_vertex in zip(vertices, offset_vertices):\n",
+    "            start_x, start_y = start_vertex\n",
+    "            end_x, end_y = end_vertex\n",
+    "\n",
+    "            if (end_y < scanline_y <= start_y) or (start_y < scanline_y <= end_y):\n",
+    "                # Calculate x-coordinate of intersection\n",
+    "                intersection_x = interpolate_x(start_vertex, end_vertex, scanline_y)\n",
+    "                intersection_points.append(intersection_x)\n",
+    "\n",
+    "        # Fill pixels between pairs of intersections\n",
+    "        if intersection_points:\n",
+    "            intersection_points.sort()\n",
+    "\n",
+    "            filled_pixels_in_row = set()\n",
+    "            for start_x, end_x in zip(\n",
+    "                intersection_points[::2], intersection_points[1::2]\n",
+    "            ):\n",
+    "                start_x, end_x = int(round(start_x)), int(round(end_x))\n",
+    "\n",
+    "                _filled_pixels_in_row = [\n",
+    "                    (x, scanline_y) for x in range(start_x, end_x + 1)\n",
+    "                ]\n",
+    "                filled_pixels_in_row.update(_filled_pixels_in_row)\n",
+    "\n",
+    "            filled_pixels.update(filled_pixels_in_row)\n",
+    "\n",
+    "        if debug:\n",
+    "            print(f\"Scanline y = {scanline_y}, Intersections: {intersection_points}\")\n",
+    "    \n",
+    "    return filled_pixels\n",
+    "\n",
+    "\n",
+    "def interpolate_x(\n",
+    "    start_vertex: Tuple[int, int],\n",
+    "    end_vertex: Tuple[int, int],\n",
+    "    y: int,\n",
+    ") -> float:\n",
+    "    \"\"\"Interpolate x value for a given y along the line segment defined by start_vertex and end_vertex.\"\"\"\n",
+    "    x1, y1 = start_vertex\n",
+    "    x2, y2 = end_vertex\n",
+    "    if y1 == y2:\n",
+    "        # case when there is a horizontal line segment\n",
+    "        raise ValueError(f\"The y value of the 2 vertices should not be the same\")\n",
+    "\n",
+    "    inverse_slope = (x2 - x1) / (y2 - y1)\n",
+    "    interpolated_x = x1 + (y - y1) * inverse_slope\n",
+    "    return interpolated_x\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1c624d9d-75d5-4711-a67c-65b76eec1234",
+   "metadata": {},
+   "source": [
+    "We use scanline fill on every set of vertices. Notice that the scanline can fill parts of the boundary as well, but it doesn't capture the entire boundary."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d3eb282d-6262-4011-829e-cf533c04a3ee",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x1600 with 12 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "polygon_pixels = {}\n",
+    "for test_polygon_name, vertices in polygon_test_cases.items():\n",
+    "    polygon_pixels[test_polygon_name] = scanline_fill(vertices)\n",
+    "    \n",
+    "plot_all_polygons(polygon_test_cases, polygon_pixels)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "036fc223-fd82-40c3-84c7-137f856b9400",
+   "metadata": {},
+   "source": [
+    "## Combining Voxel Traversal and Scanline Fill for our Polygon Fill Algorithm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc62c0f2-cd69-49c8-93f0-902d42f54eaa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "\n",
+    "def polygon_fill(\n",
+    "    vertices_df: Union[pd.DataFrame,pl.DataFrame], # dataframe with x_col and y_col for the polygon vertices\n",
+    "    x_col: str = \"x\", \n",
+    "    y_col: str = \"y\",\n",
+    "    debug: bool = False, # if true, prints diagnostic info for both voxel traversal and scanline fill algorithms\n",
+    ") -> Set[Tuple[int,int]]:\n",
+    "    \"\"\"\n",
+    "    Returns pixels that intersect a polygon\n",
+    "    This uses voxel traversal to fill the boundary, and scanline fill for the interior. All coordinates are assumed to be nonnegative integers        \n",
+    "    \"\"\"\n",
+    "\n",
+    "    vertices = list(zip(vertices_df[x_col].to_list(), vertices_df[y_col].to_list()))\n",
+    "    offset_vertices = vertices[1:] + vertices[:1]\n",
+    "\n",
+    "    polygon_pixels = set()\n",
+    "    for start_vertex, end_vertex in zip(vertices, offset_vertices):\n",
+    "        polygon_pixels.update(voxel_traversal_2d(start_vertex, end_vertex, debug))\n",
+    "        \n",
+    "    polygon_pixels.update(scanline_fill(vertices, debug))\n",
+    "\n",
+    "    return polygon_pixels"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "eeb3aa28-40d6-4942-91af-3bb86fc56c6a",
+   "metadata": {},
+   "source": [
+    "By using both algorithms, we can fill all the pixels per polygon."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e4836507-2070-41f9-b1c4-6f2f1b2dd665",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x1600 with 12 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "polygon_pixels = {}\n",
+    "for test_polygon_name, vertices in polygon_test_cases.items():\n",
+    "    vertices_df = pd.DataFrame(vertices, columns=[\"x\", \"y\"])\n",
+    "    polygon_pixels[test_polygon_name] = polygon_fill(vertices_df)\n",
+    "    \n",
+    "plot_all_polygons(polygon_test_cases, polygon_pixels)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "python3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

From ba59e00d853e18dcf947acf7a4639742b3482507 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Mon, 5 Aug 2024 20:06:52 +0800
Subject: [PATCH 05/21] change 15_polygon_fill functions to be exporti instead
 of export

---
 geowrangler/gridding_utils/polygon_fill.py | 2 +-
 notebooks/15_polygon_fill.ipynb            | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/geowrangler/gridding_utils/polygon_fill.py b/geowrangler/gridding_utils/polygon_fill.py
index 002b9ba..8c00c43 100644
--- a/geowrangler/gridding_utils/polygon_fill.py
+++ b/geowrangler/gridding_utils/polygon_fill.py
@@ -1,7 +1,7 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../../notebooks/15_polygon_fill.ipynb.
 
 # %% auto 0
-__all__ = ['EPSILON', 'voxel_traversal_2d', 'scanline_fill', 'interpolate_x', 'polygon_fill']
+__all__ = []
 
 # %% ../../notebooks/15_polygon_fill.ipynb 3
 from typing import List, Tuple, Set, Optional, Dict, Union
diff --git a/notebooks/15_polygon_fill.ipynb b/notebooks/15_polygon_fill.ipynb
index d41afd7..168a9af 100644
--- a/notebooks/15_polygon_fill.ipynb
+++ b/notebooks/15_polygon_fill.ipynb
@@ -198,7 +198,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#| export\n",
+    "#| exporti\n",
     "\n",
     "# epsilon is a constant for correcting near-misses in voxel traversal\n",
     "EPSILON = 1e-14\n",
@@ -406,7 +406,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#| export\n",
+    "#| exporti\n",
     "def scanline_fill(\n",
     "    vertices: List[Tuple[int,int]], # list of polygon vertices in order (either clockwise or counterclockwise)\n",
     "    debug: bool = False, # if true, prints diagnostic info for the algorithm  \n",
@@ -527,7 +527,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#| export\n",
+    "#| exporti\n",
     "\n",
     "def polygon_fill(\n",
     "    vertices_df: Union[pd.DataFrame,pl.DataFrame], # dataframe with x_col and y_col for the polygon vertices\n",

From fcdf35190beaa109800ce69b46bcac94b3478712 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Mon, 5 Aug 2024 22:19:41 +0800
Subject: [PATCH 06/21] add FastBingTileGenerator to grids.py and grids
 tutorial

---
 geowrangler/_modidx.py                     |  28 +-
 geowrangler/gridding_utils/polygon_fill.py |   9 +-
 geowrangler/grids.py                       | 247 +++++++-
 notebooks/00_grids.ipynb                   | 276 ++++++++-
 notebooks/15_polygon_fill.ipynb            |  13 +-
 notebooks/tutorial.grids.ipynb             | 637 +++++++++++++--------
 6 files changed, 929 insertions(+), 281 deletions(-)

diff --git a/geowrangler/_modidx.py b/geowrangler/_modidx.py
index 34c958a..e0af935 100644
--- a/geowrangler/_modidx.py
+++ b/geowrangler/_modidx.py
@@ -111,12 +111,12 @@
                                                                                                                     'geowrangler/distance_zonal_stats.py')},
             'geowrangler.gridding_utils.polygon_fill': { 'geowrangler.gridding_utils.polygon_fill.interpolate_x': ( 'polygon_fill.html#interpolate_x',
                                                                                                                     'geowrangler/gridding_utils/polygon_fill.py'),
-                                                         'geowrangler.gridding_utils.polygon_fill.polygon_fill': ( 'polygon_fill.html#polygon_fill',
-                                                                                                                   'geowrangler/gridding_utils/polygon_fill.py'),
                                                          'geowrangler.gridding_utils.polygon_fill.scanline_fill': ( 'polygon_fill.html#scanline_fill',
                                                                                                                     'geowrangler/gridding_utils/polygon_fill.py'),
                                                          'geowrangler.gridding_utils.polygon_fill.voxel_traversal_2d': ( 'polygon_fill.html#voxel_traversal_2d',
-                                                                                                                         'geowrangler/gridding_utils/polygon_fill.py')},
+                                                                                                                         'geowrangler/gridding_utils/polygon_fill.py'),
+                                                         'geowrangler.gridding_utils.polygon_fill.voxel_traversal_scanline_fill': ( 'polygon_fill.html#voxel_traversal_scanline_fill',
+                                                                                                                                    'geowrangler/gridding_utils/polygon_fill.py')},
             'geowrangler.grids': { 'geowrangler.grids.BingTileGridGenerator': ('grids.html#bingtilegridgenerator', 'geowrangler/grids.py'),
                                    'geowrangler.grids.BingTileGridGenerator.__init__': ( 'grids.html#bingtilegridgenerator.__init__',
                                                                                          'geowrangler/grids.py'),
@@ -130,6 +130,28 @@
                                                                                                       'geowrangler/grids.py'),
                                    'geowrangler.grids.BingTileGridGenerator.tile_to_polygon': ( 'grids.html#bingtilegridgenerator.tile_to_polygon',
                                                                                                 'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator': ( 'grids.html#fastbingtilegridgenerator',
+                                                                                    'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator.__init__': ( 'grids.html#fastbingtilegridgenerator.__init__',
+                                                                                             'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._lat_to_ytile': ( 'grids.html#fastbingtilegridgenerator._lat_to_ytile',
+                                                                                                  'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._latlng_to_xy': ( 'grids.html#fastbingtilegridgenerator._latlng_to_xy',
+                                                                                                  'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._lng_to_xtile': ( 'grids.html#fastbingtilegridgenerator._lng_to_xtile',
+                                                                                                  'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._polygons_to_vertices': ( 'grids.html#fastbingtilegridgenerator._polygons_to_vertices',
+                                                                                                          'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._xtile_to_lng': ( 'grids.html#fastbingtilegridgenerator._xtile_to_lng',
+                                                                                                  'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._xy_to_bbox': ( 'grids.html#fastbingtilegridgenerator._xy_to_bbox',
+                                                                                                'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._xyz_to_quadkey': ( 'grids.html#fastbingtilegridgenerator._xyz_to_quadkey',
+                                                                                                    'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator._ytile_to_lat': ( 'grids.html#fastbingtilegridgenerator._ytile_to_lat',
+                                                                                                  'geowrangler/grids.py'),
+                                   'geowrangler.grids.FastBingTileGridGenerator.generate_grid': ( 'grids.html#fastbingtilegridgenerator.generate_grid',
+                                                                                                  'geowrangler/grids.py'),
                                    'geowrangler.grids.H3GridGenerator': ('grids.html#h3gridgenerator', 'geowrangler/grids.py'),
                                    'geowrangler.grids.H3GridGenerator.__init__': ( 'grids.html#h3gridgenerator.__init__',
                                                                                    'geowrangler/grids.py'),
diff --git a/geowrangler/gridding_utils/polygon_fill.py b/geowrangler/gridding_utils/polygon_fill.py
index 8c00c43..330f385 100644
--- a/geowrangler/gridding_utils/polygon_fill.py
+++ b/geowrangler/gridding_utils/polygon_fill.py
@@ -29,10 +29,10 @@ def voxel_traversal_2d(
     direction_x = 1 if x2 > x1 else -1
     direction_y = 1 if y2 > y1 else -1
 
+    # Single point
     if (x1 == x2) and (y1 == y2):
-        raise ValueError(
-            f"start_vertex {start_vertex} and end_vertex {end_vertex} are the same"
-        )
+        pixels = [(x1, y1)]
+        return pixels
 
     # Vertical line
     elif x1 == x2:
@@ -236,7 +236,7 @@ def interpolate_x(
     return interpolated_x
 
 # %% ../../notebooks/15_polygon_fill.ipynb 17
-def polygon_fill(
+def voxel_traversal_scanline_fill(
     vertices_df: Union[
         pd.DataFrame, pl.DataFrame
     ],  # dataframe with x_col and y_col for the polygon vertices
@@ -253,6 +253,7 @@ def polygon_fill(
     offset_vertices = vertices[1:] + vertices[:1]
 
     polygon_pixels = set()
+
     for start_vertex, end_vertex in zip(vertices, offset_vertices):
         polygon_pixels.update(voxel_traversal_2d(start_vertex, end_vertex, debug))
 
diff --git a/geowrangler/grids.py b/geowrangler/grids.py
index 4a9c9b6..688808b 100644
--- a/geowrangler/grids.py
+++ b/geowrangler/grids.py
@@ -1,25 +1,29 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../notebooks/00_grids.ipynb.
 
 # %% auto 0
-__all__ = ['SquareGridBoundary', 'SquareGridGenerator', 'H3GridGenerator', 'BingTileGridGenerator']
+__all__ = ['SquareGridBoundary', 'SquareGridGenerator', 'H3GridGenerator', 'BingTileGridGenerator', 'FastBingTileGridGenerator']
 
 # %% ../notebooks/00_grids.ipynb 5
 import logging
 from functools import reduce
-from typing import List, Tuple, Union
+from typing import List, Tuple, Union, Optional
 
 import h3
 import morecantile
 import numpy as np
 import pandas as pd
+import polars as pl
 from fastcore.all import defaults, parallel
 from fastcore.basics import patch
-from geopandas import GeoDataFrame
+from geopandas import GeoDataFrame, GeoSeries
 from pandas import DataFrame
 from pyproj import Transformer
+from shapely import box
 from shapely.geometry import Polygon, shape
 from shapely.prepared import prep
 
+from geowrangler.gridding_utils.polygon_fill import voxel_traversal_scanline_fill
+
 logger = logging.getLogger(__name__)
 
 # %% ../notebooks/00_grids.ipynb 6
@@ -348,3 +352,240 @@ def generate_grid_join(
         return df
 
     return tiles_gdf.to_crs(gdf.crs)
+
+# %% ../notebooks/00_grids.ipynb 21
+class FastBingTileGridGenerator:
+    EPSILON = 1e-14
+    PIXEL_DTYPE = pl.UInt32
+    SUBPOLYGON_ID_COL = "__subpolygon_id__"
+    MAX_ZOOM = 31
+
+    def __init__(
+        self,
+        zoom_level: int,  # Zoom level of tile. See: https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system for more info
+        return_geometry: bool = True,  # If geometry should be returned. Setting this to false will only return quadkeys
+        add_xyz_cols: bool = False,  # If quadkey should be converted to their xy values.
+    ):
+        self.zoom_level = zoom_level
+        self.return_geometry = return_geometry
+        self.add_xyz_cols = add_xyz_cols
+
+        if self.zoom_level > self.MAX_ZOOM:
+            raise NotImplementedError(
+                f"Maximum allowed zoom level is {self.MAX_ZOOM}. Input was {self.zoom_level}"
+            )
+
+    def generate_grid(
+        self,
+        aoi_gdf: GeoDataFrame,
+        unique_id_col: Optional[
+            str
+        ] = None,  # the ids under this column will be preserved in the output tiles
+    ) -> Union[GeoDataFrame, pd.DataFrame]:
+
+        vertices = self._polygons_to_vertices(aoi_gdf, unique_id_col)
+        vertices = self._latlng_to_xy(vertices, lat_col="y", lng_col="x")
+
+        if unique_id_col is not None:
+            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
+        else:
+            id_cols = [self.SUBPOLYGON_ID_COL]
+
+        polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()
+
+        tiles_in_geom = set()
+        for polygon_id in polygon_ids:
+            if len(id_cols) == 2:
+                subpolygon_id, unique_id = polygon_id
+                filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (
+                    pl.col(unique_id_col) == unique_id
+                )
+                poly_vertices = vertices.filter(filter_expr)
+            else:
+                subpolygon_id = polygon_id[0]
+                filter_expr = pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id
+                poly_vertices = vertices.filter(filter_expr)
+
+            poly_vertices = poly_vertices.unique(maintain_order=True)
+            _tiles_in_geom = voxel_traversal_scanline_fill(
+                poly_vertices, x_col="x", y_col="y"
+            )
+
+            if len(id_cols) == 2:
+                _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]
+
+            tiles_in_geom.update(_tiles_in_geom)
+
+        schema = {"x": self.PIXEL_DTYPE, "y": self.PIXEL_DTYPE}
+        if len(id_cols) == 2:
+            schema[unique_id_col] = vertices[unique_id_col].dtype
+
+        tiles_in_geom = pl.from_records(
+            data=list(tiles_in_geom),
+            orient="row",
+            schema=schema,
+        )
+
+        quadkey_expr = self._xyz_to_quadkey(
+            pl.col("x"),
+            pl.col("y"),
+        )
+        tiles_in_geom = tiles_in_geom.with_columns(quadkey=quadkey_expr)
+
+        if self.return_geometry:
+            bboxes = self._xy_to_bbox(tiles_in_geom, "x", "y")
+
+            # use vectorized version in shapely 2.0
+            bboxes = box(
+                bboxes["minx"].to_list(),
+                bboxes["miny"].to_list(),
+                bboxes["maxx"].to_list(),
+                bboxes["maxy"].to_list(),
+            )
+            bboxes = GeoSeries(bboxes, crs="epsg:4326")
+
+        if not self.add_xyz_cols:
+            tiles_in_geom = tiles_in_geom.drop(["x", "y"])
+        else:
+            tiles_in_geom = tiles_in_geom.with_columns(z=pl.lit(self.zoom_level))
+            column_order = ["x", "y", "z", "quadkey"]
+            if unique_id_col is not None:
+                column_order += [unique_id_col]
+            assert set(tiles_in_geom.columns) == set(column_order)
+            tiles_in_geom = tiles_in_geom.select(column_order)
+
+        if self.return_geometry:
+            tiles_in_geom = GeoDataFrame(tiles_in_geom.to_pandas(), geometry=bboxes)
+        else:
+            tiles_in_geom = tiles_in_geom.to_pandas()
+
+        return tiles_in_geom
+
+    def _lat_to_ytile(self, lat: pl.Expr) -> pl.Expr:
+        logtan = pl.Expr.log(pl.Expr.tan((np.pi / 4) + (pl.Expr.radians(lat) / 2)))
+
+        y = 0.5 - (logtan / (2 * np.pi))
+
+        power_of_2 = int(np.power(2, self.zoom_level))
+
+        # To address loss of precision in round-tripping between tile
+        # and lng/lat, points within EPSILON of the right side of a tile
+        # are counted in the next tile over.
+        y_pixel_coord = pl.Expr.floor((y + self.EPSILON) * power_of_2)
+
+        ytile = (
+            pl.when(y <= 0)
+            .then(pl.lit(0))
+            .when(y >= 1)
+            .then(pl.lit(power_of_2 - 1))
+            .otherwise(y_pixel_coord)
+            .cast(self.PIXEL_DTYPE)
+        )
+
+        return ytile
+
+    def _lng_to_xtile(self, lng: pl.Expr) -> pl.Expr:
+        x = 0.5 + (lng / 360.0)
+        power_of_2 = int(np.power(2, self.zoom_level))
+
+        x_pixel_coord = pl.Expr.floor((x + self.EPSILON) * power_of_2)
+
+        xtile = (
+            pl.when(x <= 0)
+            .then(pl.lit(0))
+            .when(x >= 1)
+            .then(pl.lit(power_of_2 - 1))
+            .otherwise(x_pixel_coord)
+            .cast(self.PIXEL_DTYPE)
+        )
+
+        return xtile
+
+    def _latlng_to_xy(
+        self,
+        df: pl.DataFrame,
+        lat_col: str,
+        lng_col: str,
+    ) -> pl.DataFrame:
+        xy_df = df.with_columns(
+            x=self._lng_to_xtile(pl.col(lng_col)),
+            y=self._lat_to_ytile(pl.col(lat_col)),
+        )
+
+        return xy_df
+
+    def _xtile_to_lng(self, xtile: pl.Expr) -> pl.Expr:
+        """This gets the longitude of the upper left corner of the tile"""
+        power_of_2 = int(np.power(2, self.zoom_level))
+        lng_deg = (xtile / power_of_2) * 360.0 - 180.0
+        return lng_deg
+
+    def _ytile_to_lat(self, ytile: pl.Expr) -> pl.Expr:
+        """This gets the latitude of the upper left corner of the tile"""
+        power_of_2 = int(np.power(2, self.zoom_level))
+        y = ytile / power_of_2
+        lat_rad = pl.Expr.arctan(pl.Expr.sinh(np.pi * (1 - 2 * y)))
+        lat_deg = pl.Expr.degrees(lat_rad)
+        return lat_deg
+
+    def _xy_to_bbox(
+        self,
+        df: pl.DataFrame,
+        xtile_col: str,
+        ytile_col: str,
+    ) -> pl.DataFrame:
+
+        upper_left_lng = self._xtile_to_lng(pl.col(xtile_col))
+        upper_left_lat = self._ytile_to_lat(pl.col(ytile_col))
+        lower_right_lng = self._xtile_to_lng(pl.col(xtile_col) + 1)
+        lower_right_lat = self._ytile_to_lat(pl.col(ytile_col) + 1)
+
+        bbox_df = df.select(
+            minx=upper_left_lng,
+            miny=lower_right_lat,
+            maxx=lower_right_lng,
+            maxy=upper_left_lat,
+        )
+
+        return bbox_df
+
+    def _polygons_to_vertices(
+        self, polys_gdf: GeoDataFrame, unique_id_col: Optional[str] = None
+    ) -> pl.DataFrame:
+
+        if unique_id_col is not None:
+            duplicates_bool = polys_gdf[unique_id_col].duplicated()
+            if duplicates_bool.any():
+                raise ValueError(
+                    f"""{unique_id_col} is not unique!
+                    Found {duplicates_bool.sum():,} duplicates"""
+                )
+            polys_gdf = polys_gdf.set_index(unique_id_col)
+
+        polys_gdf = polys_gdf.explode(index_parts=True)
+
+        is_poly_bool = polys_gdf.type == "Polygon"
+        if not is_poly_bool.all():
+            raise ValueError(
+                f"""
+            All geometries should be polygons or multipolygons but found
+            {is_poly_bool.sum():,} after exploding the geodatarame"""
+            )
+
+        polys_gdf.index.names = [unique_id_col, self.SUBPOLYGON_ID_COL]
+        vertices_df = polys_gdf.get_coordinates().reset_index()
+        vertices_df = pl.from_pandas(vertices_df)
+
+        return vertices_df
+
+    def _xyz_to_quadkey(self, x: pl.Expr, y: pl.Expr) -> pl.Expr:
+
+        # Create expressions for the quadkey digit at each bit position
+        quadkey_digit_exprs = [
+            ((x // (2**i) % 2) | ((y // (2**i) % 2) * 2))
+            for i in reversed(range(self.zoom_level))
+        ]
+
+        quadkey = pl.concat_str(quadkey_digit_exprs)
+
+        return quadkey
diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index 99e72eb..dd39e6f 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -62,20 +62,24 @@
     "#| exporti\n",
     "import logging\n",
     "from functools import reduce\n",
-    "from typing import List, Tuple, Union\n",
+    "from typing import List, Tuple, Union, Optional\n",
     "\n",
     "import h3\n",
     "import morecantile\n",
     "import numpy as np\n",
     "import pandas as pd\n",
+    "import polars as pl\n",
     "from fastcore.all import defaults, parallel\n",
     "from fastcore.basics import patch\n",
-    "from geopandas import GeoDataFrame\n",
+    "from geopandas import GeoDataFrame, GeoSeries\n",
     "from pandas import DataFrame\n",
     "from pyproj import Transformer\n",
+    "from shapely import box\n",
     "from shapely.geometry import Polygon, shape\n",
     "from shapely.prepared import prep\n",
     "\n",
+    "from geowrangler.gridding_utils.polygon_fill import voxel_traversal_scanline_fill\n",
+    "\n",
     "logger = logging.getLogger(__name__)"
    ]
   },
@@ -513,25 +517,267 @@
     "\n",
     "    return tiles_gdf.to_crs(gdf.crs)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## `FastBingTileGridGenerator`\n",
+    "\n",
+    "This is significantly faster than `BingTileGridGenerator`\n",
+    "\n",
+    "This uses these optimizations to speed up grid generation:\n",
+    "1. Vectorized Translation Functions: Functions that translate between lat,lon and web mercator x,y are written in polars.\n",
+    "2. Voxel Traversal and Scanline Fill Algorithms: Faster alternative to finding all pixels within a polygon without using the point in polygon operation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
+    "class FastBingTileGridGenerator:\n",
+    "    EPSILON = 1e-14\n",
+    "    PIXEL_DTYPE = pl.UInt32\n",
+    "    SUBPOLYGON_ID_COL = \"__subpolygon_id__\"\n",
+    "    MAX_ZOOM = 31\n",
+    "\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        zoom_level: int,  # Zoom level of tile. See: https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system for more info\n",
+    "        return_geometry: bool = True,  # If geometry should be returned. Setting this to false will only return quadkeys\n",
+    "        add_xyz_cols: bool = False,  # If quadkey should be converted to their xy values.\n",
+    "    ):\n",
+    "        self.zoom_level = zoom_level\n",
+    "        self.return_geometry = return_geometry\n",
+    "        self.add_xyz_cols = add_xyz_cols\n",
+    "\n",
+    "        if self.zoom_level > self.MAX_ZOOM:\n",
+    "            raise NotImplementedError(f\"Maximum allowed zoom level is {self.MAX_ZOOM}. Input was {self.zoom_level}\")\n",
+    "\n",
+    "    def generate_grid(\n",
+    "        self,\n",
+    "        aoi_gdf: GeoDataFrame,\n",
+    "        unique_id_col: Optional[str] = None, # the ids under this column will be preserved in the output tiles\n",
+    "    ) -> Union[GeoDataFrame, pd.DataFrame]:\n",
+    "        \n",
+    "        vertices = self._polygons_to_vertices(aoi_gdf, unique_id_col)\n",
+    "        vertices = self._latlng_to_xy(vertices, lat_col=\"y\", lng_col=\"x\")\n",
+    "    \n",
+    "        if unique_id_col is not None:\n",
+    "            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
+    "        else:\n",
+    "            id_cols = [self.SUBPOLYGON_ID_COL]\n",
+    "    \n",
+    "        polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()\n",
+    "    \n",
+    "        tiles_in_geom = set()\n",
+    "        for polygon_id in polygon_ids:\n",
+    "            if len(id_cols) == 2:\n",
+    "                subpolygon_id, unique_id = polygon_id\n",
+    "                filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (\n",
+    "                    pl.col(unique_id_col) == unique_id\n",
+    "                )\n",
+    "                poly_vertices = vertices.filter(filter_expr)\n",
+    "            else:\n",
+    "                subpolygon_id = polygon_id[0]\n",
+    "                filter_expr = pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id\n",
+    "                poly_vertices = vertices.filter(filter_expr)\n",
+    "    \n",
+    "            poly_vertices = poly_vertices.unique(maintain_order=True)\n",
+    "            _tiles_in_geom = voxel_traversal_scanline_fill(poly_vertices, x_col=\"x\", y_col=\"y\")\n",
+    "    \n",
+    "            if len(id_cols) == 2:\n",
+    "                _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]\n",
+    "    \n",
+    "            tiles_in_geom.update(_tiles_in_geom)\n",
+    "    \n",
+    "        schema = {\"x\": self.PIXEL_DTYPE, \"y\": self.PIXEL_DTYPE}\n",
+    "        if len(id_cols) == 2:\n",
+    "            schema[unique_id_col] = vertices[unique_id_col].dtype\n",
+    "    \n",
+    "        tiles_in_geom = pl.from_records(\n",
+    "            data=list(tiles_in_geom),\n",
+    "            orient=\"row\",\n",
+    "            schema=schema,\n",
+    "        )\n",
+    "    \n",
+    "        quadkey_expr = self._xyz_to_quadkey(\n",
+    "            pl.col(\"x\"),\n",
+    "            pl.col(\"y\"),\n",
+    "        )\n",
+    "        tiles_in_geom = tiles_in_geom.with_columns(quadkey=quadkey_expr)\n",
+    "\n",
+    "        if self.return_geometry:\n",
+    "            bboxes = self._xy_to_bbox(tiles_in_geom, \"x\", \"y\")\n",
+    "        \n",
+    "            # use vectorized version in shapely 2.0\n",
+    "            bboxes = box(\n",
+    "                bboxes[\"minx\"].to_list(),\n",
+    "                bboxes[\"miny\"].to_list(),\n",
+    "                bboxes[\"maxx\"].to_list(),\n",
+    "                bboxes[\"maxy\"].to_list(),\n",
+    "            )\n",
+    "            bboxes = GeoSeries(bboxes, crs=\"epsg:4326\")\n",
+    "\n",
+    "        if not self.add_xyz_cols:\n",
+    "            tiles_in_geom = tiles_in_geom.drop([\"x\",\"y\"])\n",
+    "        else:\n",
+    "            tiles_in_geom = tiles_in_geom.with_columns(z = pl.lit(self.zoom_level))\n",
+    "            column_order = [\"x\",\"y\",\"z\",\"quadkey\"]\n",
+    "            if unique_id_col is not None:\n",
+    "                column_order += [unique_id_col]\n",
+    "            assert set(tiles_in_geom.columns) == set(column_order)\n",
+    "            tiles_in_geom = tiles_in_geom.select(column_order)\n",
+    "\n",
+    "        if self.return_geometry:\n",
+    "            tiles_in_geom = GeoDataFrame(tiles_in_geom.to_pandas(), geometry=bboxes)\n",
+    "        else:\n",
+    "            tiles_in_geom = tiles_in_geom.to_pandas()\n",
+    "    \n",
+    "        return tiles_in_geom\n",
+    "\n",
+    "    def _lat_to_ytile(self, lat: pl.Expr) -> pl.Expr:\n",
+    "        logtan = pl.Expr.log(pl.Expr.tan((np.pi / 4) + (pl.Expr.radians(lat) / 2)))\n",
+    "    \n",
+    "        y = 0.5 - (logtan / (2 * np.pi))\n",
+    "    \n",
+    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "    \n",
+    "        # To address loss of precision in round-tripping between tile\n",
+    "        # and lng/lat, points within EPSILON of the right side of a tile\n",
+    "        # are counted in the next tile over.\n",
+    "        y_pixel_coord = pl.Expr.floor((y + self.EPSILON) * power_of_2)\n",
+    "    \n",
+    "        ytile = (\n",
+    "            pl.when(y <= 0)\n",
+    "            .then(pl.lit(0))\n",
+    "            .when(y >= 1)\n",
+    "            .then(pl.lit(power_of_2 - 1))\n",
+    "            .otherwise(y_pixel_coord)\n",
+    "            .cast(self.PIXEL_DTYPE)\n",
+    "        )\n",
+    "    \n",
+    "        return ytile\n",
+    "\n",
+    "    def _lng_to_xtile(self, lng: pl.Expr) -> pl.Expr:\n",
+    "        x = 0.5 + (lng / 360.0)\n",
+    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "    \n",
+    "        x_pixel_coord = pl.Expr.floor((x + self.EPSILON) * power_of_2)\n",
+    "    \n",
+    "        xtile = (\n",
+    "            pl.when(x <= 0)\n",
+    "            .then(pl.lit(0))\n",
+    "            .when(x >= 1)\n",
+    "            .then(pl.lit(power_of_2 - 1))\n",
+    "            .otherwise(x_pixel_coord)\n",
+    "            .cast(self.PIXEL_DTYPE)\n",
+    "        )\n",
+    "    \n",
+    "        return xtile\n",
+    "\n",
+    "    def _latlng_to_xy(\n",
+    "        self,\n",
+    "        df: pl.DataFrame,\n",
+    "        lat_col: str,\n",
+    "        lng_col: str,\n",
+    "    ) -> pl.DataFrame:\n",
+    "        xy_df = df.with_columns(\n",
+    "            x=self._lng_to_xtile(pl.col(lng_col)),\n",
+    "            y=self._lat_to_ytile(pl.col(lat_col)),\n",
+    "        )\n",
+    "    \n",
+    "        return xy_df\n",
+    "\n",
+    "    def _xtile_to_lng(self, xtile: pl.Expr) -> pl.Expr:\n",
+    "        \"\"\"This gets the longitude of the upper left corner of the tile\"\"\"\n",
+    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "        lng_deg = (xtile / power_of_2) * 360.0 - 180.0\n",
+    "        return lng_deg\n",
+    "    \n",
+    "    \n",
+    "    def _ytile_to_lat(self, ytile: pl.Expr) -> pl.Expr:\n",
+    "        \"\"\"This gets the latitude of the upper left corner of the tile\"\"\"\n",
+    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "        y = ytile / power_of_2\n",
+    "        lat_rad = pl.Expr.arctan(pl.Expr.sinh(np.pi * (1 - 2 * y)))\n",
+    "        lat_deg = pl.Expr.degrees(lat_rad)\n",
+    "        return lat_deg\n",
+    "    \n",
+    "    \n",
+    "    def _xy_to_bbox(\n",
+    "        self,\n",
+    "        df: pl.DataFrame,\n",
+    "        xtile_col: str,\n",
+    "        ytile_col: str,\n",
+    "    ) -> pl.DataFrame:\n",
+    "    \n",
+    "        upper_left_lng = self._xtile_to_lng(pl.col(xtile_col))\n",
+    "        upper_left_lat = self._ytile_to_lat(pl.col(ytile_col))\n",
+    "        lower_right_lng = self._xtile_to_lng(pl.col(xtile_col) + 1)\n",
+    "        lower_right_lat = self._ytile_to_lat(pl.col(ytile_col) + 1)\n",
+    "    \n",
+    "        bbox_df = df.select(\n",
+    "            minx=upper_left_lng,\n",
+    "            miny=lower_right_lat,\n",
+    "            maxx=lower_right_lng,\n",
+    "            maxy=upper_left_lat,\n",
+    "        )\n",
+    "    \n",
+    "        return bbox_df\n",
+    "\n",
+    "    def _polygons_to_vertices(\n",
+    "        self,\n",
+    "        polys_gdf: GeoDataFrame, \n",
+    "        unique_id_col: Optional[str] = None\n",
+    "    ) -> pl.DataFrame:\n",
+    "        \n",
+    "        if unique_id_col is not None:\n",
+    "            duplicates_bool = polys_gdf[unique_id_col].duplicated()\n",
+    "            if duplicates_bool.any():\n",
+    "                raise ValueError(\n",
+    "                    f\"\"\"{unique_id_col} is not unique!\n",
+    "                    Found {duplicates_bool.sum():,} duplicates\"\"\"\n",
+    "                )\n",
+    "            polys_gdf = polys_gdf.set_index(unique_id_col)\n",
+    "    \n",
+    "        polys_gdf = polys_gdf.explode(index_parts=True)\n",
+    "    \n",
+    "        is_poly_bool = polys_gdf.type == \"Polygon\"\n",
+    "        if not is_poly_bool.all():\n",
+    "            raise ValueError(\n",
+    "                f\"\"\"\n",
+    "            All geometries should be polygons or multipolygons but found\n",
+    "            {is_poly_bool.sum():,} after exploding the geodatarame\"\"\"\n",
+    "            )\n",
+    "    \n",
+    "        polys_gdf.index.names = [unique_id_col, self.SUBPOLYGON_ID_COL]\n",
+    "        vertices_df = polys_gdf.get_coordinates().reset_index()\n",
+    "        vertices_df = pl.from_pandas(vertices_df)\n",
+    "    \n",
+    "        return vertices_df\n",
+    "\n",
+    "    def _xyz_to_quadkey(self, x: pl.Expr, y: pl.Expr) -> pl.Expr:\n",
+    "\n",
+    "        # Create expressions for the quadkey digit at each bit position\n",
+    "        quadkey_digit_exprs = [\n",
+    "            ((x // (2**i) % 2) | ((y // (2**i) % 2) * 2)) for i in reversed(range(self.zoom_level))\n",
+    "        ]\n",
+    "    \n",
+    "        quadkey = pl.concat_str(quadkey_digit_exprs)\n",
+    "    \n",
+    "        return quadkey"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "python3",
    "language": "python",
    "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.10"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/15_polygon_fill.ipynb b/notebooks/15_polygon_fill.ipynb
index 168a9af..60f3c72 100644
--- a/notebooks/15_polygon_fill.ipynb
+++ b/notebooks/15_polygon_fill.ipynb
@@ -217,10 +217,10 @@
     "    direction_x = 1 if x2 > x1 else -1\n",
     "    direction_y = 1 if y2 > y1 else -1\n",
     "\n",
+    "    # Single point\n",
     "    if (x1 == x2) and (y1 == y2):\n",
-    "        raise ValueError(\n",
-    "            f\"start_vertex {start_vertex} and end_vertex {end_vertex} are the same\"\n",
-    "        )\n",
+    "        pixels = [(x1,y1)]\n",
+    "        return pixels\n",
     "\n",
     "    # Vertical line\n",
     "    elif x1 == x2:\n",
@@ -529,7 +529,7 @@
    "source": [
     "#| exporti\n",
     "\n",
-    "def polygon_fill(\n",
+    "def voxel_traversal_scanline_fill(\n",
     "    vertices_df: Union[pd.DataFrame,pl.DataFrame], # dataframe with x_col and y_col for the polygon vertices\n",
     "    x_col: str = \"x\", \n",
     "    y_col: str = \"y\",\n",
@@ -544,9 +544,10 @@
     "    offset_vertices = vertices[1:] + vertices[:1]\n",
     "\n",
     "    polygon_pixels = set()\n",
+    "\n",
     "    for start_vertex, end_vertex in zip(vertices, offset_vertices):\n",
     "        polygon_pixels.update(voxel_traversal_2d(start_vertex, end_vertex, debug))\n",
-    "        \n",
+    "    \n",
     "    polygon_pixels.update(scanline_fill(vertices, debug))\n",
     "\n",
     "    return polygon_pixels"
@@ -581,7 +582,7 @@
     "polygon_pixels = {}\n",
     "for test_polygon_name, vertices in polygon_test_cases.items():\n",
     "    vertices_df = pd.DataFrame(vertices, columns=[\"x\", \"y\"])\n",
-    "    polygon_pixels[test_polygon_name] = polygon_fill(vertices_df)\n",
+    "    polygon_pixels[test_polygon_name] = voxel_traversal_scanline_fill(vertices_df)\n",
     "    \n",
     "plot_all_polygons(polygon_test_cases, polygon_pixels)"
    ]
diff --git a/notebooks/tutorial.grids.ipynb b/notebooks/tutorial.grids.ipynb
index 6058498..b599b1c 100644
--- a/notebooks/tutorial.grids.ipynb
+++ b/notebooks/tutorial.grids.ipynb
@@ -31,7 +31,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "1b793fa9-69d9-4f8a-8cc3-a3154e84f111",
    "metadata": {},
    "outputs": [],
@@ -42,7 +42,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "699f9813-1436-4348-b044-7163e6c65eda",
    "metadata": {},
    "outputs": [],
@@ -54,7 +54,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "a7b76044-95d4-4570-b145-bacefc2bfc8d",
    "metadata": {},
    "outputs": [],
@@ -67,7 +67,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "a2b36dee-d74a-4771-bb63-124a2686fd82",
    "metadata": {},
    "outputs": [],
@@ -82,9 +82,7 @@
   {
    "cell_type": "markdown",
    "id": "309956b8-3ec5-4223-bca5-bcb70d0e887a",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "source": [
     "## Basic Usage\n",
     "Creating a grid from a geojson file"
@@ -124,7 +122,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "f38a007c-081b-4ee4-aecc-9b116904b95e",
    "metadata": {},
    "outputs": [],
@@ -137,7 +135,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "a30cfacc-bdb2-49d9-88e5-be4c03464a54",
    "metadata": {},
    "outputs": [],
@@ -162,7 +160,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "83809aa8-069f-49fc-95ae-da95166ce2b3",
    "metadata": {},
    "outputs": [],
@@ -180,7 +178,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "465c0d62-317e-4ce5-b5ab-6ca5db92c587",
    "metadata": {},
    "outputs": [
@@ -199,7 +197,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "616984c8-32fa-4de6-b6d5-af71bc805b5c",
    "metadata": {},
    "outputs": [
@@ -284,14 +282,12 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -301,7 +297,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "id": "e4e44e60-a053-444a-8819-2bb6455df5f0",
    "metadata": {},
    "outputs": [
@@ -321,7 +317,7 @@
        "- Prime Meridian: Greenwich"
       ]
      },
-     "execution_count": 12,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -332,7 +328,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "id": "31f0e667-fb1f-48bf-ab71-606bd0c6d689",
    "metadata": {},
    "outputs": [
@@ -342,7 +338,7 @@
        "array([119.7858332,  14.4075257, 122.2429921,  16.5092548])"
       ]
      },
-     "execution_count": 13,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -355,9 +351,7 @@
   {
    "cell_type": "markdown",
    "id": "8a238d37-aede-4786-96ae-1de7c7756085",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "source": [
     "## Square Grid Generator\n",
     "### Creating Grids\n",
@@ -369,25 +363,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "id": "127cf1e6-75b6-43a0-b853-2da7f0e1537f",
    "metadata": {},
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\u001b[0;31mInit signature:\u001b[0m\n",
-      "\u001b[0mgrids\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSquareGridGenerator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mcell_size\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mgrid_projection\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'EPSG:3857'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m    \u001b[0mboundary\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mgeowrangler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrids\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSquareGridBoundary\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
-      "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mDocstring:\u001b[0m      <no docstring>\n",
-      "\u001b[0;31mFile:\u001b[0m           ~/geowrangler/geowrangler/grids.py\n",
-      "\u001b[0;31mType:\u001b[0m           type\n",
-      "\u001b[0;31mSubclasses:\u001b[0m     \n"
-     ]
+     "data": {
+      "text/plain": [
+       "\u001b[0;31mInit signature:\u001b[0m\n",
+       "\u001b[0mgrids\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSquareGridGenerator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mcell_size\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mgrid_projection\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'EPSG:3857'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m    \u001b[0mboundary\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mgeowrangler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrids\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSquareGridBoundary\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
+       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+       "\u001b[0;31mDocstring:\u001b[0m      <no docstring>\n",
+       "\u001b[0;31mFile:\u001b[0m           ~/github-repos/geowrangler/geowrangler/grids.py\n",
+       "\u001b[0;31mType:\u001b[0m           type\n",
+       "\u001b[0;31mSubclasses:\u001b[0m     "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -396,11 +392,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "id": "c173e958-a657-4848-991e-17e035894b32",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "grid_generator5k = grids.SquareGridGenerator(5_000)  # 5 km x 5 km square cells"
@@ -417,7 +411,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "id": "2f193001-319f-446d-b1fc-fa436117bf27",
    "metadata": {},
    "outputs": [
@@ -425,8 +419,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 614 ms, sys: 0 ns, total: 614 ms\n",
-      "Wall time: 617 ms\n"
+      "CPU times: user 360 ms, sys: 47 ms, total: 407 ms\n",
+      "Wall time: 443 ms\n"
      ]
     }
    ],
@@ -438,30 +432,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "id": "0ab950fa-1cf5-4813-8fbe-c15fd2149c80",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<AxesSubplot:>"
+       "<Axes: >"
       ]
      },
-     "execution_count": 17,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdsAAAGdCAYAAABae9lFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAedUlEQVR4nO3de3BU5f3H8c9CYFE0ixhIWA3hJsELoqVMDINIJhmT1HLtWEwZjJbSkV50TGUEWsTLdILY2psM1M4I9iK2jhJHaVGJhpQxYANkaC0iSRNCCIESm2wSJVBzfn/8hm23JGE32W92N3m/Zs4M55znPPuch8N+eHbPs8flOI4jAABgZlCkGwAAQH9H2AIAYIywBQDAGGELAIAxwhYAAGOELQAAxghbAACMEbYAABiLi3QDwqWjo0P19fW68sor5XK5It0cAEA/5ziOWlpa5PV6NWhQ92PXfhO29fX1Sk5OjnQzAAADzPHjx3Xttdd2W6bfhO2VV14p6f9POj4+PsKtAQD0dz6fT8nJyf786U6/CdsLHx3Hx8cTtgCAPhPMV5fcIAUAgDHCFgAAY4QtAADGCFsAAIwRtgAAGCNsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMYIWwAAjBG2AAAY6zdP/QEARLdxq3ZEugl+Nevv6tPXC3lkW1paqrlz58rr9crlcqmoqOiiMocPH9a8efPk8Xg0fPhwzZgxQ7W1tV3WuXXrVrlcroBl2LBhoTYNAICoFHLYtrW1adq0adq4cWOn+6uqqjRr1ixNmTJFJSUlOnTokNauXXvJ8IyPj9fJkyf9y7Fjx0JtGgAAUSnkj5Fzc3OVm5vb5f7vf//7+tKXvqQNGzb4t02cOPGS9bpcLiUlJYXaHAAAol5Yb5Dq6OjQjh07NHnyZGVnZ2v06NFKS0vr9KPm/9Xa2qqUlBQlJydr/vz5+vDDD7st397eLp/PF7AAABCNwhq2p0+fVmtrq9avX6+cnBy9/fbbWrhwoRYtWqTdu3d3eVxqaqpeeOEFvf766/rtb3+rjo4OzZw5U3V1dV0eU1hYKI/H41+Sk5PDeSoAAISNy3Ecp8cHu1zavn27FixYIEmqr6/XNddco7y8PL300kv+cvPmzdPw4cO1bdu2oOo9f/68rr/+euXl5empp57qtEx7e7va29v96z6fT8nJyWpublZ8fHxPTwkAYKS/3Y3s8/nk8XiCyp2wTv1JSEhQXFycbrjhhoDt119/vfbs2RN0PUOGDNGtt96qysrKLsu43W653e4etxUAEH7RFKjRJKwfIw8dOlQzZszQkSNHArZ//PHHSklJCbqezz//XH/96181ZsyYcDYPAICICHlk29raGjDirK6uVkVFhUaOHKmxY8dq5cqVWrx4sWbPnq2MjAzt3LlTb7zxhkpKSvzH3HvvvbrmmmtUWFgoSXryySd12223adKkSWpqatIzzzyjY8eO6Rvf+EbvzxAAgAgLOWzLy8uVkZHhXy8oKJAk5efna+vWrVq4cKE2b96swsJCPfjgg0pNTdWrr76qWbNm+Y+pra3VoEH/GVT/61//0vLly9XQ0KCrrrpK06dP1/vvv3/Rx9EAAMSiXt0gFU1C+aIaAGAjVr6z7esbpHgQAQAAxghbAACM8dQfAEDIYuXj4mjByBYAAGOELQAAxghbAACMEbYAABgjbAEAMEbYAgBgjKk/AIBOMb0nfBjZAgBgjLAFAMAYYQsAgDHCFgAAY4QtAADGCFsAAIwRtgAAGCNsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMZ46g8ADGA82advMLIFAMAYYQsAgDHCFgAAY4QtAADGCFsAAIxxNzIA9HMD9Y7jmvV3RboJfoxsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMaY+gMA/cBAnd4TKxjZAgBgjLAFAMAYYQsAgDHCFgAAY4QtAADGCFsAAIwx9QcAYgTTey4WTU/26Q4jWwAAjBG2AAAYI2wBADBG2AIAYIywBQDAGGELAIAxpv4AMSDWp3zEyvSMvhTrf6d9qT9cP4xsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMaY+gPAXHfTXPrDtI6uxML0nnD3f0/PuT9fBxIjWwAAzBG2AAAYI2wBADBG2AIAYIywBQDAGGELAIAxpv4AQC9Ey/Se/j51JtYxsgUAwBhhCwCAMcIWAABjIYdtaWmp5s6dK6/XK5fLpaKioovKHD58WPPmzZPH49Hw4cM1Y8YM1dbWdlvvK6+8oilTpmjYsGGaOnWq/vjHP4baNAAAolLIYdvW1qZp06Zp48aNne6vqqrSrFmzNGXKFJWUlOjQoUNau3athg0b1mWd77//vvLy8rRs2TIdPHhQCxYs0IIFC/S3v/0t1OYBABB1XI7jOD0+2OXS9u3btWDBAv+2e+65R0OGDNFvfvOboOtZvHix2tra9Oabb/q33Xbbbbrlllu0efPmoOrw+XzyeDxqbm5WfHx80K8NxIJouePVQizcRRst/R8LfTWQhJI7Yf3OtqOjQzt27NDkyZOVnZ2t0aNHKy0trdOPmv9bWVmZsrKyArZlZ2errKysy2Pa29vl8/kCFgAAolFYw/b06dNqbW3V+vXrlZOTo7ffflsLFy7UokWLtHv37i6Pa2hoUGJiYsC2xMRENTQ0dHlMYWGhPB6Pf0lOTg7beQAAEE5hH9lK0vz58/Xwww/rlltu0apVq/TlL3856I+Dg7V69Wo1Nzf7l+PHj4e1fgAAwiWsvyCVkJCguLg43XDDDQHbr7/+eu3Zs6fL45KSknTq1KmAbadOnVJSUlKXx7jdbrnd7t41GACAPhDWke3QoUM1Y8YMHTlyJGD7xx9/rJSUlC6PS09PV3FxccC2d955R+np6eFsHgAAERHyyLa1tVWVlZX+9erqalVUVGjkyJEaO3asVq5cqcWLF2v27NnKyMjQzp079cYbb6ikpMR/zL333qtrrrlGhYWFkqSHHnpId9xxh3784x/rrrvu0ssvv6zy8nI9//zzvT9DAAAiLOSwLS8vV0ZGhn+9oKBAkpSfn6+tW7dq4cKF2rx5swoLC/Xggw8qNTVVr776qmbNmuU/pra2VoMG/WdQPXPmTL300kv6wQ9+oDVr1ui6665TUVGRbrrppt6cGwAEjek9sNSrebbRhHm26M+iJQgsREu4REsfR0t/4NIiNs8WAABcjLAFAMAYYQsAgDHCFgAAY4QtAADGwvoLUgCA/+DOYlzAyBYAAGOELQAAxghbAACMEbYAABgjbAEAMEbYAgBgjKk/USDcP4DOdIOL9bSPu+vLntQZ7vr6g+7OuyfX8kDtR0Q3RrYAABgjbAEAMEbYAgBgjLAFAMAYYQsAgDHCFgAAY0z96USsTx2wmOYyUIX7Woj1ayua0JeIJYxsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMaY+hMintoSPjw1B5cS63+n4b7GEbsY2QIAYIywBQDAGGELAIAxwhYAAGOELQAAxghbAACMMfUnRLE+FaE73Z1bT6cj8NQcAGBkCwCAOcIWAABjhC0AAMYIWwAAjBG2AAAY427kTkTLnbexYqCeNwAEi5EtAADGCFsAAIwRtgAAGCNsAQAwRtgCAGCMsAUAwBhTfxAUpvcA4dXTKYaITYxsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMaY+gMARpjegwsY2QIAYIywBQDAGGELAIAxwhYAAGOELQAAxghbAACMEbYAABgjbAEAMEbYAgBgjLAFAMAYYQsAgDHCFgAAY4QtAADGeOoPAPQCT/ZBMEIe2ZaWlmru3Lnyer1yuVwqKioK2H/ffffJ5XIFLDk5Od3W+fjjj190zJQpU0JtGgAAUSnkkW1bW5umTZumr3/961q0aFGnZXJycrRlyxb/utvtvmS9N954o3bt2vWfhsUx6AYA9A8hJ1pubq5yc3O7LeN2u5WUlBRaQ+LiQj4GAIBYYHKDVElJiUaPHq3U1FStWLFCjY2Nlzzm6NGj8nq9mjBhgpYsWaLa2tpuy7e3t8vn8wUsAABEo7CHbU5Ojn7961+ruLhYTz/9tHbv3q3c3Fx9/vnnXR6TlpamrVu3aufOndq0aZOqq6t1++23q6WlpctjCgsL5fF4/EtycnK4TwUAgLBwOY7j9Phgl0vbt2/XggULuizzj3/8QxMnTtSuXbuUmZkZVL1NTU1KSUnRs88+q2XLlnVapr29Xe3t7f51n8+n5ORkNTc3Kz4+PqTzCJdxq3ZE5HUBRA53Iw9cPp9PHo8nqNwxvwtpwoQJSkhIUGVlZdBhO2LECE2ePFmVlZVdlnG73UHdeAUAvUWgorfMf9Sirq5OjY2NGjNmTNDHtLa2qqqqKqRjAACIViGHbWtrqyoqKlRRUSFJqq6uVkVFhWpra9Xa2qqVK1dq7969qqmpUXFxsebPn69JkyYpOzvbX0dmZqaee+45//ojjzyi3bt3q6amRu+//74WLlyowYMHKy8vr/dnCABAhIX8MXJ5ebkyMjL86wUFBZKk/Px8bdq0SYcOHdKLL76opqYmeb1e3XnnnXrqqacCPvKtqqrSmTNn/Ot1dXXKy8tTY2OjRo0apVmzZmnv3r0aNWpUb84NAICoEHLYzpkzR93dU/XWW29dso6ampqA9ZdffjnUZgAAEDN4EAEAAMYIWwAAjBG2AAAYI2wBADBG2AIAYIywBQDAGGELAIAxwhYAAGOELQAAxghbAACMEbYAABgjbAEAMEbYAgBgjLAFAMAYYQsAgLGQn2eLrtWsv6vLfeNW7ejDlgDoTHf/RgFLjGwBADBG2AIAYIywBQDAGGELAIAxwhYAAGOELQAAxpj600eYFgQAAxcjWwAAjBG2AAAYI2wBADBG2AIAYIywBQDAGGELAIAxpv4AGDC6m2bHE4FgiZEtAADGCFsAAIwRtgAAGCNsAQAwRtgCAGCMsAUAwBhTf6IATwQCgP6NkS0AAMYIWwAAjBG2AAAYI2wBADBG2AIAYIywBQDAGGELAIAxwhYAAGOELQAAxghbAACMEbYAABgjbAEAMEbYAgBgjKf+ABgwunvCFmCJkS0AAMYIWwAAjBG2AAAYI2wBADBG2AIAYIywBQDAGGELAIAxwhYAAGOELQAAxghbAACMEbYAABgjbAEAMMaDCAD0KzxsANGIkS0AAMYIWwAAjBG2AAAYI2wBADAWctiWlpZq7ty58nq9crlcKioqCth/3333yeVyBSw5OTmXrHfjxo0aN26chg0bprS0NH3wwQehNg0AgKgUcti2tbVp2rRp2rhxY5dlcnJydPLkSf+ybdu2buv8/e9/r4KCAq1bt04HDhzQtGnTlJ2drdOnT4faPAAAok7IU39yc3OVm5vbbRm3262kpKSg63z22We1fPly3X///ZKkzZs3a8eOHXrhhRe0atWqUJvYr3Q3jWHcqh192BIAQE+ZfGdbUlKi0aNHKzU1VStWrFBjY2OXZc+dO6f9+/crKyvrP40aNEhZWVkqKyuzaB4AAH0q7D9qkZOTo0WLFmn8+PGqqqrSmjVrlJubq7KyMg0ePPii8mfOnNHnn3+uxMTEgO2JiYn66KOPunyd9vZ2tbe3+9d9Pl/4TgIAgDAKe9jec889/j9PnTpVN998syZOnKiSkhJlZmaG7XUKCwv1xBNPhK0+AACsmE/9mTBhghISElRZWdnp/oSEBA0ePFinTp0K2H7q1Kluv/ddvXq1mpub/cvx48fD2m4AAMLFPGzr6urU2NioMWPGdLp/6NChmj59uoqLi/3bOjo6VFxcrPT09C7rdbvdio+PD1gAAIhGIYdta2urKioqVFFRIUmqrq5WRUWFamtr1draqpUrV2rv3r2qqalRcXGx5s+fr0mTJik7O9tfR2Zmpp577jn/ekFBgX71q1/pxRdf1OHDh7VixQq1tbX5704GACCWhfydbXl5uTIyMvzrBQUFkqT8/Hxt2rRJhw4d0osvvqimpiZ5vV7deeedeuqpp+R2u/3HVFVV6cyZM/71xYsX65///Kcee+wxNTQ06JZbbtHOnTsvumkKAIBY5HIcx4l0I8LB5/PJ4/Goubl5wHykzDxb4GI8Yg99JZTc4beRAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjYf+5RoQXdxwDQOxjZAsAgDHCFgAAY4QtAADGCFsAAIwRtgAAGCNsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMYIWwAAjBG2AAAY46k/Ua5m/V1d7uOJQAAQGxjZAgBgjLAFAMAYYQsAgDHCFgAAY4QtAADGCFsAAIwx9QdAWHQ3TQ0Y6BjZAgBgjLAFAMAYYQsAgDHCFgAAY4QtAADGuBs5hnV19ycPKAhNX95FGwt/N9xVDIQfI1sAAIwRtgAAGCNsAQAwRtgCAGCMsAUAwBhhCwCAMab+9EMWUzdiYcpKLOjp301P+59pPEB0YGQLAIAxwhYAAGOELQAAxghbAACMEbYAABgjbAEAMMbUHyAGMIUHiG2MbAEAMEbYAgBgjLAFAMAYYQsAgDHCFgAAY4QtAADGmPqDoPT102oAoD9hZAsAgDHCFgAAY4QtAADGCFsAAIwRtgAAGCNsAQAw5nIcx4l0I8LB5/PJ4/GoublZ8fHxkW4OghAL04J42g6AroSSO4xsAQAwRtgCAGCMsAUAwBhhCwCAMcIWAABjhC0AAMYIWwAAjBG2AAAYCzlsS0tLNXfuXHm9XrlcLhUVFXVZ9oEHHpDL5dJPf/rTbut8/PHH5XK5ApYpU6aE2jQAAKJSyGHb1tamadOmaePGjd2W2759u/bu3Suv1xtUvTfeeKNOnjzpX/bs2RNq0wAAiEpxoR6Qm5ur3NzcbsucOHFC3/3ud/XWW2/prruC+7m7uLg4JSUlhdocAACiXti/s+3o6NDSpUu1cuVK3XjjjUEfd/ToUXm9Xk2YMEFLlixRbW1tt+Xb29vl8/kCFgAAolHYw/bpp59WXFycHnzwwaCPSUtL09atW7Vz505t2rRJ1dXVuv3229XS0tLlMYWFhfJ4PP4lOTk5HM0HACDsQv4YuTv79+/Xz372Mx04cEAulyvo4/77Y+mbb75ZaWlpSklJ0R/+8ActW7as02NWr16tgoIC/7rP5yNwAQBRKawj2z//+c86ffq0xo4dq7i4OMXFxenYsWP63ve+p3HjxgVdz4gRIzR58mRVVlZ2Wcbtdis+Pj5gAQAgGoV1ZLt06VJlZWUFbMvOztbSpUt1//33B11Pa2urqqqqtHTp0nA2DwCAiAg5bFtbWwNGnNXV1aqoqNDIkSM1duxYXX311QHlhwwZoqSkJKWmpvq3ZWZmauHChfrOd74jSXrkkUc0d+5cpaSkqL6+XuvWrdPgwYOVl5fX0/MCACBqhBy25eXlysjI8K9f+N40Pz9fW7duDaqOqqoqnTlzxr9eV1envLw8NTY2atSoUZo1a5b27t2rUaNGhdo8AACiTshhO2fOHDmOE3T5mpqaS257+eWXQ20GAAAxg99GBgDAWFhvkAJCUbO+818XG7dqR1S0AwDChZEtAADGCFsAAIwRtgAAGCNsAQAwRtgCAGCMu5ERdbg7GEB/w8gWAABjhC0AAMYIWwAAjBG2AAAYI2wBADBG2AIAYIywBQDAGGELAIAxwhYAAGOELQAAxghbAACMEbYAABgjbAEAMEbYAgBgjLAFAMBYv3mereM4kiSfzxfhlgAABoILeXMhf7rTb8K2paVFkpScnBzhlgAABpKWlhZ5PJ5uy7icYCI5BnR0dKi+vl5XXnmlXC5XpJvTKz6fT8nJyTp+/Lji4+Mj3ZyoR3+Fjj4LDf0VuoHQZ47jqKWlRV6vV4MGdf+tbL8Z2Q4aNEjXXnttpJsRVvHx8f32IrVAf4WOPgsN/RW6/t5nlxrRXsANUgAAGCNsAQAwRthGIbfbrXXr1sntdke6KTGB/godfRYa+it09FmgfnODFAAA0YqRLQAAxghbAACMEbYAABgjbAEAMEbYhllpaanmzp0rr9crl8uloqIi/77z58/r0Ucf1dSpUzV8+HB5vV7de++9qq+vD6jjk08+0ZIlSxQfH68RI0Zo2bJlam1t7fZ1z549q29/+9u6+uqrdcUVV+grX/mKTp06ZXGKYRWp/pozZ45cLlfA8sADD1icYtiFo89++MMfaubMmbr88ss1YsSIoF7XcRw99thjGjNmjC677DJlZWXp6NGjYTwzG5Hqr/vuu++iaywnJyeMZ2ajt/1VU1OjZcuWafz48brssss0ceJErVu3TufOnev2dWP1PSxYhG2YtbW1adq0adq4ceNF+z799FMdOHBAa9eu1YEDB/Taa6/pyJEjmjdvXkC5JUuW6MMPP9Q777yjN998U6WlpfrmN7/Z7es+/PDDeuONN/TKK69o9+7dqq+v16JFi8J6bhYi1V+StHz5cp08edK/bNiwIWznZSkcfXbu3DndfffdWrFiRdCvu2HDBv385z/X5s2btW/fPg0fPlzZ2dk6e/Zsr8/JUqT6S5JycnICrrFt27b16lz6Qm/766OPPlJHR4d++ctf6sMPP9RPfvITbd68WWvWrOn2dWP1PSxoDsxIcrZv395tmQ8++MCR5Bw7dsxxHMf5+9//7khy/vKXv/jL/OlPf3JcLpdz4sSJTutoampyhgwZ4rzyyiv+bYcPH3YkOWVlZb0/kT7SV/3lOI5zxx13OA899FA4mh1RPemz/7ZlyxbH4/Fc8nU6OjqcpKQk55lnnvFva2pqctxut7Nt27ZQmx0xfdVfjuM4+fn5zvz580NvZBTpbX9dsGHDBmf8+PFd7u8v72HdYWQbYc3NzXK5XP6PpsrKyjRixAh98Ytf9JfJysrSoEGDtG/fvk7r2L9/v86fP6+srCz/tilTpmjs2LEqKyszbX9fC0d/XfC73/1OCQkJuummm7R69Wp9+umnlk2PmP/ts56orq5WQ0NDwDXm8XiUlpbW76+x3igpKdHo0aOVmpqqFStWqLGxsfcNjDLB9Fdzc7NGjhzZ5f6B8B7Wbx5EEIvOnj2rRx99VHl5ef4f6m5oaNDo0aMDysXFxWnkyJFqaGjotJ6GhgYNHTr0oos9MTGxy2NiUbj6S5K+9rWvKSUlRV6vV4cOHdKjjz6qI0eO6LXXXjM9h77WWZ/1xIW+TExMDNg+EK6xnsrJydGiRYs0fvx4VVVVac2aNcrNzVVZWZkGDx4cphZHVjD9VVlZqV/84hf60Y9+1GU9A+E9jLCNkPPnz+urX/2qHMfRpk2bIt2cqBfu/vrv73SnTp2qMWPGKDMzU1VVVZo4cWKv648GXGOhCXd/3XPPPf4/T506VTfffLMmTpyokpISZWZm9rr+SAumv06cOKGcnBzdfffdWr58eR+3MLrwMXIEXLhIjx07pnfeeSfgf4RJSUk6ffp0QPl///vf+uSTT5SUlNRpfUlJSTp37pyampoCtp86darLY2JJuPurM2lpaZL+/3/h/UF3fdYTF/ryf+8OHQjXWLhMmDBBCQkJ/eIaC6a/6uvrlZGRoZkzZ+r555/vtr7+/h4mEbZ97sJFevToUe3atUtXX311wP709HQ1NTVp//79/m3vvvuuOjo6/IHwv6ZPn64hQ4aouLjYv+3IkSOqra1Venq6zYn0EYv+6kxFRYUkacyYMWFpdyRdqs96Yvz48UpKSgq4xnw+n/bt29fvr7FwqaurU2NjY8xfY8H014kTJzRnzhxNnz5dW7ZsueSD1fvze5hfRG/P6odaWlqcgwcPOgcPHnQkOc8++6xz8OBB59ixY865c+ecefPmOddee61TUVHhnDx50r+0t7f768jJyXFuvfVWZ9++fc6ePXuc6667zsnLy/Pvr6urc1JTU519+/b5tz3wwAPO2LFjnXfffdcpLy930tPTnfT09D49956IRH9VVlY6Tz75pFNeXu5UV1c7r7/+ujNhwgRn9uzZfX7+PRGOPjt27Jhz8OBB54knnnCuuOIKf30tLS3+Mqmpqc5rr73mX1+/fr0zYsQI5/XXX3cOHTrkzJ8/3xk/frzz2Wef9en5hyoS/dXS0uI88sgjTllZmVNdXe3s2rXL+cIXvuBcd911ztmzZ/u8D0LR2/6qq6tzJk2a5GRmZjp1dXUBZS7oT+9hwSJsw+y9995zJF205OfnO9XV1Z3uk+S89957/joaGxudvLw854orrnDi4+Od+++/P+Af9YV6/vuYzz77zPnWt77lXHXVVc7ll1/uLFy4MODijlaR6K/a2lpn9uzZzsiRIx232+1MmjTJWblypdPc3NzHZ98z4eiz/Pz8S5aR5GzZssW/3tHR4axdu9ZJTEx03G63k5mZ6Rw5cqTvTryHItFfn376qXPnnXc6o0aNcoYMGeKkpKQ4y5cvdxoaGvr25Hugt/21ZcuWLstc0J/ew4LFI/YAADDGd7YAABgjbAEAMEbYAgBgjLAFAMAYYQsAgDHCFgAAY4QtAADGCFsAAIwRtgAAGCNsAQAwRtgCAGCMsAUAwNj/AeulbcinYOpxAAAAAElFTkSuQmCC",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -479,7 +471,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "id": "6856c206-da79-45bf-956b-6d660ce2545e",
    "metadata": {},
    "outputs": [
@@ -499,7 +491,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "361728f9-e1c6-41d1-978c-383d0b6d4fb6",
    "metadata": {},
    "outputs": [],
@@ -511,20 +503,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "id": "2ccb76b9-c26c-483e-95a9-7e65c206965e",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -544,7 +534,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "id": "dd907f45-32ed-4810-97f9-2eaacf869119",
    "metadata": {},
    "outputs": [
@@ -597,7 +587,7 @@
        "      <th>3</th>\n",
        "      <td>2</td>\n",
        "      <td>24</td>\n",
-       "      <td>POLYGON ((119.87566 15.44910, 119.92058 15.449...</td>\n",
+       "      <td>POLYGON ((119.87566 15.4491, 119.92058 15.4491...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
@@ -614,11 +604,11 @@
        "0  7   8  POLYGON ((120.10024 14.75528, 120.14516 14.755...\n",
        "1  6   8  POLYGON ((120.05533 14.75528, 120.10024 14.755...\n",
        "2  9   8  POLYGON ((120.19008 14.75528, 120.23499 14.755...\n",
-       "3  2  24  POLYGON ((119.87566 15.44910, 119.92058 15.449...\n",
+       "3  2  24  POLYGON ((119.87566 15.4491, 119.92058 15.4491...\n",
        "4  2  25  POLYGON ((119.87566 15.49239, 119.92058 15.492..."
       ]
      },
-     "execution_count": 21,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -630,20 +620,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "id": "0b2dd0ae-db26-4b92-b7bd-255b8511d547",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -656,9 +644,7 @@
   {
    "cell_type": "markdown",
    "id": "c789ea17-c6ba-4c3b-8c98-53d3637f2229",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "source": [
     "### Gridding at a coarser resolution\n",
     "Let's try the same process but with a bigger grid (15K)"
@@ -666,11 +652,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "id": "160ad35f-c110-4162-b5c1-da35bf0892ea",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "grid_generator15k = grids.SquareGridGenerator(15_000)  # 15 km x 15 km grids"
@@ -687,18 +671,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": null,
    "id": "7153ffba-8b39-48f1-89d1-fa2875e36c59",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 548 ms, sys: 0 ns, total: 548 ms\n",
-      "Wall time: 547 ms\n"
+      "CPU times: user 316 ms, sys: 40 ms, total: 356 ms\n",
+      "Wall time: 363 ms\n"
      ]
     }
    ],
@@ -709,30 +691,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "id": "98ea6185-66ad-47a6-ba56-a80e449d74aa",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<AxesSubplot:>"
+       "<Axes: >"
       ]
      },
-     "execution_count": 25,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -751,7 +731,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": null,
    "id": "da9dbcf6-c4e8-474a-afce-2548f0c834a0",
    "metadata": {},
    "outputs": [
@@ -770,7 +750,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": null,
    "id": "09158ebe-0577-48de-9b5a-06ad4f70d214",
    "metadata": {},
    "outputs": [],
@@ -798,7 +778,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "id": "60de1059-cfb6-4e66-8b4c-c0bee92e701c",
    "metadata": {},
    "outputs": [],
@@ -809,7 +789,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": null,
    "id": "b3840cec-938c-48f6-b4e3-c6455cc5e83a",
    "metadata": {},
    "outputs": [
@@ -862,7 +842,7 @@
        "153  18  16  POLYGON ((122.21128 16.48548, 122.34603 16.485..."
       ]
      },
-     "execution_count": 29,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -873,20 +853,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": null,
    "id": "816d056c-a735-4600-8d15-2fe3812fd35c",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -898,7 +876,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": null,
    "id": "a60cef23-2d9c-49c4-9633-56acf654c078",
    "metadata": {},
    "outputs": [],
@@ -908,7 +886,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": null,
    "id": "ec41b566-49e7-4784-9785-8aaafb250938",
    "metadata": {},
    "outputs": [
@@ -916,8 +894,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 27.1 ms, sys: 0 ns, total: 27.1 ms\n",
-      "Wall time: 27.8 ms\n"
+      "CPU times: user 10.8 ms, sys: 1.4 ms, total: 12.2 ms\n",
+      "Wall time: 11.5 ms\n"
      ]
     }
    ],
@@ -928,17 +906,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": null,
    "id": "b0b48828-ec68-47ee-8f54-54b86d3f3f3c",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "272"
+       "289"
       ]
      },
-     "execution_count": 33,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -949,7 +927,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": null,
    "id": "efd299f7-c676-4ae8-95a6-31e074d459d5",
    "metadata": {},
    "outputs": [
@@ -983,47 +961,47 @@
        "    <tr>\n",
        "      <th>0</th>\n",
        "      <td>29</td>\n",
+       "      <td>29</td>\n",
+       "      <td>POLYGON ((120.04634 14.6597, 120.05533 14.6597...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>29</td>\n",
        "      <td>30</td>\n",
        "      <td>POLYGON ((120.04634 14.66839, 120.05533 14.668...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>1</th>\n",
+       "      <th>2</th>\n",
        "      <td>29</td>\n",
        "      <td>31</td>\n",
        "      <td>POLYGON ((120.04634 14.67708, 120.05533 14.677...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>2</th>\n",
+       "      <th>3</th>\n",
        "      <td>29</td>\n",
        "      <td>32</td>\n",
        "      <td>POLYGON ((120.04634 14.68577, 120.05533 14.685...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
-       "      <th>3</th>\n",
+       "      <th>4</th>\n",
        "      <td>29</td>\n",
        "      <td>33</td>\n",
        "      <td>POLYGON ((120.04634 14.69446, 120.05533 14.694...</td>\n",
        "    </tr>\n",
-       "    <tr>\n",
-       "      <th>4</th>\n",
-       "      <td>29</td>\n",
-       "      <td>34</td>\n",
-       "      <td>POLYGON ((120.04634 14.70315, 120.05533 14.703...</td>\n",
-       "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
        "</div>"
       ],
       "text/plain": [
        "    x   y                                           geometry\n",
-       "0  29  30  POLYGON ((120.04634 14.66839, 120.05533 14.668...\n",
-       "1  29  31  POLYGON ((120.04634 14.67708, 120.05533 14.677...\n",
-       "2  29  32  POLYGON ((120.04634 14.68577, 120.05533 14.685...\n",
-       "3  29  33  POLYGON ((120.04634 14.69446, 120.05533 14.694...\n",
-       "4  29  34  POLYGON ((120.04634 14.70315, 120.05533 14.703..."
+       "0  29  29  POLYGON ((120.04634 14.6597, 120.05533 14.6597...\n",
+       "1  29  30  POLYGON ((120.04634 14.66839, 120.05533 14.668...\n",
+       "2  29  31  POLYGON ((120.04634 14.67708, 120.05533 14.677...\n",
+       "3  29  32  POLYGON ((120.04634 14.68577, 120.05533 14.685...\n",
+       "4  29  33  POLYGON ((120.04634 14.69446, 120.05533 14.694..."
       ]
      },
-     "execution_count": 34,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1034,20 +1012,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": null,
    "id": "e3f273ea-557a-4f7a-95a7-63c9fd1075f0",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcQAAAGdCAYAAACM3gMgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA6BUlEQVR4nO3de3iU9Z3//+dgQkiUiRCBJJUhaWAjUApE1IWwQsohBIpKXezakEbQVpCDEDat2E5RUwU8EbbSoJUmuqzbtWsnF3YrpzoKDgdJQqq0AYQORCGIaJgB1IDk/v3RH/N1zHEOkZvM63Fdc12dO5/7lffHsfNykjszFsMwDERERCJcl0s9gIiIiBmoEEVERFAhioiIACpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQEg6lIP8HVpbGzk2LFjdO/eHYvFcqnHERGRABmGwenTp0lOTqZLl/C/nouYQjx27Bh9+/a91GOIiEiI3n//fa699tqw50ZMIXbv3h34xz9Iq9V6iacREZFAeb1e+vbt63s+D7eIKcSLPya1Wq0qRBGRy1hH/dpLF9WIiIigQhQREQFUiCIiIoAKUUREBFAhioiIACpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQFUiCIiIoAKUUREBIigN/cOl/c+fo/T506HLe/jTz8mIS4hIvLMPJvZ88w8m9nzzDxbpOV179qdAQkDwpLVEVSIAXjv4/f4p2f+6VKPISJy2Tow74BpS1GFGICLrwzXTVvHwF4DQ87703t/wu60U5RVxOQBkzt1nplnM3uemWcze56ZZ4u0vJqPapjhmBHWn7CFmwoxCAN7DSQjKSPknJqTNQCk9kjt9Hlmns3seWaezex5Zp4tEvPMThfViIiIoEIUEREBVIgiIiKAClFERARQIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoEIUEREBgijErVu3MnXqVJKTk7FYLJSXl7e4dvbs2VgsFoqLi1vNvHDhAna7ndTUVGJjY0lLS6OoqAjDMHxrDMPgF7/4BUlJScTGxjJ+/Hjee++9QMcXERFpVsCFePbsWYYOHcrq1atbXedwONi5cyfJycltZq5YsYKSkhKeeeYZampqWLFiBY8//ji/+tWvfGsef/xx/uM//oM1a9awa9currzySrKzs/n8888D3YKIiEgTAb+5d05ODjk5Oa2uOXr0KPPnz2fjxo1MmTKlzczt27dz6623+tampKTw3//937z99tvAP14dFhcX8/Of/5xbb70VgBdffJE+ffpQXl7Ov/3bvwW6DRERET9h/x1iY2MjeXl5FBYWMnjw4HadM2rUKP785z9z4MABAP7yl7/w1ltv+YrX7XZz/Phxxo8f7zsnPj6em266iR07djSb2dDQgNfr9buJiIi0JOwf/7RixQqioqJYsGBBu8954IEH8Hq9XHfddVxxxRVcuHCBRx99lNzcXACOHz8OQJ8+ffzO69Onj+9rX7Vs2TIefvjhIHchIiKRJqyvECsrK1m1ahVlZWVYLJZ2n/fyyy/zX//1X7z00ktUVVXxwgsv8OSTT/LCCy8EPcuSJUvweDy+2/vvvx90loiIdH5hfYW4bds2Tpw4gc1m8x27cOECixcvpri4mMOHDzd7XmFhIQ888IDvd4FDhgzhyJEjLFu2jPz8fBITEwH48MMPSUpK8p334YcfMmzYsGYzY2JiiImJCc/GvsKxz+H74MxQuGpdADjdzpCzzJ5n5tnMnmfm2cyeZ+bZIi3PXe8OOaOjWYwv/21DoCdbLDgcDm677TYAPv74Y+rq6vzWZGdnk5eXx8yZM0lPT282JyEhgV/+8pfMmTPHd2zZsmWUlpZy4MABDMMgOTmZf//3f2fx4sUAeL1eevfuTVlZWbsuqvF6vcTHx+PxeLBarUHt11XrYnTp6KDOFRER2DRjExPSJgR1bjiex1sT8CvEM2fOcPDgQd99t9tNdXU1PXv2xGazkZCQ4Lc+OjqaxMREvzIcN24c06ZNY968eQBMnTqVRx99FJvNxuDBg9mzZw9PP/00s2bNAv5RvAsXLuSXv/wlAwYMIDU1FbvdTnJysq+Mvw6x0bEAFGUVkdojNeQ8V62LkooS5oyYQ6Yts1PnmXk2s+eZeTaz55l5tkjLc9e7sTvtJMQltL34UjEC5HQ6DaDJLT8/v9n1/fr1M1auXNnk2NKlS333vV6vcf/99xs2m83o1q2b8c1vftP42c9+ZjQ0NPjWNDY2Gna73ejTp48RExNjjBs3zti/f3+75/Z4PAZgeDyeQLbrp/JYpcFDGJXHKoPO+LJ176wzeAhj3TvrOn2emWcze56ZZzN7nplni7S8cDx/huN5vDUBv0IcO3as3zvItKW53xt+9Vj37t0pLi5u9R1tLBYLjzzyCI888ki7v7eIiEh76b1MRUREUCGKiIgAKkQRERFAhSgiIgKoEEVERAAVooiICKBCFBERAVSIIiIigApRREQEUCGKiIgAKkQRERFAhSgiIgKoEEVERAAVooiICKBCFBERASDgz0MUcOxzUHOyJuQcV60LAKfbGXKW2fPMPJvZ88w8m9nzzDxbpOW5690hZ3Q0ixHIp/1exrxeL/Hx8Xg8HqxWa1AZrloXo0tHh3kyEZHIsWnGJiakTQjq3HA8j7dGrxADEBsdC0BRVhGpPVJDznPVuiipKGHOiDlk2jI7dZ6ZZzN7nplnM3uemWeLtDx3vRu7005CXELIc3UUFWIQJg+YTEZSRliySipKyLRlkjskt9PnmXk2s+eZeTaz55l5tkjKq6qrwu60h2WmjqKLakRERFAhioiIACpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQFUiCIiIoAKUUREBFAhioiIACpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQFUiCIiIkAQHxC8detWnnjiCSorK6mrq8PhcHDbbbc1u3b27Nk8++yzrFy5koULF7aYmZKSwpEjR5ocv++++1i9ejUAx48fp7CwkM2bN3P69GnS09P52c9+xu233x7oFkLm2Oeg5mRNyDmuWhcATrcz5Cyz55l5NrPnmXk2s+eZebZIy3PXu0PO6GgWwzCMQE547bXXcLlcXH/99Xzve99rsRAdDgcPP/wwH330EYWFha0W4kcffcSFCxd89/fu3cuECRNwOp2MHTsWgIkTJ3Lq1CmeeeYZrrnmGl566SWWLl1KRUUFw4cPb3Nur9dLfHw8Ho8Hq9UayJZ9XLUuRpeODupcERGBTTM2MSFtQlDnhuN5vDUBv0LMyckhJyen1TVHjx5l/vz5bNy4kSlTprSZ2atXL7/7y5cvJy0tjTFjxviObd++nZKSEm688UYAfv7zn7Ny5UoqKyvbVYjhEBsdC0BRVhGpPVJDznPVuiipKGHOiDlk2jI7dZ6ZZzN7nplnM3uemWeLtDx3vRu7005CXELIc3WUgAuxLY2NjeTl5VFYWMjgwYMDPv/cuXOsW7eOgoICLBaL7/ioUaP4n//5H6ZMmcLVV1/Nyy+/zOeff+57BflVDQ0NNDQ0+O57vd6AZ2nJ5AGTyUjKCEtWSUUJmbZMcofkdvo8M89m9jwzz2b2PDPPFkl5VXVV2J32sMzUUcJ+Uc2KFSuIiopiwYIFQZ1fXl7OqVOnuOuuu/yOv/zyy5w/f56EhARiYmK49957cTgc9O/fv9mcZcuWER8f77v17ds3qHlERCQyhLUQKysrWbVqFWVlZX6v7gKxdu1acnJySE5O9jtut9s5deoUW7ZsoaKigoKCAu644w7efffdZnOWLFmCx+Px3d5///2g5hERkcgQ1h+Zbtu2jRMnTmCz2XzHLly4wOLFiykuLubw4cOtnn/kyBG2bNnCH/7wB7/jhw4d4plnnmHv3r2+H8MOHTqUbdu2sXr1atasWdMkKyYmhpiYmNA3JSIiESGshZiXl8f48eP9jmVnZ5OXl8fMmTPbPL+0tJTevXs3uRDn008/BaBLF/8XtFdccQWNjY0hTi0iIhJEIZ45c4aDBw/67rvdbqqrq+nZsyc2m42EBP8riKKjo0lMTCQ9Pd13bNy4cUybNo158+b5jjU2NlJaWkp+fj5RUf5jXXfddfTv3597772XJ598koSEBMrLy9m8eTN//OMfA92CiIhIEwEXYkVFBVlZWb77BQUFAOTn51NWVtaujEOHDnHy5Em/Y1u2bKG2tpZZs2Y1WR8dHc2f/vQnHnjgAaZOncqZM2fo378/L7zwApMnTw50CyIiIk0EXIhjx44lkL/lb+73hs0dmzhxYqu5AwYM4JVXXmn39xUREQmE3stUREQEFaKIiAigQhQREQFUiCIiIoAKUUREBFAhioiIACpEERERQIUoIiICqBBFRESADviA4Ejg2Oeg5mRNyDmuWhcATrcz5Cyz55l5NrPnmXk2s+eZebZIy3PXu0PO6GgWI5D3YbuMeb1e4uPj8Xg8WK3WoDJctS5Gl44O82QiIpFj04xNTEibENS54Xgeb41eIQYgNjoWgKKsIlJ7pIac56p1UVJRwpwRc8i0ZXbqPDPPZvY8M89m9jwzzxZpee56N3annYS4hLYXXyIqxCBMHjCZjKSMsGSVVJSQacskd0hup88z82xmzzPzbGbPM/NskZRXVVeF3WkPy0wdRRfViIiIoEIUEREBVIgiIiKAClFERARQIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoEIUEREBVIgiIiKAClFERARQIYqIiAAqRBEREUCFKCIiAujzEIPi2Oeg5mRNyDmuWhcATrcz5Cyz55l5NrPnmXk2s+eZebZIy3PXu0PO6GgWwzCMSz3E18Hr9RIfH4/H48FqtQaV4ap1Mbp0dJgnExGJHJtmbGJC2oSgzg3H83hr9AoxALHRsQAUZRWR2iM15DxXrYuSihLmjJhDpi2zU+eZeTaz55l5NrPnmXm2SMtz17uxO+0kxCWEPFdHUSEGYfKAyWQkZYQlq6SihExbJrlDcjt9nplnM3uemWcze56ZZ4ukvKq6KuxOe1hm6ii6qEZERAQVooiICBBEIW7dupWpU6eSnJyMxWKhvLy8xbWzZ8/GYrFQXFzcamZKSgoWi6XJbe7cuX7rduzYwXe+8x2uvPJKrFYrN998M5999lmgWxAREWki4EI8e/YsQ4cOZfXq1a2uczgc7Ny5k+Tk5DYzd+/eTV1dne+2efNmAKZPn+5bs2PHDiZNmsTEiRN5++232b17N/PmzaNLF73IFRGR0AV8UU1OTg45OTmtrjl69Cjz589n48aNTJkypc3MXr16+d1fvnw5aWlpjBkzxnds0aJFLFiwgAceeMB3LD09PcDpRUREmhf2l1eNjY3k5eVRWFjI4MGDAz7/3LlzrFu3jlmzZmGxWAA4ceIEu3btonfv3owaNYo+ffowZswY3nrrrRZzGhoa8Hq9fjcREZGWhL0QV6xYQVRUFAsWLAjq/PLyck6dOsVdd93lO/b3v/8dgIceeogf/ehHbNiwgYyMDMaNG8d7773XbM6yZcuIj4/33fr27RvUPCIiEhnCWoiVlZWsWrWKsrIy36u7QK1du5acnBy/3z02NjYCcO+99zJz5kyGDx/OypUrSU9P57e//W2zOUuWLMHj8fhu77//flDziIhIZAhrIW7bto0TJ05gs9mIiooiKiqKI0eOsHjxYlJSUto8/8iRI2zZsoV77rnH73hSUhIAgwYN8js+cOBAamtrm82KiYnBarX63URERFoS1neqycvLY/z48X7HsrOzycvLY+bMmW2eX1paSu/evZtciJOSkkJycjL79+/3O37gwIE2L/ARERFpj4AL8cyZMxw8eNB33+12U11dTc+ePbHZbCQk+L9PXXR0NImJiX5XhI4bN45p06Yxb94837HGxkZKS0vJz88nKsp/LIvFQmFhIUuXLmXo0KEMGzaMF154gX379vG///u/gW5BRESkiYALsaKigqysLN/9goICAPLz8ykrK2tXxqFDhzh58qTfsS1btlBbW8usWbOaPWfhwoV8/vnnLFq0iE8++YShQ4eyefNm0tLSAt2CiIhIEwEX4tixYwnkE6MOHz7crmMTJ05sM/eBBx7w+ztEERGRcNHbvIiIiKBCFBERAVSIIiIigD4gOCiOfQ5qTtaEnOOqdQHgdDtDzjJ7nplnM3uemWcze56ZZ4u0PHe9O+SMjmYxArlC5jLm9XqJj4/H4/EE/Uf6rloXo0tHh3kyEZHIsWnGJiakTQjq3HA8j7dGrxADEBsdC0BRVhGpPVJDznPVuiipKGHOiDlk2jI7dZ6ZZzN7nplnM3uemWeLtDx3vRu7005CXELbiy8RFWIQJg+YTEZSRliySipKyLRlkjskt9PnmXk2s+eZeTaz55l5tkjKq6qrwu60h2WmjqKLakRERFAhioiIACpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQFUiCIiIoAKUUREBFAhioiIACpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQFUiCIiIoA+IDgojn0Oak7WhJzjqnUB4HQ7Q84ye56ZZzN7nplnM3uemWeLtDx3vTvkjI5mMQzDuNRDfB28Xi/x8fF4PB6sVmtQGa5aF6NLR4d5MhGRyLFpxiYmpE0I6txwPI+3Rq8QAxAbHQtAUVYRqT1SQ85z1booqShhzog5ZNoyO3WemWcze56ZZzN7nplni7Q8d70bu9NOQlxCyHN1FBViECYPmExGUkZYskoqSsi0ZZI7JLfT55l5NrPnmXk2s+eZebZIyquqq8LutIdlpo6ii2pERERQIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoEIUEREBVIgiIiJAEIW4detWpk6dSnJyMhaLhfLy8hbXzp49G4vFQnFxcauZKSkpWCyWJre5c+c2WWsYBjk5OW1+bxERkUAEXIhnz55l6NChrF69utV1DoeDnTt3kpyc3Gbm7t27qaur8902b94MwPTp05usLS4uxmKxBDq2iIhIqwJ+67acnBxycnJaXXP06FHmz5/Pxo0bmTJlSpuZvXr18ru/fPly0tLSGDNmjN/x6upqnnrqKSoqKkhKSgp0dBERkRaF/b1MGxsbycvLo7CwkMGDBwd8/rlz51i3bh0FBQV+rwQ//fRTfvCDH7B69WoSExPbzGloaKChocF33+v1BjyLiIhEjrBfVLNixQqioqJYsGBBUOeXl5dz6tQp7rrrLr/jixYtYtSoUdx6663tylm2bBnx8fG+W9++fYOaR0REIkNYXyFWVlayatUqqqqqgv4939q1a8nJyfH73eP69et5/fXX2bNnT7tzlixZQkFBge++1+tVKYqISIvC+gpx27ZtnDhxApvNRlRUFFFRURw5coTFixeTkpLS5vlHjhxhy5Yt3HPPPX7HX3/9dQ4dOsTVV1/tywW4/fbbGTt2bLNZMTExWK1Wv5uIiEhLwvoKMS8vj/Hjx/sdy87OJi8vj5kzZ7Z5fmlpKb17925yIc4DDzzQpCSHDBnCypUrmTp1auiDi4hIxAu4EM+cOcPBgwd9991uN9XV1fTs2RObzUZCgv+nIUdHR5OYmEh6errv2Lhx45g2bRrz5s3zHWtsbKS0tJT8/HzfK8CLEhMTm72QxmazkZoa+ifXB8qxz0HNyZqQc1y1LgCcbmfIWWbPM/NsZs8z82xmzzPzbJGW5653h5zR0SyGYRiBnPDGG2+QlZXV5Hh+fj5lZWVNjqekpLBw4UIWLlzod+yuu+7ioYce8h3btGkT2dnZ7N+/n3/6p39qe3CLBYfDwW233dauub1eL/Hx8Xg8nqB/fOqqdTG6dHRQ54qICGyasYkJaROCOjccz+OtCfgV4tixYwmkQw8fPtyuYxMnTgwoN8AeD4vY6FgAirKKSO0R+itTV62LkooS5oyYQ6Yts1PnmXk2s+eZeTaz55l5tkjLc9e7sTvtJMQltL34Egn73yFGgskDJpORlBGWrJKKEjJtmeQOye30eWaezex5Zp7N7Hlmni2S8qrqqrA77WGZqaPozb1FRERQIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoEIUEREBVIgiIiKAClFERARQIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoEIUEREB9HmIQXHsc1BzsibkHFetCwCn2xlyltnzzDyb2fPMPJvZ88w8W6TluevdIWd0NItxKT56/hLwer3Ex8fj8XiwWq1BZbhqXYwuHR3myUREIsemGZuYkDYhqHPD8TzeGr1CDEBsdCwARVlFpPZIDTnPVeuipKKEOSPmkGnL7NR5Zp7N7Hlmns3seWaeLdLy3PVu7E47CXEJIc/VUVSIQZg8YDIZSRlhySqpKCHTlknukNxOn2fm2cyeZ+bZzJ5n5tkiKa+qrgq70x6WmTqKLqoRERFBhSgiIgKoEEVERAAVooiICKBCFBERAVSIIiIigApRREQEUCGKiIgAKkQRERFAhSgiIgKoEEVERAAVooiICKBCFBERAVSIIiIiQBCFuHXrVqZOnUpycjIWi4Xy8vIW186ePRuLxUJxcXGrmSkpKVgslia3uXPnAvDJJ58wf/580tPTiY2NxWazsWDBAjweT6Dji4iINCvgQjx79ixDhw5l9erVra5zOBzs3LmT5OTkNjN3795NXV2d77Z582YApk+fDsCxY8c4duwYTz75JHv37qWsrIwNGzZw9913Bzq+iIhIswL+gOCcnBxycnJaXXP06FHmz5/Pxo0bmTJlSpuZvXr18ru/fPly0tLSGDNmDADf+ta3eOWVV3xfT0tL49FHH2XGjBl88cUXREV9vZ9z7NjnoOZkTcg5rloXAE63M+Qss+eZeTaz55l5NrPnmXm2SMtz17tDzuhoFsMwjKBPtlhwOBzcdtttvmONjY2MHz+eW2+9lfvvv5+UlBQWLlzIwoUL25V57tw5kpOTKSgo4MEHH2xx3fPPP8+SJUv46KOPmv16Q0MDDQ0Nvvter5e+ffvi8XiwWq3tmuWrXLUuRpeODupcERGBTTM2MSFtQlDner1e4uPjQ3oeb03YX1qtWLGCqKgoFixYENT55eXlnDp1irvuuqvFNSdPnqSoqIgf//jHLa5ZtmwZDz/8cFAztCQ2OhaAoqwiUnukhpznqnVRUlHCnBFzyLRlduo8M89m9jwzz2b2PDPPFml57no3dqedhLiEkOfqKGEtxMrKSlatWkVVVRUWiyWojLVr15KTk9Pi7x69Xi9Tpkxh0KBBPPTQQy3mLFmyhIKCAr/z+vbtG9RMXzV5wGQykjLCklVSUUKmLZPcIbmdPs/Ms5k9z8yzmT3PzLNFUl5VXRV2pz0sM3WUsP7ZxbZt2zhx4gQ2m42oqCiioqI4cuQIixcvJiUlpc3zjxw5wpYtW7jnnnua/frp06eZNGkS3bt3x+FwEB0d3WJWTEwMVqvV7yYiItKSsL5CzMvLY/z48X7HsrOzycvLY+bMmW2eX1paSu/evZu9EMfr9ZKdnU1MTAzr16+nW7duYZtbREQk4EI8c+YMBw8e9N13u91UV1fTs2dPbDYbCQn+Px+Ojo4mMTGR9PR037Fx48Yxbdo05s2b5zvW2NhIaWkp+fn5Ta4a9Xq9TJw4kU8//ZR169bh9Xrxer3AP65QveKKKwLdhoiIiJ+AC7GiooKsrCzf/Yu/p8vPz6esrKxdGYcOHeLkyZN+x7Zs2UJtbS2zZs1qsr6qqopdu3YB0L9/f7+vud3udv04VkREpDUBF+LYsWMJ5C81Dh8+3K5jEydObDE30O8pIiISKL2XqYiICCpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQFUiCIiIoAKUUREBFAhioiIACpEERERQIUoIiIChPnjnyKFY5+DmpM1Iee4al0AON3OkLPMnmfm2cyeZ+bZzJ5n5tkiLc9d7w45o6NZjAh512yv10t8fDwejyfoDwt21boYXTo6zJOJiESOTTM2MSFtQlDnhuN5vDV6hRiA2OhYAIqyikjtkRpynqvWRUlFCXNGzCHTltmp88w8m9nzzDyb2fPMPFuk5bnr3diddhLiEtpefImoEIMwecBkMpIywpJVUlFCpi2T3CG5nT7PzLOZPc/Ms5k9z8yzRVJeVV0Vdqc9LDN1FF1UIyIiggpRREQEUCGKiIgAKkQRERFAhSgiIgKoEEVERAAVooiICKBCFBERAVSIIiIigApRREQEUCGKiIgAKkQRERFAhSgiIgKoEEVERAAVooiICKBCFBERAfQBwUFx7HNQc7Im5BxXrQsAp9sZcpbZ88w8m9nzzDyb2fPMPFuk5bnr3SFndDSLYRjGpR7i6+D1eomPj8fj8WC1WoPKcNW6GF06OsyTiYhEjk0zNjEhbUJQ54bjebw1eoUYgNjoWACKsopI7ZEacp6r1kVJRQlzRswh05bZqfPMPJvZ88w8m9nzzDxbpOW5693YnXYS4hJCnqujqBCDMHnAZDKSMsKSVVJRQqYtk9whuZ0+z8yzmT3PzLOZPc/Ms0VSXlVdFXanPSwzdZSAL6rZunUrU6dOJTk5GYvFQnl5eYtrZ8+ejcViobi4uNXMlJQULBZLk9vcuXN9az7//HPmzp1LQkICV111FbfffjsffvhhoOOLiIg0K+BCPHv2LEOHDmX16tWtrnM4HOzcuZPk5OQ2M3fv3k1dXZ3vtnnzZgCmT5/uW7No0SJeffVVfv/73/Pmm29y7Ngxvve97wU6voiISLMC/pFpTk4OOTk5ra45evQo8+fPZ+PGjUyZMqXNzF69evndX758OWlpaYwZMwYAj8fD2rVreemll/jOd74DQGlpKQMHDmTnzp388z//c6DbEBER8RP2v0NsbGwkLy+PwsJCBg8eHPD5586dY926dcyaNQuLxQJAZWUl58+fZ/z48b511113HTabjR07djSb09DQgNfr9buJiIi0JOyFuGLFCqKioliwYEFQ55eXl3Pq1Cnuuusu37Hjx4/TtWtXrr76ar+1ffr04fjx483mLFu2jPj4eN+tb9++Qc0jIiKRIayFWFlZyapVqygrK/O9ugvU2rVrycnJadfvHluzZMkSPB6P7/b++++HlCciIp1bWAtx27ZtnDhxApvNRlRUFFFRURw5coTFixeTkpLS5vlHjhxhy5Yt3HPPPX7HExMTOXfuHKdOnfI7/uGHH5KYmNhsVkxMDFar1e8mIiLSkrAWYl5eHu+88w7V1dW+W3JyMoWFhWzcuLHN80tLS+ndu3eTC3Guv/56oqOj+fOf/+w7tn//fmpraxk5cmQ4tyAiIhEq4KtMz5w5w8GDB3333W431dXV9OzZE5vNRkKC/7sQREdHk5iYSHp6uu/YuHHjmDZtGvPmzfMda2xspLS0lPz8fKKi/MeKj4/n7rvvpqCggJ49e2K1Wpk/fz4jR47UFaYiIhIWARdiRUUFWVlZvvsFBQUA5OfnU1ZW1q6MQ4cOcfLkSb9jW7Zsoba2llmzZjV7zsqVK+nSpQu33347DQ0NZGdn8+tf/zrQ8UVERJoVcCGOHTuWQN4P/PDhw+06NnHixFZzu3XrxurVq9t8QwAREZFg6PMQRUREUCGKiIgAKkQRERFAhSgiIgLo8xCD4tjnoOZkTcg5rloXAE63M+Qss+eZeTaz55l5NrPnmXm2SMtz17tDzuhoFiOQS0YvY16vl/j4eDweT9DvWuOqdTG6dHSYJxMRiRybZmxiQtqEoM4Nx/N4a/QKMQCx0bEAFGUVkdojNeQ8V62LkooS5oyYQ6Yts1PnmXk2s+eZeTaz55l5tkjLc9e7sTvtJMQltL34ElEhBmHygMlkJGWEJaukooRMWya5Q3I7fZ6ZZzN7nplnM3uemWeLpLyquirsTntYZuoouqhGREQEFaKIiAigQhQREQFUiCIiIoAKUUREBFAhioiIACpEERERQIUoIiICqBBFREQAFaKIiAigQhQREQFUiCIiIoAKUUREBFAhioiIACpEERERQIUoIiIC6AOCg+LY56DmZE3IOa5aFwBOtzPkLLPnmXk2s+eZeTaz55l5tkjLc9e7Q87oaBbDMIxLPcTXwev1Eh8fj8fjwWq1BpXhqnUxunR0mCcTEYkcm2ZsYkLahKDODcfzeGv0CjEAsdGxABRlFZHaIzXkPFeti5KKEuaMmEOmLbNT55l5NrPnmXk2s+eZebZIy3PXu7E77STEJYQ8V0dRIQZh8oDJZCRlhCWrpKKETFsmuUNyO32emWcze56ZZzN7nplni6S8qroq7E57WGbqKLqoRkREBBWiiIgIoEIUEREBVIgiIiKAClFERARQIYqIiABBFOLWrVuZOnUqycnJWCwWysvLW1w7e/ZsLBYLxcXFbeYePXqUGTNmkJCQQGxsLEOGDKGiosL39TNnzjBv3jyuvfZaYmNjGTRoEGvWrAl0fBERkWYFXIhnz55l6NChrF69utV1DoeDnTt3kpyc3GZmfX09mZmZREdH89prr/G3v/2Np556ih49evjWFBQUsGHDBtatW0dNTQ0LFy5k3rx5rF+/PtAtiIiINBHwH+bn5OSQk5PT6pqjR48yf/58Nm7cyJQpU9rMXLFiBX379qW0tNR3LDXV/51gtm/fTn5+PmPHjgXgxz/+Mc8++yxvv/02t9xyS6DbEBER8RP23yE2NjaSl5dHYWEhgwcPbtc569evZ8SIEUyfPp3evXszfPhwfvOb3/itGTVqFOvXr+fo0aMYhoHT6eTAgQNMnDix2cyGhga8Xq/fTUREpCVhL8QVK1YQFRXFggUL2n3O3//+d0pKShgwYAAbN25kzpw5LFiwgBdeeMG35le/+hWDBg3i2muvpWvXrkyaNInVq1dz8803N5u5bNky4uPjfbe+ffuGvDcREem8wvpeppWVlaxatYqqqiosFku7z2tsbGTEiBE89thjAAwfPpy9e/eyZs0a8vPzgX8U4s6dO1m/fj39+vVj69atzJ07l+TkZMaPH98kc8mSJRQUFPjue71elaKIiLQorIW4bds2Tpw4gc1m8x27cOECixcvpri4mMOHDzd7XlJSEoMGDfI7NnDgQF555RUAPvvsMx588EEcDofvd5Lf/va3qa6u5sknn2y2EGNiYoiJiQnTzkREpLMLayHm5eU1Kafs7Gzy8vKYOXNmi+dlZmayf/9+v2MHDhygX79+AJw/f57z58/TpYv/T3ivuOIKGhsbwzS9iIhEsoAL8cyZMxw8eNB33+12U11dTc+ePbHZbCQk+H/WVXR0NImJiaSnp/uOjRs3jmnTpjFv3jwAFi1axKhRo3jssce44447ePvtt3nuued47rnnALBarYwZM4bCwkJiY2Pp168fb775Ji+++CJPP/10UBsXERH5soALsaKigqysLN/9i7+ny8/Pp6ysrF0Zhw4d4uTJk777N9xwAw6HgyVLlvDII4+QmppKcXExubn/7/O3fve737FkyRJyc3P55JNP6NevH48++iizZ88OdAsiIiJNBFyIY8eOxTCMdq9v7veGzR377ne/y3e/+90WcxITE/3+TvFScuxzUHOyJuQcV60LAKfbGXKW2fPMPJvZ88w8m9nzzDxbpOW5690hZ3Q0ixFIu13GvF4v8fHxeDwerFZrUBmuWhejS0eHeTIRkcixacYmJqRNCOrccDyPtyasF9V0drHRsQAUZRWR2iO1jdVtc9W6KKkoYc6IOWTaMjt1nplnM3uemWcze56ZZ4u0PHe9G7vTTkJcQtuLLxEVYhAmD5hMRlJGWLJKKkrItGWSOyS37cWXeZ6ZZzN7nplnM3uemWeLpLyquirsTntYZuoo+vgnERERVIgiIiKAClFERARQIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoEIUEREBVIgiIiKAClFERARQIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoA8IDopjn4OakzUh57hqXQA43c6Qs8yeZ+bZzJ5n5tnMnmfm2SItz13vDjmjo1kMwzAu9RBfB6/XS3x8PB6PB6vVGlSGq9bF6NLRYZ5MRCRybJqxiQlpE4I6NxzP463RK8QAxEbHAlCUVURqj9SQ81y1LkoqSpgzYg6ZtsxOnWfm2cyeZ+bZzJ5n5tkiLc9d78butJMQlxDyXB1FhRiEyQMmk5GUEZaskooSMm2Z5A7J7fR5Zp7N7Hlmns3seWaeLZLyquqqsDvtYZmpo+iiGhEREVSIIiIigApRREQEUCGKiIgAKkQRERFAhSgiIgKoEEVERAAVooiICKBCFBERAVSIIiIigApRREQEUCGKiIgAQRTi1q1bmTp1KsnJyVgsFsrLy1tcO3v2bCwWC8XFxW3mHj16lBkzZpCQkEBsbCxDhgyhoqLCb01NTQ233HIL8fHxXHnlldxwww3U1tYGugUREZEmAi7Es2fPMnToUFavXt3qOofDwc6dO0lOTm4zs76+nszMTKKjo3nttdf429/+xlNPPUWPHj18aw4dOsTo0aO57rrreOONN3jnnXew2+1069Yt0C2IiIg0EfDHP+Xk5JCTk9PqmqNHjzJ//nw2btzIlClT2sxcsWIFffv2pbS01HcsNdX/8wZ/9rOfMXnyZB5//HHfsbS0tACnFxERaV7YPw+xsbGRvLw8CgsLGTx4cLvOWb9+PdnZ2UyfPp0333yTb3zjG9x333386Ec/8mX+3//9Hz/5yU/Izs5mz549pKamsmTJEm677bZmMxsaGmhoaPDd93q9Ie/toqq6qrDkuOvdAOw7uS8smWbOM/NsZs8z82xmzzPzbJGWV/NRTcjzdDSLYRhG0CdbLDgcDr9SWrZsGU6nk40bN2KxWEhJSWHhwoUsXLiwxZyLP/YsKChg+vTp7N69m/vvv581a9aQn5/P8ePHSUpKIi4ujl/+8pdkZWWxYcMGHnzwQZxOJ2PGjGmS+dBDD/Hwww83Oe7xeLBarUHtt+50HclPt/0jYBERad6BeQcYkDAgqHO9Xi/x8fEhPY+3JqyvECsrK1m1ahVVVVVYLJZ2n9fY2MiIESN47LHHABg+fDh79+71FWJjYyMAt956K4sWLQJg2LBhbN++nTVr1jRbiEuWLKGgoMB33+v10rdv31C2R1L3JI4VHKPuTF1IOV/22fnPiI2OjYg8M89m9jwzz2b2PDPPFml53bt2D7oMvw5hLcRt27Zx4sQJbDab79iFCxdYvHgxxcXFHD58uNnzkpKSGDRokN+xgQMH8sorrwBwzTXXEBUV1eyat956q9nMmJgYYmJiQthN85K6J5HUPSnsuSIicmmFtRDz8vIYP36837Hs7Gzy8vKYOXNmi+dlZmayf/9+v2MHDhygX79+AHTt2pUbbrih1TUiIiKhCLgQz5w5w8GDB3333W431dXV9OzZE5vNRkJCgt/66OhoEhMTSU9P9x0bN24c06ZNY968eQAsWrSIUaNG8dhjj3HHHXfw9ttv89xzz/Hcc8/5ziksLOT73/8+N998s+93iK+++ipvvPFGoFsQERFpygiQ0+k0gCa3/Pz8Ztf369fPWLlyZZNjS5cu9Tv26quvGt/61reMmJgY47rrrjOee+65Jllr1641+vfvb3Tr1s0YOnSoUV5e3u65PR6PARgej6fd54iIiHl09PN4SFeZXk46+uokERHpWB39PK73MhUREUGFKCIiAqgQRUREABWiiIgIoEIUEREBVIgiIiKAClFERARQIYqIiAAqRBEREaADPiDYrC6+IU84PyhYRES+PhefvzvqDdYiphBPnz4NEPJnIoqIyKV1+vRp4uPjw54bMe9l2tjYyLFjx+jevXtAH14ciIsfQvz+++93uvdL1d4uT9rb5Ul7a55hGJw+fZrk5GS6dAn/b/wi5hVily5duPbaa7+W72W1Wjvdv8QXaW+XJ+3t8qS9NdURrwwv0kU1IiIiqBBFREQAFWJYxcTEsHTpUmJiYi71KGGnvV2etLfLk/Z2aUTMRTUiIiKt0StEERERVIgiIiKAClFERARQIYqIiAARUohbt25l6tSpJCcnY7FYKC8v933t/Pnz/PSnP2XIkCFceeWVJCcn88Mf/pBjx475ZXzyySfk5uZitVq5+uqrufvuuzlz5kyr3/fzzz9n7ty5JCQkcNVVV3H77bfz4Ycf+q2xWCxNbr/73e/81rzxxhtkZGQQExND//79KSsrM/3eysrKmt2bxWLhxIkTvn019/Xjx49f0r0999xzjB07FqvVisVi4dSpU03WtCf3nXfe4V/+5V/o1q0bffv25fHHH/d9zax7O3z4MHfffTepqanExsaSlpbG0qVLOXfunN+a5h63nTt3mnpvACkpKU3mXr58ud+ay/Fxa+n/SxaLhd27dwPmfNw++eQT5s+fT3p6OrGxsdhsNhYsWIDH4/FbV1tby5QpU4iLi6N3794UFhbyxRdfNPln0NLzZHtFRCGePXuWoUOHsnr16iZf+/TTT6mqqsJut1NVVcUf/vAH9u/fzy233OK3Ljc3l7/+9a9s3ryZP/7xj2zdupUf//jHrX7fRYsW8eqrr/L73/+eN998k2PHjvG9732vybrS0lLq6up8t9tuu833NbfbzZQpU8jKyqK6upqFCxdyzz33sHHjRlPv7fvf/77fnurq6sjOzmbMmDH07t3bL2v//v1+6y5+/VLt7dNPP2XSpEk8+OCDLa5pK9fr9TJx4kT69etHZWUlTzzxBA899BDPPfecqfe2b98+GhsbefbZZ/nrX//KypUrWbNmTbPrt2zZ4ve4XX/99abe20WPPPKI39zz58/3fe1yfdxGjRrV5P9v99xzD6mpqYwYMcJvrZket2PHjnHs2DGefPJJ9u7dS1lZGRs2bODuu+/2rblw4QJTpkzh3LlzbN++nRdeeIGysjJ+8Ytf+Na09TzZbkaEAQyHw9HqmrffftsAjCNHjhiGYRh/+9vfDMDYvXu3b81rr71mWCwW4+jRo81mnDp1yoiOjjZ+//vf+47V1NQYgLFjx452z/OTn/zEGDx4sN+x73//+0Z2drbp9/ZlJ06cMKKjo40XX3zRd8zpdBqAUV9f3+rMX+fevqyl+dqT++tf/9ro0aOH0dDQ4Fvz05/+1EhPTzf13prz+OOPG6mpqb77brfbAIw9e/a0ea7Z9tavXz9j5cqVLZ7bWR63c+fOGb169TIeeeQR3zGzP24Xvfzyy0bXrl2N8+fPG4ZhGH/605+MLl26GMePH/etKSkpMaxWq+9xCuR5sjUR8QoxUB6PB4vFwtVXXw3Ajh07uPrqq/3+S2v8+PF06dKFXbt2NZtRWVnJ+fPnGT9+vO/Yddddh81mY8eOHX5r586dyzXXXMONN97Ib3/7W7+PNtmxY4dfBkB2dnaTDLPu7aIXX3yRuLg4/vVf/7XJ14YNG0ZSUhITJkzA5XIFta9w7a092pO7Y8cObr75Zrp27epbk52dzf79+6mvrw/4e35de2vpe/fs2bPJ8VtuuYXevXszevRo1q9fH1L+17m35cuXk5CQwPDhw3niiSf8fvTWWR639evX8/HHHzNz5swmXzP74+bxeLBarURFRflyhwwZQp8+fXxrsrOz8Xq9/PWvf/WtCcfzZMS8uXd7ff755/z0pz/lzjvv9L3x7PHjx5v8mC8qKoqePXv6ft/1VcePH6dr166+f1ku6tOnj985jzzyCN/5zneIi4tj06ZN3HfffZw5c4YFCxb4cr78L8LFDK/Xy2effUZsbKxp9/Zla9eu5Qc/+IHfvElJSaxZs4YRI0bQ0NDA888/z9ixY9m1axcZGRnt3lc499Ye7ck9fvw4qampfmsuPo7Hjx+nR48e7f5+X+fevurgwYP86le/4sknn/Qdu+qqq3jqqafIzMykS5cuvPLKK9x2222Ul5c3+RFaW77uvS1YsICMjAx69uzJ9u3bWbJkCXV1dTz99NO+790ZHre1a9eSnZ3t94EGl8PjdvLkSYqKivx+zNrSc+DFr7W2JtDnSRXil5w/f5477rgDwzAoKSn5Wr6n3W73/e/hw4dz9uxZnnjiCV8hhsul2NtFO3bsoKamhv/8z//0O56enk56errv/qhRozh06BArV65ssrY1l3JvHe1S7u3o0aNMmjSJ6dOn86Mf/ch3/JprrqGgoMB3/4YbbuDYsWM88cQTAT2xXoq9fXnub3/723Tt2pV7772XZcuWhfWtxC7l4/bBBx+wceNGXn75Zb/jZn/cvF4vU6ZMYdCgQTz00ENhyw2EfmT6/7v4IB85coTNmzf7fSxJYmKi78rIi7744gs++eQTEhMTm81LTEzk3LlzTa4G+/DDD1s8B+Cmm27igw8+oKGhwZfz1StTP/zwQ6xWa7v/q+dS7+35559n2LBhvl/et+bGG2/k4MGD7djVP4R7b+3RntyWHreLX2uPS7G3i44dO0ZWVhajRo3yXVDSmptuusn0j1tzbrrpJr744gsOHz7s+96X8+MG/7hILyEhoV0lZ5bH7fTp00yaNInu3bvjcDiIjo72y23rMQnH8ySoEIH/9yC/9957bNmyhYSEBL+vjxw5klOnTlFZWek79vrrr9PY2MhNN93UbOb1119PdHQ0f/7zn33H9u/fT21tLSNHjmxxlurqanr06OH7r9WRI0f6ZQBs3ry51Qwz7e3MmTO8/PLLfleNtaa6upqkpKRLtrf2aE/uyJEj2bp1K+fPn/et2bx5M+np6e36sdul2hv845Xh2LFjuf766yktLW3XB7FeDo9bS3N36dLF96O+y/lxg398gG5paSk//OEP/UqlJWZ43C5e2du1a1fWr19Pt27dmuS+++67fmV7sYwHDRrkWxPK86RPQJfgXKZOnz5t7Nmzx9izZ48BGE8//bSxZ88e48iRI8a5c+eMW265xbj22muN6upqo66uznf78pVmkyZNMoYPH27s2rXLeOutt4wBAwYYd955p+/rH3zwgZGenm7s2rXLd2z27NmGzWYzXn/9daOiosIYOXKkMXLkSN/X169fb/zmN78x3n33XeO9994zfv3rXxtxcXHGL37xC9+av//970ZcXJxRWFho1NTUGKtXrzauuOIKY8OGDabe20XPP/+80a1bt2avilu5cqVRXl5uvPfee8a7775r3H///UaXLl2MLVu2XNK91dXVGXv27DF+85vfGICxdetWY8+ePcbHH3/c7txTp04Zffr0MfLy8oy9e/cav/vd74y4uDjj2WefNfXePvjgA6N///7GuHHjjA8++MDve19UVlZmvPTSS0ZNTY1RU1NjPProo0aXLl2M3/72t6be2/bt242VK1ca1dXVxqFDh4x169YZvXr1Mn74wx9e9o/bRVu2bDEAo6amxvgqMz5uHo/HuOmmm4whQ4YYBw8e9Mv94osvDMMwjC+++ML41re+ZUycONGorq42NmzYYPTq1ctYsmSJL7et58n2iohCvHip8ldv+fn5vkuRm7s5nU5fxscff2zceeedxlVXXWVYrVZj5syZxunTp31fv5jz5XM+++wz47777jN69OhhxMXFGdOmTfN7YnnttdeMYcOGGVdddZVx5ZVXGkOHDjXWrFljXLhwocn8w4YNM7p27Wp885vfNEpLS02/t4tGjhxp/OAHP2j2cVmxYoWRlpZmdOvWzejZs6cxduxY4/XXX7/ke1u6dGmzuV/+595WrmEYxl/+8hdj9OjRRkxMjPGNb3zDWL58uen3Vlpa2uL3vqisrMwYOHCgERcXZ1itVuPGG2/0+xMcs+6tsrLSuOmmm4z4+HijW7duxsCBA43HHnvM+Pzzzy/7x+2iO++80xg1apTRHDM+bi19T8Bwu92+8w4fPmzk5OQYsbGxxjXXXGMsXrzY92cZX56/pefJ9tLHP4mIiKDfIYqIiAAqRBEREUCFKCIiAqgQRUREABWiiIgIoEIUEREBVIgiIiKAClFERARQIYqIiAAqRBEREUCFKCIiAqgQRUREAPj/AHY/vL9lr0z6AAAAAElFTkSuQmCC",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1057,7 +1033,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": null,
    "id": "5033161b-a163-492e-960d-6e6eaa389df0",
    "metadata": {},
    "outputs": [
@@ -1065,8 +1041,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 20.2 ms, sys: 0 ns, total: 20.2 ms\n",
-      "Wall time: 18.7 ms\n"
+      "CPU times: user 5.02 ms, sys: 454 µs, total: 5.47 ms\n",
+      "Wall time: 5.32 ms\n"
      ]
     }
    ],
@@ -1077,7 +1053,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": null,
    "id": "5513e071-e8d5-4952-9af5-dfe2eb5f58a9",
    "metadata": {},
    "outputs": [
@@ -1087,7 +1063,7 @@
        "20"
       ]
      },
-     "execution_count": 37,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1098,7 +1074,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": null,
    "id": "31677ee2-2e13-4ff3-b153-b8048954879b",
    "metadata": {},
    "outputs": [
@@ -1133,25 +1109,25 @@
        "      <th>0</th>\n",
        "      <td>269</td>\n",
        "      <td>239</td>\n",
-       "      <td>POLYGON ((122.20230 16.47686, 122.21128 16.476...</td>\n",
+       "      <td>POLYGON ((122.2023 16.47686, 122.21128 16.4768...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
        "      <td>269</td>\n",
        "      <td>240</td>\n",
-       "      <td>POLYGON ((122.20230 16.48548, 122.21128 16.485...</td>\n",
+       "      <td>POLYGON ((122.2023 16.48548, 122.21128 16.4854...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
        "      <td>269</td>\n",
        "      <td>241</td>\n",
-       "      <td>POLYGON ((122.20230 16.49409, 122.21128 16.494...</td>\n",
+       "      <td>POLYGON ((122.2023 16.49409, 122.21128 16.4940...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
        "      <td>269</td>\n",
        "      <td>242</td>\n",
-       "      <td>POLYGON ((122.20230 16.50270, 122.21128 16.502...</td>\n",
+       "      <td>POLYGON ((122.2023 16.5027, 122.21128 16.5027,...</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
@@ -1165,14 +1141,14 @@
       ],
       "text/plain": [
        "     x    y                                           geometry\n",
-       "0  269  239  POLYGON ((122.20230 16.47686, 122.21128 16.476...\n",
-       "1  269  240  POLYGON ((122.20230 16.48548, 122.21128 16.485...\n",
-       "2  269  241  POLYGON ((122.20230 16.49409, 122.21128 16.494...\n",
-       "3  269  242  POLYGON ((122.20230 16.50270, 122.21128 16.502...\n",
+       "0  269  239  POLYGON ((122.2023 16.47686, 122.21128 16.4768...\n",
+       "1  269  240  POLYGON ((122.2023 16.48548, 122.21128 16.4854...\n",
+       "2  269  241  POLYGON ((122.2023 16.49409, 122.21128 16.4940...\n",
+       "3  269  242  POLYGON ((122.2023 16.5027, 122.21128 16.5027,...\n",
        "4  270  239  POLYGON ((122.21128 16.47686, 122.22027 16.476..."
       ]
      },
-     "execution_count": 38,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1183,20 +1159,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": null,
    "id": "ee6b820c-dd65-470c-ac02-c818ad8b935f",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1206,20 +1180,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": null,
    "id": "ef13d939-6418-473e-b6e5-1a45c230ba83",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1232,9 +1204,7 @@
   {
    "cell_type": "markdown",
    "id": "39f1ea27-9790-44fe-b5c0-f4bc774f608b",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "source": [
     "## Generating grids for multiple distant areas\n",
     "If you are using AOIs that are vary far from each other, Grid Generator already optmizes the implementation for you\n"
@@ -1242,20 +1212,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": null,
    "id": "a8c8c992-8232-448e-a24d-cbc0a4decc30",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1269,7 +1237,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": null,
    "id": "295ef464-9ee0-42a4-939f-475168e32533",
    "metadata": {},
    "outputs": [],
@@ -1279,20 +1247,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 43,
+   "execution_count": null,
    "id": "c5b73551-6e4a-40af-b51a-600513f3b2e0",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1311,20 +1277,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 44,
+   "execution_count": null,
    "id": "2365f4e2-34b2-4f37-ac49-54a278bdc754",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1344,7 +1308,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": null,
    "id": "e749c420-4777-4db2-aea9-fc35c52ca767",
    "metadata": {},
    "outputs": [],
@@ -1354,7 +1318,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": null,
    "id": "a7112cb1-2921-4612-af44-b8ecc1129fe8",
    "metadata": {},
    "outputs": [
@@ -1362,8 +1326,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 2.79 s, sys: 6.39 ms, total: 2.8 s\n",
-      "Wall time: 2.81 s\n"
+      "CPU times: user 1.44 s, sys: 69.8 ms, total: 1.51 s\n",
+      "Wall time: 1.54 s\n"
      ]
     }
    ],
@@ -1374,20 +1338,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": null,
    "id": "8283168b-8e11-436f-9f56-a395d8bc1b2e",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1407,7 +1369,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": null,
    "id": "51341c59-7d3b-4bc4-80db-c6f3ad7ad097",
    "metadata": {},
    "outputs": [],
@@ -1417,7 +1379,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 49,
+   "execution_count": null,
    "id": "5167a86b-3d0f-4bd7-84ec-ba00a0405cdf",
    "metadata": {},
    "outputs": [
@@ -1425,8 +1387,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 2.75 s, sys: 26.9 ms, total: 2.78 s\n",
-      "Wall time: 2.78 s\n"
+      "CPU times: user 1.44 s, sys: 69 ms, total: 1.51 s\n",
+      "Wall time: 1.52 s\n"
      ]
     }
    ],
@@ -1437,7 +1399,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 50,
+   "execution_count": null,
    "id": "b72b45f0-ef82-49fc-b5fa-3350efc28fe7",
    "metadata": {},
    "outputs": [
@@ -1447,7 +1409,7 @@
        "84"
       ]
      },
-     "execution_count": 50,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1458,7 +1420,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 51,
+   "execution_count": null,
    "id": "3a6862f8-2006-47e3-a3e8-598c14980a8f",
    "metadata": {},
    "outputs": [
@@ -1489,23 +1451,23 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>85694103fffffff</td>\n",
+       "      <td>85694ccffffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>856941d7fffffff</td>\n",
+       "      <td>85694187fffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>85694e83fffffff</td>\n",
+       "      <td>85694107fffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>85694e93fffffff</td>\n",
+       "      <td>856943abfffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>85694387fffffff</td>\n",
+       "      <td>8569411bfffffff</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1513,14 +1475,14 @@
       ],
       "text/plain": [
        "            hex_id\n",
-       "0  85694103fffffff\n",
-       "1  856941d7fffffff\n",
-       "2  85694e83fffffff\n",
-       "3  85694e93fffffff\n",
-       "4  85694387fffffff"
+       "0  85694ccffffffff\n",
+       "1  85694187fffffff\n",
+       "2  85694107fffffff\n",
+       "3  856943abfffffff\n",
+       "4  8569411bfffffff"
       ]
      },
-     "execution_count": 51,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1541,7 +1503,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 52,
+   "execution_count": null,
    "id": "d1142166-24f7-449d-9255-89b86b0d025a",
    "metadata": {},
    "outputs": [],
@@ -1551,7 +1513,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": null,
    "id": "5f2752e4-3a8f-428f-b48f-d4e12448dc1c",
    "metadata": {},
    "outputs": [
@@ -1559,8 +1521,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 7.37 s, sys: 0 ns, total: 7.37 s\n",
-      "Wall time: 7.37 s\n"
+      "CPU times: user 3.46 s, sys: 66.7 ms, total: 3.53 s\n",
+      "Wall time: 3.58 s\n"
      ]
     }
    ],
@@ -1572,20 +1534,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 54,
+   "execution_count": null,
    "id": "d78a4698-1e95-4b67-b1ec-3d6274d5671b",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
+       "<Figure size 640x480 with 1 Axes>"
       ]
      },
-     "metadata": {
-      "needs_background": "light"
-     },
+     "metadata": {},
      "output_type": "display_data"
     }
    ],
@@ -1598,9 +1558,7 @@
   {
    "cell_type": "markdown",
    "id": "3d4f5a18-cf9d-4cc1-a2b4-a768e2e18ea8",
-   "metadata": {
-    "tags": []
-   },
+   "metadata": {},
    "source": [
     "### Not exporting geometry\n",
     "\n",
@@ -1609,7 +1567,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": null,
    "id": "c36c4083-c542-4993-b6ae-9c433ad04265",
    "metadata": {},
    "outputs": [],
@@ -1621,7 +1579,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": null,
    "id": "4422e030-9268-4933-8c66-90ef4952ab12",
    "metadata": {},
    "outputs": [
@@ -1629,8 +1587,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 7.45 s, sys: 7.19 ms, total: 7.45 s\n",
-      "Wall time: 7.45 s\n"
+      "CPU times: user 3.47 s, sys: 50.2 ms, total: 3.52 s\n",
+      "Wall time: 3.53 s\n"
      ]
     }
    ],
@@ -1642,7 +1600,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": null,
    "id": "5bbc35cc-1ebe-4c3f-a7b2-aff8a271c361",
    "metadata": {},
    "outputs": [
@@ -1704,7 +1662,7 @@
        "4  132303012031"
       ]
      },
-     "execution_count": 57,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1727,7 +1685,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 65,
+   "execution_count": null,
    "id": "09153b22",
    "metadata": {},
    "outputs": [],
@@ -1737,7 +1695,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": null,
    "id": "971c03ba",
    "metadata": {},
    "outputs": [
@@ -1745,8 +1703,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 8.85 s, sys: 20 ms, total: 8.87 s\n",
-      "Wall time: 8.87 s\n"
+      "CPU times: user 3.46 s, sys: 61.4 ms, total: 3.52 s\n",
+      "Wall time: 3.53 s\n"
      ]
     }
    ],
@@ -1758,7 +1716,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": null,
    "id": "1a455ab4",
    "metadata": {},
    "outputs": [
@@ -1851,7 +1809,7 @@
        "4  POLYGON ((119.79492 15.70766, 119.79492 15.792...  "
       ]
      },
-     "execution_count": 67,
+     "execution_count": null,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1861,32 +1819,211 @@
     "bing_region3_keys.head()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "1ca320fb-e931-4b81-ac78-1f41b925ad4b",
+   "metadata": {},
+   "source": [
+    "## Fast Bing Tile Grid Generator\n",
+    "### Generating grids\n",
+    "Let us generate grids of zoom_level 12 using the `FastBingTileGridGenerator`. This should run significantly faster than `BingTileGridGenerator`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44d53b7e-ea7f-4b5a-abb2-fbb47b6e5d9a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fast_bing_tile_grid_generator = grids.FastBingTileGridGenerator(12)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "597bfa50-2ea7-4cbc-ac62-569be911e369",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 45.9 ms, sys: 51 ms, total: 96.9 ms\n",
+      "Wall time: 106 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "fast_bing_tile_gdf = fast_bing_tile_grid_generator.generate_grid(region3_gdf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "714b54b0-93c7-4eea-b32e-09a8fbfccc18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#| no_test\n",
+    "ax = region3_gdf.plot(facecolor=\"none\", edgecolor=\"blue\")\n",
+    "ax = fast_bing_tile_gdf.plot(ax=ax, facecolor=\"none\", edgecolor=\"green\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "550d2c31-881f-4305-99dc-2740cc930a62",
+   "metadata": {},
+   "source": [
+    "Since `FastBingTileGridGenerator` uses a different algorithm to find the tiles inside a polygon, the tiles aren't always exact but it's typically close.\n",
+    "\n",
+    "In the case below, there's a 1 tile mismatch. There's 1 tile available in `BingTileGridGenerator` but not in `FastBingTileGridGenerator`. This typically happens on some corners of polygons."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4f3103cf-28a5-4364-bce8-1aceb606774f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(319, 318)"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "bing_tile_gdf.shape[0], fast_bing_tile_gdf.shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b1a3c07e-32eb-4b9e-b130-1d710becebe3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#| no_test\n",
+    "\n",
+    "bool_mask = ~bing_tile_gdf[\"quadkey\"].isin(fast_bing_tile_gdf[\"quadkey\"])\n",
+    "ax = region3_gdf.plot(facecolor=\"none\", edgecolor=\"blue\")\n",
+    "ax = bing_tile_gdf.loc[bool_mask,:].plot(ax=ax, facecolor=\"none\", edgecolor=\"green\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a97bd715-9377-4244-aa32-ac9fa29d1f80",
+   "metadata": {},
+   "source": [
+    "We can even use a higher zoom_level, say 17, and `FastBingTileGridGenerator` will still run significantly faster than `BingTileGridGenerator` at zoom_level 12 despite the former having ~783 times more grid tiles."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "b59c213f",
+   "id": "300455fd-3b9a-4c39-a2a9-680762b3c67e",
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "fast_bing_tile_grid_generator = grids.FastBingTileGridGenerator(17)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "dd22df4b-b9ac-421a-983b-81bfe706bfa5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CPU times: user 732 ms, sys: 73.1 ms, total: 805 ms\n",
+      "Wall time: 785 ms\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "fast_bing_tile_gdf = fast_bing_tile_grid_generator.generate_grid(region3_gdf)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "61a79876-06a2-43f0-8772-d57b8ba274fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "249646"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fast_bing_tile_gdf.shape[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "63b933cf-df68-4f23-942b-d9e84e3d2419",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "782.58934169279"
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "fast_bing_tile_gdf.shape[0]/bing_region3_keys.shape[0]"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "python3",
    "language": "python",
    "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.10"
   }
  },
  "nbformat": 4,

From 30d995601e1dcb464a33eae9419178e9199d6a1c Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Mon, 5 Aug 2024 22:42:00 +0800
Subject: [PATCH 07/21] add usage of unique_id_col in grids tutorial

---
 notebooks/tutorial.grids.ipynb | 154 +++++++++++++++++++++++++--------
 1 file changed, 119 insertions(+), 35 deletions(-)

diff --git a/notebooks/tutorial.grids.ipynb b/notebooks/tutorial.grids.ipynb
index b599b1c..53c9f79 100644
--- a/notebooks/tutorial.grids.ipynb
+++ b/notebooks/tutorial.grids.ipynb
@@ -419,8 +419,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 360 ms, sys: 47 ms, total: 407 ms\n",
-      "Wall time: 443 ms\n"
+      "CPU times: user 345 ms, sys: 37 ms, total: 382 ms\n",
+      "Wall time: 392 ms\n"
      ]
     }
    ],
@@ -679,8 +679,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 316 ms, sys: 40 ms, total: 356 ms\n",
-      "Wall time: 363 ms\n"
+      "CPU times: user 315 ms, sys: 35.2 ms, total: 350 ms\n",
+      "Wall time: 355 ms\n"
      ]
     }
    ],
@@ -894,8 +894,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 10.8 ms, sys: 1.4 ms, total: 12.2 ms\n",
-      "Wall time: 11.5 ms\n"
+      "CPU times: user 10.1 ms, sys: 1.82 ms, total: 11.9 ms\n",
+      "Wall time: 10.8 ms\n"
      ]
     }
    ],
@@ -1041,8 +1041,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 5.02 ms, sys: 454 µs, total: 5.47 ms\n",
-      "Wall time: 5.32 ms\n"
+      "CPU times: user 5.15 ms, sys: 752 µs, total: 5.9 ms\n",
+      "Wall time: 5.45 ms\n"
      ]
     }
    ],
@@ -1326,8 +1326,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 1.44 s, sys: 69.8 ms, total: 1.51 s\n",
-      "Wall time: 1.54 s\n"
+      "CPU times: user 1.43 s, sys: 66.1 ms, total: 1.49 s\n",
+      "Wall time: 1.5 s\n"
      ]
     }
    ],
@@ -1344,7 +1344,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1387,8 +1387,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 1.44 s, sys: 69 ms, total: 1.51 s\n",
-      "Wall time: 1.52 s\n"
+      "CPU times: user 1.43 s, sys: 61.6 ms, total: 1.5 s\n",
+      "Wall time: 1.53 s\n"
      ]
     }
    ],
@@ -1451,23 +1451,23 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>0</th>\n",
-       "      <td>85694ccffffffff</td>\n",
+       "      <td>856941abfffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>1</th>\n",
-       "      <td>85694187fffffff</td>\n",
+       "      <td>856941a7fffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>2</th>\n",
-       "      <td>85694107fffffff</td>\n",
+       "      <td>85694137fffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>3</th>\n",
-       "      <td>856943abfffffff</td>\n",
+       "      <td>85694e93fffffff</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>4</th>\n",
-       "      <td>8569411bfffffff</td>\n",
+       "      <td>85694123fffffff</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
        "</table>\n",
@@ -1475,11 +1475,11 @@
       ],
       "text/plain": [
        "            hex_id\n",
-       "0  85694ccffffffff\n",
-       "1  85694187fffffff\n",
-       "2  85694107fffffff\n",
-       "3  856943abfffffff\n",
-       "4  8569411bfffffff"
+       "0  856941abfffffff\n",
+       "1  856941a7fffffff\n",
+       "2  85694137fffffff\n",
+       "3  85694e93fffffff\n",
+       "4  85694123fffffff"
       ]
      },
      "execution_count": null,
@@ -1521,8 +1521,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 3.46 s, sys: 66.7 ms, total: 3.53 s\n",
-      "Wall time: 3.58 s\n"
+      "CPU times: user 3.45 s, sys: 57.9 ms, total: 3.51 s\n",
+      "Wall time: 3.53 s\n"
      ]
     }
    ],
@@ -1587,8 +1587,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 3.47 s, sys: 50.2 ms, total: 3.52 s\n",
-      "Wall time: 3.53 s\n"
+      "CPU times: user 3.44 s, sys: 53 ms, total: 3.5 s\n",
+      "Wall time: 3.51 s\n"
      ]
     }
    ],
@@ -1703,8 +1703,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 3.46 s, sys: 61.4 ms, total: 3.52 s\n",
-      "Wall time: 3.53 s\n"
+      "CPU times: user 3.47 s, sys: 52.9 ms, total: 3.52 s\n",
+      "Wall time: 3.54 s\n"
      ]
     }
    ],
@@ -1849,8 +1849,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 45.9 ms, sys: 51 ms, total: 96.9 ms\n",
-      "Wall time: 106 ms\n"
+      "CPU times: user 48.5 ms, sys: 51.8 ms, total: 100 ms\n",
+      "Wall time: 97.1 ms\n"
      ]
     }
    ],
@@ -1943,7 +1943,9 @@
    "id": "a97bd715-9377-4244-aa32-ac9fa29d1f80",
    "metadata": {},
    "source": [
-    "We can even use a higher zoom_level, say 17, and `FastBingTileGridGenerator` will still run significantly faster than `BingTileGridGenerator` at zoom_level 12 despite the former having ~783 times more grid tiles."
+    "We can even use a higher zoom_level, say 17, and `FastBingTileGridGenerator` will still run significantly faster than `BingTileGridGenerator` at zoom_level 12 despite the former having ~783 times more grid tiles.\n",
+    "\n",
+    "We can also pass in a column name to `unique_id_col` so that the grids can preserve the ID from the AOI. This makes it convenient so you don't have to do another spatial intersection between the tiles gdf and the AOI gdf to get the AOI IDs."
    ]
   },
   {
@@ -1966,14 +1968,96 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 732 ms, sys: 73.1 ms, total: 805 ms\n",
-      "Wall time: 785 ms\n"
+      "CPU times: user 808 ms, sys: 94 ms, total: 902 ms\n",
+      "Wall time: 858 ms\n"
      ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Reg_Name</th>\n",
+       "      <th>quadkey</th>\n",
+       "      <th>geometry</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Region III</td>\n",
+       "      <td>13230310022202003</td>\n",
+       "      <td>POLYGON ((120.94299 16.01942, 120.94299 16.022...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Region III</td>\n",
+       "      <td>13230310203301302</td>\n",
+       "      <td>POLYGON ((121.23688 15.6918, 121.23688 15.6944...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Region III</td>\n",
+       "      <td>13230310220201233</td>\n",
+       "      <td>POLYGON ((120.97046 15.51721, 120.97046 15.519...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Region III</td>\n",
+       "      <td>13230301302232013</td>\n",
+       "      <td>POLYGON ((120.28931 15.63891, 120.28931 15.641...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Region III</td>\n",
+       "      <td>13230301320120322</td>\n",
+       "      <td>POLYGON ((120.336 15.55954, 120.336 15.56219, ...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     Reg_Name            quadkey  \\\n",
+       "0  Region III  13230310022202003   \n",
+       "1  Region III  13230310203301302   \n",
+       "2  Region III  13230310220201233   \n",
+       "3  Region III  13230301302232013   \n",
+       "4  Region III  13230301320120322   \n",
+       "\n",
+       "                                            geometry  \n",
+       "0  POLYGON ((120.94299 16.01942, 120.94299 16.022...  \n",
+       "1  POLYGON ((121.23688 15.6918, 121.23688 15.6944...  \n",
+       "2  POLYGON ((120.97046 15.51721, 120.97046 15.519...  \n",
+       "3  POLYGON ((120.28931 15.63891, 120.28931 15.641...  \n",
+       "4  POLYGON ((120.336 15.55954, 120.336 15.56219, ...  "
+      ]
+     },
+     "execution_count": null,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
     "%%time\n",
-    "fast_bing_tile_gdf = fast_bing_tile_grid_generator.generate_grid(region3_gdf)"
+    "fast_bing_tile_gdf = fast_bing_tile_grid_generator.generate_grid(region3_gdf, unique_id_col = \"Reg_Name\")\n",
+    "fast_bing_tile_gdf.head()"
    ]
   },
   {

From 8bed2285bb1bc72b2e980aa67249db739912f969 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 20:41:05 +0800
Subject: [PATCH 08/21] convert unary_union to union_all in gridding, and
 update FastBingTileGenerator

---
 geowrangler/grids.py     | 43 ++++++++++++++++++++----------------
 notebooks/00_grids.ipynb | 47 ++++++++++++++++++++++------------------
 2 files changed, 50 insertions(+), 40 deletions(-)

diff --git a/geowrangler/grids.py b/geowrangler/grids.py
index 688808b..1390b5c 100644
--- a/geowrangler/grids.py
+++ b/geowrangler/grids.py
@@ -120,7 +120,7 @@ def generate_grid(self: SquareGridGenerator, gdf: GeoDataFrame) -> GeoDataFrame:
         boundary = SquareGridBoundary(x_min, y_min, x_max, y_max)
 
     polygons = {}
-    unary_union = reprojected_gdf.unary_union
+    unary_union = reprojected_gdf.union_all(method="unary")
     if isinstance(unary_union, Polygon):
         polygons.update(self.create_grid_for_polygon(boundary, unary_union))
     else:
@@ -161,11 +161,11 @@ def get_hexes_for_polygon(self: H3GridGenerator, poly: Polygon):
 def generate_grid(self: H3GridGenerator, gdf: GeoDataFrame) -> DataFrame:
     reprojected_gdf = gdf.to_crs("epsg:4326")  # h3 hexes are in epsg:4326 CRS
     hex_ids = set()
-    unary_union = reprojected_gdf.unary_union
+    unary_union = reprojected_gdf.union_all(method="unary")
     if isinstance(unary_union, Polygon):
         hex_ids.update(self.get_hexes_for_polygon(unary_union))
     else:
-        for geom in reprojected_gdf.unary_union.geoms:
+        for geom in unary_union.geoms:
             _hexes = self.get_hexes_for_polygon(geom)
             hex_ids.update(_hexes)
     df = DataFrame({"hex_id": list(hex_ids)})
@@ -234,11 +234,11 @@ def get_all_tiles_for_polygon(self: BingTileGridGenerator, polygon: Polygon):
 def generate_grid(self: BingTileGridGenerator, gdf: GeoDataFrame) -> DataFrame:
     reprojected_gdf = gdf.to_crs("epsg:4326")  # quadkeys hexes are in epsg:4326 CRS
     tiles = {}
-    unary_union = reprojected_gdf.unary_union
+    unary_union = reprojected_gdf.union_all(method="unary")
     if isinstance(unary_union, Polygon):
         tiles.update(self.get_tiles_for_polygon(unary_union))
     else:
-        for geom in reprojected_gdf.unary_union.geoms:
+        for geom in unary_union.geoms:
             _tiles = self.get_tiles_for_polygon(geom)
             tiles.update(_tiles)
     quadkey, geom_tile = zip(*((k, v) for k, v in tiles.items()))
@@ -307,11 +307,11 @@ def generate_grid_join(
         ["geometry"]
     ]  # quadkeys hexes are in epsg:4326 CRS
     tiles = []
-    unary_union = reprojected_gdf.unary_union
+    unary_union = reprojected_gdf.union_all(method="unary")
     if isinstance(unary_union, Polygon):
         tiles += self.get_all_tiles_for_polygon(unary_union)
     else:
-        for geom in reprojected_gdf.unary_union.geoms:
+        for geom in unary_union.geoms:
             tiles += self.get_all_tiles_for_polygon(
                 geom,
             )
@@ -389,22 +389,22 @@ def generate_grid(
         if unique_id_col is not None:
             id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
         else:
-            id_cols = [self.SUBPOLYGON_ID_COL]
+            complement_cols = ["x", "y", self.SUBPOLYGON_ID_COL]
+            unique_id_col = list(set(vertices.columns) - set(complement_cols))
+            assert len(unique_id_col) == 1
+            unique_id_col = unique_id_col[0]
+
+            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
 
         polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()
 
         tiles_in_geom = set()
         for polygon_id in polygon_ids:
-            if len(id_cols) == 2:
-                subpolygon_id, unique_id = polygon_id
-                filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (
-                    pl.col(unique_id_col) == unique_id
-                )
-                poly_vertices = vertices.filter(filter_expr)
-            else:
-                subpolygon_id = polygon_id[0]
-                filter_expr = pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id
-                poly_vertices = vertices.filter(filter_expr)
+            subpolygon_id, unique_id = polygon_id
+            filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (
+                pl.col(unique_id_col) == unique_id
+            )
+            poly_vertices = vertices.filter(filter_expr)
 
             poly_vertices = poly_vertices.unique(maintain_order=True)
             _tiles_in_geom = voxel_traversal_scanline_fill(
@@ -448,7 +448,7 @@ def generate_grid(
             tiles_in_geom = tiles_in_geom.drop(["x", "y"])
         else:
             tiles_in_geom = tiles_in_geom.with_columns(z=pl.lit(self.zoom_level))
-            column_order = ["x", "y", "z", "quadkey"]
+            column_order = ["quadkey", "x", "y", "z"]
             if unique_id_col is not None:
                 column_order += [unique_id_col]
             assert set(tiles_in_geom.columns) == set(column_order)
@@ -561,6 +561,11 @@ def _polygons_to_vertices(
                     Found {duplicates_bool.sum():,} duplicates"""
                 )
             polys_gdf = polys_gdf.set_index(unique_id_col)
+        else:
+            # reset index if it is not unique
+            if polys_gdf.index.nunique() != len(polys_gdf.index):
+                polys_gdf = polys_gdf.reset_index(drop=True)
+            unique_id_col = polys_gdf.index.name
 
         polys_gdf = polys_gdf.explode(index_parts=True)
 
diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index dd39e6f..50037a2 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -219,7 +219,7 @@
     "        boundary = SquareGridBoundary(x_min, y_min, x_max, y_max)\n",
     "\n",
     "    polygons = {}\n",
-    "    unary_union = reprojected_gdf.unary_union\n",
+    "    unary_union = reprojected_gdf.union_all(method=\"unary\")\n",
     "    if isinstance(unary_union, Polygon):\n",
     "        polygons.update(self.create_grid_for_polygon(boundary, unary_union))\n",
     "    else:\n",
@@ -281,11 +281,11 @@
     "def generate_grid(self: H3GridGenerator, gdf: GeoDataFrame) -> DataFrame:\n",
     "    reprojected_gdf = gdf.to_crs(\"epsg:4326\")  # h3 hexes are in epsg:4326 CRS\n",
     "    hex_ids = set()\n",
-    "    unary_union = reprojected_gdf.unary_union\n",
+    "    unary_union = reprojected_gdf.union_all(method=\"unary\")\n",
     "    if isinstance(unary_union, Polygon):\n",
     "        hex_ids.update(self.get_hexes_for_polygon(unary_union))\n",
     "    else:\n",
-    "        for geom in reprojected_gdf.unary_union.geoms:\n",
+    "        for geom in unary_union.geoms:\n",
     "            _hexes = self.get_hexes_for_polygon(geom)\n",
     "            hex_ids.update(_hexes)\n",
     "    df = DataFrame({\"hex_id\": list(hex_ids)})\n",
@@ -375,11 +375,11 @@
     "def generate_grid(self: BingTileGridGenerator, gdf: GeoDataFrame) -> DataFrame:\n",
     "    reprojected_gdf = gdf.to_crs(\"epsg:4326\")  # quadkeys hexes are in epsg:4326 CRS\n",
     "    tiles = {}\n",
-    "    unary_union = reprojected_gdf.unary_union\n",
+    "    unary_union = reprojected_gdf.union_all(method=\"unary\")\n",
     "    if isinstance(unary_union, Polygon):\n",
     "        tiles.update(self.get_tiles_for_polygon(unary_union))\n",
     "    else:\n",
-    "        for geom in reprojected_gdf.unary_union.geoms:\n",
+    "        for geom in unary_union.geoms:\n",
     "            _tiles = self.get_tiles_for_polygon(geom)\n",
     "            tiles.update(_tiles)\n",
     "    quadkey, geom_tile = zip(*((k, v) for k, v in tiles.items()))\n",
@@ -471,11 +471,11 @@
     "        [\"geometry\"]\n",
     "    ]  # quadkeys hexes are in epsg:4326 CRS\n",
     "    tiles = []\n",
-    "    unary_union = reprojected_gdf.unary_union\n",
+    "    unary_union = reprojected_gdf.union_all(method=\"unary\")\n",
     "    if isinstance(unary_union, Polygon):\n",
     "        tiles += self.get_all_tiles_for_polygon(unary_union)\n",
     "    else:\n",
-    "        for geom in reprojected_gdf.unary_union.geoms:\n",
+    "        for geom in unary_union.geoms:\n",
     "            tiles += self.get_all_tiles_for_polygon(\n",
     "                geom,\n",
     "            )\n",
@@ -565,27 +565,27 @@
     "        \n",
     "        vertices = self._polygons_to_vertices(aoi_gdf, unique_id_col)\n",
     "        vertices = self._latlng_to_xy(vertices, lat_col=\"y\", lng_col=\"x\")\n",
-    "    \n",
+    "\n",
     "        if unique_id_col is not None:\n",
     "            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
     "        else:\n",
-    "            id_cols = [self.SUBPOLYGON_ID_COL]\n",
+    "            complement_cols = [\"x\",\"y\",self.SUBPOLYGON_ID_COL]\n",
+    "            unique_id_col = list(set(vertices.columns) - set(complement_cols))\n",
+    "            assert len(unique_id_col) == 1\n",
+    "            unique_id_col = unique_id_col[0]\n",
+    "            \n",
+    "            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
     "    \n",
     "        polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()\n",
     "    \n",
     "        tiles_in_geom = set()\n",
     "        for polygon_id in polygon_ids:\n",
-    "            if len(id_cols) == 2:\n",
-    "                subpolygon_id, unique_id = polygon_id\n",
-    "                filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (\n",
-    "                    pl.col(unique_id_col) == unique_id\n",
-    "                )\n",
-    "                poly_vertices = vertices.filter(filter_expr)\n",
-    "            else:\n",
-    "                subpolygon_id = polygon_id[0]\n",
-    "                filter_expr = pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id\n",
-    "                poly_vertices = vertices.filter(filter_expr)\n",
-    "    \n",
+    "            subpolygon_id, unique_id = polygon_id\n",
+    "            filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (\n",
+    "                pl.col(unique_id_col) == unique_id\n",
+    "            )\n",
+    "            poly_vertices = vertices.filter(filter_expr)\n",
+    "            \n",
     "            poly_vertices = poly_vertices.unique(maintain_order=True)\n",
     "            _tiles_in_geom = voxel_traversal_scanline_fill(poly_vertices, x_col=\"x\", y_col=\"y\")\n",
     "    \n",
@@ -626,7 +626,7 @@
     "            tiles_in_geom = tiles_in_geom.drop([\"x\",\"y\"])\n",
     "        else:\n",
     "            tiles_in_geom = tiles_in_geom.with_columns(z = pl.lit(self.zoom_level))\n",
-    "            column_order = [\"x\",\"y\",\"z\",\"quadkey\"]\n",
+    "            column_order = [\"quadkey\",\"x\",\"y\",\"z\"]\n",
     "            if unique_id_col is not None:\n",
     "                column_order += [unique_id_col]\n",
     "            assert set(tiles_in_geom.columns) == set(column_order)\n",
@@ -743,6 +743,11 @@
     "                    Found {duplicates_bool.sum():,} duplicates\"\"\"\n",
     "                )\n",
     "            polys_gdf = polys_gdf.set_index(unique_id_col)\n",
+    "        else:\n",
+    "            # reset index if it is not unique\n",
+    "            if polys_gdf.index.nunique() != len(polys_gdf.index):\n",
+    "                polys_gdf = polys_gdf.reset_index(drop=True)\n",
+    "            unique_id_col = polys_gdf.index.name\n",
     "    \n",
     "        polys_gdf = polys_gdf.explode(index_parts=True)\n",
     "    \n",

From ab4cceb407c69a3d1c6bd99ad0505b94a9ff7955 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 20:43:55 +0800
Subject: [PATCH 09/21] add tests for FastBingTileGridGenerator

---
 tests/test_grids.py | 70 ++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 63 insertions(+), 7 deletions(-)

diff --git a/tests/test_grids.py b/tests/test_grids.py
index 6519862..6396cd1 100644
--- a/tests/test_grids.py
+++ b/tests/test_grids.py
@@ -130,12 +130,15 @@ def test_h3_grid_generator_get_hexes_for_polygon():
     assert len(hex_ids) == 31
 
 
+BING_TILE_N_TILES = 36
+BING_TILE_MULTIPOLY_N_TILES = 46
+
 def test_bing_tile_grid_generator(sample_gdf):
     grid_generator = grids.BingTileGridGenerator(10)
     grids_gdf = grid_generator.generate_grid(sample_gdf)
     assert "geometry" in grids_gdf
     assert isinstance(grids_gdf, gpd.GeoDataFrame)
-    assert len(grids_gdf) == 36
+    assert len(grids_gdf) == BING_TILE_N_TILES
 
 
 def test_bing_tile_grid_generator_mutliple_polygons(sample_gdf):
@@ -155,7 +158,7 @@ def test_bing_tile_grid_generator_mutliple_polygons(sample_gdf):
     grids_gdf = grid_generator.generate_grid(pd.concat([gdf2, sample_gdf]))
     assert "geometry" in grids_gdf
     assert isinstance(grids_gdf, gpd.GeoDataFrame)
-    assert len(grids_gdf) == 46
+    assert len(grids_gdf) == BING_TILE_MULTIPOLY_N_TILES
 
 
 def test_bing_tile_grid_generator_return_geometry_false(
@@ -165,7 +168,7 @@ def test_bing_tile_grid_generator_return_geometry_false(
     grids_gdf = grid_generator.generate_grid(sample_gdf)
     assert "geometry" not in grids_gdf
     assert isinstance(grids_gdf, pd.DataFrame)
-    assert len(grids_gdf) == 36
+    assert len(grids_gdf) == BING_TILE_N_TILES
 
 
 def test_bing_tile_grid_generator_add_xyz_true(
@@ -177,7 +180,7 @@ def test_bing_tile_grid_generator_add_xyz_true(
     assert "y" in grids_gdf
     assert "z" in grids_gdf
     assert isinstance(grids_gdf, pd.DataFrame)
-    assert len(grids_gdf) == 36
+    assert len(grids_gdf) == BING_TILE_N_TILES
 
 
 def test_bing_tile_grid_generator_join(sample_gdf):
@@ -185,7 +188,7 @@ def test_bing_tile_grid_generator_join(sample_gdf):
     grids_gdf = grid_generator.generate_grid_join(sample_gdf)
     assert "geometry" in grids_gdf
     assert isinstance(grids_gdf, gpd.GeoDataFrame)
-    assert len(grids_gdf) == 36
+    assert len(grids_gdf) == BING_TILE_N_TILES
 
 
 def test_bing_tile_grid_generator_join_mutliple_polygons(sample_gdf):
@@ -205,7 +208,7 @@ def test_bing_tile_grid_generator_join_mutliple_polygons(sample_gdf):
     grids_gdf = grid_generator.generate_grid_join(pd.concat([gdf2, sample_gdf]))
     assert "geometry" in grids_gdf
     assert isinstance(grids_gdf, gpd.GeoDataFrame)
-    assert len(grids_gdf) == 46
+    assert len(grids_gdf) == BING_TILE_MULTIPOLY_N_TILES
 
 
 def test_bing_tile_grid_generator_join_return_geometry_false(
@@ -215,4 +218,57 @@ def test_bing_tile_grid_generator_join_return_geometry_false(
     grids_gdf = grid_generator.generate_grid_join(sample_gdf)
     assert "geometry" not in grids_gdf
     assert isinstance(grids_gdf, pd.DataFrame)
-    assert len(grids_gdf) == 36
+    assert len(grids_gdf) == BING_TILE_N_TILES
+
+# FastBingTileGridGenerator has 6 more tiles than  because it considered tiles exactly on the border
+FAST_BING_TILE_N_TILES = BING_TILE_N_TILES + 6
+FAST_BING_TILE_MULTIPOLY_N_TILES = BING_TILE_MULTIPOLY_N_TILES + 6
+
+def test_fast_bing_tile_grid_generator(sample_gdf):
+    grid_generator = grids.FastBingTileGridGenerator(10)
+    grids_gdf = grid_generator.generate_grid(sample_gdf)
+    assert "geometry" in grids_gdf
+    assert isinstance(grids_gdf, gpd.GeoDataFrame)
+    assert len(grids_gdf) == FAST_BING_TILE_N_TILES 
+
+
+def test_fast_bing_tile_grid_generator_mutliple_polygons(sample_gdf):
+    grid_generator = grids.FastBingTileGridGenerator(10)
+    gdf2 = gpd.GeoDataFrame(
+        geometry=[
+            Polygon(
+                [
+                    (3, 3),
+                    (3, 4),
+                    (4, 3),
+                ]
+            )
+        ],
+        crs="EPSG:4326",
+    )
+    grids_gdf = grid_generator.generate_grid(pd.concat([gdf2, sample_gdf]))
+    assert "geometry" in grids_gdf
+    assert isinstance(grids_gdf, gpd.GeoDataFrame)
+    assert len(grids_gdf) == FAST_BING_TILE_MULTIPOLY_N_TILES
+
+
+def test_fast_bing_tile_grid_generator_return_geometry_false(
+    sample_gdf,
+):
+    grid_generator = grids.FastBingTileGridGenerator(10, return_geometry=False)
+    grids_gdf = grid_generator.generate_grid(sample_gdf)
+    assert "geometry" not in grids_gdf
+    assert isinstance(grids_gdf, pd.DataFrame)
+    assert len(grids_gdf) == FAST_BING_TILE_N_TILES
+
+
+def test_fast_bing_tile_grid_generator_add_xyz_true(
+    sample_gdf,
+):
+    grid_generator = grids.FastBingTileGridGenerator(10, add_xyz_cols=True)
+    grids_gdf = grid_generator.generate_grid(sample_gdf)
+    assert "x" in grids_gdf
+    assert "y" in grids_gdf
+    assert "z" in grids_gdf
+    assert isinstance(grids_gdf, pd.DataFrame)
+    assert len(grids_gdf) == FAST_BING_TILE_N_TILES
\ No newline at end of file

From 99005cf215f11a48515b7cc8a14dfecad111e93c Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 20:58:05 +0800
Subject: [PATCH 10/21] clean comments in 15_polygon_fill

---
 notebooks/15_polygon_fill.ipynb | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/notebooks/15_polygon_fill.ipynb b/notebooks/15_polygon_fill.ipynb
index 60f3c72..81735a4 100644
--- a/notebooks/15_polygon_fill.ipynb
+++ b/notebooks/15_polygon_fill.ipynb
@@ -157,7 +157,7 @@
     "    n_imgs_per_row: int = 3,\n",
     "):\n",
     "    n = len(polygon_vertices_dict)\n",
-    "    rows = (n + n_imgs_per_row - 1) // n_imgs_per_row  # Calculate the number of rows needed\n",
+    "    rows = (n + n_imgs_per_row - 1) // n_imgs_per_row \n",
     "    fig, axes = plt.subplots(nrows=rows, ncols=n_imgs_per_row, figsize=(4 * n_imgs_per_row, 4 * rows))\n",
     "\n",
     "    if n_imgs_per_row == 1:\n",
@@ -168,12 +168,11 @@
     "\n",
     "    # Iterate over each polygon and its corresponding pixels\n",
     "    for ax, (name, vertices) in zip(axes_flat, polygon_vertices_dict.items()):\n",
-    "        pixels = polygon_pixels_dict.get(name, set())  # Safely get pixels for the polygon\n",
+    "        pixels = polygon_pixels_dict.get(name, set())\n",
     "        plot_polygon(ax, vertices, pixels)\n",
     "        ax.set_title(name)\n",
-    "        ax.axis('equal')  # Ensure the aspect ratio is equal to properly display polygons\n",
+    "        ax.axis('equal')\n",
     "    \n",
-    "    # Turn off any unused axes\n",
     "    for ax in axes_flat[n:]:\n",
     "        ax.axis('off')\n",
     "    \n",

From 1ee970364360f190830dcf1e12d37c4756e7df57 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 21:30:55 +0800
Subject: [PATCH 11/21] update sidebar.yml with 15_polygon_fill notebook

---
 notebooks/sidebar.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/notebooks/sidebar.yml b/notebooks/sidebar.yml
index 295b60b..64be5b3 100644
--- a/notebooks/sidebar.yml
+++ b/notebooks/sidebar.yml
@@ -23,6 +23,7 @@ website:
       - section: Module Reference
         contents:
           - 00_grids.ipynb
+          - 15_polygon_fill.ipynb
           - 01_validation.ipynb
           - 02_vector_zonal_stats.ipynb
           - 03_raster_zonal_stats.ipynb

From 6276154d8b5283106693f206c7f4363a31845c66 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 22:26:00 +0800
Subject: [PATCH 12/21] update argument comment in FastBingTileGridGenerator

---
 geowrangler/grids.py     | 2 +-
 notebooks/00_grids.ipynb | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/geowrangler/grids.py b/geowrangler/grids.py
index 1390b5c..aa5f6b1 100644
--- a/geowrangler/grids.py
+++ b/geowrangler/grids.py
@@ -364,7 +364,7 @@ def __init__(
         self,
         zoom_level: int,  # Zoom level of tile. See: https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system for more info
         return_geometry: bool = True,  # If geometry should be returned. Setting this to false will only return quadkeys
-        add_xyz_cols: bool = False,  # If quadkey should be converted to their xy values.
+        add_xyz_cols: bool = False,  # If xyz columns should be returned. Unlike BingTileGridGenerator, choosing to return xyz columns doesn't substantionally add compute time.
     ):
         self.zoom_level = zoom_level
         self.return_geometry = return_geometry
diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index 50037a2..855d19e 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -548,7 +548,7 @@
     "        self,\n",
     "        zoom_level: int,  # Zoom level of tile. See: https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system for more info\n",
     "        return_geometry: bool = True,  # If geometry should be returned. Setting this to false will only return quadkeys\n",
-    "        add_xyz_cols: bool = False,  # If quadkey should be converted to their xy values.\n",
+    "        add_xyz_cols: bool = False,  # If xyz columns should be returned. Unlike BingTileGridGenerator, choosing to return xyz columns doesn't substantionally add compute time. \n",
     "    ):\n",
     "        self.zoom_level = zoom_level\n",
     "        self.return_geometry = return_geometry\n",

From 58cc0b12d8dfc521f170bb5e122ab2b0af6bd483 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 22:59:18 +0800
Subject: [PATCH 13/21] fix handling if unique_id_col in
 FastBingTileGridGenerator

---
 geowrangler/grids.py     | 7 ++++---
 notebooks/00_grids.ipynb | 7 ++++---
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/geowrangler/grids.py b/geowrangler/grids.py
index aa5f6b1..c8ef7ec 100644
--- a/geowrangler/grids.py
+++ b/geowrangler/grids.py
@@ -388,13 +388,14 @@ def generate_grid(
 
         if unique_id_col is not None:
             id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
+            has_unique_id_col = True
         else:
             complement_cols = ["x", "y", self.SUBPOLYGON_ID_COL]
             unique_id_col = list(set(vertices.columns) - set(complement_cols))
             assert len(unique_id_col) == 1
             unique_id_col = unique_id_col[0]
-
             id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
+            has_unique_id_col = False
 
         polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()
 
@@ -411,13 +412,13 @@ def generate_grid(
                 poly_vertices, x_col="x", y_col="y"
             )
 
-            if len(id_cols) == 2:
+            if has_unique_id_col:
                 _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]
 
             tiles_in_geom.update(_tiles_in_geom)
 
         schema = {"x": self.PIXEL_DTYPE, "y": self.PIXEL_DTYPE}
-        if len(id_cols) == 2:
+        if has_unique_id_col:
             schema[unique_id_col] = vertices[unique_id_col].dtype
 
         tiles_in_geom = pl.from_records(
diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index 855d19e..fa761ca 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -568,13 +568,14 @@
     "\n",
     "        if unique_id_col is not None:\n",
     "            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
+    "            has_unique_id_col = True\n",
     "        else:\n",
     "            complement_cols = [\"x\",\"y\",self.SUBPOLYGON_ID_COL]\n",
     "            unique_id_col = list(set(vertices.columns) - set(complement_cols))\n",
     "            assert len(unique_id_col) == 1\n",
     "            unique_id_col = unique_id_col[0]\n",
-    "            \n",
     "            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
+    "            has_unique_id_col = False\n",
     "    \n",
     "        polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()\n",
     "    \n",
@@ -589,13 +590,13 @@
     "            poly_vertices = poly_vertices.unique(maintain_order=True)\n",
     "            _tiles_in_geom = voxel_traversal_scanline_fill(poly_vertices, x_col=\"x\", y_col=\"y\")\n",
     "    \n",
-    "            if len(id_cols) == 2:\n",
+    "            if has_unique_id_col:\n",
     "                _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]\n",
     "    \n",
     "            tiles_in_geom.update(_tiles_in_geom)\n",
     "    \n",
     "        schema = {\"x\": self.PIXEL_DTYPE, \"y\": self.PIXEL_DTYPE}\n",
-    "        if len(id_cols) == 2:\n",
+    "        if has_unique_id_col:\n",
     "            schema[unique_id_col] = vertices[unique_id_col].dtype\n",
     "    \n",
     "        tiles_in_geom = pl.from_records(\n",

From 4c6ffc68e33486b51a337d9b780534cf046fa5eb Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 23:08:28 +0800
Subject: [PATCH 14/21] fix bug in FastBingTileGridGenerator

---
 geowrangler/grids.py     | 2 +-
 notebooks/00_grids.ipynb | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/geowrangler/grids.py b/geowrangler/grids.py
index c8ef7ec..dd7a5f2 100644
--- a/geowrangler/grids.py
+++ b/geowrangler/grids.py
@@ -450,7 +450,7 @@ def generate_grid(
         else:
             tiles_in_geom = tiles_in_geom.with_columns(z=pl.lit(self.zoom_level))
             column_order = ["quadkey", "x", "y", "z"]
-            if unique_id_col is not None:
+            if has_unique_id_col:
                 column_order += [unique_id_col]
             assert set(tiles_in_geom.columns) == set(column_order)
             tiles_in_geom = tiles_in_geom.select(column_order)
diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index fa761ca..d07d5c7 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -628,7 +628,7 @@
     "        else:\n",
     "            tiles_in_geom = tiles_in_geom.with_columns(z = pl.lit(self.zoom_level))\n",
     "            column_order = [\"quadkey\",\"x\",\"y\",\"z\"]\n",
-    "            if unique_id_col is not None:\n",
+    "            if has_unique_id_col:\n",
     "                column_order += [unique_id_col]\n",
     "            assert set(tiles_in_geom.columns) == set(column_order)\n",
     "            tiles_in_geom = tiles_in_geom.select(column_order)\n",

From b1af3141a60011042c393c6fe8d36910499d8763 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 23:23:27 +0800
Subject: [PATCH 15/21] update polygon fill notebook with colab button and
 extra boilerplate cells

---
 notebooks/15_polygon_fill.ipynb | 29 +++++++++++++++++++++++++----
 1 file changed, 25 insertions(+), 4 deletions(-)

diff --git a/notebooks/15_polygon_fill.ipynb b/notebooks/15_polygon_fill.ipynb
index 81735a4..e254319 100644
--- a/notebooks/15_polygon_fill.ipynb
+++ b/notebooks/15_polygon_fill.ipynb
@@ -6,7 +6,7 @@
    "metadata": {},
    "source": [
     "---\n",
-    "description: polygon fill algorithms\n",
+    "description: polygon fill algorithms for speeding up grid generation\n",
     "output-file: polygon_fill.html\n",
     "title: Polygon Fill\n",
     "\n",
@@ -19,9 +19,7 @@
    "id": "d8a7ff4c-1763-4e17-86fe-7dd0aa78f64a",
    "metadata": {},
    "source": [
-    "[![](https://colab.research.google.com/assets/colab-badge.svg \"Open in Colab button\")]()\n",
-    "\n",
-    "### Colab link to follow"
+    "[![](https://colab.research.google.com/assets/colab-badge.svg \"Open in Colab button\")](https://colab.research.google.com/github/thinkingmachines/geowrangler/blob/master/notebooks/15_polygon_fill.ipynb)"
    ]
   },
   {
@@ -34,6 +32,29 @@
     "#| default_exp gridding_utils.polygon_fill"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22ec5393-a2a4-4d00-a062-08da616dd003",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "446efacd-669d-4f2f-b848-d16335cfed79",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| include: false\n",
+    "#| no_test\n",
+    "![ -e /content ] && pip install -Uqq geowrangler"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

From b7ff449f8483b75ee6859e3bf474fb4a642e8559 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 23:46:22 +0800
Subject: [PATCH 16/21] refactored methods of FastBingTileGridGenerator so it's
 clearer in the docs

---
 geowrangler/gridding_utils/polygon_fill.py |   8 +-
 geowrangler/grids.py                       | 384 +++++++++---------
 notebooks/00_grids.ipynb                   | 433 +++++++++++----------
 notebooks/15_polygon_fill.ipynb            |  90 ++++-
 notebooks/index.ipynb                      |   1 +
 5 files changed, 509 insertions(+), 407 deletions(-)

diff --git a/geowrangler/gridding_utils/polygon_fill.py b/geowrangler/gridding_utils/polygon_fill.py
index 330f385..8c92307 100644
--- a/geowrangler/gridding_utils/polygon_fill.py
+++ b/geowrangler/gridding_utils/polygon_fill.py
@@ -3,14 +3,14 @@
 # %% auto 0
 __all__ = []
 
-# %% ../../notebooks/15_polygon_fill.ipynb 3
+# %% ../../notebooks/15_polygon_fill.ipynb 5
 from typing import List, Tuple, Set, Optional, Dict, Union
 
 import numpy as np
 import pandas as pd
 import polars as pl
 
-# %% ../../notebooks/15_polygon_fill.ipynb 9
+# %% ../../notebooks/15_polygon_fill.ipynb 11
 # epsilon is a constant for correcting near-misses in voxel traversal
 EPSILON = 1e-14
 
@@ -161,7 +161,7 @@ def voxel_traversal_2d(
 
     return pixels
 
-# %% ../../notebooks/15_polygon_fill.ipynb 13
+# %% ../../notebooks/15_polygon_fill.ipynb 15
 def scanline_fill(
     vertices: List[
         Tuple[int, int]
@@ -235,7 +235,7 @@ def interpolate_x(
     interpolated_x = x1 + (y - y1) * inverse_slope
     return interpolated_x
 
-# %% ../../notebooks/15_polygon_fill.ipynb 17
+# %% ../../notebooks/15_polygon_fill.ipynb 19
 def voxel_traversal_scanline_fill(
     vertices_df: Union[
         pd.DataFrame, pl.DataFrame
diff --git a/geowrangler/grids.py b/geowrangler/grids.py
index dd7a5f2..1092e80 100644
--- a/geowrangler/grids.py
+++ b/geowrangler/grids.py
@@ -187,7 +187,7 @@ def __init__(
         self,
         zoom_level: int,  # Zoom level of tile. See: https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system for more info
         return_geometry: bool = True,  # If geometry should be returned. Setting this to false will only return quadkeys
-        add_xyz_cols: bool = False,  # If quadkey should be converted to their xy values.
+        add_xyz_cols: bool = False,  # If quadkey should be converted to their xyz values.
     ):
         self.zoom_level = zoom_level
         self.return_geometry = return_geometry
@@ -375,223 +375,243 @@ def __init__(
                 f"Maximum allowed zoom level is {self.MAX_ZOOM}. Input was {self.zoom_level}"
             )
 
-    def generate_grid(
-        self,
-        aoi_gdf: GeoDataFrame,
-        unique_id_col: Optional[
-            str
-        ] = None,  # the ids under this column will be preserved in the output tiles
-    ) -> Union[GeoDataFrame, pd.DataFrame]:
-
-        vertices = self._polygons_to_vertices(aoi_gdf, unique_id_col)
-        vertices = self._latlng_to_xy(vertices, lat_col="y", lng_col="x")
-
-        if unique_id_col is not None:
-            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
-            has_unique_id_col = True
-        else:
-            complement_cols = ["x", "y", self.SUBPOLYGON_ID_COL]
-            unique_id_col = list(set(vertices.columns) - set(complement_cols))
-            assert len(unique_id_col) == 1
-            unique_id_col = unique_id_col[0]
-            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
-            has_unique_id_col = False
-
-        polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()
-
-        tiles_in_geom = set()
-        for polygon_id in polygon_ids:
-            subpolygon_id, unique_id = polygon_id
-            filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (
-                pl.col(unique_id_col) == unique_id
-            )
-            poly_vertices = vertices.filter(filter_expr)
+# %% ../notebooks/00_grids.ipynb 22
+@patch
+def generate_grid(
+    self: FastBingTileGridGenerator,
+    aoi_gdf: GeoDataFrame,
+    unique_id_col: Optional[
+        str
+    ] = None,  # the ids under this column will be preserved in the output tiles
+) -> Union[GeoDataFrame, pd.DataFrame]:
+
+    vertices = self._polygons_to_vertices(aoi_gdf, unique_id_col)
+    vertices = self._latlng_to_xy(vertices, lat_col="y", lng_col="x")
+
+    if unique_id_col is not None:
+        id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
+        has_unique_id_col = True
+    else:
+        complement_cols = ["x", "y", self.SUBPOLYGON_ID_COL]
+        unique_id_col = list(set(vertices.columns) - set(complement_cols))
+        assert len(unique_id_col) == 1
+        unique_id_col = unique_id_col[0]
+        id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]
+        has_unique_id_col = False
+
+    polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()
+
+    tiles_in_geom = set()
+    for polygon_id in polygon_ids:
+        subpolygon_id, unique_id = polygon_id
+        filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (
+            pl.col(unique_id_col) == unique_id
+        )
+        poly_vertices = vertices.filter(filter_expr)
 
-            poly_vertices = poly_vertices.unique(maintain_order=True)
-            _tiles_in_geom = voxel_traversal_scanline_fill(
-                poly_vertices, x_col="x", y_col="y"
-            )
+        poly_vertices = poly_vertices.unique(maintain_order=True)
+        _tiles_in_geom = voxel_traversal_scanline_fill(
+            poly_vertices, x_col="x", y_col="y"
+        )
 
-            if has_unique_id_col:
-                _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]
+        if has_unique_id_col:
+            _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]
 
-            tiles_in_geom.update(_tiles_in_geom)
+        tiles_in_geom.update(_tiles_in_geom)
 
-        schema = {"x": self.PIXEL_DTYPE, "y": self.PIXEL_DTYPE}
-        if has_unique_id_col:
-            schema[unique_id_col] = vertices[unique_id_col].dtype
+    schema = {"x": self.PIXEL_DTYPE, "y": self.PIXEL_DTYPE}
+    if has_unique_id_col:
+        schema[unique_id_col] = vertices[unique_id_col].dtype
 
-        tiles_in_geom = pl.from_records(
-            data=list(tiles_in_geom),
-            orient="row",
-            schema=schema,
-        )
+    tiles_in_geom = pl.from_records(
+        data=list(tiles_in_geom),
+        orient="row",
+        schema=schema,
+    )
 
-        quadkey_expr = self._xyz_to_quadkey(
-            pl.col("x"),
-            pl.col("y"),
+    quadkey_expr = self._xyz_to_quadkey(
+        pl.col("x"),
+        pl.col("y"),
+    )
+    tiles_in_geom = tiles_in_geom.with_columns(quadkey=quadkey_expr)
+
+    if self.return_geometry:
+        bboxes = self._xy_to_bbox(tiles_in_geom, "x", "y")
+
+        # use vectorized version in shapely 2.0
+        bboxes = box(
+            bboxes["minx"].to_list(),
+            bboxes["miny"].to_list(),
+            bboxes["maxx"].to_list(),
+            bboxes["maxy"].to_list(),
         )
-        tiles_in_geom = tiles_in_geom.with_columns(quadkey=quadkey_expr)
+        bboxes = GeoSeries(bboxes, crs="epsg:4326")
 
-        if self.return_geometry:
-            bboxes = self._xy_to_bbox(tiles_in_geom, "x", "y")
+    if not self.add_xyz_cols:
+        tiles_in_geom = tiles_in_geom.drop(["x", "y"])
+    else:
+        tiles_in_geom = tiles_in_geom.with_columns(z=pl.lit(self.zoom_level))
+        column_order = ["quadkey", "x", "y", "z"]
+        if has_unique_id_col:
+            column_order += [unique_id_col]
+        assert set(tiles_in_geom.columns) == set(column_order)
+        tiles_in_geom = tiles_in_geom.select(column_order)
 
-            # use vectorized version in shapely 2.0
-            bboxes = box(
-                bboxes["minx"].to_list(),
-                bboxes["miny"].to_list(),
-                bboxes["maxx"].to_list(),
-                bboxes["maxy"].to_list(),
-            )
-            bboxes = GeoSeries(bboxes, crs="epsg:4326")
+    if self.return_geometry:
+        tiles_in_geom = GeoDataFrame(tiles_in_geom.to_pandas(), geometry=bboxes)
+    else:
+        tiles_in_geom = tiles_in_geom.to_pandas()
 
-        if not self.add_xyz_cols:
-            tiles_in_geom = tiles_in_geom.drop(["x", "y"])
-        else:
-            tiles_in_geom = tiles_in_geom.with_columns(z=pl.lit(self.zoom_level))
-            column_order = ["quadkey", "x", "y", "z"]
-            if has_unique_id_col:
-                column_order += [unique_id_col]
-            assert set(tiles_in_geom.columns) == set(column_order)
-            tiles_in_geom = tiles_in_geom.select(column_order)
-
-        if self.return_geometry:
-            tiles_in_geom = GeoDataFrame(tiles_in_geom.to_pandas(), geometry=bboxes)
-        else:
-            tiles_in_geom = tiles_in_geom.to_pandas()
+    return tiles_in_geom
 
-        return tiles_in_geom
+# %% ../notebooks/00_grids.ipynb 23
+@patch
+def _lat_to_ytile(self: FastBingTileGridGenerator, lat: pl.Expr) -> pl.Expr:
+    logtan = pl.Expr.log(pl.Expr.tan((np.pi / 4) + (pl.Expr.radians(lat) / 2)))
 
-    def _lat_to_ytile(self, lat: pl.Expr) -> pl.Expr:
-        logtan = pl.Expr.log(pl.Expr.tan((np.pi / 4) + (pl.Expr.radians(lat) / 2)))
+    y = 0.5 - (logtan / (2 * np.pi))
 
-        y = 0.5 - (logtan / (2 * np.pi))
+    power_of_2 = int(np.power(2, self.zoom_level))
 
-        power_of_2 = int(np.power(2, self.zoom_level))
+    # To address loss of precision in round-tripping between tile
+    # and lng/lat, points within EPSILON of the right side of a tile
+    # are counted in the next tile over.
+    y_pixel_coord = pl.Expr.floor((y + self.EPSILON) * power_of_2)
 
-        # To address loss of precision in round-tripping between tile
-        # and lng/lat, points within EPSILON of the right side of a tile
-        # are counted in the next tile over.
-        y_pixel_coord = pl.Expr.floor((y + self.EPSILON) * power_of_2)
+    ytile = (
+        pl.when(y <= 0)
+        .then(pl.lit(0))
+        .when(y >= 1)
+        .then(pl.lit(power_of_2 - 1))
+        .otherwise(y_pixel_coord)
+        .cast(self.PIXEL_DTYPE)
+    )
 
-        ytile = (
-            pl.when(y <= 0)
-            .then(pl.lit(0))
-            .when(y >= 1)
-            .then(pl.lit(power_of_2 - 1))
-            .otherwise(y_pixel_coord)
-            .cast(self.PIXEL_DTYPE)
-        )
+    return ytile
 
-        return ytile
 
-    def _lng_to_xtile(self, lng: pl.Expr) -> pl.Expr:
-        x = 0.5 + (lng / 360.0)
-        power_of_2 = int(np.power(2, self.zoom_level))
+@patch
+def _lng_to_xtile(self: FastBingTileGridGenerator, lng: pl.Expr) -> pl.Expr:
+    x = 0.5 + (lng / 360.0)
+    power_of_2 = int(np.power(2, self.zoom_level))
+
+    x_pixel_coord = pl.Expr.floor((x + self.EPSILON) * power_of_2)
+
+    xtile = (
+        pl.when(x <= 0)
+        .then(pl.lit(0))
+        .when(x >= 1)
+        .then(pl.lit(power_of_2 - 1))
+        .otherwise(x_pixel_coord)
+        .cast(self.PIXEL_DTYPE)
+    )
 
-        x_pixel_coord = pl.Expr.floor((x + self.EPSILON) * power_of_2)
+    return xtile
 
-        xtile = (
-            pl.when(x <= 0)
-            .then(pl.lit(0))
-            .when(x >= 1)
-            .then(pl.lit(power_of_2 - 1))
-            .otherwise(x_pixel_coord)
-            .cast(self.PIXEL_DTYPE)
-        )
 
-        return xtile
+@patch
+def _latlng_to_xy(
+    self: FastBingTileGridGenerator,
+    df: pl.DataFrame,
+    lat_col: str,
+    lng_col: str,
+) -> pl.DataFrame:
+    xy_df = df.with_columns(
+        x=self._lng_to_xtile(pl.col(lng_col)),
+        y=self._lat_to_ytile(pl.col(lat_col)),
+    )
 
-    def _latlng_to_xy(
-        self,
-        df: pl.DataFrame,
-        lat_col: str,
-        lng_col: str,
-    ) -> pl.DataFrame:
-        xy_df = df.with_columns(
-            x=self._lng_to_xtile(pl.col(lng_col)),
-            y=self._lat_to_ytile(pl.col(lat_col)),
-        )
+    return xy_df
 
-        return xy_df
 
-    def _xtile_to_lng(self, xtile: pl.Expr) -> pl.Expr:
-        """This gets the longitude of the upper left corner of the tile"""
-        power_of_2 = int(np.power(2, self.zoom_level))
-        lng_deg = (xtile / power_of_2) * 360.0 - 180.0
-        return lng_deg
+@patch
+def _xtile_to_lng(self: FastBingTileGridGenerator, xtile: pl.Expr) -> pl.Expr:
+    """This gets the longitude of the upper left corner of the tile"""
+    power_of_2 = int(np.power(2, self.zoom_level))
+    lng_deg = (xtile / power_of_2) * 360.0 - 180.0
+    return lng_deg
 
-    def _ytile_to_lat(self, ytile: pl.Expr) -> pl.Expr:
-        """This gets the latitude of the upper left corner of the tile"""
-        power_of_2 = int(np.power(2, self.zoom_level))
-        y = ytile / power_of_2
-        lat_rad = pl.Expr.arctan(pl.Expr.sinh(np.pi * (1 - 2 * y)))
-        lat_deg = pl.Expr.degrees(lat_rad)
-        return lat_deg
 
-    def _xy_to_bbox(
-        self,
-        df: pl.DataFrame,
-        xtile_col: str,
-        ytile_col: str,
-    ) -> pl.DataFrame:
-
-        upper_left_lng = self._xtile_to_lng(pl.col(xtile_col))
-        upper_left_lat = self._ytile_to_lat(pl.col(ytile_col))
-        lower_right_lng = self._xtile_to_lng(pl.col(xtile_col) + 1)
-        lower_right_lat = self._ytile_to_lat(pl.col(ytile_col) + 1)
-
-        bbox_df = df.select(
-            minx=upper_left_lng,
-            miny=lower_right_lat,
-            maxx=lower_right_lng,
-            maxy=upper_left_lat,
-        )
+@patch
+def _ytile_to_lat(self: FastBingTileGridGenerator, ytile: pl.Expr) -> pl.Expr:
+    """This gets the latitude of the upper left corner of the tile"""
+    power_of_2 = int(np.power(2, self.zoom_level))
+    y = ytile / power_of_2
+    lat_rad = pl.Expr.arctan(pl.Expr.sinh(np.pi * (1 - 2 * y)))
+    lat_deg = pl.Expr.degrees(lat_rad)
+    return lat_deg
 
-        return bbox_df
 
-    def _polygons_to_vertices(
-        self, polys_gdf: GeoDataFrame, unique_id_col: Optional[str] = None
-    ) -> pl.DataFrame:
+@patch
+def _xy_to_bbox(
+    self: FastBingTileGridGenerator,
+    df: pl.DataFrame,
+    xtile_col: str,
+    ytile_col: str,
+) -> pl.DataFrame:
+
+    upper_left_lng = self._xtile_to_lng(pl.col(xtile_col))
+    upper_left_lat = self._ytile_to_lat(pl.col(ytile_col))
+    lower_right_lng = self._xtile_to_lng(pl.col(xtile_col) + 1)
+    lower_right_lat = self._ytile_to_lat(pl.col(ytile_col) + 1)
+
+    bbox_df = df.select(
+        minx=upper_left_lng,
+        miny=lower_right_lat,
+        maxx=lower_right_lng,
+        maxy=upper_left_lat,
+    )
 
-        if unique_id_col is not None:
-            duplicates_bool = polys_gdf[unique_id_col].duplicated()
-            if duplicates_bool.any():
-                raise ValueError(
-                    f"""{unique_id_col} is not unique!
-                    Found {duplicates_bool.sum():,} duplicates"""
-                )
-            polys_gdf = polys_gdf.set_index(unique_id_col)
-        else:
-            # reset index if it is not unique
-            if polys_gdf.index.nunique() != len(polys_gdf.index):
-                polys_gdf = polys_gdf.reset_index(drop=True)
-            unique_id_col = polys_gdf.index.name
+    return bbox_df
 
-        polys_gdf = polys_gdf.explode(index_parts=True)
 
-        is_poly_bool = polys_gdf.type == "Polygon"
-        if not is_poly_bool.all():
+@patch
+def _polygons_to_vertices(
+    self: FastBingTileGridGenerator,
+    polys_gdf: GeoDataFrame,
+    unique_id_col: Optional[str] = None,
+) -> pl.DataFrame:
+
+    if unique_id_col is not None:
+        duplicates_bool = polys_gdf[unique_id_col].duplicated()
+        if duplicates_bool.any():
             raise ValueError(
-                f"""
-            All geometries should be polygons or multipolygons but found
-            {is_poly_bool.sum():,} after exploding the geodatarame"""
+                f"""{unique_id_col} is not unique!
+                Found {duplicates_bool.sum():,} duplicates"""
             )
+        polys_gdf = polys_gdf.set_index(unique_id_col)
+    else:
+        # reset index if it is not unique
+        if polys_gdf.index.nunique() != len(polys_gdf.index):
+            polys_gdf = polys_gdf.reset_index(drop=True)
+        unique_id_col = polys_gdf.index.name
+
+    polys_gdf = polys_gdf.explode(index_parts=True)
+
+    is_poly_bool = polys_gdf.type == "Polygon"
+    if not is_poly_bool.all():
+        raise ValueError(
+            f"""
+        All geometries should be polygons or multipolygons but found
+        {is_poly_bool.sum():,} after exploding the geodatarame"""
+        )
 
-        polys_gdf.index.names = [unique_id_col, self.SUBPOLYGON_ID_COL]
-        vertices_df = polys_gdf.get_coordinates().reset_index()
-        vertices_df = pl.from_pandas(vertices_df)
+    polys_gdf.index.names = [unique_id_col, self.SUBPOLYGON_ID_COL]
+    vertices_df = polys_gdf.get_coordinates().reset_index()
+    vertices_df = pl.from_pandas(vertices_df)
 
-        return vertices_df
+    return vertices_df
 
-    def _xyz_to_quadkey(self, x: pl.Expr, y: pl.Expr) -> pl.Expr:
 
-        # Create expressions for the quadkey digit at each bit position
-        quadkey_digit_exprs = [
-            ((x // (2**i) % 2) | ((y // (2**i) % 2) * 2))
-            for i in reversed(range(self.zoom_level))
-        ]
+@patch
+def _xyz_to_quadkey(self: FastBingTileGridGenerator, x: pl.Expr, y: pl.Expr) -> pl.Expr:
+
+    # Create expressions for the quadkey digit at each bit position
+    quadkey_digit_exprs = [
+        ((x // (2**i) % 2) | ((y // (2**i) % 2) * 2))
+        for i in reversed(range(self.zoom_level))
+    ]
 
-        quadkey = pl.concat_str(quadkey_digit_exprs)
+    quadkey = pl.concat_str(quadkey_digit_exprs)
 
-        return quadkey
+    return quadkey
diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index d07d5c7..bbd0813 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -314,7 +314,7 @@
     "        self,\n",
     "        zoom_level: int,  # Zoom level of tile. See: https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system for more info\n",
     "        return_geometry: bool = True,  # If geometry should be returned. Setting this to false will only return quadkeys\n",
-    "        add_xyz_cols: bool = False,  # If quadkey should be converted to their xy values.\n",
+    "        add_xyz_cols: bool = False,  # If quadkey should be converted to their xyz values.\n",
     "    ):\n",
     "        self.zoom_level = zoom_level\n",
     "        self.return_geometry = return_geometry\n",
@@ -555,227 +555,252 @@
     "        self.add_xyz_cols = add_xyz_cols\n",
     "\n",
     "        if self.zoom_level > self.MAX_ZOOM:\n",
-    "            raise NotImplementedError(f\"Maximum allowed zoom level is {self.MAX_ZOOM}. Input was {self.zoom_level}\")\n",
+    "            raise NotImplementedError(f\"Maximum allowed zoom level is {self.MAX_ZOOM}. Input was {self.zoom_level}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| export\n",
     "\n",
-    "    def generate_grid(\n",
-    "        self,\n",
-    "        aoi_gdf: GeoDataFrame,\n",
-    "        unique_id_col: Optional[str] = None, # the ids under this column will be preserved in the output tiles\n",
-    "    ) -> Union[GeoDataFrame, pd.DataFrame]:\n",
+    "@patch\n",
+    "def generate_grid(\n",
+    "    self: FastBingTileGridGenerator,\n",
+    "    aoi_gdf: GeoDataFrame,\n",
+    "    unique_id_col: Optional[str] = None, # the ids under this column will be preserved in the output tiles\n",
+    ") -> Union[GeoDataFrame, pd.DataFrame]:\n",
+    "    \n",
+    "    vertices = self._polygons_to_vertices(aoi_gdf, unique_id_col)\n",
+    "    vertices = self._latlng_to_xy(vertices, lat_col=\"y\", lng_col=\"x\")\n",
+    "\n",
+    "    if unique_id_col is not None:\n",
+    "        id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
+    "        has_unique_id_col = True\n",
+    "    else:\n",
+    "        complement_cols = [\"x\",\"y\",self.SUBPOLYGON_ID_COL]\n",
+    "        unique_id_col = list(set(vertices.columns) - set(complement_cols))\n",
+    "        assert len(unique_id_col) == 1\n",
+    "        unique_id_col = unique_id_col[0]\n",
+    "        id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
+    "        has_unique_id_col = False\n",
+    "\n",
+    "    polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()\n",
+    "\n",
+    "    tiles_in_geom = set()\n",
+    "    for polygon_id in polygon_ids:\n",
+    "        subpolygon_id, unique_id = polygon_id\n",
+    "        filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (\n",
+    "            pl.col(unique_id_col) == unique_id\n",
+    "        )\n",
+    "        poly_vertices = vertices.filter(filter_expr)\n",
     "        \n",
-    "        vertices = self._polygons_to_vertices(aoi_gdf, unique_id_col)\n",
-    "        vertices = self._latlng_to_xy(vertices, lat_col=\"y\", lng_col=\"x\")\n",
+    "        poly_vertices = poly_vertices.unique(maintain_order=True)\n",
+    "        _tiles_in_geom = voxel_traversal_scanline_fill(poly_vertices, x_col=\"x\", y_col=\"y\")\n",
     "\n",
-    "        if unique_id_col is not None:\n",
-    "            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
-    "            has_unique_id_col = True\n",
-    "        else:\n",
-    "            complement_cols = [\"x\",\"y\",self.SUBPOLYGON_ID_COL]\n",
-    "            unique_id_col = list(set(vertices.columns) - set(complement_cols))\n",
-    "            assert len(unique_id_col) == 1\n",
-    "            unique_id_col = unique_id_col[0]\n",
-    "            id_cols = [self.SUBPOLYGON_ID_COL, unique_id_col]\n",
-    "            has_unique_id_col = False\n",
-    "    \n",
-    "        polygon_ids = vertices.select(id_cols).unique(maintain_order=True).rows()\n",
-    "    \n",
-    "        tiles_in_geom = set()\n",
-    "        for polygon_id in polygon_ids:\n",
-    "            subpolygon_id, unique_id = polygon_id\n",
-    "            filter_expr = (pl.col(self.SUBPOLYGON_ID_COL) == subpolygon_id) & (\n",
-    "                pl.col(unique_id_col) == unique_id\n",
-    "            )\n",
-    "            poly_vertices = vertices.filter(filter_expr)\n",
-    "            \n",
-    "            poly_vertices = poly_vertices.unique(maintain_order=True)\n",
-    "            _tiles_in_geom = voxel_traversal_scanline_fill(poly_vertices, x_col=\"x\", y_col=\"y\")\n",
-    "    \n",
-    "            if has_unique_id_col:\n",
-    "                _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]\n",
-    "    \n",
-    "            tiles_in_geom.update(_tiles_in_geom)\n",
-    "    \n",
-    "        schema = {\"x\": self.PIXEL_DTYPE, \"y\": self.PIXEL_DTYPE}\n",
     "        if has_unique_id_col:\n",
-    "            schema[unique_id_col] = vertices[unique_id_col].dtype\n",
-    "    \n",
-    "        tiles_in_geom = pl.from_records(\n",
-    "            data=list(tiles_in_geom),\n",
-    "            orient=\"row\",\n",
-    "            schema=schema,\n",
-    "        )\n",
-    "    \n",
-    "        quadkey_expr = self._xyz_to_quadkey(\n",
-    "            pl.col(\"x\"),\n",
-    "            pl.col(\"y\"),\n",
-    "        )\n",
-    "        tiles_in_geom = tiles_in_geom.with_columns(quadkey=quadkey_expr)\n",
+    "            _tiles_in_geom = [(x, y, unique_id) for (x, y) in _tiles_in_geom]\n",
     "\n",
-    "        if self.return_geometry:\n",
-    "            bboxes = self._xy_to_bbox(tiles_in_geom, \"x\", \"y\")\n",
-    "        \n",
-    "            # use vectorized version in shapely 2.0\n",
-    "            bboxes = box(\n",
-    "                bboxes[\"minx\"].to_list(),\n",
-    "                bboxes[\"miny\"].to_list(),\n",
-    "                bboxes[\"maxx\"].to_list(),\n",
-    "                bboxes[\"maxy\"].to_list(),\n",
-    "            )\n",
-    "            bboxes = GeoSeries(bboxes, crs=\"epsg:4326\")\n",
+    "        tiles_in_geom.update(_tiles_in_geom)\n",
     "\n",
-    "        if not self.add_xyz_cols:\n",
-    "            tiles_in_geom = tiles_in_geom.drop([\"x\",\"y\"])\n",
-    "        else:\n",
-    "            tiles_in_geom = tiles_in_geom.with_columns(z = pl.lit(self.zoom_level))\n",
-    "            column_order = [\"quadkey\",\"x\",\"y\",\"z\"]\n",
-    "            if has_unique_id_col:\n",
-    "                column_order += [unique_id_col]\n",
-    "            assert set(tiles_in_geom.columns) == set(column_order)\n",
-    "            tiles_in_geom = tiles_in_geom.select(column_order)\n",
-    "\n",
-    "        if self.return_geometry:\n",
-    "            tiles_in_geom = GeoDataFrame(tiles_in_geom.to_pandas(), geometry=bboxes)\n",
-    "        else:\n",
-    "            tiles_in_geom = tiles_in_geom.to_pandas()\n",
-    "    \n",
-    "        return tiles_in_geom\n",
+    "    schema = {\"x\": self.PIXEL_DTYPE, \"y\": self.PIXEL_DTYPE}\n",
+    "    if has_unique_id_col:\n",
+    "        schema[unique_id_col] = vertices[unique_id_col].dtype\n",
     "\n",
-    "    def _lat_to_ytile(self, lat: pl.Expr) -> pl.Expr:\n",
-    "        logtan = pl.Expr.log(pl.Expr.tan((np.pi / 4) + (pl.Expr.radians(lat) / 2)))\n",
-    "    \n",
-    "        y = 0.5 - (logtan / (2 * np.pi))\n",
-    "    \n",
-    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
-    "    \n",
-    "        # To address loss of precision in round-tripping between tile\n",
-    "        # and lng/lat, points within EPSILON of the right side of a tile\n",
-    "        # are counted in the next tile over.\n",
-    "        y_pixel_coord = pl.Expr.floor((y + self.EPSILON) * power_of_2)\n",
-    "    \n",
-    "        ytile = (\n",
-    "            pl.when(y <= 0)\n",
-    "            .then(pl.lit(0))\n",
-    "            .when(y >= 1)\n",
-    "            .then(pl.lit(power_of_2 - 1))\n",
-    "            .otherwise(y_pixel_coord)\n",
-    "            .cast(self.PIXEL_DTYPE)\n",
-    "        )\n",
-    "    \n",
-    "        return ytile\n",
+    "    tiles_in_geom = pl.from_records(\n",
+    "        data=list(tiles_in_geom),\n",
+    "        orient=\"row\",\n",
+    "        schema=schema,\n",
+    "    )\n",
     "\n",
-    "    def _lng_to_xtile(self, lng: pl.Expr) -> pl.Expr:\n",
-    "        x = 0.5 + (lng / 360.0)\n",
-    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
-    "    \n",
-    "        x_pixel_coord = pl.Expr.floor((x + self.EPSILON) * power_of_2)\n",
+    "    quadkey_expr = self._xyz_to_quadkey(\n",
+    "        pl.col(\"x\"),\n",
+    "        pl.col(\"y\"),\n",
+    "    )\n",
+    "    tiles_in_geom = tiles_in_geom.with_columns(quadkey=quadkey_expr)\n",
+    "\n",
+    "    if self.return_geometry:\n",
+    "        bboxes = self._xy_to_bbox(tiles_in_geom, \"x\", \"y\")\n",
     "    \n",
-    "        xtile = (\n",
-    "            pl.when(x <= 0)\n",
-    "            .then(pl.lit(0))\n",
-    "            .when(x >= 1)\n",
-    "            .then(pl.lit(power_of_2 - 1))\n",
-    "            .otherwise(x_pixel_coord)\n",
-    "            .cast(self.PIXEL_DTYPE)\n",
+    "        # use vectorized version in shapely 2.0\n",
+    "        bboxes = box(\n",
+    "            bboxes[\"minx\"].to_list(),\n",
+    "            bboxes[\"miny\"].to_list(),\n",
+    "            bboxes[\"maxx\"].to_list(),\n",
+    "            bboxes[\"maxy\"].to_list(),\n",
     "        )\n",
-    "    \n",
-    "        return xtile\n",
+    "        bboxes = GeoSeries(bboxes, crs=\"epsg:4326\")\n",
     "\n",
-    "    def _latlng_to_xy(\n",
-    "        self,\n",
-    "        df: pl.DataFrame,\n",
-    "        lat_col: str,\n",
-    "        lng_col: str,\n",
-    "    ) -> pl.DataFrame:\n",
-    "        xy_df = df.with_columns(\n",
-    "            x=self._lng_to_xtile(pl.col(lng_col)),\n",
-    "            y=self._lat_to_ytile(pl.col(lat_col)),\n",
-    "        )\n",
-    "    \n",
-    "        return xy_df\n",
+    "    if not self.add_xyz_cols:\n",
+    "        tiles_in_geom = tiles_in_geom.drop([\"x\",\"y\"])\n",
+    "    else:\n",
+    "        tiles_in_geom = tiles_in_geom.with_columns(z = pl.lit(self.zoom_level))\n",
+    "        column_order = [\"quadkey\",\"x\",\"y\",\"z\"]\n",
+    "        if has_unique_id_col:\n",
+    "            column_order += [unique_id_col]\n",
+    "        assert set(tiles_in_geom.columns) == set(column_order)\n",
+    "        tiles_in_geom = tiles_in_geom.select(column_order)\n",
     "\n",
-    "    def _xtile_to_lng(self, xtile: pl.Expr) -> pl.Expr:\n",
-    "        \"\"\"This gets the longitude of the upper left corner of the tile\"\"\"\n",
-    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
-    "        lng_deg = (xtile / power_of_2) * 360.0 - 180.0\n",
-    "        return lng_deg\n",
-    "    \n",
-    "    \n",
-    "    def _ytile_to_lat(self, ytile: pl.Expr) -> pl.Expr:\n",
-    "        \"\"\"This gets the latitude of the upper left corner of the tile\"\"\"\n",
-    "        power_of_2 = int(np.power(2, self.zoom_level))\n",
-    "        y = ytile / power_of_2\n",
-    "        lat_rad = pl.Expr.arctan(pl.Expr.sinh(np.pi * (1 - 2 * y)))\n",
-    "        lat_deg = pl.Expr.degrees(lat_rad)\n",
-    "        return lat_deg\n",
-    "    \n",
-    "    \n",
-    "    def _xy_to_bbox(\n",
-    "        self,\n",
-    "        df: pl.DataFrame,\n",
-    "        xtile_col: str,\n",
-    "        ytile_col: str,\n",
-    "    ) -> pl.DataFrame:\n",
-    "    \n",
-    "        upper_left_lng = self._xtile_to_lng(pl.col(xtile_col))\n",
-    "        upper_left_lat = self._ytile_to_lat(pl.col(ytile_col))\n",
-    "        lower_right_lng = self._xtile_to_lng(pl.col(xtile_col) + 1)\n",
-    "        lower_right_lat = self._ytile_to_lat(pl.col(ytile_col) + 1)\n",
-    "    \n",
-    "        bbox_df = df.select(\n",
-    "            minx=upper_left_lng,\n",
-    "            miny=lower_right_lat,\n",
-    "            maxx=lower_right_lng,\n",
-    "            maxy=upper_left_lat,\n",
-    "        )\n",
-    "    \n",
-    "        return bbox_df\n",
+    "    if self.return_geometry:\n",
+    "        tiles_in_geom = GeoDataFrame(tiles_in_geom.to_pandas(), geometry=bboxes)\n",
+    "    else:\n",
+    "        tiles_in_geom = tiles_in_geom.to_pandas()\n",
     "\n",
-    "    def _polygons_to_vertices(\n",
-    "        self,\n",
-    "        polys_gdf: GeoDataFrame, \n",
-    "        unique_id_col: Optional[str] = None\n",
-    "    ) -> pl.DataFrame:\n",
-    "        \n",
-    "        if unique_id_col is not None:\n",
-    "            duplicates_bool = polys_gdf[unique_id_col].duplicated()\n",
-    "            if duplicates_bool.any():\n",
-    "                raise ValueError(\n",
-    "                    f\"\"\"{unique_id_col} is not unique!\n",
-    "                    Found {duplicates_bool.sum():,} duplicates\"\"\"\n",
-    "                )\n",
-    "            polys_gdf = polys_gdf.set_index(unique_id_col)\n",
-    "        else:\n",
-    "            # reset index if it is not unique\n",
-    "            if polys_gdf.index.nunique() != len(polys_gdf.index):\n",
-    "                polys_gdf = polys_gdf.reset_index(drop=True)\n",
-    "            unique_id_col = polys_gdf.index.name\n",
-    "    \n",
-    "        polys_gdf = polys_gdf.explode(index_parts=True)\n",
+    "    return tiles_in_geom"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#| exporti\n",
+    "\n",
+    "@patch\n",
+    "def _lat_to_ytile(self:FastBingTileGridGenerator, lat: pl.Expr) -> pl.Expr:\n",
+    "    logtan = pl.Expr.log(pl.Expr.tan((np.pi / 4) + (pl.Expr.radians(lat) / 2)))\n",
+    "\n",
+    "    y = 0.5 - (logtan / (2 * np.pi))\n",
+    "\n",
+    "    power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "\n",
+    "    # To address loss of precision in round-tripping between tile\n",
+    "    # and lng/lat, points within EPSILON of the right side of a tile\n",
+    "    # are counted in the next tile over.\n",
+    "    y_pixel_coord = pl.Expr.floor((y + self.EPSILON) * power_of_2)\n",
+    "\n",
+    "    ytile = (\n",
+    "        pl.when(y <= 0)\n",
+    "        .then(pl.lit(0))\n",
+    "        .when(y >= 1)\n",
+    "        .then(pl.lit(power_of_2 - 1))\n",
+    "        .otherwise(y_pixel_coord)\n",
+    "        .cast(self.PIXEL_DTYPE)\n",
+    "    )\n",
+    "\n",
+    "    return ytile\n",
+    "\n",
+    "@patch\n",
+    "def _lng_to_xtile(self:FastBingTileGridGenerator, lng: pl.Expr) -> pl.Expr:\n",
+    "    x = 0.5 + (lng / 360.0)\n",
+    "    power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "\n",
+    "    x_pixel_coord = pl.Expr.floor((x + self.EPSILON) * power_of_2)\n",
+    "\n",
+    "    xtile = (\n",
+    "        pl.when(x <= 0)\n",
+    "        .then(pl.lit(0))\n",
+    "        .when(x >= 1)\n",
+    "        .then(pl.lit(power_of_2 - 1))\n",
+    "        .otherwise(x_pixel_coord)\n",
+    "        .cast(self.PIXEL_DTYPE)\n",
+    "    )\n",
+    "\n",
+    "    return xtile\n",
+    "\n",
+    "@patch\n",
+    "def _latlng_to_xy(\n",
+    "    self:FastBingTileGridGenerator,\n",
+    "    df: pl.DataFrame,\n",
+    "    lat_col: str,\n",
+    "    lng_col: str,\n",
+    ") -> pl.DataFrame:\n",
+    "    xy_df = df.with_columns(\n",
+    "        x=self._lng_to_xtile(pl.col(lng_col)),\n",
+    "        y=self._lat_to_ytile(pl.col(lat_col)),\n",
+    "    )\n",
+    "\n",
+    "    return xy_df\n",
+    "\n",
+    "@patch\n",
+    "def _xtile_to_lng(self:FastBingTileGridGenerator, xtile: pl.Expr) -> pl.Expr:\n",
+    "    \"\"\"This gets the longitude of the upper left corner of the tile\"\"\"\n",
+    "    power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "    lng_deg = (xtile / power_of_2) * 360.0 - 180.0\n",
+    "    return lng_deg\n",
+    "\n",
+    "@patch\n",
+    "def _ytile_to_lat(self:FastBingTileGridGenerator, ytile: pl.Expr) -> pl.Expr:\n",
+    "    \"\"\"This gets the latitude of the upper left corner of the tile\"\"\"\n",
+    "    power_of_2 = int(np.power(2, self.zoom_level))\n",
+    "    y = ytile / power_of_2\n",
+    "    lat_rad = pl.Expr.arctan(pl.Expr.sinh(np.pi * (1 - 2 * y)))\n",
+    "    lat_deg = pl.Expr.degrees(lat_rad)\n",
+    "    return lat_deg\n",
+    "\n",
+    "@patch\n",
+    "def _xy_to_bbox(\n",
+    "    self:FastBingTileGridGenerator,\n",
+    "    df: pl.DataFrame,\n",
+    "    xtile_col: str,\n",
+    "    ytile_col: str,\n",
+    ") -> pl.DataFrame:\n",
+    "\n",
+    "    upper_left_lng = self._xtile_to_lng(pl.col(xtile_col))\n",
+    "    upper_left_lat = self._ytile_to_lat(pl.col(ytile_col))\n",
+    "    lower_right_lng = self._xtile_to_lng(pl.col(xtile_col) + 1)\n",
+    "    lower_right_lat = self._ytile_to_lat(pl.col(ytile_col) + 1)\n",
+    "\n",
+    "    bbox_df = df.select(\n",
+    "        minx=upper_left_lng,\n",
+    "        miny=lower_right_lat,\n",
+    "        maxx=lower_right_lng,\n",
+    "        maxy=upper_left_lat,\n",
+    "    )\n",
+    "\n",
+    "    return bbox_df\n",
+    "\n",
+    "@patch\n",
+    "def _polygons_to_vertices(\n",
+    "    self:FastBingTileGridGenerator,\n",
+    "    polys_gdf: GeoDataFrame, \n",
+    "    unique_id_col: Optional[str] = None\n",
+    ") -> pl.DataFrame:\n",
     "    \n",
-    "        is_poly_bool = polys_gdf.type == \"Polygon\"\n",
-    "        if not is_poly_bool.all():\n",
+    "    if unique_id_col is not None:\n",
+    "        duplicates_bool = polys_gdf[unique_id_col].duplicated()\n",
+    "        if duplicates_bool.any():\n",
     "            raise ValueError(\n",
-    "                f\"\"\"\n",
-    "            All geometries should be polygons or multipolygons but found\n",
-    "            {is_poly_bool.sum():,} after exploding the geodatarame\"\"\"\n",
+    "                f\"\"\"{unique_id_col} is not unique!\n",
+    "                Found {duplicates_bool.sum():,} duplicates\"\"\"\n",
     "            )\n",
-    "    \n",
-    "        polys_gdf.index.names = [unique_id_col, self.SUBPOLYGON_ID_COL]\n",
-    "        vertices_df = polys_gdf.get_coordinates().reset_index()\n",
-    "        vertices_df = pl.from_pandas(vertices_df)\n",
-    "    \n",
-    "        return vertices_df\n",
+    "        polys_gdf = polys_gdf.set_index(unique_id_col)\n",
+    "    else:\n",
+    "        # reset index if it is not unique\n",
+    "        if polys_gdf.index.nunique() != len(polys_gdf.index):\n",
+    "            polys_gdf = polys_gdf.reset_index(drop=True)\n",
+    "        unique_id_col = polys_gdf.index.name\n",
+    "\n",
+    "    polys_gdf = polys_gdf.explode(index_parts=True)\n",
+    "\n",
+    "    is_poly_bool = polys_gdf.type == \"Polygon\"\n",
+    "    if not is_poly_bool.all():\n",
+    "        raise ValueError(\n",
+    "            f\"\"\"\n",
+    "        All geometries should be polygons or multipolygons but found\n",
+    "        {is_poly_bool.sum():,} after exploding the geodatarame\"\"\"\n",
+    "        )\n",
     "\n",
-    "    def _xyz_to_quadkey(self, x: pl.Expr, y: pl.Expr) -> pl.Expr:\n",
+    "    polys_gdf.index.names = [unique_id_col, self.SUBPOLYGON_ID_COL]\n",
+    "    vertices_df = polys_gdf.get_coordinates().reset_index()\n",
+    "    vertices_df = pl.from_pandas(vertices_df)\n",
     "\n",
-    "        # Create expressions for the quadkey digit at each bit position\n",
-    "        quadkey_digit_exprs = [\n",
-    "            ((x // (2**i) % 2) | ((y // (2**i) % 2) * 2)) for i in reversed(range(self.zoom_level))\n",
-    "        ]\n",
-    "    \n",
-    "        quadkey = pl.concat_str(quadkey_digit_exprs)\n",
-    "    \n",
-    "        return quadkey"
+    "    return vertices_df\n",
+    "\n",
+    "@patch\n",
+    "def _xyz_to_quadkey(self:FastBingTileGridGenerator, x: pl.Expr, y: pl.Expr) -> pl.Expr:\n",
+    "\n",
+    "    # Create expressions for the quadkey digit at each bit position\n",
+    "    quadkey_digit_exprs = [\n",
+    "        ((x // (2**i) % 2) | ((y // (2**i) % 2) * 2)) for i in reversed(range(self.zoom_level))\n",
+    "    ]\n",
+    "\n",
+    "    quadkey = pl.concat_str(quadkey_digit_exprs)\n",
+    "\n",
+    "    return quadkey"
    ]
   }
  ],
diff --git a/notebooks/15_polygon_fill.ipynb b/notebooks/15_polygon_fill.ipynb
index e254319..112610c 100644
--- a/notebooks/15_polygon_fill.ipynb
+++ b/notebooks/15_polygon_fill.ipynb
@@ -26,7 +26,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "4aa6e5ff-d0c0-4463-93d7-85a4855c63e1",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| default_exp gridding_utils.polygon_fill"
@@ -36,7 +40,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "22ec5393-a2a4-4d00-a062-08da616dd003",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "%reload_ext autoreload\n",
@@ -47,7 +55,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "446efacd-669d-4f2f-b848-d16335cfed79",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| include: false\n",
@@ -59,7 +71,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "52b870c5-564a-40c0-8286-fdfe52f4fdc2",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -74,9 +90,14 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "81fb9b86-f20c-455b-b4d2-c323263df245",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
+    "#| hide\n",
     "import matplotlib.pyplot as plt\n",
     "import matplotlib.patches as patches"
    ]
@@ -88,18 +109,25 @@
    "source": [
     "## Overview\n",
     "\n",
-    "We will use 2 separate algorithms for filling in pixels in polygons.\n",
-    "1. [Voxel Traversal Algorithm](https://github.com/cgyurgyik/fast-voxel-traversal-algorithm/blob/master/overview/FastVoxelTraversalOverview.md): We use this for filling in pixels along the polygon boundary. We implement 2D voxel traversal for every line segment of the polygon boundary.\n",
+    "We will use 2 separate algorithms for filling in pixels in polygons:\n",
+    "\n",
+    "1. [Voxel Traversal Algorithm](https://github.com/cgyurgyik/fast-voxel-traversal-algorithm/blob/master/overview/FastVoxelTraversalOverview.md): We use this for filling in pixels along the polygon boundary. 2D voxel traversal is used for every line segment of the polygon boundary.\n",
     "2. [Scanline Fill Algorithm](https://www.educative.io/answers/what-is-scanline-fill-algorithm): We use this for filling in pixels in the polygon interior.\n",
     "\n",
-    "All pixels and polygon vertices are assumed to have nonnegative integer coordinates"
+    "These algorithms are currently used in `FastBingTileGridGeneration`\n",
+    "\n",
+    "All pixels and polygon vertices are assumed to have nonnegative integer coordinates."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "id": "798c7c6b-ec87-4dac-8275-1d19dc4df9ae",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| hide\n",
@@ -142,7 +170,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "db03abe9-0d42-44f8-bdbc-9d22eac5fa14",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| hide\n",
@@ -215,7 +247,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "e44a78ba-c885-4ab7-bcfa-104346df376a",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| exporti\n",
@@ -375,14 +411,18 @@
    "id": "2f06427e-157f-42d2-a332-e8fc69fb7d15",
    "metadata": {},
    "source": [
-    "We use voxel traversal on every line segment to fill the polygon boundary."
+    "Voxel traversal is used on every line segment to fill the polygon boundary."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "id": "dc732d7e-91a6-4f0a-811a-cc9cc92a1df8",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -423,7 +463,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "29616c05-3a87-4952-a4f6-eb97c958599b",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| exporti\n",
@@ -511,7 +555,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "d3eb282d-6262-4011-829e-cf533c04a3ee",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -544,7 +592,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "bc62c0f2-cd69-49c8-93f0-902d42f54eaa",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| exporti\n",
@@ -585,7 +637,11 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "e4836507-2070-41f9-b1c4-6f2f1b2dd665",
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [
     {
      "data": {
diff --git a/notebooks/index.ipynb b/notebooks/index.ipynb
index aae93dd..826748d 100644
--- a/notebooks/index.ipynb
+++ b/notebooks/index.ipynb
@@ -226,6 +226,7 @@
     "#### Reference\n",
     "\n",
     "* [Grids Generation](https://geowrangler.thinkingmachin.es/grids.html)\n",
+    "* [Polygon Fill Algorithms](https://geowrangler.thinkingmachin.es/polygon_fill.html)\n",
     "* [Geometry Validation](https://geowrangler.thinkingmachin.es/validation.html)\n",
     "* [Vector Zonal Stats](https://geowrangler.thinkingmachin.es/vector_zonal_stats.html)\n",
     "* [Raster Zonal Stats](https://geowrangler.thinkingmachin.es/raster_zonal_stats.html)\n",

From 891e48501e52087cae9b3cf012c04f526f87c437 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Tue, 6 Aug 2024 23:49:25 +0800
Subject: [PATCH 17/21] add comment in grids tutorial

---
 notebooks/tutorial.grids.ipynb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/notebooks/tutorial.grids.ipynb b/notebooks/tutorial.grids.ipynb
index 53c9f79..0047a48 100644
--- a/notebooks/tutorial.grids.ipynb
+++ b/notebooks/tutorial.grids.ipynb
@@ -2099,6 +2099,7 @@
     }
    ],
    "source": [
+    "# computes how many more tiles there are in FastBingTileGridGenerator zoom 17 vs BingTileGridGenerator zoom 12\n",
     "fast_bing_tile_gdf.shape[0]/bing_region3_keys.shape[0]"
    ]
   }

From 2f757c318e2aa6864f31597f0f92cabb150a272d Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Wed, 7 Aug 2024 00:00:42 +0800
Subject: [PATCH 18/21] tidy up of 00_grids.ipynb by adding markdown

---
 geowrangler/grids.py     |  36 ++++-----
 notebooks/00_grids.ipynb | 153 +++++++++++++++++++++++++++++++++------
 2 files changed, 148 insertions(+), 41 deletions(-)

diff --git a/geowrangler/grids.py b/geowrangler/grids.py
index 1092e80..60ba7b9 100644
--- a/geowrangler/grids.py
+++ b/geowrangler/grids.py
@@ -1,7 +1,7 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../notebooks/00_grids.ipynb.
 
 # %% auto 0
-__all__ = ['SquareGridBoundary', 'SquareGridGenerator', 'H3GridGenerator', 'BingTileGridGenerator', 'FastBingTileGridGenerator']
+__all__ = ['SquareGridGenerator', 'H3GridGenerator', 'BingTileGridGenerator', 'FastBingTileGridGenerator']
 
 # %% ../notebooks/00_grids.ipynb 5
 import logging
@@ -26,7 +26,7 @@
 
 logger = logging.getLogger(__name__)
 
-# %% ../notebooks/00_grids.ipynb 6
+# %% ../notebooks/00_grids.ipynb 7
 class SquareGridBoundary:
     """Reusing Boundary. x_min, y_min, x_max, and y_max are in the the target crs"""
 
@@ -57,7 +57,7 @@ def get_range_subset(
             yrange[y_mask],
         )
 
-# %% ../notebooks/00_grids.ipynb 7
+# %% ../notebooks/00_grids.ipynb 8
 class SquareGridGenerator:
     def __init__(
         self,
@@ -69,7 +69,7 @@ def __init__(
         self.grid_projection = grid_projection
         self.boundary = boundary
 
-# %% ../notebooks/00_grids.ipynb 8
+# %% ../notebooks/00_grids.ipynb 9
 @patch
 def create_cell(
     self: SquareGridGenerator,
@@ -86,7 +86,7 @@ def create_cell(
         ]
     )
 
-# %% ../notebooks/00_grids.ipynb 9
+# %% ../notebooks/00_grids.ipynb 10
 @patch
 def create_grid_for_polygon(self: SquareGridGenerator, boundary, geometry):
     x_idx_offset, xrange, y_idx_offset, yrange = boundary.get_range_subset(
@@ -105,7 +105,7 @@ def create_grid_for_polygon(self: SquareGridGenerator, boundary, geometry):
                 )
     return cells
 
-# %% ../notebooks/00_grids.ipynb 10
+# %% ../notebooks/00_grids.ipynb 11
 @patch
 def generate_grid(self: SquareGridGenerator, gdf: GeoDataFrame) -> GeoDataFrame:
     reprojected_gdf = gdf.to_crs(self.grid_projection)
@@ -137,7 +137,7 @@ def generate_grid(self: SquareGridGenerator, gdf: GeoDataFrame) -> GeoDataFrame:
             {"x": [], "y": [], "geometry": []}, geometry="geometry", crs=gdf.crs
         )
 
-# %% ../notebooks/00_grids.ipynb 11
+# %% ../notebooks/00_grids.ipynb 13
 class H3GridGenerator:
     def __init__(
         self,
@@ -147,7 +147,7 @@ def __init__(
         self.resolution = resolution
         self.return_geometry = return_geometry
 
-# %% ../notebooks/00_grids.ipynb 12
+# %% ../notebooks/00_grids.ipynb 14
 @patch
 def get_hexes_for_polygon(self: H3GridGenerator, poly: Polygon):
     return h3.polyfill(
@@ -156,7 +156,7 @@ def get_hexes_for_polygon(self: H3GridGenerator, poly: Polygon):
         geo_json_conformant=True,
     )
 
-# %% ../notebooks/00_grids.ipynb 13
+# %% ../notebooks/00_grids.ipynb 15
 @patch
 def generate_grid(self: H3GridGenerator, gdf: GeoDataFrame) -> DataFrame:
     reprojected_gdf = gdf.to_crs("epsg:4326")  # h3 hexes are in epsg:4326 CRS
@@ -181,7 +181,7 @@ def generate_grid(self: H3GridGenerator, gdf: GeoDataFrame) -> DataFrame:
     )
     return h3_gdf.to_crs(gdf.crs)
 
-# %% ../notebooks/00_grids.ipynb 14
+# %% ../notebooks/00_grids.ipynb 17
 class BingTileGridGenerator:
     def __init__(
         self,
@@ -218,7 +218,7 @@ def get_tiles_for_polygon(
             tiles = {qk: (geom, tile) for qk, geom, tile in tiles}
         return tiles
 
-# %% ../notebooks/00_grids.ipynb 15
+# %% ../notebooks/00_grids.ipynb 18
 @patch
 def get_all_tiles_for_polygon(self: BingTileGridGenerator, polygon: Polygon):
     """Get the interseting tiles with polygon for a zoom level. Polygon should be in EPSG:4326"""
@@ -229,7 +229,7 @@ def get_all_tiles_for_polygon(self: BingTileGridGenerator, polygon: Polygon):
     )
     return tiles
 
-# %% ../notebooks/00_grids.ipynb 16
+# %% ../notebooks/00_grids.ipynb 19
 @patch
 def generate_grid(self: BingTileGridGenerator, gdf: GeoDataFrame) -> DataFrame:
     reprojected_gdf = gdf.to_crs("epsg:4326")  # quadkeys hexes are in epsg:4326 CRS
@@ -264,7 +264,7 @@ def generate_grid(self: BingTileGridGenerator, gdf: GeoDataFrame) -> DataFrame:
 
     return tiles_gdf
 
-# %% ../notebooks/00_grids.ipynb 17
+# %% ../notebooks/00_grids.ipynb 20
 def get_intersect_partition(item):
     tiles_gdf, reprojected_gdf = item
     tiles_gdf.sindex
@@ -274,7 +274,7 @@ def get_intersect_partition(item):
     )
     return intersect_tiles_gdf
 
-# %% ../notebooks/00_grids.ipynb 18
+# %% ../notebooks/00_grids.ipynb 21
 def get_parallel_intersects(
     tiles_gdf, reprojected_gdf, n_workers=defaults.cpus, progress=True
 ):
@@ -294,7 +294,7 @@ def get_parallel_intersects(
     results.drop_duplicates(subset=["quadkey"], inplace=True)
     return results
 
-# %% ../notebooks/00_grids.ipynb 19
+# %% ../notebooks/00_grids.ipynb 22
 @patch
 def generate_grid_join(
     self: BingTileGridGenerator,
@@ -353,7 +353,7 @@ def generate_grid_join(
 
     return tiles_gdf.to_crs(gdf.crs)
 
-# %% ../notebooks/00_grids.ipynb 21
+# %% ../notebooks/00_grids.ipynb 24
 class FastBingTileGridGenerator:
     EPSILON = 1e-14
     PIXEL_DTYPE = pl.UInt32
@@ -375,7 +375,7 @@ def __init__(
                 f"Maximum allowed zoom level is {self.MAX_ZOOM}. Input was {self.zoom_level}"
             )
 
-# %% ../notebooks/00_grids.ipynb 22
+# %% ../notebooks/00_grids.ipynb 25
 @patch
 def generate_grid(
     self: FastBingTileGridGenerator,
@@ -464,7 +464,7 @@ def generate_grid(
 
     return tiles_in_geom
 
-# %% ../notebooks/00_grids.ipynb 23
+# %% ../notebooks/00_grids.ipynb 26
 @patch
 def _lat_to_ytile(self: FastBingTileGridGenerator, lat: pl.Expr) -> pl.Expr:
     logtan = pl.Expr.log(pl.Expr.tan((np.pi / 4) + (pl.Expr.radians(lat) / 2)))
diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index bbd0813..a5d63ac 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -23,7 +23,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| default_exp grids"
@@ -32,7 +36,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| include: false\n",
@@ -43,7 +51,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| include: false\n",
@@ -56,7 +68,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| exporti\n",
@@ -83,13 +99,26 @@
     "logger = logging.getLogger(__name__)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# `SquareGridGenerator`\n",
+    "\n",
+    "This gridding approach creates equally spaced grids relative to the bounding box of the AOI. The grid spacing is defined by `cell_size`"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
-    "#| export\n",
+    "#| exporti\n",
     "\n",
     "\n",
     "class SquareGridBoundary:\n",
@@ -126,7 +155,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -147,7 +180,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -173,7 +210,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -199,7 +240,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -237,10 +282,21 @@
     "        )"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# `H3GridGenerator`"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -257,7 +313,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -273,7 +333,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -302,10 +366,21 @@
     "    return h3_gdf.to_crs(gdf.crs)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# `BingTileGridGenerator`"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -349,7 +424,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -367,7 +446,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -409,7 +492,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| exporti\n",
@@ -428,7 +515,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| exporti\n",
@@ -455,7 +546,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -522,7 +617,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## `FastBingTileGridGenerator`\n",
+    "# `FastBingTileGridGenerator`\n",
     "\n",
     "This is significantly faster than `BingTileGridGenerator`\n",
     "\n",
@@ -534,7 +629,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -561,7 +660,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| export\n",
@@ -654,7 +757,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
    "outputs": [],
    "source": [
     "#| exporti\n",

From 1f11caadae0ba4144f7a69294a5358fa8cabf327 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Wed, 7 Aug 2024 00:09:44 +0800
Subject: [PATCH 19/21] fix markdown formatting

---
 notebooks/00_grids.ipynb | 1 +
 1 file changed, 1 insertion(+)

diff --git a/notebooks/00_grids.ipynb b/notebooks/00_grids.ipynb
index a5d63ac..1096177 100644
--- a/notebooks/00_grids.ipynb
+++ b/notebooks/00_grids.ipynb
@@ -622,6 +622,7 @@
     "This is significantly faster than `BingTileGridGenerator`\n",
     "\n",
     "This uses these optimizations to speed up grid generation:\n",
+    "\n",
     "1. Vectorized Translation Functions: Functions that translate between lat,lon and web mercator x,y are written in polars.\n",
     "2. Voxel Traversal and Scanline Fill Algorithms: Faster alternative to finding all pixels within a polygon without using the point in polygon operation."
    ]

From 15f2cf3131fbea6c5f4c9bd6cdc36462b8192ed4 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Thu, 8 Aug 2024 14:04:40 +0800
Subject: [PATCH 20/21] modify main polygon_fill functions from exporti to
 export

---
 geowrangler/gridding_utils/polygon_fill.py | 45 ++++++++--------
 notebooks/15_polygon_fill.ipynb            | 60 +++++++++++++---------
 2 files changed, 58 insertions(+), 47 deletions(-)

diff --git a/geowrangler/gridding_utils/polygon_fill.py b/geowrangler/gridding_utils/polygon_fill.py
index 8c92307..8d05c82 100644
--- a/geowrangler/gridding_utils/polygon_fill.py
+++ b/geowrangler/gridding_utils/polygon_fill.py
@@ -1,7 +1,7 @@
 # AUTOGENERATED! DO NOT EDIT! File to edit: ../../notebooks/15_polygon_fill.ipynb.
 
 # %% auto 0
-__all__ = []
+__all__ = ['voxel_traversal_2d', 'scanline_fill', 'voxel_traversal_scanline_fill']
 
 # %% ../../notebooks/15_polygon_fill.ipynb 5
 from typing import List, Tuple, Set, Optional, Dict, Union
@@ -11,10 +11,6 @@
 import polars as pl
 
 # %% ../../notebooks/15_polygon_fill.ipynb 11
-# epsilon is a constant for correcting near-misses in voxel traversal
-EPSILON = 1e-14
-
-
 def voxel_traversal_2d(
     start_vertex: Tuple[int, int],
     end_vertex: Tuple[int, int],
@@ -22,6 +18,9 @@ def voxel_traversal_2d(
 ) -> List[Tuple[int, int]]:
     """Returns all pixels between two points as inspired by Amanatides & Woo's “A Fast Voxel Traversal Algorithm For Ray Tracing”"""
 
+    # epsilon is a constant for correcting near-misses in voxel traversal
+    EPSILON = 1e-14
+
     # Setup initial conditions
     x1, y1 = start_vertex
     x2, y2 = end_vertex
@@ -162,6 +161,23 @@ def voxel_traversal_2d(
     return pixels
 
 # %% ../../notebooks/15_polygon_fill.ipynb 15
+def interpolate_x(
+    start_vertex: Tuple[int, int],
+    end_vertex: Tuple[int, int],
+    y: int,
+) -> float:
+    """Interpolate x value for a given y along the line segment defined by start_vertex and end_vertex."""
+    x1, y1 = start_vertex
+    x2, y2 = end_vertex
+    if y1 == y2:
+        # case when there is a horizontal line segment
+        raise ValueError(f"The y value of the 2 vertices should not be the same")
+
+    inverse_slope = (x2 - x1) / (y2 - y1)
+    interpolated_x = x1 + (y - y1) * inverse_slope
+    return interpolated_x
+
+# %% ../../notebooks/15_polygon_fill.ipynb 16
 def scanline_fill(
     vertices: List[
         Tuple[int, int]
@@ -218,24 +234,7 @@ def scanline_fill(
 
     return filled_pixels
 
-
-def interpolate_x(
-    start_vertex: Tuple[int, int],
-    end_vertex: Tuple[int, int],
-    y: int,
-) -> float:
-    """Interpolate x value for a given y along the line segment defined by start_vertex and end_vertex."""
-    x1, y1 = start_vertex
-    x2, y2 = end_vertex
-    if y1 == y2:
-        # case when there is a horizontal line segment
-        raise ValueError(f"The y value of the 2 vertices should not be the same")
-
-    inverse_slope = (x2 - x1) / (y2 - y1)
-    interpolated_x = x1 + (y - y1) * inverse_slope
-    return interpolated_x
-
-# %% ../../notebooks/15_polygon_fill.ipynb 19
+# %% ../../notebooks/15_polygon_fill.ipynb 20
 def voxel_traversal_scanline_fill(
     vertices_df: Union[
         pd.DataFrame, pl.DataFrame
diff --git a/notebooks/15_polygon_fill.ipynb b/notebooks/15_polygon_fill.ipynb
index 112610c..560d4d8 100644
--- a/notebooks/15_polygon_fill.ipynb
+++ b/notebooks/15_polygon_fill.ipynb
@@ -254,10 +254,7 @@
    },
    "outputs": [],
    "source": [
-    "#| exporti\n",
-    "\n",
-    "# epsilon is a constant for correcting near-misses in voxel traversal\n",
-    "EPSILON = 1e-14\n",
+    "#| export\n",
     "\n",
     "def voxel_traversal_2d(\n",
     "    start_vertex: Tuple[int, int], \n",
@@ -266,6 +263,9 @@
     ") -> List[Tuple[int, int]]:\n",
     "    \"\"\"Returns all pixels between two points as inspired by Amanatides & Woo's “A Fast Voxel Traversal Algorithm For Ray Tracing” \"\"\"\n",
     "\n",
+    "    # epsilon is a constant for correcting near-misses in voxel traversal\n",
+    "    EPSILON = 1e-14\n",
+    "\n",
     "    # Setup initial conditions\n",
     "    x1, y1 = start_vertex\n",
     "    x2, y2 = end_vertex\n",
@@ -462,7 +462,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "id": "29616c05-3a87-4952-a4f6-eb97c958599b",
+   "id": "6140fc04",
    "metadata": {
     "vscode": {
      "languageId": "python"
@@ -471,6 +471,35 @@
    "outputs": [],
    "source": [
     "#| exporti\n",
+    "def interpolate_x(\n",
+    "    start_vertex: Tuple[int, int],\n",
+    "    end_vertex: Tuple[int, int],\n",
+    "    y: int,\n",
+    ") -> float:\n",
+    "    \"\"\"Interpolate x value for a given y along the line segment defined by start_vertex and end_vertex.\"\"\"\n",
+    "    x1, y1 = start_vertex\n",
+    "    x2, y2 = end_vertex\n",
+    "    if y1 == y2:\n",
+    "        # case when there is a horizontal line segment\n",
+    "        raise ValueError(f\"The y value of the 2 vertices should not be the same\")\n",
+    "\n",
+    "    inverse_slope = (x2 - x1) / (y2 - y1)\n",
+    "    interpolated_x = x1 + (y - y1) * inverse_slope\n",
+    "    return interpolated_x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "29616c05-3a87-4952-a4f6-eb97c958599b",
+   "metadata": {
+    "vscode": {
+     "languageId": "python"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "#| export\n",
     "def scanline_fill(\n",
     "    vertices: List[Tuple[int,int]], # list of polygon vertices in order (either clockwise or counterclockwise)\n",
     "    debug: bool = False, # if true, prints diagnostic info for the algorithm  \n",
@@ -523,24 +552,7 @@
     "        if debug:\n",
     "            print(f\"Scanline y = {scanline_y}, Intersections: {intersection_points}\")\n",
     "    \n",
-    "    return filled_pixels\n",
-    "\n",
-    "\n",
-    "def interpolate_x(\n",
-    "    start_vertex: Tuple[int, int],\n",
-    "    end_vertex: Tuple[int, int],\n",
-    "    y: int,\n",
-    ") -> float:\n",
-    "    \"\"\"Interpolate x value for a given y along the line segment defined by start_vertex and end_vertex.\"\"\"\n",
-    "    x1, y1 = start_vertex\n",
-    "    x2, y2 = end_vertex\n",
-    "    if y1 == y2:\n",
-    "        # case when there is a horizontal line segment\n",
-    "        raise ValueError(f\"The y value of the 2 vertices should not be the same\")\n",
-    "\n",
-    "    inverse_slope = (x2 - x1) / (y2 - y1)\n",
-    "    interpolated_x = x1 + (y - y1) * inverse_slope\n",
-    "    return interpolated_x\n"
+    "    return filled_pixels\n"
    ]
   },
   {
@@ -599,7 +611,7 @@
    },
    "outputs": [],
    "source": [
-    "#| exporti\n",
+    "#| export\n",
     "\n",
     "def voxel_traversal_scanline_fill(\n",
     "    vertices_df: Union[pd.DataFrame,pl.DataFrame], # dataframe with x_col and y_col for the polygon vertices\n",

From 06458275e7c554c754260c97b33bf9dba73ee651 Mon Sep 17 00:00:00 2001
From: Joshua Cortez <joshua.m.cortez@gmail.com>
Date: Thu, 8 Aug 2024 15:19:35 +0800
Subject: [PATCH 21/21] fix typo in test_grids comment

---
 tests/test_grids.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_grids.py b/tests/test_grids.py
index 6396cd1..2ae856f 100644
--- a/tests/test_grids.py
+++ b/tests/test_grids.py
@@ -220,7 +220,7 @@ def test_bing_tile_grid_generator_join_return_geometry_false(
     assert isinstance(grids_gdf, pd.DataFrame)
     assert len(grids_gdf) == BING_TILE_N_TILES
 
-# FastBingTileGridGenerator has 6 more tiles than  because it considered tiles exactly on the border
+# FastBingTileGridGenerator returns 6 more tiles than BingTileGridGenerator because it considered tiles exactly on the border
 FAST_BING_TILE_N_TILES = BING_TILE_N_TILES + 6
 FAST_BING_TILE_MULTIPOLY_N_TILES = BING_TILE_MULTIPOLY_N_TILES + 6