added CRS conversion, plotly map instead of Folium

app.py

@@ -1,6 +1,8 @@
 # [DEBUG]
 from osgeo import gdal
 
+import os
+from config import OUTPUT_DIR
 import gradio as gr
 import logging
 from inference_tab import get_inference_widgets, run_inference,georefImg
@@ -14,7 +16,7 @@ logging.basicConfig(level=logging.DEBUG)
 
 with gr.Blocks() as demo:
     with gr.Tab("Inference"):
-        image_input, gcp_input, city_name, score_th, run_button, output, download_file = get_inference_widgets(run_inference,georefImg)
+        image_input, gcp_input, city_name,user_crs, score_th, run_button, output, download_file = get_inference_widgets(run_inference,georefImg)
     with gr.Tab("Annotation"):
         get_annotation_widgets()
     with gr.Tab("Map"): 

inference_tab/inference_logic.py

@@ -13,7 +13,7 @@ import rasterio.features
 from shapely.geometry import shape
 import pandas as pd
 import osmnx as ox
-from osgeo import gdal
+from osgeo import gdal, osr
 import geopandas as gpd
 from rapidfuzz import process, fuzz
 from huggingface_hub import hf_hub_download
@@ -24,6 +24,7 @@ from .helpers import box_inside_global,nms_iou,non_max_suppression,tile_image_wi
 from pyproj import Transformer
 import shutil
 import re
+from pyproj import Transformer
 
 # Global cache
 _trocr_processor = None
@@ -471,17 +472,18 @@ def georefTile(tile_coords, gcp_path):
 
 
 
-def georefImg(image_path, gcp_path):
-    
-    yield "Reading GCP CSV..."
+def georefImg(image_path, gcp_path, user_crs):
 
     TMP_FILE = os.path.join(OUTPUT_DIR,"tmp.tif")
     GEO_FILE = os.path.join(OUTPUT_DIR,"georeferenced.tif")
+    VRT_FILE = os.path.join(OUTPUT_DIR,"vrt_file.vrt")
 
     for f in [TMP_FILE, GEO_FILE]:
         if os.path.exists(f):
             os.remove(f)
 
+    yield "Read GCP points..."
+
     df = pd.read_csv(gcp_path)
 
     H,W,_ = img_shape(image_path)
@@ -489,7 +491,7 @@ def georefImg(image_path, gcp_path):
 
     # Build GCPs
     gcps = []
-    for _, r in df.iterrows():
+    '''for _, r in df.iterrows():
         gcps.append(
             gdal.GCP(
                 float(r['mapX']),    
@@ -499,28 +501,64 @@ def georefImg(image_path, gcp_path):
                 #H-float(r['sourceY']) 
                 abs(float(r['sourceY']))
             )
-        )
+        )'''
 
-    gdal.Translate(
+    for _, r in df.iterrows():
+        gcps.append((
+            float(r['mapX']),    
+            float(r['mapY']),
+            float(r['sourceX']), 
+            #H-float(r['sourceY']) 
+            abs(float(r['sourceY']))
+            ))
+        
+
+    # OLD
+    '''gdal.Translate(
             TMP_FILE,
             image_path,
             format="GTiff",
             GCPs=gcps,
             outputSRS="EPSG:3857" 
-        )
+        )'''
+    
+    yield "Transform GCP to user specified CRS..."
+
+    # Transform GCP from user provided CRS to Web Mercator 3857
+    transformer=Transformer.from_crs(f"epsg:{user_crs}","epsg:3857",always_xy=True)
+    gcps3857=[]
+    for px,py,x,y in gcps:
+        x3857,y3857=transformer.transform(px,py)
+        gcp=gdal.GCP(x3857,y3857,0,x,y)
+        gcps3857.append(gcp)
+
+    yield "Apply GCP to the image..."
+
+    # Apply GCP to the image
+    src_ds=gdal.Open(image_path)
+    drv=gdal.GetDriverByName('VRT')
+    vrt_ds=drv.CreateCopy(VRT_FILE,src_ds,0)
+
+    # Set the GCPs and spatial reference system
+    srs3857=osr.SpatialReference()
+    srs3857.ImportFromEPSG(3857)
+    vrt_ds.SetGCPs(gcps3857,srs3857.ExportToWkt())
+    vrt_ds=None # close vrt to save changes
+
 
     gdal.Warp(
         GEO_FILE,
-        TMP_FILE,
+        VRT_FILE, # TMP_FILE,
         dstSRS="EPSG:3857",  
         resampleAlg="near", 
         polynomialOrder=1,
-        creationOptions=["COMPRESS=LZW"] 
+        creationOptions=["COMPRESS=LZW"],
+        format='GTiff'
     )
 
     
 
-    yield "Georeferencing is done."
+    yield "The map is georeferenced."
 
 
 def extractStreetNet(city_name):

inference_tab/inference_setup.py

@@ -84,9 +84,13 @@ def get_inference_widgets(run_inference,georefImg):
                 type="numpy", label="City Map",
                 height=500, width=500
             )
-            city_name = gr.Textbox(label="Enter city name")
+            
             image_input = gr.File(label="Select Image File")
             gcp_input = gr.File(label="Select GCP Points File", file_types=[".points"])
+
+            city_name = gr.Textbox(label="Enter city name")
+            user_crs = gr.Textbox(label="Enter CRS for the GCP",value="3395")
+
             create_btn = gr.Button("Create Tiles")
             georef_btn = gr.Button("Georeference Full Map")
            
@@ -124,9 +128,9 @@ def get_inference_widgets(run_inference,georefImg):
 
     georef_btn.click(
         fn=georefImg,
-        inputs=[image_input, gcp_input],
+        inputs=[image_input, gcp_input,user_crs],
         outputs=[output]
     )
 
 
-    return image_input, gcp_input, city_name, score_th, run_button, output, download_file
+    return image_input, gcp_input, city_name, user_crs, score_th, run_button, output, download_file

map_tab/map_logic.py

@@ -1,94 +1,120 @@
 import os
-import folium
-from folium.raster_layers import ImageOverlay
-from geopy.geocoders import Nominatim
-import rasterio
+import io
+import base64
 import numpy as np
-from matplotlib import cm, colors
 import pandas as pd
+import rasterio
 import pyproj
 import matplotlib.pyplot as plt
-from branca.colormap import linear
+from matplotlib import cm, colors
+from geopy.geocoders import Nominatim
 from config import OUTPUT_DIR
+import plotly.graph_objects as go
+from PIL import Image
 
 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"
+        return go.Figure().add_annotation(text="Please enter a city")
 
+    # --- Geocode 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)
-
+        return go.Figure().add_annotation(text=f"Could not find '{city}'")
+
+    lat_center, lon_center = loc.latitude, loc.longitude
+    fig = go.Figure()
+
+    # --- Add city marker ---
+    fig.add_trace(go.Scattermapbox(
+        lat=[lat_center],
+        lon=[lon_center],
+        mode="markers+text",
+        text=["City center"],
+        textposition="top right",
+        marker=dict(size=12, color="blue")
+    ))
+
+    # --- Load raster ---
     raster_path = os.path.join(OUTPUT_DIR, "georeferenced.tif")
     if not os.path.exists(raster_path):
-        return "Georeferenced raster not found"
+        return go.Figure().add_annotation(text="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
+    # --- Optional raster overlay ---
     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
+        with rasterio.open(raster_path) as src:
+            arr = src.read(out_dtype="uint8")
+            if arr.shape[0] >= 3:
+                img = arr[:3].transpose(1, 2, 0)
+            else:
+                img = arr[0]
+
+        img = np.clip(img, 0, 255)
+        image = Image.fromarray(img)
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG")
+        encoded = base64.b64encode(buffer.getvalue()).decode()
+
+        fig.update_layout(mapbox_layers=[
+            dict(
+                sourcetype="image",
+                source="data:image/png;base64," + encoded,
+                coordinates=[
+                    [lon_min, lat_max],
+                    [lon_max, lat_max],
+                    [lon_max, lat_min],
+                    [lon_min, lat_min]
+                ],
+                opacity=0.65
+            )
+        ])
+
+        # Add raster center marker
+        cx, cy = (xmin + xmax) / 2, (ymin + ymax) / 2
+        clon, clat = transformer.transform(cx, cy)
+        fig.add_trace(go.Scattermapbox(
+            lat=[clat],
+            lon=[clon],
+            mode="markers+text",
+            text=["Raster center"],
+            textposition="bottom right",
+            marker=dict(size=10, color="red")
+        ))
+
+    # --- Optional grid overlay ---
     if show_grid:
-        _add_grid_overlay(m, transformer)
-
-    return m._repr_html_()
+        _add_grid_overlay_plotly(fig, transformer)
+
+    # --- Layout ---
+    fig.update_layout(
+        mapbox_style="open-street-map",
+        mapbox_zoom=12,
+        mapbox_center={"lat": lat_center, "lon": lon_center},
+        margin={"l": 0, "r": 0, "t": 0, "b": 0},
+        showlegend=False
+    )
+    return fig
 
 
-def _add_grid_overlay(m, transformer):
+def _add_grid_overlay_plotly(fig, transformer):
+    """Add grid overlay as filled polygons on the Plotly map."""
     grid_values = []
 
     for fname in os.listdir(OUTPUT_DIR):
@@ -122,12 +148,9 @@ def _add_grid_overlay(m, transformer):
     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
+        max_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)
+    cmap = plt.get_cmap("Reds")
 
     for grid, tile_xmin, tile_ymin, n_rows, n_cols in grid_values:
         for r in range(n_rows):
@@ -143,14 +166,15 @@ def _add_grid_overlay(m, transformer):
                 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)
+                lons = [lon0, lon1, lon1, lon0, lon0]
+                lats = [lat0, lat0, lat1, lat1, lat0]
+                fig.add_trace(go.Scattermapbox(
+                    lon=lons,
+                    lat=lats,
+                    mode="lines",
+                    fill="toself",
+                    fillcolor=color,
+                    line=dict(width=0),
+                    hoverinfo="text",
+                    text=f"{val:.2f}"
+                ))

map_tab/map_setup.py

@@ -3,7 +3,8 @@ from .map_logic import make_map
 
 
 def get_map_widgets(city_component):
-    map_output = gr.HTML(value="Map will appear here once you type a city", elem_id="map-widget")
+    #map_output = gr.HTML(value="Map will appear here once you type a city", elem_id="map-widget")
+    map_output = gr.Plot(label="Map", value=None)
     show_grid = gr.Checkbox(label="Draw Grid", value=False)
     show_georef = gr.Checkbox(label="Show Georeferenced Map", value=False)