Deploy from GitHub Actions

.streamlit/config.toml

@@ -0,0 +1,10 @@
+[theme]
+primaryColor = "#1a9850"
+backgroundColor = "#1e1e1e"
+secondaryBackgroundColor = "#2d2d2d"
+textColor = "#ffffff"
+
+[server]
+headless = true
+enableCORS = false
+enableXsrfProtection = false

.streamlit/secrets.toml

@@ -0,0 +1,5 @@
+# Add your secrets here
+# HF_TOKEN = "hf_your_token_here"
+# DATASET_ID = "Rahul-fix/cologne-green-data"
+#
+# NOTE: For HF Spaces, set these in Settings > Repository secrets instead

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.11-slim
+
+# Install system dependencies for GDAL/rasterio
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
+    libgdal-dev \
+    gdal-bin \
+    libgeos-dev \
+    libproj-dev \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set GDAL environment
+ENV GDAL_CONFIG=/usr/bin/gdal-config
+
+WORKDIR /app
+
+# Copy requirements first for caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app files
+COPY app.py utils.py ./
+
+# Expose Streamlit port (HF Spaces uses 7860)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK CMD curl --fail http://localhost:7860/_stcore/health || exit 1
+
+# Run Streamlit
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.enableCORS=false", "--server.enableXsrfProtection=false"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Cologne Green Project
+emoji: 🌳
+colorFrom: green
+colorTo: green
+sdk: docker
+pinned: false
+short_description: 'Urban green analysis as a part of #Correlaid lc Cologne'
+---
+
+For more information, Check out the project on GitHub: https://github.com/Rahul-fix/cologne-green-project

app.py

@@ -0,0 +1,474 @@
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
+import folium
+from streamlit_folium import st_folium
+from shapely.geometry import Point, box
+import geopandas as gpd
+import duckdb
+import rasterio
+from huggingface_hub import HfFileSystem
+import shapely.wkb
+from dotenv import load_dotenv
+import os
+from pathlib import Path
+
+# Import extracted utilities (shared with app_local.py)
+from utils import (
+    FLAIR_COLORS, CLASS_LABELS, process_mosaic
+)
+
+# --- Cloud Configuration ---
+load_dotenv()
+env_path = Path(__file__).parent.parent / "DL_cologne_green" / ".env"
+if env_path.exists():
+    load_dotenv(env_path)
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+DATASET_ID = os.getenv("DATASET_ID", "Rahul-fix/cologne-green-data")
+BASE_URL = f"hf://datasets/{DATASET_ID}"
+STORAGE_OPTS = {"token": HF_TOKEN} if HF_TOKEN else None
+
+# --- DuckDB Connection ---
+@st.cache_resource
+def get_db_connection():
+    con = duckdb.connect(database=":memory:")
+    con.execute("INSTALL spatial; LOAD spatial;")
+    con.execute("INSTALL httpfs; LOAD httpfs;")
+    if HF_TOKEN:
+        fs = HfFileSystem(token=HF_TOKEN)
+        con.register_filesystem(fs)
+    return con
+
+con = get_db_connection()
+
+# --- Cloud Data Loading Functions (mirror utils.py structure) ---
+def safe_load_wkb(x):
+    try: return shapely.wkb.loads(bytes(x))
+    except: return None
+
+@st.cache_data(ttl=3600)
+def load_quarters_with_stats():
+    """Load Veedel boundaries with stats - Cloud version of utils.load_quarters_with_stats"""
+    try:
+        query = f"""
+            SELECT 
+                v.name, ST_AsWKB(v.geometry) as geometry,
+                COALESCE(s.green_area_m2, 0) as green_area_m2,
+                COALESCE(s.ndvi_mean, 0) as ndvi_mean,
+                v.Shape_Area,
+                s.area_0, s.area_1, s.area_2, s.area_3, s.area_4, s.area_5, s.area_6, s.area_7,
+                s.area_8, s.area_9, s.area_10, s.area_11, s.area_12, s.area_13, s.area_14, s.area_15,
+                s.area_16, s.area_17, s.area_18
+            FROM '{BASE_URL}/data/boundaries/Stadtviertel.parquet' v 
+            LEFT JOIN '{BASE_URL}/data/stats/extended_stats.parquet' s ON v.name = s.name
+        """
+        df = con.execute(query).fetchdf()
+        df['geometry'] = df['geometry'].apply(safe_load_wkb)
+        df = df.dropna(subset=['geometry'])
+        
+        gdf = gpd.GeoDataFrame(df, geometry='geometry', crs="EPSG:4326")
+        
+        # CRS Check (remote data may be in EPSG:25832)
+        if not gdf.empty and gdf.total_bounds[0] > 180:
+            gdf.crs = "EPSG:25832"
+            gdf = gdf.to_crs("EPSG:4326")
+        
+        # Calculate green_pct
+        if 'green_area_m2' in gdf.columns and 'Shape_Area' in gdf.columns:
+            gdf['green_pct'] = (gdf['green_area_m2'] / gdf['Shape_Area']) * 100
+        else:
+            gdf['green_pct'] = 0.0
+        
+        return gdf
+    except Exception as e:
+        st.error(f"Error loading quarters: {e}")
+        return gpd.GeoDataFrame()
+
+@st.cache_data(ttl=3600)
+def load_boroughs():
+    """Load borough boundaries - Cloud version of utils.load_boroughs"""
+    try:
+        query = f"SELECT STB_NAME as name, ST_AsWKB(geometry) as geometry FROM '{BASE_URL}/data/boundaries/Stadtbezirke.parquet'"
+        df = con.execute(query).fetchdf()
+        df['geometry'] = df['geometry'].apply(safe_load_wkb)
+        df = df.dropna(subset=['geometry'])
+        
+        gdf = gpd.GeoDataFrame(df, geometry='geometry', crs="EPSG:4326")
+        
+        if not gdf.empty and gdf.total_bounds[0] > 180:
+            gdf.crs = "EPSG:25832"
+            gdf = gdf.to_crs("EPSG:4326")
+        
+        return gdf
+    except Exception as e:
+        st.error(f"Error loading boroughs: {e}")
+        return gpd.GeoDataFrame()
+
+@st.cache_data(ttl=3600)
+def get_tile_to_veedel_mapping():
+    """Get tile-to-Veedel mapping - Cloud version of utils.get_tile_to_veedel_mapping"""
+    try:
+        tiles_df = pd.read_csv(f"{BASE_URL}/data/metadata/cologne_tiles.csv", storage_options=STORAGE_OPTS)
+        geometries = [box(r['Koordinatenursprung_East'], r['Koordinatenursprung_North'], 
+                         r['Koordinatenursprung_East']+1000, r['Koordinatenursprung_North']+1000) for _, r in tiles_df.iterrows()]
+        tiles_gdf = gpd.GeoDataFrame(tiles_df, geometry=geometries, crs="EPSG:25832")
+        
+        q_gdf = gpd.read_parquet(f"{BASE_URL}/data/boundaries/Stadtviertel.parquet", storage_options=STORAGE_OPTS)
+        if q_gdf.crs != "EPSG:25832": q_gdf = q_gdf.to_crs("EPSG:25832")
+        
+        joined = gpd.sjoin(tiles_gdf, q_gdf, how="inner", predicate="intersects")
+        return joined.groupby('name')['Kachelname'].apply(list).to_dict()
+    except Exception as e:
+        return {}
+
+@st.cache_data(ttl=3600)
+def list_available_tiles():
+    """List available tiles from cloud (processed, web_optimized, or raw)"""
+    try:
+        fs = HfFileSystem(token=HF_TOKEN)
+        tiles = set()
+        
+        # Check processed masks
+        processed_files = fs.glob(f"datasets/{DATASET_ID}/data/processed/*_mask.tif")
+        for f in processed_files:
+            tiles.add(Path(f).stem.replace("_mask", ""))
+        
+        # Check web_optimized masks
+        web_opt_files = fs.glob(f"datasets/{DATASET_ID}/data/web_optimized/*_mask.tif")
+        for f in web_opt_files:
+            tiles.add(Path(f).stem.replace("_mask", ""))
+        
+        # Also include raw tiles (for satellite view)
+        raw_files = fs.glob(f"datasets/{DATASET_ID}/data/raw/*.jp2")
+        for f in raw_files:
+            tiles.add(Path(f).stem)
+        
+        return list(tiles)
+    except:
+        return []
+
+def get_mosaic_data_remote(tile_names, layer_type):
+    """Load and mosaic tiles - Cloud version of utils.get_mosaic_data_local"""
+    fs = HfFileSystem(token=HF_TOKEN)
+    sources = []
+    memfiles = []
+    
+    try:
+        for tile in tile_names:
+            suffix = "_mask" if "Land Cover" in layer_type else "_ndvi" if "NDVI" in layer_type else ""
+            
+            paths = [
+                f"datasets/{DATASET_ID}/data/web_optimized/{tile}{suffix}.tif",
+                f"datasets/{DATASET_ID}/data/processed/{tile}{suffix}.tif",
+            ]
+            if layer_type == "Satellite":
+                paths.append(f"datasets/{DATASET_ID}/data/raw/{tile}.jp2")
+            
+            found_bytes = None
+            for p in paths:
+                try:
+                    with fs.open(p, "rb") as f:
+                        found_bytes = f.read()
+                        break
+                except: continue
+            
+            if found_bytes:
+                m = rasterio.MemoryFile(found_bytes)
+                memfiles.append(m)
+                sources.append(m.open())
+        
+        # Use shared processing logic
+        result = process_mosaic(sources, layer_type)
+        
+        # Cleanup
+        for s in sources: s.close()
+        for m in memfiles: m.close()
+        
+        return result
+    except Exception as e:
+        return None, None
+
+# 1. Page Configuration
+st.set_page_config(page_title="GreenCologne (Cloud)", layout="wide")
+st.title("🌿 GreenCologne (Cloud Dashboard)")
+
+# --- Sidebar: Dataset Info ---
+with st.sidebar:
+    st.header("ℹ️ About This Dataset")
+    
+    with st.expander("📡 Data Sources", expanded=False):
+        st.markdown("""
+        **Satellite Imagery**  
+        [OpenNRW DOP10](https://www.bezreg-koeln.nrw.de/geobasis-nrw/produkte-und-dienste/luftbild-und-satellitenbildinformationen/aktuelle-luftbild-und-0) – 10cm resolution aerial photos (2022-2025)
+        
+        **Administrative Boundaries**  
+        [Offene Daten Köln](https://www.offenedaten-koeln.de/) – Stadtviertel & Stadtbezirke
+        
+        **Coverage**  
+        840 tiles covering Cologne's 86 Veedels
+        """)
+    
+    with st.expander("🤖 Model & Methodology", expanded=False):
+        st.markdown("""
+        **Land Cover Classification**  
+        [FLAIR-Hub](https://huggingface.co/IGNF/FLAIR-HUB_LC-A_IR_swinbase-upernet) – Deep learning semantic segmentation trained on French aerial imagery, adapted for German urban landscapes.
+        
+        **19 Land Cover Classes**  
+        Buildings, deciduous trees, herbaceous vegetation, water, impervious surfaces, agricultural land, and more.
+        
+        **NDVI Calculation**  
+        Normalized Difference Vegetation Index computed from NIR and Red bands:  
+        `NDVI = (NIR - Red) / (NIR + Red)`
+        
+        **Green Area Detection**  
+        Classes 4 (Deciduous), 5 (Coniferous), 17 (Herbaceous), and 18 (Agricultural) are classified as green areas.
+        """)
+    
+    with st.expander("🙏 Acknowledgments", expanded=False):
+        st.markdown("""
+        - [CorrelAid](https://correlaid.org/) – Data-for-good community
+        - [OpenNRW](https://www.opengeodata.nrw.de/) – Open geospatial data
+        - [IGNF/FLAIR-Hub](https://huggingface.co/IGNF/FLAIR-HUB_LC-A_IR_swinbase-upernet) – Segmentation model
+        - [Stadt Köln](https://www.stadt-koeln.de/) – Open administrative data
+        """)
+
+if not HF_TOKEN:
+    st.warning("⚠️ HF_TOKEN missing. Set in .env or Streamlit Secrets.")
+
+# 2. Data Loading
+gdf_quarters = load_quarters_with_stats()
+gdf_boroughs = load_boroughs()
+tile_mapping = get_tile_to_veedel_mapping()
+available_tiles = list_available_tiles()
+
+# 3. State Management
+if 'selected_veedel' not in st.session_state: st.session_state['selected_veedel'] = "All"
+if 'map_center' not in st.session_state: st.session_state['map_center'] = [50.9375, 6.9603] # Cologne
+if 'map_zoom' not in st.session_state: st.session_state['map_zoom'] = 11
+if 'map_click_counter' not in st.session_state: st.session_state['map_click_counter'] = 0
+
+# --- Helper Functions ---
+def update_zoom_for_veedel(veedel_name):
+     if veedel_name == "All":
+        st.session_state['map_center'] = [50.9375, 6.9603]
+        st.session_state['map_zoom'] = 10
+     elif gdf_quarters is not None and not gdf_quarters.empty:
+         match = gdf_quarters[gdf_quarters['name'] == veedel_name]
+         if not match.empty:
+             centroid = match.geometry.centroid.iloc[0]
+             st.session_state['map_center'] = [centroid.y, centroid.x]
+             st.session_state['map_zoom'] = 14
+
+def on_veedel_change():
+    sel = st.session_state['selected_veedel_widget']
+    st.session_state['selected_veedel'] = sel
+    update_zoom_for_veedel(sel)
+
+# --- Layout ---
+col_map, col_details = st.columns([0.65, 0.35], gap="medium")
+
+with col_details:
+    st.markdown("### GreenCologne Analysis")
+    tab_opts, tab_stats = st.tabs(["🛠️ Options", "📊 Statistics"])
+    
+    veedel_list = ["All"] + sorted(gdf_quarters['name'].unique().tolist()) if gdf_quarters is not None and not gdf_quarters.empty else ["All"]
+    
+    # --- Tab 1: Options ---
+    with tab_opts:
+        # Sync Widget
+        if 'selected_veedel_widget' in st.session_state and st.session_state['selected_veedel'] != st.session_state['selected_veedel_widget']:
+            st.session_state['selected_veedel_widget'] = st.session_state['selected_veedel']
+
+        selected_veedel = st.selectbox(
+            "Select Quarter (Veedel/Stadtviertel):", 
+            veedel_list, 
+            key='selected_veedel_widget', 
+            on_change=on_veedel_change,
+            index=veedel_list.index(st.session_state['selected_veedel']) if st.session_state['selected_veedel'] in veedel_list else 0
+        )
+
+        # Tile Logic - Only load tiles when a specific veedel is selected
+        tiles_to_display = []
+        if selected_veedel != "All":
+            veedel_tiles = set(tile_mapping.get(selected_veedel, []))
+            filtered_tiles = [t for t in veedel_tiles if t in available_tiles]
+            tiles_to_display = sorted(filtered_tiles)
+        
+        # Layer Selection
+        layer_selection = st.radio(
+            "Select Layer:",
+            ["Satellite", "Land Cover", "NDVI"],
+            index=2,
+            horizontal=True
+        )
+        
+        # Legends
+        st.markdown("#### Legends")
+        st.markdown("**Veedel Health (Mean NDVI)**")
+        st.markdown("""
+        <div style="background: linear-gradient(to right, #d73027, #ffffbf, #1a9850); height: 10px; width: 100%; border-radius: 5px;"></div>
+        <div style="display: flex; justify-content: space-between; font-size: 10px; margin-top: 2px;"><span>0.0 (Low)</span><span>0.3</span><span>0.6+ (High)</span></div>
+        <div style="font-size: 11px; color: #666; margin-bottom: 15px;">*Average vegetation index per district.</div>
+        """, unsafe_allow_html=True)
+
+        if layer_selection == "Land Cover":
+            st.markdown("**Land Cover Classes**")
+            legend_html = "<div style='display: grid; grid-template-columns: 1fr 1fr; gap: 5px; font-size: 12px;'>"
+            for cls_id, label in CLASS_LABELS.items():
+                if cls_id == 13: continue
+                c = FLAIR_COLORS[cls_id]
+                legend_html += f"<div style='display: flex; align-items: center;'><div style='width: 12px; height: 12px; background: rgba({c[0]},{c[1]},{c[2]},{c[3]/255}); margin-right: 5px; border: 1px solid #ccc;'></div>{label}</div>"
+            st.markdown(legend_html + "</div>", unsafe_allow_html=True)
+            
+        elif layer_selection == "NDVI":
+            st.markdown("**Pixel Vegetation Index (NDVI)**")
+            st.markdown("""
+            <div style="background: linear-gradient(to right, #d73027, #ffffbf, #1a9850); height: 10px; width: 100%; border-radius: 5px;"></div>
+            <div style="display: flex; justify-content: space-between; font-size: 10px; margin-top: 2px;"><span>-0.4 (Water)</span><span>0.3</span><span>1.0 (Dense)</span></div>
+            """, unsafe_allow_html=True)
+
+    # --- Tab 2: Statistics ---
+    with tab_stats:
+        if gdf_quarters is not None and not gdf_quarters.empty:
+            title = "Cologne (All Veedels) Stats"
+            area_m2 = 0
+            total_area_m2 = 1
+            class_data_source = None
+
+            if selected_veedel != "All":
+                row = gdf_quarters[gdf_quarters['name'] == selected_veedel]
+                if not row.empty:
+                    title = f"{selected_veedel} Stats"
+                    area_m2 = row['green_area_m2'].values[0] if 'green_area_m2' in row else 0
+                    total_area_m2 = row['Shape_Area'].values[0] if 'Shape_Area' in row else 1
+                    class_data_source = row
+                else: 
+                     st.warning(f"No stats for {selected_veedel}")
+            else:
+                area_m2 = gdf_quarters['green_area_m2'].sum() if 'green_area_m2' in gdf_quarters else 0
+                total_area_m2 = gdf_quarters['Shape_Area'].sum() if 'Shape_Area' in gdf_quarters else 1
+                class_cols = [c for c in gdf_quarters.columns if str(c).startswith('area_')]
+                if class_cols:
+                    class_data_source = pd.DataFrame([{c: gdf_quarters[c].sum() for c in class_cols}])
+
+            st.markdown(f"#### {title}")
+            c1, c2 = st.columns(2)
+            c1.metric("Green Area", f"{(area_m2/10000):.2f} ha")
+            c2.metric("Green Coverage", f"{(area_m2/total_area_m2)*100:.1f}%")
+            st.divider()
+            
+            if class_data_source is not None and not class_data_source.empty:
+                class_cols = [c for c in class_data_source.columns if str(c).startswith('area_')]
+                if class_cols:
+                    class_data = class_data_source[class_cols].T.reset_index()
+                    class_data.columns = ['class_col', 'area_m2']
+                    class_data['class_id'] = pd.to_numeric(class_data['class_col'].str.replace('area_', '', regex=False), errors='coerce').fillna(0).astype(int)
+                    class_data['class_name'] = class_data['class_id'].map(CLASS_LABELS)
+                    class_data['color'] = class_data['class_id'].map(lambda x: f"rgba({FLAIR_COLORS[x][0]},{FLAIR_COLORS[x][1]},{FLAIR_COLORS[x][2]}, 1)")
+                    class_data = class_data.sort_values(by='area_m2', ascending=False)
+                    
+                    fig_pie = px.pie(
+                        class_data, 
+                        names='class_name', 
+                        values='area_m2', 
+                        title="Land Cover Distribution", 
+                        color='class_name', 
+                        color_discrete_map={row['class_name']: row['color'] for _, row in class_data.iterrows()},
+                        labels={'class_name': 'Land Cover', 'area_m2': 'Area'}
+                    )
+                    fig_pie.update_traces(
+                        textposition='inside',
+                        textinfo='percent',
+                        hovertemplate='<b>%{label}</b><br>Area: %{value:,.0f} m² (%{percent})<extra></extra>'
+                    )
+                    st.plotly_chart(fig_pie, use_container_width=True)
+                else: st.info("No detailed land cover data.")
+
+# --- Map View ---
+with col_map:
+    # 1. Base Map
+    m = folium.Map(location=st.session_state['map_center'], zoom_start=st.session_state['map_zoom'], tiles="CartoDB positron", crs='EPSG3857')
+    
+    # 2. Results: Districts
+    if gdf_boroughs is not None and not gdf_boroughs.empty:
+        folium.GeoJson(
+            gdf_boroughs, name="Districts",
+            style_function=lambda x: {'fillColor': 'none', 'color': '#333333', 'weight': 2, 'dashArray': '5, 5', 'fillOpacity': 0.0},
+            tooltip=folium.GeoJsonTooltip(fields=['name'], aliases=['Bezirk:'])
+        ).add_to(m)
+    
+    # 3. Quarters (Veedel)
+    if gdf_quarters is not None and not gdf_quarters.empty:
+        min_ndvi = gdf_quarters['ndvi_mean'].min() if 'ndvi_mean' in gdf_quarters else 0
+        max_ndvi = gdf_quarters['ndvi_mean'].max() if 'ndvi_mean' in gdf_quarters else 0.6
+        if pd.isna(min_ndvi): min_ndvi = 0
+        if pd.isna(max_ndvi): max_ndvi = 0.6
+        
+        def get_style(feature):
+            name = feature['properties']['name']
+            is_sel = (selected_veedel != "All" and name == selected_veedel)
+            val = feature['properties'].get('ndvi_mean')
+            
+            fill_color = 'gray'
+            if is_sel: fill_color = '#ffff00'
+            elif val is not None and not pd.isna(val):
+                norm = max(0, min(1, (val - min_ndvi) / (max_ndvi - min_ndvi + 1e-9)))
+                fill_color = mcolors.to_hex(plt.get_cmap('RdYlGn')(norm))
+            
+            return {
+                'fillColor': fill_color,
+                'color': 'black' if is_sel else '#666666',
+                'weight': 3 if is_sel else 1,
+                'fillOpacity': 0.0 if is_sel else 0.6 
+            }
+
+        folium.GeoJson(
+            gdf_quarters, name="Veedel (NDVI)", style_function=get_style,
+            tooltip=folium.GeoJsonTooltip(
+                fields=['name', 'green_area_m2', 'green_pct', 'ndvi_mean'], 
+                aliases=['Veedel:', 'Green Area (m²):', 'Green Coverage (%):', 'Mean NDVI:'], 
+                localize=True, fmt='.2f'
+            )
+        ).add_to(m)
+
+    # 4. Tiles Grid (Mosaic)
+    if tiles_to_display:
+        with st.spinner(f"Loading {len(tiles_to_display)} tiles..."):
+            mosaic_img, mosaic_bounds = get_mosaic_data_remote(tiles_to_display, layer_selection)
+            if mosaic_img is not None and mosaic_bounds:
+                folium.raster_layers.ImageOverlay(
+                    image=mosaic_img, bounds=mosaic_bounds,
+                    opacity=0.8 if "Land Cover" in layer_selection else 1.0,
+                    name=f"Mosaic - {layer_selection}", control=False
+                ).add_to(m)
+
+    folium.LayerControl().add_to(m)
+
+    # 5. Click Logic (Hybrid)
+    map_key = f"map_{st.session_state['selected_veedel']}_{st.session_state['map_zoom']}_{st.session_state['map_click_counter']}"
+    map_output = st_folium(m, width=None, height=700, key=map_key, use_container_width=True, returned_objects=["last_object_clicked", "last_clicked"])
+    
+    clicked_name_final = None
+    if map_output:
+        # A: Check Object Property
+        if map_output.get('last_object_clicked'):
+            props = map_output['last_object_clicked'].get('properties', {})
+            if props and 'name' in props: clicked_name_final = props['name']
+        
+        # B: Spatial Query Fallback
+        if not clicked_name_final and map_output.get('last_clicked'):
+             lat = map_output['last_clicked']['lat']
+             lng = map_output['last_clicked']['lng']
+             if lat and lng and gdf_quarters is not None:
+                 p = Point(lng, lat)
+                 matches = gdf_quarters[gdf_quarters.geometry.contains(p)]
+                 if not matches.empty: clicked_name_final = matches['name'].iloc[0]
+
+    if clicked_name_final and clicked_name_final in veedel_list and clicked_name_final != st.session_state['selected_veedel']:
+        st.session_state['selected_veedel'] = clicked_name_final
+        update_zoom_for_veedel(clicked_name_final)
+        st.session_state['map_click_counter'] += 1
+        st.rerun()

requirements.txt

@@ -0,0 +1,13 @@
+streamlit>=1.28.0
+streamlit-folium>=0.15.0
+geopandas>=0.14.0
+pandas>=2.0.0
+duckdb>=0.9.0
+rasterio>=1.3.0
+huggingface_hub>=0.19.0
+matplotlib>=3.7.0
+plotly>=5.18.0
+folium>=0.15.0
+shapely>=2.0.0
+python-dotenv>=1.0.0
+pyarrow>=14.0.0

utils.py

@@ -0,0 +1,230 @@
+import streamlit as st
+import pandas as pd
+import duckdb
+import rasterio
+from rasterio.mask import mask
+from rasterio.merge import merge
+from rasterio.warp import calculate_default_transform, reproject, Resampling
+from rasterio.crs import CRS
+import numpy as np
+import matplotlib.colors as mcolors
+import matplotlib.pyplot as plt
+from shapely.geometry import box
+import geopandas as gpd
+from pathlib import Path
+
+# --- Constants ---
+DATA_DIR = Path("data")
+STATS_FILE = DATA_DIR / "stats" / "extended_stats.parquet"
+QUARTERS_FILE = DATA_DIR / "boundaries" / "Stadtviertel.parquet"
+BOROUGHS_FILE = DATA_DIR / "boundaries" / "Stadtbezirke.parquet"
+PROCESSED_DIR = DATA_DIR / "processed"
+TILES_METADATA_FILE = DATA_DIR / "metadata" / "cologne_tiles.csv"
+
+FLAIR_COLORS = {
+    0: [206, 112, 121, 255],   # Building
+    1: [185, 226, 212, 255],   # Greenhouse
+    2: [98, 208, 255, 255],    # Swimming pool
+    3: [166, 170, 183, 255],   # Impervious surface
+    4: [152, 119, 82, 255],    # Pervious surface
+    5: [187, 176, 150, 255],   # Bare soil
+    6: [51, 117, 161, 255],    # Water
+    7: [233, 239, 254, 255],   # Snow
+    8: [140, 215, 106, 255],   # Herbaceous vegetation
+    9: [222, 207, 85, 255],    # Agricultural land
+    10: [208, 163, 73, 255],   # Plowed land
+    11: [176, 130, 144, 255],  # Vineyard
+    12: [76, 145, 41, 255],    # Deciduous
+    13: [18, 100, 33, 255],    # Coniferous
+    14: [181, 195, 53, 255],   # Brushwood
+    15: [228, 142, 77, 255],   # Clear cut
+    16: [34, 34, 34, 255],     # Ligneous
+    17: [34, 34, 34, 255],     # Mixed
+    18: [34, 34, 34, 255],     # Other
+}
+
+CLASS_LABELS = {
+    0: 'Building', 1: 'Greenhouse', 2: 'Swimming pool',
+    3: 'Impervious surface', 4: 'Pervious surface', 5: 'Bare soil',
+    6: 'Water', 7: 'Snow', 8: 'Herbaceous vegetation',
+    9: 'Agricultural land', 10: 'Plowed land', 11: 'Vineyard',
+    12: 'Deciduous', 13: 'Coniferous', 14: 'Brushwood',
+    15: 'Clear cut', 16: 'Ligneous', 17: 'Mixed', 18: 'Other'
+}
+
+# --- Data Loading ---
+@st.cache_data
+def load_quarters_with_stats():
+    # Load Boundaries
+    if not QUARTERS_FILE.exists(): return None
+    gdf = gpd.read_parquet(QUARTERS_FILE)
+    if gdf.crs != "EPSG:4326": gdf = gdf.to_crs("EPSG:4326")
+    
+    # Load Stats
+    try:
+        con = duckdb.connect()
+        df_s = con.execute(f"SELECT * FROM '{STATS_FILE}'").df()
+        con.close()
+        
+        # Merge
+        if 'name' in gdf.columns and 'name' in df_s.columns:
+            gdf = gdf.merge(df_s, on='name', how='left')
+            if 'green_area_m2' in gdf.columns:
+                gdf['green_area_m2'] = gdf['green_area_m2'].fillna(0)
+        
+        # Calculate Percentage (Critical)
+        if 'green_area_m2' in gdf.columns and 'Shape_Area' in gdf.columns:
+             gdf['green_pct'] = (gdf['green_area_m2'] / gdf['Shape_Area']) * 100
+        else:
+             gdf['green_pct'] = 0.0
+
+    except Exception as e:
+        st.error(f"Error loading stats: {e}")
+    
+    return gdf
+
+@st.cache_data
+def load_boroughs():
+    if not BOROUGHS_FILE.exists(): return None
+    gdf = gpd.read_parquet(BOROUGHS_FILE)
+    if gdf.crs != "EPSG:4326": gdf = gdf.to_crs("EPSG:4326")
+    if 'STB_NAME' in gdf.columns: gdf = gdf.rename(columns={'STB_NAME': 'name'})
+    return gdf
+
+@st.cache_data
+def get_tile_to_veedel_mapping():
+    if not TILES_METADATA_FILE.exists() or not QUARTERS_FILE.exists(): return {}
+    tiles_df = pd.read_csv(TILES_METADATA_FILE)
+    geometries = []
+    for _, row in tiles_df.iterrows():
+        e, n = row['Koordinatenursprung_East'], row['Koordinatenursprung_North']
+        geometries.append(box(e, n, e + 1000, n + 1000))
+    tiles_gdf = gpd.GeoDataFrame(tiles_df, geometry=geometries, crs="EPSG:25832")
+    
+    quarters_gdf = gpd.read_parquet(QUARTERS_FILE)
+    if quarters_gdf.crs != "EPSG:25832": quarters_gdf = quarters_gdf.to_crs("EPSG:25832")
+        
+    joined = gpd.sjoin(tiles_gdf, quarters_gdf, how="inner", predicate="intersects")
+    return joined.groupby('name')['Kachelname'].apply(list).to_dict()
+
+# --- Mosaic Logic (Shared) ---
+def process_mosaic(sources, layer_type):
+    """
+    Core Mosaic Logic: Merges, Reprojects, and Colorizes open rasterio sources.
+    Aguments:
+        sources: List of open rasterio DatasetReader objects (file or memory).
+        layer_type: String enum ["Satellite", "Land Cover", "NDVI"]
+    """
+    try:
+        if not sources: return None, None
+
+        # 1. Mosaic (Native CRS)
+        # We assume sources are compatible (same bands, dtype). Merge handles overlap.
+        mosaic, out_trans = merge(sources)
+        
+        # 2. Reproject to WGS84
+        src_crs = CRS.from_epsg(25832) # Assuming all inputs are 25832
+        src_height, src_width = mosaic.shape[1], mosaic.shape[2]
+        dst_crs = CRS.from_epsg(4326)
+        
+        dst_transform, dst_width, dst_height = calculate_default_transform(
+            src_crs, dst_crs, src_width, src_height, 
+            *rasterio.transform.array_bounds(src_height, src_width, out_trans)
+        )
+        
+        count = mosaic.shape[0]
+        if layer_type == "Satellite" and count < 3: count = 1 
+        
+        dst_array = np.zeros((count, dst_height, dst_width), dtype=mosaic.dtype)
+        
+        reproject(
+            source=mosaic, destination=dst_array,
+            src_transform=out_trans, src_crs=src_crs,
+            dst_transform=dst_transform, dst_crs=dst_crs,
+            resampling=Resampling.nearest
+        )
+        
+        # 3. Visualization Post-Processing
+        final_image = None
+        
+        if layer_type == "Satellite":
+            if dst_array.shape[0] >= 3:
+                rgb = np.moveaxis(dst_array[:3], 0, -1)
+                
+                # Handle uint16
+                if rgb.dtype == 'uint16':
+                     p2, p98 = np.percentile(rgb[rgb > 0], (2, 98))
+                     rgb = np.clip((rgb - p2) / (p98 - p2), 0, 1)
+                     final_image = (rgb * 255).astype(np.uint8)
+                else:
+                    final_image = rgb
+                
+                # Alpha (Create transparency for 0 values)
+                alpha = np.any(final_image > 0, axis=2).astype(np.uint8) * 255
+                final_image = np.dstack((final_image, alpha))
+
+        elif layer_type == "Land Cover":
+            mask_data = dst_array[0]
+            rgba = np.zeros((mask_data.shape[0], mask_data.shape[1], 4), dtype=np.uint8)
+            for cls_id, color in FLAIR_COLORS.items(): 
+                rgba[mask_data == cls_id] = color
+            final_image = rgba
+
+        elif layer_type == "NDVI":
+            ndvi = dst_array[0].astype('float32')
+            norm = mcolors.Normalize(vmin=-0.4, vmax=1, clip=True)(ndvi)
+            cmap = plt.get_cmap('RdYlGn')
+            final_image_float = cmap(norm)
+            final_image = (final_image_float * 255).astype(np.uint8)
+            
+        # Calculate Bounds for Leaflet
+        dst_bounds = rasterio.transform.array_bounds(dst_height, dst_width, dst_transform)
+        folium_bounds = [[dst_bounds[1], dst_bounds[0]], [dst_bounds[3], dst_bounds[2]]]
+
+        return final_image, folium_bounds
+
+    except Exception as e:
+        # st.error(f"Mosaic Process Error: {e}")
+        return None, None
+
+def get_mosaic_data_local(tile_names, layer_type):
+    """
+    Local IO Wrapper for Mosaic Logic
+    """
+    sources = []
+    try:
+        for tile_name in tile_names:
+            # Determine Suffix
+            suffix = "_mask" if ("Land Cover" in layer_type) else "_ndvi"
+            if layer_type == "Satellite": suffix = ""
+            
+            # Paths
+            opt_path = DATA_DIR / "web_optimized" / f"{tile_name}{suffix}.tif"
+            raw_path = DATA_DIR / "raw" / f"{tile_name}.jp2"
+            processed_mask = PROCESSED_DIR / f"{tile_name}_mask.tif"
+            processed_ndvi = PROCESSED_DIR / f"{tile_name}_ndvi.tif"
+            
+            path_to_open = None
+            if layer_type == "Satellite":
+                if opt_path.exists(): path_to_open = opt_path
+                elif raw_path.exists(): path_to_open = raw_path
+            elif "Land Cover" in layer_type:
+                if opt_path.exists(): path_to_open = opt_path
+                elif processed_mask.exists(): path_to_open = processed_mask
+            elif layer_type == "NDVI":
+                if opt_path.exists(): path_to_open = opt_path
+                elif processed_ndvi.exists(): path_to_open = processed_ndvi
+            
+            if path_to_open:
+                sources.append(rasterio.open(path_to_open))
+        
+        result = process_mosaic(sources, layer_type)
+        
+        # Cleanup
+        for s in sources: s.close()
+        
+        return result
+
+    except Exception as e:
+        for s in sources: s.close()
+        return None, None