split map logic; add osm output

inference_tab/inference_logic.py

@@ -616,6 +616,13 @@ def fuzzyMatch(score_th,tile_dict):
     RES_PATH=os.path.join(OUTPUT_DIR,f"street_matches_tile{tile_number}.csv")
     results_df.to_csv(RES_PATH, index=False)
 
+    # NEW: Save OSM shapefile export as CSV
+    OSM_CSV_PATH = os.path.join(OUTPUT_DIR, f"osm_extract_tile{tile_number}.csv")
+    osm_export_df = osm_gdf[["name", "geometry"]].copy()
+    # convert geometry to WKT for CSV storage
+    osm_export_df["geometry"] = osm_export_df["geometry"].apply(lambda g: g.wkt)
+    osm_export_df.to_csv(OSM_CSV_PATH, index=False)
+
     # remove street labels from blobs folder that are more than or equal to score threshold
     manual_df = results_df[results_df['osm_match_score'] >= int(score_th)]
 
@@ -630,4 +637,4 @@ def fuzzyMatch(score_th,tile_dict):
         if os.path.exists(margin_path):
             os.remove(margin_path)
 
-    yield f"{RES_PATH}"
+    yield f"Saved results: {RES_PATH}, {OSM_CSV_PATH}"

map_tab/map_logic.py

@@ -0,0 +1,156 @@
+import os
+import folium
+from folium.raster_layers import ImageOverlay
+from geopy.geocoders import Nominatim
+import rasterio
+import numpy as np
+from matplotlib import cm, colors
+import pandas as pd
+import pyproj
+import matplotlib.pyplot as plt
+from branca.colormap import linear
+from config import OUTPUT_DIR
+
+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:
+        arr = src.read()
+        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:
+        return "Please enter a city"
+
+    geolocator = Nominatim(
+        user_agent="histOSM_gradioAPP (maria.u.kuznetsova@gmail.com)",
+        timeout=10
+    )
+    loc = geolocator.geocode(city)
+    if loc is None:
+        return f"Could not find '{city}'"
+
+    m = folium.Map(location=[loc.latitude, loc.longitude], zoom_start=12)
+
+    raster_path = os.path.join(OUTPUT_DIR, "georeferenced.tif")
+    if not os.path.exists(raster_path):
+        return "Georeferenced raster not found"
+
+    with rasterio.open(raster_path) as src:
+        bounds = src.bounds
+        crs = src.crs
+
+    xmin, ymin, xmax, ymax = bounds
+    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)
+    lat_min, lat_max = sorted([lat0, lat1])
+    lon_min, lon_max = sorted([lon0, lon1])
+
+    # Overlay raster if requested
+    if show_georef:
+        raster_img_path = os.path.join(OUTPUT_DIR, "georeferenced_rgba.png")
+        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.85,
+            interactive=True,
+        ).add_to(m)
+
+    # Debug markers
+    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:
+        _add_grid_overlay(m, transformer)
+
+    return m._repr_html_()
+
+
+def _add_grid_overlay(m, transformer):
+    grid_values = []
+
+    for fname in os.listdir(OUTPUT_DIR):
+        if fname.startswith("street_matches_tile") and fname.endswith(".csv"):
+            df = pd.read_csv(os.path.join(OUTPUT_DIR, fname))
+            if df.empty:
+                continue
+
+            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))
+            n_rows = int(np.ceil((tile_ymax - tile_ymin) / CELL_SIZE_M))
+
+            grid = np.zeros((n_rows, n_cols))
+            counts = np.zeros((n_rows, n_cols))
+
+            for _, row in df.iterrows():
+                col = int((row['x'] - tile_xmin) // CELL_SIZE_M)
+                row_idx = int((row['y'] - tile_ymin) // CELL_SIZE_M)
+                if 0 <= col < n_cols and 0 <= row_idx < n_rows:
+                    grid[row_idx, col] += row['osm_match_score']
+                    counts[row_idx, col] += 1
+
+            mask = counts > 0
+            grid[mask] /= counts[mask]
+            grid_values.append((grid, tile_xmin, tile_ymin, n_rows, n_cols))
+
+    if not grid_values:
+        return
+
+    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)

map_tab/map_setup.py

@@ -1,160 +1,5 @@
-import os
 import gradio as gr
-import folium
-from folium.raster_layers import ImageOverlay
-from geopy.geocoders import Nominatim
-import rasterio
-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:
-        return "Please enter a city"
-
-    geolocator = Nominatim(user_agent="histOSM_gradioAPP (maria.u.kuznetsova@gmail.com)",
-                           timeout=10)
-    loc = geolocator.geocode(city)
-    if loc is None:
-        return f"Could not find '{city}'"
-
-    m = folium.Map(location=[loc.latitude, loc.longitude], zoom_start=12)
-
-    raster_path = os.path.join(OUTPUT_DIR, "georeferenced.tif")
-    if not os.path.exists(raster_path):
-        return "Georeferenced raster not found"
-
-    with rasterio.open(raster_path) as src:
-        bounds = src.bounds
-        crs = src.crs
-
-    xmin, ymin, xmax, ymax = bounds
-    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 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.85,
-            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:
-        grid_values = []
-        for fname in os.listdir(OUTPUT_DIR):
-            if fname.startswith("street_matches_tile") and fname.endswith(".csv"):
-                df = pd.read_csv(os.path.join(OUTPUT_DIR, fname))
-                if df.empty:
-                    continue
-
-                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))
-                n_rows = int(np.ceil((tile_ymax - tile_ymin) / CELL_SIZE_M))
-
-                grid = np.zeros((n_rows, n_cols))
-                counts = np.zeros((n_rows, n_cols))
-
-                for _, row in df.iterrows():
-                    col = int((row['x'] - tile_xmin) // CELL_SIZE_M)
-                    row_idx = int((row['y'] - tile_ymin) // CELL_SIZE_M)
-                    if 0 <= col < n_cols and 0 <= row_idx < n_rows:
-                        grid[row_idx, col] += row['osm_match_score']
-                        counts[row_idx, col] += 1
-
-                mask = counts > 0
-                grid[mask] /= counts[mask]
-                grid_values.append((grid, tile_xmin, tile_ymin, n_rows, n_cols))
-
-        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_()
+from map_logic import make_map
 
 
 def get_map_widgets(city_component):