check georef overlay

map_tab/map_setup.py

@@ -8,11 +8,36 @@ import numpy as np
 from matplotlib import cm, colors
 import pandas as pd
 import pyproj
+import matplotlib.pyplot as plt
 from config import OUTPUT_DIR
 from branca.colormap import linear
 
 CELL_SIZE_M = 100  # meters
 
+
+def export_georeferenced_png(raster_path, png_path):
+    """
+    Export the raster to a georeferenced PNG
+    that aligns with Folium ImageOverlay.
+    """
+    with rasterio.open(raster_path) as src:
+        # Read all bands (or just 1 if grayscale)
+        arr = src.read()
+
+        # Handle RGB or single-band case
+        if arr.shape[0] >= 3:
+            img = arr[:3].transpose(1, 2, 0)  # (H, W, RGB)
+        else:
+            img = arr[0]
+
+        bounds = src.bounds
+
+    plt.imshow(img, extent=[bounds.left, bounds.right, bounds.bottom, bounds.top])
+    plt.axis("off")
+    plt.savefig(png_path, bbox_inches="tight", pad_inches=0, transparent=True)
+    plt.close()
+
+
 def make_map(city, show_grid, show_georef):
     city = city.strip()
     if not city:
@@ -29,26 +54,39 @@ def make_map(city, show_grid, show_georef):
     if not os.path.exists(raster_path):
         return "Georeferenced raster not found"
 
-    # Raster bounds and CRS
     with rasterio.open(raster_path) as src:
         bounds = src.bounds
         crs = src.crs
 
     xmin, ymin, xmax, ymax = bounds
-    transformer = pyproj.Transformer.from_crs("EPSG:3857", "EPSG:4326", always_xy=True)
+    transformer = pyproj.Transformer.from_crs(crs, "EPSG:4326", always_xy=True)
+
+    # Convert raster bounds to lat/lon
+    lon0, lat0 = transformer.transform(xmin, ymin)
+    lon1, lat1 = transformer.transform(xmax, ymax)
+
+    # Enforce correct ordering for Folium
+    lat_min, lat_max = sorted([lat0, lat1])
+    lon_min, lon_max = sorted([lon0, lon1])
 
     # Show georeferenced raster if requested
     if show_georef:
         raster_img_path = os.path.join(OUTPUT_DIR, "georeferenced_rgba.png")
-        if os.path.exists(raster_img_path):
-            lon0, lat0 = transformer.transform(xmin, ymin)
-            lon1, lat1 = transformer.transform(xmax, ymax)
-            ImageOverlay(
-                image=raster_img_path,
-                bounds=[[lat0, lon0], [lat1, lon1]],
-                opacity=0.7,
-                interactive=True
-            ).add_to(m)
+        if not os.path.exists(raster_img_path):
+            export_georeferenced_png(raster_path, raster_img_path)
+
+        ImageOverlay(
+            image=raster_img_path,
+            bounds=[[lat_min, lon_min], [lat_max, lon_max]],
+            opacity=0.7,
+            interactive=True,
+        ).add_to(m)
+
+    # Debug markers (optional, helps see alignment)
+    folium.Marker([loc.latitude, loc.longitude], tooltip="City center").add_to(m)
+    cx, cy = (xmin + xmax) / 2, (ymin + ymax) / 2
+    clon, clat = transformer.transform(cx, cy)
+    folium.Marker([clat, clon], tooltip="Raster center").add_to(m)
 
     # Grid overlay
     if show_grid:
@@ -59,7 +97,6 @@ def make_map(city, show_grid, show_georef):
                 if df.empty:
                     continue
 
-                # Tile bounds
                 tile_xmin, tile_xmax = df['x'].min(), df['x'].max()
                 tile_ymin, tile_ymax = df['y'].min(), df['y'].max()
                 n_cols = int(np.ceil((tile_xmax - tile_xmin) / CELL_SIZE_M))
@@ -76,49 +113,49 @@ def make_map(city, show_grid, show_georef):
                         counts[row_idx, col] += 1
 
                 mask = counts > 0
-                grid[mask] /= counts[mask]  # average OSM match score
+                grid[mask] /= counts[mask]
                 grid_values.append((grid, tile_xmin, tile_ymin, n_rows, n_cols))
 
-        # Flatten all grid values for global min/max
-        all_scores = np.concatenate([g[0].flatten() for g in grid_values])
-        min_val, max_val = all_scores.min(), all_scores.max()
-        if min_val == max_val:
-            max_val = min_val + 1e-6
-
-        cmap = cm.get_cmap('Reds')
-
-        # Create a linear colormap for legend
-        colormap = linear.Reds_09.scale(min_val, max_val)
-        colormap.caption = 'Average OSM Match Score'
-        colormap.add_to(m)
-
-        # Draw grid cells
-        for grid, tile_xmin, tile_ymin, n_rows, n_cols in grid_values:
-            for r in range(n_rows):
-                for c in range(n_cols):
-                    val = grid[r, c]
-                    if val <= 0:
-                        continue
-                    norm_val = (val - min_val) / (max_val - min_val)
-                    color = colors.to_hex(cmap(norm_val))
-                    x0 = tile_xmin + c * CELL_SIZE_M
-                    y0 = tile_ymin + r * CELL_SIZE_M
-                    x1 = x0 + CELL_SIZE_M
-                    y1 = y0 + CELL_SIZE_M
-                    lon0, lat0 = transformer.transform(x0, y0)
-                    lon1, lat1 = transformer.transform(x1, y1)
-                    folium.Rectangle(
-                        bounds=[[lat0, lon0], [lat1, lon1]],
-                        color=None,  # no border
-                        weight=0,
-                        fill=True,
-                        fill_color=color,
-                        fill_opacity=0.7,
-                        popup=f"{val:.2f}"  # only the value
-                    ).add_to(m)
+        if grid_values:
+            all_scores = np.concatenate([g[0].flatten() for g in grid_values])
+            min_val, max_val = all_scores.min(), all_scores.max()
+            if min_val == max_val:
+                max_val = min_val + 1e-6
+
+            cmap = cm.get_cmap("Reds")
+            colormap = linear.Reds_09.scale(min_val, max_val)
+            colormap.caption = "Average OSM Match Score"
+            colormap.add_to(m)
+
+            for grid, tile_xmin, tile_ymin, n_rows, n_cols in grid_values:
+                for r in range(n_rows):
+                    for c in range(n_cols):
+                        val = grid[r, c]
+                        if val <= 0:
+                            continue
+                        norm_val = (val - min_val) / (max_val - min_val)
+                        color = colors.to_hex(cmap(norm_val))
+                        x0 = tile_xmin + c * CELL_SIZE_M
+                        y0 = tile_ymin + r * CELL_SIZE_M
+                        x1 = x0 + CELL_SIZE_M
+                        y1 = y0 + CELL_SIZE_M
+                        lon0, lat0 = transformer.transform(x0, y0)
+                        lon1, lat1 = transformer.transform(x1, y1)
+                        lat_min, lat_max = sorted([lat0, lat1])
+                        lon_min, lon_max = sorted([lon0, lon1])
+                        folium.Rectangle(
+                            bounds=[[lat_min, lon_min], [lat_max, lon_max]],
+                            color=None,
+                            weight=0,
+                            fill=True,
+                            fill_color=color,
+                            fill_opacity=0.7,
+                            popup=f"{val:.2f}",
+                        ).add_to(m)
 
     return m._repr_html_()
 
+
 def get_map_widgets(city_component):
     map_output = gr.HTML(value="Map will appear here once you type a city", elem_id="map-widget")
     show_grid = gr.Checkbox(label="Draw Grid", value=False)