feat: initial clean project structure with Git LFS

.gitattributes

@@ -33,6 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+fonts/HYWenRunSongYunU.ttf filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
 *.JPG filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+cache/
+posters/
+__pycache__/
+*.pyc
+.DS_Store
+.env
+*.log

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ankur Gupta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -11,3 +11,290 @@ license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# City Map Poster Generator
+
+Generate beautiful, minimalist map posters for any city in the world.
+
+<img src="posters/singapore_neon_cyberpunk_20260108_184503.png" width="250">
+<img src="posters/dubai_midnight_blue_20260108_174920.png" width="250">
+
+## Examples
+
+
+| Country      | City           | Theme           | Poster |
+|:------------:|:--------------:|:---------------:|:------:|
+| USA          | San Francisco  | sunset          | <img src="posters/san_francisco_sunset_20260108_184122.png" width="250"> |
+| Spain        | Barcelona      | warm_beige      | <img src="posters/barcelona_warm_beige_20260108_172924.png" width="250"> |
+| Italy        | Venice         | blueprint       | <img src="posters/venice_blueprint_20260108_165527.png" width="250"> |
+| Japan        | Tokyo          | japanese_ink    | <img src="posters/tokyo_japanese_ink_20260108_165830.png" width="250"> |
+| India        | Mumbai         | contrast_zones  | <img src="posters/mumbai_contrast_zones_20260108_170325.png" width="250"> |
+| Morocco      | Marrakech      | terracotta      | <img src="posters/marrakech_terracotta_20260108_180821.png" width="250"> |
+| Singapore    | Singapore      | neon_cyberpunk  | <img src="posters/singapore_neon_cyberpunk_20260108_184503.png" width="250"> |
+| Australia    | Melbourne      | forest          | <img src="posters/melbourne_forest_20260108_181459.png" width="250"> |
+| UAE          | Dubai          | midnight_blue   | <img src="posters/dubai_midnight_blue_20260108_174920.png" width="250"> |
+
+## Installation
+
+Recommended: Use `uv` to create a virtual environment and install dependencies:
+
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install -r requirements.txt
+```
+
+Or simply sync with uv:
+
+```bash
+uv sync
+```
+
+## Web UI (Gradio)
+
+Launch the visual interface for interactive poster generation:
+
+```bash
+uv run python app.py
+```
+
+Then open [http://localhost:7860](http://localhost:7860) in your browser.
+
+**Features:**
+- 🔍 City search or cascading selection (Country → Province → City)
+- 🎨 17 themes with color preview
+- ⚙️ Adjustable parameters (distance, size, format)
+- 🖼️ Real-time preview and download
+
+## Command Line Usage
+
+If the virtual environment is activated:
+```bash
+python create_map_poster.py --city <city> --country <country> [options]
+```
+
+Or without activating:
+```bash
+.venv/bin/python create_map_poster.py --city <city> --country <country> [options]
+```
+
+### Options
+
+| Option | Short | Description | Default |
+|--------|-------|-------------|---------|
+| `--city` | `-c` | City name | required |
+| `--country` | `-C` | Country name | required |
+| `--theme` | `-t` | Theme name | feature_based |
+| `--distance` | `-d` | Map radius in meters | 29000 |
+| `--list-themes` | | List all available themes | |
+
+### Examples
+
+```bash
+# Iconic grid patterns
+python create_map_poster.py -c "New York" -C "USA" -t noir -d 12000           # Manhattan grid
+python create_map_poster.py -c "Barcelona" -C "Spain" -t warm_beige -d 8000   # Eixample district
+
+# Waterfront & canals
+python create_map_poster.py -c "Venice" -C "Italy" -t blueprint -d 4000       # Canal network
+python create_map_poster.py -c "Amsterdam" -C "Netherlands" -t ocean -d 6000  # Concentric canals
+python create_map_poster.py -c "Dubai" -C "UAE" -t midnight_blue -d 15000     # Palm & coastline
+
+# Radial patterns
+python create_map_poster.py -c "Paris" -C "France" -t pastel_dream -d 10000   # Haussmann boulevards
+python create_map_poster.py -c "Moscow" -C "Russia" -t noir -d 12000          # Ring roads
+
+# Organic old cities
+python create_map_poster.py -c "Tokyo" -C "Japan" -t japanese_ink -d 15000    # Dense organic streets
+python create_map_poster.py -c "Marrakech" -C "Morocco" -t terracotta -d 5000 # Medina maze
+python create_map_poster.py -c "Rome" -C "Italy" -t warm_beige -d 8000        # Ancient layout
+
+# Coastal cities
+python create_map_poster.py -c "San Francisco" -C "USA" -t sunset -d 10000    # Peninsula grid
+python create_map_poster.py -c "Sydney" -C "Australia" -t ocean -d 12000      # Harbor city
+python create_map_poster.py -c "Mumbai" -C "India" -t contrast_zones -d 18000 # Coastal peninsula
+
+# River cities
+python create_map_poster.py -c "London" -C "UK" -t noir -d 15000              # Thames curves
+python create_map_poster.py -c "Budapest" -C "Hungary" -t copper_patina -d 8000  # Danube split
+
+# List available themes
+python create_map_poster.py --list-themes
+```
+
+### Distance Guide
+
+| Distance | Best for |
+|----------|----------|
+| 4000-6000m | Small/dense cities (Venice, Amsterdam center) |
+| 8000-12000m | Medium cities, focused downtown (Paris, Barcelona) |
+| 15000-20000m | Large metros, full city view (Tokyo, Mumbai) |
+
+## Themes
+
+17 themes available in `themes/` directory:
+
+| Theme | Style |
+|-------|-------|
+| `feature_based` | Classic black & white with road hierarchy |
+| `gradient_roads` | Smooth gradient shading |
+| `contrast_zones` | High contrast urban density |
+| `noir` | Pure black background, white roads |
+| `midnight_blue` | Navy background with gold roads |
+| `blueprint` | Architectural blueprint aesthetic |
+| `neon_cyberpunk` | Dark with electric pink/cyan |
+| `warm_beige` | Vintage sepia tones |
+| `pastel_dream` | Soft muted pastels |
+| `japanese_ink` | Minimalist ink wash style |
+| `forest` | Deep greens and sage |
+| `ocean` | Blues and teals for coastal cities |
+| `terracotta` | Mediterranean warmth |
+| `sunset` | Warm oranges and pinks |
+| `autumn` | Seasonal burnt oranges and reds |
+| `copper_patina` | Oxidized copper aesthetic |
+| `monochrome_blue` | Single blue color family |
+
+## Output
+
+Posters are saved to `posters/` directory with format:
+```
+{city}_{theme}_{YYYYMMDD_HHMMSS}.png
+```
+
+## Adding Custom Themes
+
+Create a JSON file in `themes/` directory:
+
+```json
+{
+  "name": "My Theme",
+  "description": "Description of the theme",
+  "bg": "#FFFFFF",
+  "text": "#000000",
+  "gradient_color": "#FFFFFF",
+  "water": "#C0C0C0",
+  "parks": "#F0F0F0",
+  "road_motorway": "#0A0A0A",
+  "road_primary": "#1A1A1A",
+  "road_secondary": "#2A2A2A",
+  "road_tertiary": "#3A3A3A",
+  "road_residential": "#4A4A4A",
+  "road_default": "#3A3A3A"
+}
+```
+
+## Project Structure
+
+```
+map_poster/
+├── create_map_poster.py          # Main script
+├── themes/               # Theme JSON files
+├── fonts/                # Roboto font files
+├── posters/              # Generated posters
+└── README.md
+```
+
+## Hacker's Guide
+
+Quick reference for contributors who want to extend or modify the script.
+
+### Architecture Overview
+
+```
+┌─────────────────┐     ┌──────────────┐     ┌─────────────────┐
+│   CLI Parser    │────▶│  Geocoding   │────▶│  Data Fetching  │
+│   (argparse)    │     │  (Nominatim) │     │    (OSMnx)      │
+└─────────────────┘     └──────────────┘     └─────────────────┘
+                                                     │
+                        ┌──────────────┐             ▼
+                        │    Output    │◀────┌─────────────────┐
+                        │  (matplotlib)│     │   Rendering     │
+                        └──────────────┘     │  (matplotlib)   │
+                                             └─────────────────┘
+```
+
+### Key Functions
+
+| Function | Purpose | Modify when... |
+|----------|---------|----------------|
+| `get_coordinates()` | City → lat/lon via Nominatim | Switching geocoding provider |
+| `create_poster()` | Main rendering pipeline | Adding new map layers |
+| `get_edge_colors_by_type()` | Road color by OSM highway tag | Changing road styling |
+| `get_edge_widths_by_type()` | Road width by importance | Adjusting line weights |
+| `create_gradient_fade()` | Top/bottom fade effect | Modifying gradient overlay |
+| `load_theme()` | JSON theme → dict | Adding new theme properties |
+
+### Rendering Layers (z-order)
+
+```
+z=11  Text labels (city, country, coords)
+z=10  Gradient fades (top & bottom)
+z=3   Roads (via ox.plot_graph)
+z=2   Parks (green polygons)
+z=1   Water (blue polygons)
+z=0   Background color
+```
+
+### OSM Highway Types → Road Hierarchy
+
+```python
+# In get_edge_colors_by_type() and get_edge_widths_by_type()
+motorway, motorway_link     → Thickest (1.2), darkest
+trunk, primary              → Thick (1.0)
+secondary                   → Medium (0.8)
+tertiary                    → Thin (0.6)
+residential, living_street  → Thinnest (0.4), lightest
+```
+
+### Adding New Features
+
+**New map layer (e.g., railways):**
+```python
+# In create_poster(), after parks fetch:
+try:
+    railways = ox.features_from_point(point, tags={'railway': 'rail'}, dist=dist)
+except:
+    railways = None
+
+# Then plot before roads:
+if railways is not None and not railways.empty:
+    railways.plot(ax=ax, color=THEME['railway'], linewidth=0.5, zorder=2.5)
+```
+
+**New theme property:**
+1. Add to theme JSON: `"railway": "#FF0000"`
+2. Use in code: `THEME['railway']`
+3. Add fallback in `load_theme()` default dict
+
+### Typography Positioning
+
+All text uses `transform=ax.transAxes` (0-1 normalized coordinates):
+```
+y=0.14  City name (spaced letters)
+y=0.125 Decorative line
+y=0.10  Country name
+y=0.07  Coordinates
+y=0.02  Attribution (bottom-right)
+```
+
+### Useful OSMnx Patterns
+
+```python
+# Get all buildings
+buildings = ox.features_from_point(point, tags={'building': True}, dist=dist)
+
+# Get specific amenities
+cafes = ox.features_from_point(point, tags={'amenity': 'cafe'}, dist=dist)
+
+# Different network types
+G = ox.graph_from_point(point, dist=dist, network_type='drive')  # roads only
+G = ox.graph_from_point(point, dist=dist, network_type='bike')   # bike paths
+G = ox.graph_from_point(point, dist=dist, network_type='walk')   # pedestrian
+```
+
+### Performance Tips
+
+- Large `dist` values (>20km) = slow downloads + memory heavy
+- Cache coordinates locally to avoid Nominatim rate limits
+- Use `network_type='drive'` instead of `'all'` for faster renders
+- Reduce `dpi` from 300 to 150 for quick previews

app.py

@@ -0,0 +1,580 @@
+# -*- coding: utf-8 -*-
+"""
+Gradio Web Interface for City Map Poster Generator
+"""
+
+import os
+import json
+import gradio as gr
+import tempfile
+from datetime import datetime
+
+# Import from the main module
+from cities_data import (
+    CITIES, 
+    get_countries, 
+    get_provinces, 
+    get_cities, 
+    get_city_full_name,
+    translate,
+    get_country_key
+)
+
+
+# --- Constants ---
+THEMES_DIR = "themes"
+FONTS_DIR = "fonts"
+POSTERS_DIR = "posters"
+
+# Layer Constants
+LAYERS_EN = ["Motorway", "Primary Roads", "Secondary Roads", "Water", "Parks"]
+LAYERS_CN = ["高速公路", "主干道", "次干道", "水域", "公园"]
+LAYER_KEYS = ["motorway", "primary", "secondary", "water", "parks"]
+
+
+
+def get_available_themes():
+    """Scans the themes directory and returns a list of available theme names."""
+    if not os.path.exists(THEMES_DIR):
+        return []
+    
+    themes = []
+    for file in sorted(os.listdir(THEMES_DIR)):
+        if file.endswith('.json'):
+            theme_name = file[:-5]
+            themes.append(theme_name)
+    return themes
+
+
+def get_theme_choices(lang='en'):
+    """Return a list of (Display Name, Internal Name) tuples for themes."""
+    internal_names = get_available_themes()
+    choices = []
+    
+    for internal_name in internal_names:
+        theme_info = load_theme_info(internal_name)
+        if theme_info:
+            proper_name = theme_info.get("name", internal_name)
+            display_name = translate(proper_name, lang)
+            choices.append((display_name, internal_name))
+        else:
+            choices.append((internal_name, internal_name))
+            
+    return choices
+
+
+def load_theme_info(theme_name):
+    """Load theme details for preview."""
+    theme_file = os.path.join(THEMES_DIR, f"{theme_name}.json")
+    if os.path.exists(theme_file):
+        with open(theme_file, 'r') as f:
+            return json.load(f)
+    return None
+
+
+def get_theme_preview_html(theme_name, lang='en'):
+    """Generate HTML preview for a theme."""
+    theme = load_theme_info(theme_name)
+    lang_code = 'en' if lang == "English" else 'cn'
+    
+    if not theme:
+        return f"<p>{'Theme load failed' if lang_code == 'en' else '主题加载失败'}</p>"
+    
+    # Translated labels
+    labels = {
+        "bg": "Background" if lang_code == "en" else "背景",
+        "text": "Text" if lang_code == "en" else "文字",
+        "motorway": "Motorway" if lang_code == "en" else "高速公路",
+        "primary": "Primary Road" if lang_code == "en" else "主干道",
+        "secondary": "Secondary Road" if lang_code == "en" else "次干道",
+        "water": "Water" if lang_code == "en" else "水域",
+        "parks": "Parks" if lang_code == "en" else "公园",
+    }
+    
+    # Create color swatches
+    colors = [
+        (labels["bg"], theme.get("bg", "#FFFFFF")),
+        (labels["text"], theme.get("text", "#000000")),
+        (labels["motorway"], theme.get("road_motorway", "#000000")),
+        (labels["primary"], theme.get("road_primary", "#333333")),
+        (labels["secondary"], theme.get("road_secondary", "#666666")),
+        (labels["water"], theme.get("water", "#C0C0C0")),
+        (labels["parks"], theme.get("parks", "#F0F0F0")),
+    ]
+    
+    display_name = translate(theme.get('name', theme_name), lang_code)
+    description = theme.get('description', '')
+    # Optional: translate description if we really want to, but might be too much work
+    
+    html = f"""
+    <div style="padding: 12px; background: {theme.get('bg', '#FFFFFF')}; border-radius: 8px; border: 1px solid #ddd;">
+        <h4 style="color: {theme.get('text', '#000000')}; margin: 0 0 8px 0; font-size: 14px;">
+            {display_name}
+        </h4>
+        <p style="color: {theme.get('text', '#000000')}; opacity: 0.7; margin: 0 0 12px 0; font-size: 12px;">
+            {description}
+        </p>
+        <div style="display: flex; flex-wrap: wrap; gap: 6px;">
+    """
+    
+    for label, color in colors:
+        html += f"""
+            <div style="display: flex; align-items: center; gap: 4px;">
+                <div style="width: 20px; height: 20px; background: {color}; border-radius: 4px; border: 1px solid #ccc;"></div>
+                <span style="font-size: 10px; color: {theme.get('text', '#000')}; opacity: 0.8;">{label}</span>
+            </div>
+        """
+    
+    html += "</div></div>"
+    return html
+
+
+def generate_poster(
+    country_display, 
+    province, 
+    city_dropdown,
+    theme_name, 
+    distance, 
+    width, 
+    height, 
+    output_format,
+    no_crop,
+    poster_lang,
+    layers_selection,
+    progress=gr.Progress()
+):
+    """
+    Generate the map poster with given parameters.
+    """
+    # Import here to avoid circular imports and ensure THEME is set correctly
+    import create_map_poster as cmp
+    
+    # Decode layer selection
+    show_motorway = any(x in ["Motorway", "高速公路"] for x in layers_selection)
+    show_primary = any(x in ["Primary Roads", "��干道"] for x in layers_selection)
+    show_secondary = any(x in ["Secondary Roads", "次干道"] for x in layers_selection)
+    show_water = any(x in ["Water", "水域"] for x in layers_selection)
+    show_parks = any(x in ["Parks", "公园"] for x in layers_selection)
+    
+    # Parse country
+    selected_country = get_country_key(country_display)
+    
+    # Use dropdown selection
+    selected_city = city_dropdown
+    # If the selected_city is translated, we need the original for geocoding
+    # But get_coordinates typically handles common translations or we can just pass the dropdown value
+    # Actually, selected_city from dropdown might be "Guangzhou" or "广州"
+    # cmp.get_coordinates(selected_city, selected_country)
+    # selected_country is now standardized (e.g. "中国" or "USA")
+    
+    if not selected_city:
+        return None, "❌ 请选择城市名称"
+    
+    if not selected_country:
+        return None, "❌ 请选择国家"
+    
+    # Determine display names based on poster_lang
+    lang_code = 'en' if poster_lang == "English" else 'cn'
+    display_city = translate(selected_city, lang_code)
+    display_country = translate(selected_country, lang_code)
+    
+    progress(0.1, desc="正在加载主题...")
+    
+    # Load theme
+    cmp.THEME = cmp.load_theme(theme_name)
+    
+    progress(0.2, desc="正在获取坐标...")
+    
+    try:
+        # We search coordinates using the selection
+        # CMP might need the "original" names if OSM behaves better with them
+        # For China, "广州" is better than "Guangzhou" for geopy sometimes, but geopy is usually good.
+        # Let's ensure we use the 'original' internal key if possible for best OSM matching
+        # However, for cities, we don't have a strict key map like for countries.
+        # We can try to translate to CN if it's a Chinese city.
+        search_city = selected_city
+        search_country = selected_country
+        
+        coords = cmp.get_coordinates(search_city, search_country)
+    except Exception as e:
+        return None, f"❌ 无法找到城市坐标: {str(e)}"
+    
+    progress(0.3, desc="正在生成海报...")
+    
+    # Generate output filename (using English/Slugified names)
+    en_city = translate(selected_city, 'en')
+    output_file = cmp.generate_output_filename(en_city, theme_name, output_format)
+    
+    try:
+        # Wrap the generator to yield status updates and final result
+        for status in cmp.create_poster(
+            display_city, # Pass translated names for display
+            display_country, 
+            coords, 
+            distance, 
+            output_file, 
+            output_format,
+            width=width, 
+            height=height, 
+            no_crop=no_crop,
+            show_motorway=show_motorway,
+            show_primary=show_primary,
+            show_secondary=show_secondary,
+            show_water=show_water,
+            show_parks=show_parks
+        ):
+            # Translate common status messages if possible
+            status_display = status
+            if lang_code == 'cn':
+                if "Downloading street network" in status: status_display = "正在下载街道数据..."
+                elif "Downloading features" in status: status_display = "正在下载水域和公园数据..."
+                elif "Rendering map" in status: status_display = "正在渲染地图..."
+                elif "Applying road styles" in status: status_display = "正在应用样式..."
+                elif "Saving to" in status: status_display = "正在保存海报..."
+                elif "Done" in status: status_display = "完成！"
+            
+            yield None, f"⏳ {status_display}"
+        
+        progress(1.0, desc="完成!")
+        
+        yield output_file, f"✅ 海报生成成功！保存至: {output_file}"
+        
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        yield None, f"❌ 生成失败: {str(e)}"
+
+
+def update_provinces(country, lang='en'):
+    """Update province dropdown based on country selection and language."""
+    # Map back to internal key for data lookup
+    lang_code = 'en' if lang == "English" else 'cn'
+    provinces = get_provinces(country, lang_code)
+    if provinces:
+        return gr.update(choices=provinces, value=provinces[0], visible=True)
+    return gr.update(choices=[], value=None, visible=False)
+
+
+def update_cities(country, province, lang='en'):
+    """Update city dropdown based on province selection and language."""
+    lang_code = 'en' if lang == "English" else 'cn'
+    cities = get_cities(country, province, lang_code)
+    if cities:
+        return gr.update(choices=cities, value=cities[0])
+    return gr.update(choices=[], value=None)
+
+
+
+def on_theme_change(theme_name, lang='en'):
+    """Update theme preview when theme changes."""
+    return get_theme_preview_html(theme_name, lang)
+
+
+# --- Build Gradio Interface ---
+def create_interface():
+    """Create and return the Gradio interface."""
+    
+    # Get initial data (Default English)
+    default_lang_code = "en"
+    default_lang_radio = "English"
+    countries = get_countries(default_lang_code)
+    theme_choices = get_theme_choices(default_lang_code)
+    
+    default_country = "China" if "China" in countries else countries[0]
+    default_provinces = get_provinces(default_country, default_lang_code)
+    default_province = default_provinces[0] if default_provinces else None
+    default_cities = get_cities(default_country, default_province, default_lang_code) if default_province else []
+    default_city = default_cities[0] if default_cities else None
+    default_theme = theme_choices[0][1] if theme_choices else "feature_based"
+    default_layers = LAYERS_EN
+    
+    with gr.Blocks(
+        title="城市地图海报生成器",
+    ) as demo:
+        
+        # Header
+        gr.HTML("""
+            <div class="header-title">城市地图海报生成器</div>
+            <div class="header-subtitle">选择任意城市，自定义主题风格，生成精美地图海报</div>
+        """)
+        
+        with gr.Row():
+            # Left Column - Controls
+            with gr.Column(scale=1):
+                
+                # City Selection Section
+                gr.HTML('<div class="section-title">📍 城市选择</div>')
+                
+                lang_radio = gr.Radio(
+                    choices=["English", "Chinese"],
+                    value="English",
+                    label="海报语言",
+                    info="选择海报及界面的显示语言"
+                )
+                
+                country_dropdown = gr.Dropdown(
+                    choices=countries,
+                    value=default_country,
+                    label="选择国家",
+                    interactive=True
+                )
+                
+                province_dropdown = gr.Dropdown(
+                    choices=default_provinces,
+                    value=default_province,
+                    label="选择省份/州",
+                    interactive=True
+                )
+                
+                city_dropdown = gr.Dropdown(
+                    choices=default_cities,
+                    value=default_city,
+                    label="选择城市",
+                    interactive=True
+                )
+                
+                gr.HTML("<hr style='margin: 20px 0; border-color: #eee;'>")
+                
+                # Theme Section
+                gr.HTML('<div class="section-title">🎨 主题风格</div>')
+                
+                theme_dropdown = gr.Dropdown(
+                    choices=theme_choices,
+                    value=default_theme,
+                    label="选择主题",
+                    interactive=True
+                )
+                
+                theme_preview = gr.HTML(
+                    value=get_theme_preview_html(default_theme, default_lang_radio),
+                    label="主题预览"
+                )
+                
+                gr.HTML("<hr style='margin: 20px 0; border-color: #eee;'>")
+                
+                # Parameters Section
+                gr.HTML('<div class="section-title">⚙️ 参数设置</div>')
+                
+                distance_slider = gr.Slider(
+                    minimum=4000,
+                    maximum=30000,
+                    value=10000,
+                    step=1000,
+                    label="地图范围 (米)",
+                    info="4000-6000: 小城区 | 8000-12000: 中等城市 | 15000+: 大都市 (范围越大生成越慢)"
+                )
+                
+                with gr.Row():
+                    width_input = gr.Number(
+                        value=12.0,
+                        label="宽度 (英寸)",
+                        minimum=6,
+                        maximum=24
+                    )
+                    height_input = gr.Number(
+                        value=16.0,
+                        label="高度 (英寸)",
+                        minimum=8,
+                        maximum=32
+                    )
+                
+                format_radio = gr.Radio(
+                    choices=["png", "svg", "pdf"],
+                    value="png",
+                    label="输出格式",
+                    info="PNG: 适合打印 | SVG: 矢量图 | PDF: 文档"
+                )
+                
+                no_crop_checkbox = gr.Checkbox(
+                    value=False,
+                    label="保留边距 (不裁剪)",
+                    info="勾选后保留海报边缘背景"
+                )
+                
+                layers_checkbox = gr.CheckboxGroup(
+                    choices=LAYERS_EN,
+                    value=LAYERS_EN,
+                    label="图层显示",
+                    info="选择需要显示的地图元素"
+                )
+                
+                # Generate Button
+                generate_btn = gr.Button(
+                    "🚀 生成海��",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            # Right Column - Output
+            with gr.Column(scale=1):
+                gr.HTML('<div class="section-title">🖼️ 生成结果</div>')
+                
+                output_image = gr.Image(
+                    label="海报预览",
+                    type="filepath",
+                    elem_classes=["output-image"],
+                    height=600,
+                    interactive=False
+                )
+                
+                output_status = gr.Textbox(
+                    label="状态",
+                    interactive=False
+                )
+                
+                download_btn = gr.DownloadButton(
+                    label="📥 下载海报",
+                    visible=False
+                )
+        
+        # --- Event Handlers ---
+        
+        # Language change -> update all dropdowns
+        def on_lang_change(lang, current_theme, current_layers):
+            lang_code = 'en' if lang == "English" else 'cn'
+            new_countries = get_countries(lang_code)
+            
+            # Find closest match for current selections if possible
+            default_co = "China" if lang == "English" else "中国"
+            if default_co not in new_countries:
+                default_co = new_countries[0]
+            
+            new_provinces = get_provinces(default_co, lang_code)
+            default_pr = new_provinces[0] if new_provinces else None
+            
+            new_cities = get_cities(default_co, default_pr, lang_code) if default_pr else []
+            default_ci = new_cities[0] if new_cities else None
+            
+            # Themes
+            new_theme_choices = get_theme_choices(lang_code)
+            new_preview = get_theme_preview_html(current_theme, lang)
+            
+            # Layers
+            # Map current selection to keys then to new language
+            map_en_to_key = dict(zip(LAYERS_EN, LAYER_KEYS))
+            map_cn_to_key = dict(zip(LAYERS_CN, LAYER_KEYS))
+            map_key_to_en = dict(zip(LAYER_KEYS, LAYERS_EN))
+            map_key_to_cn = dict(zip(LAYER_KEYS, LAYERS_CN))
+            
+            current_keys = []
+            for x in current_layers:
+                if x in map_en_to_key: current_keys.append(map_en_to_key[x])
+                elif x in map_cn_to_key: current_keys.append(map_cn_to_key[x])
+            
+            target_map = map_key_to_en if lang == "English" else map_key_to_cn
+            new_layer_choices = LAYERS_EN if lang == "English" else LAYERS_CN
+            new_layer_values = [target_map[k] for k in current_keys if k in target_map]
+            
+            return (
+                gr.update(choices=new_countries, value=default_co),
+                gr.update(choices=new_provinces, value=default_pr),
+                gr.update(choices=new_cities, value=default_ci),
+                gr.update(choices=new_theme_choices),
+                new_preview,
+                gr.update(choices=new_layer_choices, value=new_layer_values, label="Layers" if lang == "English" else "图层显示")
+            )
+
+        lang_radio.change(
+            fn=on_lang_change,
+            inputs=[lang_radio, theme_dropdown, layers_checkbox],
+            outputs=[country_dropdown, province_dropdown, city_dropdown, theme_dropdown, theme_preview, layers_checkbox]
+        )
+        
+        # Country change -> update provinces
+        country_dropdown.change(
+            fn=update_provinces,
+            inputs=[country_dropdown, lang_radio],
+            outputs=[province_dropdown]
+        )
+        
+        # Province change -> update cities
+        province_dropdown.change(
+            fn=update_cities,
+            inputs=[country_dropdown, province_dropdown, lang_radio],
+            outputs=[city_dropdown]
+        )
+        
+        # Theme change -> update preview
+        theme_dropdown.change(
+            fn=on_theme_change,
+            inputs=[theme_dropdown, lang_radio],
+            outputs=[theme_preview]
+        )
+        
+        # Generate button click
+        def on_generate_complete(filepath, status):
+            """Handle generate completion - show download button if successful."""
+            if filepath and os.path.exists(filepath):
+                return filepath, status, gr.update(visible=True, value=filepath)
+            return filepath, status, gr.update(visible=False)
+        
+        generate_btn.click(
+            fn=generate_poster,
+            inputs=[
+                country_dropdown,
+                province_dropdown,
+                city_dropdown,
+                theme_dropdown,
+                distance_slider,
+                width_input,
+                height_input,
+                format_radio,
+                no_crop_checkbox,
+                lang_radio,
+                layers_checkbox
+            ],
+            outputs=[output_image, output_status]
+        ).then(
+            fn=on_generate_complete,
+            inputs=[output_image, output_status],
+            outputs=[output_image, output_status, download_btn]
+        )
+        
+        # Footer
+        gr.HTML("""
+            <div style="text-align: center; margin-top: 24px; padding: 12px; color: #888; font-size: 12px;">
+                <p>数据来源: © OpenStreetMap contributors | 地理编码: Nominatim</p>
+                <p>提示: 生成大范围地图可能需要较长时间，请耐心等待</p>
+            </div>
+        """)
+    
+    return demo
+
+
+# --- Main Entry ---
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        theme=gr.themes.Default(),
+        css="""
+        .header-title {
+            text-align: center;
+            font-size: 2em;
+            font-weight: bold;
+            margin-bottom: 0.5em;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+        }
+        .header-subtitle {
+            text-align: center;
+            color: #666;
+            margin-bottom: 1.5em;
+        }
+        .section-title {
+            font-weight: 600;
+            font-size: 1.1em;
+            margin-bottom: 0.5em;
+            color: #333;
+        }
+        .output-image {
+            border-radius: 12px;
+            box-shadow: 0 4px 12px rgba(0,0,0,0.1);
+        }
+        """
+    )

cities_data.py

@@ -0,0 +1,996 @@
+# -*- coding: utf-8 -*-
+"""
+Cities database with hierarchical structure for cascading selection.
+Format: Country -> Province/State -> Cities
+"""
+
+CITIES = {
+    "中国": {
+        "北京": ["北京"],
+        "上海": ["上海"],
+        "天津": ["天津"],
+        "重庆": ["重庆"],
+        "广东": [
+            "广州",
+            "深圳",
+            "东莞",
+            "佛山",
+            "珠海",
+            "惠州",
+            "中山",
+            "汕头",
+            "湛江",
+            "江门",
+        ],
+        "浙江": ["杭州", "宁波", "温州", "绍兴", "嘉兴", "金华", "台州", "湖州"],
+        "江苏": ["南京", "苏州", "无锡", "常州", "南通", "徐州", "扬州", "镇江"],
+        "山东": ["济南", "青岛", "烟台", "威海", "潍坊", "临沂", "济宁", "淄博"],
+        "四川": ["成都", "绵阳", "德阳", "宜宾", "泸州", "南充", "乐山"],
+        "湖北": ["武汉", "宜昌", "襄阳", "荆州", "黄石", "十堰"],
+        "湖南": ["长沙", "株洲", "湘潭", "衡阳", "岳阳", "常德"],
+        "河南": ["郑州", "洛阳", "开封", "新乡", "安阳", "焦作"],
+        "河北": ["石家庄", "唐山", "秦皇岛", "邯郸", "保定", "沧州"],
+        "福建": ["福州", "厦门", "泉州", "漳州", "莆田", "龙岩"],
+        "安徽": ["合肥", "芜湖", "蚌埠", "马鞍山", "安庆", "黄山"],
+        "江西": ["南昌", "九江", "景德镇", "赣州", "上饶", "吉安"],
+        "陕西": ["西安", "咸阳", "宝鸡", "延安", "榆林", "汉中"],
+        "山西": ["太原", "大同", "临汾", "运城", "晋中", "长治"],
+        "辽宁": ["沈阳", "大连", "鞍山", "抚顺", "本溪", "营口"],
+        "吉林": ["长春", "吉林", "四平", "通化", "延边"],
+        "黑龙江": ["哈尔滨", "齐齐哈尔", "牡丹江", "佳木斯", "大庆"],
+        "云南": ["昆明", "大理", "丽江", "西双版纳", "曲靖"],
+        "贵州": ["贵阳", "遵义", "安顺", "六盘水", "毕节"],
+        "甘肃": ["兰州", "天水", "嘉峪关", "酒泉", "张掖"],
+        "海南": ["海口", "三亚", "儋州", "琼海"],
+        "广西": ["南宁", "桂林", "柳州", "梧州", "北海", "玉林"],
+        "内蒙古": ["呼和浩特", "包头", "鄂尔多斯", "赤峰", "呼伦贝尔"],
+        "新疆": ["乌鲁木齐", "喀什", "吐鲁番", "阿克苏", "伊宁"],
+        "西藏": ["拉萨", "日喀则", "林芝", "昌都"],
+        "宁夏": ["银川", "石嘴山", "吴忠", "固原"],
+        "青海": ["西宁", "格尔木", "玉树", "海东"],
+        "香港": ["香港"],
+        "澳门": ["澳门"],
+        "台湾": ["台北", "高雄", "台中", "台南", "新竹", "基隆"],
+    },
+    "USA": {
+        "California": [
+            "Los Angeles",
+            "San Francisco",
+            "San Diego",
+            "San Jose",
+            "Sacramento",
+            "Oakland",
+            "Fresno",
+        ],
+        "New York": ["New York City", "Buffalo", "Rochester", "Albany", "Syracuse"],
+        "Texas": [
+            "Houston",
+            "Dallas",
+            "Austin",
+            "San Antonio",
+            "Fort Worth",
+            "El Paso",
+        ],
+        "Florida": ["Miami", "Orlando", "Tampa", "Jacksonville", "Fort Lauderdale"],
+        "Illinois": ["Chicago", "Aurora", "Naperville", "Rockford"],
+        "Pennsylvania": ["Philadelphia", "Pittsburgh", "Harrisburg"],
+        "Arizona": ["Phoenix", "Tucson", "Mesa", "Scottsdale"],
+        "Nevada": ["Las Vegas", "Reno", "Henderson"],
+        "Washington": ["Seattle", "Tacoma", "Spokane", "Bellevue"],
+        "Massachusetts": ["Boston", "Cambridge", "Worcester"],
+        "Colorado": ["Denver", "Colorado Springs", "Aurora", "Boulder"],
+        "Georgia": ["Atlanta", "Savannah", "Augusta"],
+        "North Carolina": ["Charlotte", "Raleigh", "Durham"],
+        "Michigan": ["Detroit", "Grand Rapids", "Ann Arbor"],
+        "Oregon": ["Portland", "Salem", "Eugene"],
+        "District of Columbia": ["Washington"],
+        "Hawaii": ["Honolulu"],
+    },
+    "Japan": {
+        "関東": ["Tokyo", "Yokohama", "Kawasaki", "Saitama", "Chiba"],
+        "関西": ["Osaka", "Kyoto", "Kobe", "Nara"],
+        "中部": ["Nagoya", "Kanazawa", "Shizuoka"],
+        "北海道": ["Sapporo", "Hakodate", "Asahikawa"],
+        "九州": ["Fukuoka", "Nagasaki", "Kumamoto", "Kagoshima"],
+        "東北": ["Sendai", "Aomori", "Akita"],
+        "中国": ["Hiroshima", "Okayama"],
+        "四国": ["Matsuyama", "Takamatsu"],
+        "沖縄": ["Naha", "Okinawa"],
+    },
+    "UK": {
+        "England": [
+            "London",
+            "Manchester",
+            "Birmingham",
+            "Liverpool",
+            "Leeds",
+            "Bristol",
+            "Sheffield",
+            "Newcastle",
+            "Nottingham",
+            "Cambridge",
+            "Oxford",
+        ],
+        "Scotland": ["Edinburgh", "Glasgow", "Aberdeen", "Dundee"],
+        "Wales": ["Cardiff", "Swansea", "Newport"],
+        "Northern Ireland": ["Belfast", "Londonderry"],
+    },
+    "France": {
+        "Île-de-France": ["Paris"],
+        "Provence-Alpes-Côte d'Azur": ["Marseille", "Nice", "Cannes", "Toulon"],
+        "Auvergne-Rhône-Alpes": ["Lyon", "Grenoble", "Saint-Étienne"],
+        "Nouvelle-Aquitaine": ["Bordeaux", "Limoges"],
+        "Occitanie": ["Toulouse", "Montpellier", "Nîmes"],
+        "Hauts-de-France": ["Lille", "Amiens"],
+        "Grand Est": ["Strasbourg", "Reims", "Nancy", "Metz"],
+        "Normandie": ["Rouen", "Le Havre", "Caen"],
+        "Bretagne": ["Rennes", "Brest", "Nantes"],
+    },
+    "Germany": {
+        "Bayern": ["Munich", "Nuremberg", "Augsburg"],
+        "Berlin": ["Berlin"],
+        "Hamburg": ["Hamburg"],
+        "Hessen": ["Frankfurt", "Wiesbaden"],
+        "Baden-Württemberg": ["Stuttgart", "Heidelberg", "Freiburg", "Karlsruhe"],
+        "Nordrhein-Westfalen": ["Cologne", "Düsseldorf", "Dortmund", "Essen", "Bonn"],
+        "Niedersachsen": ["Hanover", "Braunschweig", "Oldenburg"],
+        "Sachsen": ["Dresden", "Leipzig"],
+        "Brandenburg": ["Potsdam"],
+    },
+    "Italy": {
+        "Lazio": ["Rome"],
+        "Lombardia": ["Milan", "Bergamo", "Brescia"],
+        "Veneto": ["Venice", "Verona", "Padua"],
+        "Toscana": ["Florence", "Pisa", "Siena"],
+        "Campania": ["Naples", "Salerno"],
+        "Piemonte": ["Turin", "Genoa"],
+        "Emilia-Romagna": ["Bologna", "Parma", "Modena"],
+        "Sicilia": ["Palermo", "Catania", "Syracuse"],
+    },
+    "Spain": {
+        "Comunidad de Madrid": ["Madrid"],
+        "Cataluña": ["Barcelona", "Tarragona", "Girona"],
+        "Andalucía": ["Seville", "Granada", "Málaga", "Córdoba"],
+        "Comunidad Valenciana": ["Valencia", "Alicante"],
+        "País Vasco": ["Bilbao", "San Sebastián"],
+        "Galicia": ["Santiago de Compostela", "A Coruña", "Vigo"],
+        "Islas Baleares": ["Palma de Mallorca"],
+        "Islas Canarias": ["Las Palmas", "Santa Cruz de Tenerife"],
+    },
+    "Australia": {
+        "New South Wales": ["Sydney", "Newcastle", "Wollongong"],
+        "Victoria": ["Melbourne", "Geelong"],
+        "Queensland": ["Brisbane", "Gold Coast", "Cairns"],
+        "Western Australia": ["Perth", "Fremantle"],
+        "South Australia": ["Adelaide"],
+        "Tasmania": ["Hobart"],
+        "Australian Capital Territory": ["Canberra"],
+        "Northern Territory": ["Darwin"],
+    },
+    "Canada": {
+        "Ontario": ["Toronto", "Ottawa", "Hamilton", "Mississauga"],
+        "Quebec": ["Montreal", "Quebec City", "Laval"],
+        "British Columbia": ["Vancouver", "Victoria", "Surrey"],
+        "Alberta": ["Calgary", "Edmonton"],
+        "Manitoba": ["Winnipeg"],
+        "Saskatchewan": ["Saskatoon", "Regina"],
+        "Nova Scotia": ["Halifax"],
+    },
+    "South Korea": {
+        "서울특별시": ["Seoul"],
+        "부산광역시": ["Busan"],
+        "경기도": ["Incheon", "Suwon", "Seongnam"],
+        "대구광역시": ["Daegu"],
+        "대전광역시": ["Daejeon"],
+        "광주광역시": ["Gwangju"],
+        "제주특별자치도": ["Jeju"],
+    },
+    "Singapore": {
+        "Singapore": ["Singapore"],
+    },
+    "India": {
+        "Maharashtra": ["Mumbai", "Pune", "Nagpur"],
+        "Delhi": ["New Delhi"],
+        "Karnataka": ["Bangalore", "Mysore"],
+        "Tamil Nadu": ["Chennai", "Coimbatore", "Madurai"],
+        "West Bengal": ["Kolkata"],
+        "Gujarat": ["Ahmedabad", "Surat", "Vadodara"],
+        "Telangana": ["Hyderabad"],
+        "Kerala": ["Kochi", "Trivandrum"],
+        "Rajasthan": ["Jaipur", "Jodhpur", "Udaipur"],
+        "Uttar Pradesh": ["Lucknow", "Agra", "Varanasi"],
+    },
+    "Russia": {
+        "Центральный": ["Moscow"],
+        "Северо-Западный": ["Saint Petersburg", "Kaliningrad"],
+        "Южный": ["Sochi", "Rostov-on-Don", "Krasnodar"],
+        "Приволжский": ["Kazan", "Nizhny Novgorod", "Samara"],
+        "Уральский": ["Yekaterinburg", "Chelyabinsk"],
+        "Сибирский": ["Novosibirsk", "Krasnoyarsk", "Irkutsk"],
+        "Дальневосточный": ["Vladivostok", "Khabarovsk"],
+    },
+    "Brazil": {
+        "São Paulo": ["São Paulo", "Campinas", "Santos"],
+        "Rio de Janeiro": ["Rio de Janeiro", "Niterói"],
+        "Minas Gerais": ["Belo Horizonte"],
+        "Bahia": ["Salvador"],
+        "Rio Grande do Sul": ["Porto Alegre"],
+        "Paraná": ["Curitiba"],
+        "Distrito Federal": ["Brasília"],
+        "Ceará": ["Fortaleza"],
+        "Pernambuco": ["Recife"],
+        "Amazonas": ["Manaus"],
+    },
+    "Mexico": {
+        "Ciudad de México": ["Mexico City"],
+        "Jalisco": ["Guadalajara"],
+        "Nuevo León": ["Monterrey"],
+        "Quintana Roo": ["Cancún", "Playa del Carmen"],
+        "Baja California": ["Tijuana", "Ensenada"],
+        "Yucatán": ["Mérida"],
+        "Puebla": ["Puebla"],
+        "Guanajuato": ["León", "Guanajuato"],
+    },
+    "Netherlands": {
+        "Noord-Holland": ["Amsterdam", "Haarlem"],
+        "Zuid-Holland": ["Rotterdam", "The Hague", "Leiden"],
+        "Utrecht": ["Utrecht"],
+        "Noord-Brabant": ["Eindhoven", "Tilburg", "'s-Hertogenbosch"],
+        "Gelderland": ["Arnhem", "Nijmegen"],
+        "Limburg": ["Maastricht"],
+    },
+    "Belgium": {
+        "Brussels-Capital": ["Brussels"],
+        "Flanders": ["Antwerp", "Ghent", "Bruges"],
+        "Wallonia": ["Liège", "Charleroi", "Namur"],
+    },
+    "Switzerland": {
+        "Zürich": ["Zurich"],
+        "Bern": ["Bern"],
+        "Geneva": ["Geneva"],
+        "Vaud": ["Lausanne"],
+        "Basel-Stadt": ["Basel"],
+        "Lucerne": ["Lucerne"],
+    },
+    "Austria": {
+        "Wien": ["Vienna"],
+        "Salzburg": ["Salzburg"],
+        "Tirol": ["Innsbruck"],
+        "Steiermark": ["Graz"],
+        "Oberösterreich": ["Linz"],
+    },
+    "Portugal": {
+        "Lisboa": ["Lisbon"],
+        "Porto": ["Porto"],
+        "Faro": ["Faro", "Albufeira"],
+        "Coimbra": ["Coimbra"],
+    },
+    "Greece": {
+        "Attica": ["Athens", "Piraeus"],
+        "Central Macedonia": ["Thessaloniki"],
+        "Crete": ["Heraklion"],
+        "South Aegean": ["Rhodes", "Mykonos", "Santorini"],
+    },
+    "Turkey": {
+        "Istanbul": ["Istanbul"],
+        "Ankara": ["Ankara"],
+        "Izmir": ["Izmir"],
+        "Antalya": ["Antalya"],
+        "Bursa": ["Bursa"],
+        "Cappadocia": ["Nevşehir", "Göreme"],
+    },
+    "UAE": {
+        "Dubai": ["Dubai"],
+        "Abu Dhabi": ["Abu Dhabi"],
+        "Sharjah": ["Sharjah"],
+        "Ras Al Khaimah": ["Ras Al Khaimah"],
+    },
+    "Thailand": {
+        "Bangkok": ["Bangkok"],
+        "Chiang Mai": ["Chiang Mai"],
+        "Phuket": ["Phuket"],
+        "Chonburi": ["Pattaya"],
+        "Krabi": ["Krabi"],
+    },
+    "Vietnam": {
+        "Hà Nội": ["Hanoi"],
+        "Hồ Chí Minh": ["Ho Chi Minh City"],
+        "Đà Nẵng": ["Da Nang"],
+        "Khánh Hòa": ["Nha Trang"],
+        "Quảng Ninh": ["Ha Long"],
+    },
+    "Indonesia": {
+        "DKI Jakarta": ["Jakarta"],
+        "Bali": ["Bali", "Denpasar", "Ubud"],
+        "Jawa Timur": ["Surabaya"],
+        "Jawa Barat": ["Bandung"],
+        "DI Yogyakarta": ["Yogyakarta"],
+    },
+    "Malaysia": {
+        "Kuala Lumpur": ["Kuala Lumpur"],
+        "Penang": ["George Town"],
+        "Selangor": ["Petaling Jaya", "Shah Alam"],
+        "Johor": ["Johor Bahru"],
+        "Sabah": ["Kota Kinabalu"],
+        "Sarawak": ["Kuching"],
+    },
+    "Philippines": {
+        "Metro Manila": ["Manila", "Makati", "Quezon City"],
+        "Cebu": ["Cebu City"],
+        "Davao": ["Davao City"],
+        "Palawan": ["Puerto Princesa"],
+    },
+    "Egypt": {
+        "Cairo Governorate": ["Cairo"],
+        "Alexandria Governorate": ["Alexandria"],
+        "Giza Governorate": ["Giza"],
+        "Luxor Governorate": ["Luxor"],
+        "Red Sea Governorate": ["Hurghada", "Sharm El Sheikh"],
+    },
+    "South Africa": {
+        "Gauteng": ["Johannesburg", "Pretoria"],
+        "Western Cape": ["Cape Town"],
+        "KwaZulu-Natal": ["Durban"],
+        "Eastern Cape": ["Port Elizabeth"],
+    },
+    "Morocco": {
+        "Casablanca-Settat": ["Casablanca"],
+        "Rabat-Salé-Kénitra": ["Rabat"],
+        "Marrakech-Safi": ["Marrakech", "Essaouira"],
+        "Fès-Meknès": ["Fes", "Meknes"],
+        "Tanger-Tétouan-Al Hoceïma": ["Tangier", "Chefchaouen"],
+    },
+    "Argentina": {
+        "Buenos Aires": ["Buenos Aires", "La Plata"],
+        "Córdoba": ["Córdoba"],
+        "Mendoza": ["Mendoza"],
+        "Santa Fe": ["Rosario"],
+        "Tierra del Fuego": ["Ushuaia"],
+    },
+    "Chile": {
+        "Región Metropolitana": ["Santiago"],
+        "Valparaíso": ["Valparaíso", "Viña del Mar"],
+        "Biobío": ["Concepción"],
+        "Los Lagos": ["Puerto Montt"],
+        "Magallanes": ["Punta Arenas"],
+    },
+    "Colombia": {
+        "Bogotá D.C.": ["Bogotá"],
+        "Antioquia": ["Medellín"],
+        "Valle del Cauca": ["Cali"],
+        "Atlántico": ["Barranquilla"],
+        "Bolívar": ["Cartagena"],
+    },
+    "Peru": {
+        "Lima": ["Lima"],
+        "Cusco": ["Cusco"],
+        "Arequipa": ["Arequipa"],
+        "La Libertad": ["Trujillo"],
+    },
+    "New Zealand": {
+        "Auckland": ["Auckland"],
+        "Wellington": ["Wellington"],
+        "Canterbury": ["Christchurch"],
+        "Otago": ["Dunedin", "Queenstown"],
+    },
+    "Ireland": {
+        "Leinster": ["Dublin"],
+        "Munster": ["Cork", "Limerick"],
+        "Connacht": ["Galway"],
+    },
+    "Sweden": {
+        "Stockholms län": ["Stockholm"],
+        "Västra Götalands län": ["Gothenburg"],
+        "Skåne län": ["Malmö"],
+        "Uppsala län": ["Uppsala"],
+    },
+    "Norway": {
+        "Oslo": ["Oslo"],
+        "Vestland": ["Bergen"],
+        "Troms og Finnmark": ["Tromsø"],
+        "Trøndelag": ["Trondheim"],
+    },
+    "Denmark": {
+        "Hovedstaden": ["Copenhagen"],
+        "Midtjylland": ["Aarhus"],
+        "Syddanmark": ["Odense"],
+    },
+    "Finland": {
+        "Uusimaa": ["Helsinki", "Espoo"],
+        "Pirkanmaa": ["Tampere"],
+        "Southwest Finland": ["Turku"],
+        "Lapland": ["Rovaniemi"],
+    },
+    "Poland": {
+        "Mazowieckie": ["Warsaw"],
+        "Małopolskie": ["Kraków"],
+        "Wielkopolskie": ["Poznań"],
+        "Dolnośląskie": ["Wrocław"],
+        "Pomorskie": ["Gdańsk"],
+    },
+    "Czech Republic": {
+        "Praha": ["Prague"],
+        "Jihomoravský": ["Brno"],
+        "Moravskoslezský": ["Ostrava"],
+        "Plzeňský": ["Plzeň"],
+    },
+    "Hungary": {
+        "Budapest": ["Budapest"],
+        "Pest": ["Szentendre"],
+        "Baranya": ["Pécs"],
+        "Hajdú-Bihar": ["Debrecen"],
+    },
+    "Israel": {
+        "Tel Aviv District": ["Tel Aviv", "Jaffa"],
+        "Jerusalem District": ["Jerusalem"],
+        "Haifa District": ["Haifa"],
+        "Southern District": ["Eilat"],
+    },
+    "Saudi Arabia": {
+        "Riyadh": ["Riyadh"],
+        "Makkah": ["Mecca", "Jeddah"],
+        "Eastern Province": ["Dammam", "Dhahran"],
+        "Medina": ["Medina"],
+    },
+    "Qatar": {
+        "Doha": ["Doha"],
+    },
+    "Kenya": {
+        "Nairobi": ["Nairobi"],
+        "Mombasa": ["Mombasa"],
+        "Nakuru": ["Nakuru"],
+    },
+    "Nigeria": {
+        "Lagos": ["Lagos"],
+        "Abuja": ["Abuja"],
+        "Kano": ["Kano"],
+    },
+    "Pakistan": {
+        "Punjab": ["Lahore", "Faisalabad"],
+        "Sindh": ["Karachi"],
+        "Islamabad": ["Islamabad"],
+        "Khyber Pakhtunkhwa": ["Peshawar"],
+    },
+    "Bangladesh": {
+        "Dhaka Division": ["Dhaka"],
+        "Chittagong Division": ["Chittagong"],
+        "Sylhet Division": ["Sylhet"],
+    },
+    "Sri Lanka": {
+        "Western Province": ["Colombo"],
+        "Central Province": ["Kandy"],
+        "Southern Province": ["Galle"],
+    },
+    "Nepal": {
+        "Bagmati": ["Kathmandu"],
+        "Gandaki": ["Pokhara"],
+    },
+}
+
+# Translation layer for dual-language support
+CN_TO_EN = {
+    # Countries (CN -> EN)
+    "中国": "China",
+    "美国": "United States",
+    "日本": "Japan",
+    "英国": "United Kingdom",
+    "法国": "France",
+    "德国": "Germany",
+    "意大利": "Italy",
+    "西班牙": "Spain",
+    "澳大利亚": "Australia",
+    "加拿大": "Canada",
+    "韩国": "South Korea",
+    "新加坡": "Singapore",
+    "印度": "India",
+    "俄罗斯": "Russia",
+    "巴西": "Brazil",
+    "墨西哥": "Mexico",
+    "荷兰": "Netherlands",
+    "比利时": "Belgium",
+    "瑞士": "Switzerland",
+    "奥地利": "Austria",
+    "葡萄牙": "Portugal",
+    "希腊": "Greece",
+    "土耳其": "Turkey",
+    "阿联酋": "United Arab Emirates",
+    "泰国": "Thailand",
+    "越南": "Vietnam",
+    "印度尼西亚": "Indonesia",
+    "马来西亚": "Malaysia",
+    "菲律宾": "Philippines",
+    "埃及": "Egypt",
+    "南非": "South Africa",
+    "摩洛哥": "Morocco",
+    "阿根廷": "Argentina",
+    "智利": "Chile",
+    "哥伦比亚": "Colombia",
+    "秘鲁": "Peru",
+    "新西兰": "New Zealand",
+    "爱尔兰": "Ireland",
+    "瑞典": "Sweden",
+    "挪威": "Norway",
+    "丹麦": "Denmark",
+    "芬兰": "Finland",
+    "波兰": "Poland",
+    "捷克": "Czech Republic",
+    "匈牙利": "Hungary",
+    "以色列": "Israel",
+    "沙特阿拉伯": "Saudi Arabia",
+    "卡塔尔": "Qatar",
+    "肯尼亚": "Kenya",
+    "尼日利亚": "Nigeria",
+    "巴基斯坦": "Pakistan",
+    "孟加拉国": "Bangladesh",
+    "斯里兰卡": "Sri Lanka",
+    "尼泊尔": "Nepal",
+    # Chinese Provinces (CN -> EN)
+    "北京": "Beijing",
+    "上海": "Shanghai",
+    "天津": "Tianjin",
+    "重庆": "Chongqing",
+    "广东": "Guangdong",
+    "浙江": "Zhejiang",
+    "江苏": "Jiangsu",
+    "山东": "Shandong",
+    "四川": "Sichuan",
+    "湖北": "Hubei",
+    "湖南": "Hunan",
+    "河南": "Henan",
+    "河北": "Hebei",
+    "福建": "Fujian",
+    "安徽": "Anhui",
+    "江西": "Jiangxi",
+    "陕西": "Shaanxi",
+    "山西": "Shanxi",
+    "辽宁": "Liaoning",
+    "吉林": "Jilin",
+    "黑龙江": "Heilongjiang",
+    "云南": "Yunnan",
+    "贵州": "Guizhou",
+    "甘肃": "Gansu",
+    "海南": "Hainan",
+    "广西": "Guangxi",
+    "内蒙古": "Inner Mongolia",
+    "新疆": "Xinjiang",
+    "西藏": "Tibet",
+    "宁夏": "Ningxia",
+    "青海": "Qinghai",
+    "香港": "Hong Kong",
+    "澳门": "Macau",
+    "台湾": "Taiwan",
+    # Chinese Cities (CN -> EN)
+    "广州": "Guangzhou",
+    "深圳": "Shenzhen",
+    "东莞": "Dongguan",
+    "佛山": "Foshan",
+    "珠海": "Zhuhai",
+    "惠州": "Huizhou",
+    "中山": "Zhongshan",
+    "汕头": "Shantou",
+    "湛江": "Zhanjiang",
+    "江门": "Jiangmen",
+    "梧州": "Wuzhou",
+    "杭州": "Hangzhou",
+    "宁波": "Ningbo",
+    "温州": "Wenzhou",
+    "绍���": "Shaoxing",
+    "嘉兴": "Jiaxing",
+    "金华": "Jinhua",
+    "台州": "Taizhou",
+    "湖州": "Huzhou",
+    "南京": "Nanjing",
+    "苏州": "Suzhou",
+    "无锡": "Wuxi",
+    "常州": "Changzhou",
+    "南通": "Nantong",
+    "徐州": "Xuzhou",
+    "扬州": "Yangzhou",
+    "镇江": "Zhenjiang",
+    "济南": "Jinan",
+    "青岛": "Qingdao",
+    "烟台": "Yantai",
+    "威海": "Weihai",
+    "潍坊": "Weifang",
+    "临沂": "Linyi",
+    "济宁": "Jining",
+    "淄博": "Zibo",
+    "成都": "Chengdu",
+    "绵阳": "Mianyang",
+    "德阳": "Deyang",
+    "宜宾": "Yibin",
+    "泸州": "Luzhou",
+    "南充": "Nanchong",
+    "乐山": "Leshan",
+    "武汉": "Wuhan",
+    "宜昌": "Yichang",
+    "襄阳": "Xiangyang",
+    "荆州": "Jingzhou",
+    "黄石": "Huangshi",
+    "十堰": "Shiyan",
+    "长沙": "Changsha",
+    "株洲": "Zhuzhou",
+    "湘潭": "Xiangtan",
+    "衡阳": "Hengyang",
+    "岳阳": "Yueyang",
+    "常德": "Changde",
+    "郑州": "Zhengzhou",
+    "洛阳": "Luoyang",
+    "开封": "Kaifeng",
+    "新乡": "Xinxiang",
+    "安阳": "Anyang",
+    "焦作": "Jiaozuo",
+    "石家庄": "Shijiazhuang",
+    "唐山": "Tangshan",
+    "秦皇岛": "Qinhuangdao",
+    "邯郸": "Handan",
+    "保定": "Baoding",
+    "沧州": "Cangzhou",
+    "福州": "Fuzhou",
+    "厦门": "Xiamen",
+    "泉州": "Quanzhou",
+    "漳州": "Zhangzhou",
+    "莆田": "Putian",
+    "龙岩": "Longyan",
+    "合肥": "Hefei",
+    "芜湖": "Wuhu",
+    "蚌埠": "Bengbu",
+    "马鞍山": "Ma'anshan",
+    "安庆": "Anqing",
+    "黄山": "Huangshan",
+    "南昌": "Nanchang",
+    "九江": "Jiujiang",
+    "景德镇": "Jingdezhen",
+    "赣州": "Ganzhou",
+    "上饶": "Shangrao",
+    "吉安": "Ji'an",
+    "西安": "Xi'an",
+    "咸阳": "Xianyang",
+    "宝鸡": "Baoji",
+    "延安": "Yan'an",
+    "榆林": "Yulin",
+    "汉中": "Hanzhong",
+    "太原": "Taiyuan",
+    "大同": "Datong",
+    "临汾": "Linfen",
+    "运城": "Yuncheng",
+    "晋中": "Jinzhong",
+    "长治": "Changzhi",
+    "沈阳": "Shenyang",
+    "大连": "Dalian",
+    "鞍山": "Anshan",
+    "抚顺": "Fushun",
+    "本溪": "Benxi",
+    "营口": "Yingkou",
+    "长春": "Changchun",
+    "吉林": "Jilin",
+    "四平": "Siping",
+    "通化": "Tonghua",
+    "延边": "Yanbian",
+    "哈尔滨": "Harbin",
+    "齐齐哈尔": "Qiqihar",
+    "牡丹江": "Mudanjiang",
+    "佳木斯": "Jiamusi",
+    "大庆": "Daqing",
+    "昆明": "Kunming",
+    "大理": "Dali",
+    "丽江": "Lijiang",
+    "西双版纳": "Xishuangbanna",
+    "曲靖": "Qujing",
+    "贵阳": "Guiyang",
+    "遵义": "Zunyi",
+    "安顺": "Anshun",
+    "六盘水": "Liupanshui",
+    "毕节": "Bijie",
+    "兰州": "Lanzhou",
+    "天水": "Tianshui",
+    "嘉峪关": "Jiayuguan",
+    "酒泉": "Jiuquan",
+    "张掖": "Zhangye",
+    "海口": "Haikou",
+    "三亚": "Sanya",
+    "儋州": "Danzhou",
+    "琼海": "Qionghai",
+    "南宁": "Nanning",
+    "桂林": "Guilin",
+    "柳州": "Liuzhou",
+    "北海": "Beihai",
+    "玉林": "Yulin",
+    "呼和浩特": "Hohhot",
+    "包头": "Baotou",
+    "鄂尔多斯": "Ordos",
+    "赤峰": "Chifeng",
+    "呼伦贝尔": "Hulunbuir",
+    "乌鲁木齐": "Urumqi",
+    "喀什": "Kashgar",
+    "吐鲁番": "Turpan",
+    "阿克苏": "Aksu",
+    "伊宁": "Yining",
+    "拉萨": "Lhasa",
+    "日喀则": "Shigatse",
+    "林芝": "Nyingchi",
+    "昌都": "Qamdo",
+    "银川": "Yinchuan",
+    "石嘴山": "Shizuishan",
+    "吴忠": "Wuzhong",
+    "固原": "Guyuan",
+    "西宁": "Xining",
+    "格尔木": "Golmud",
+    "玉树": "Yushu",
+    "海东": "Haidong",
+    "台北": "Taipei",
+    "高雄": "Kaohsiung",
+    "台中": "Taichung",
+    "台南": "Tainan",
+    "新竹": "Hsinchu",
+    "基隆": "Keelung",
+    # Theme Names - MOVED TO EN_TO_CN
+}
+
+# English name to Chinese (for when UI/Poster is in Chinese)
+EN_TO_CN = {
+    "China": "中国",
+    "USA": "美国",
+    "United States": "美国",
+    "Japan": "日本",
+    "UK": "英国",
+    "United Kingdom": "英国",
+    "France": "法国",
+    "Germany": "德国",
+    "Italy": "意大利",
+    "Spain": "西班牙",
+    "Australia": "澳大利亚",
+    "Canada": "加拿大",
+    "South Korea": "韩国",
+    "Singapore": "新加坡",
+    "India": "印度",
+    "Russia": "俄罗斯",
+    "Brazil": "巴西",
+    "Mexico": "墨西哥",
+    "Netherlands": "荷兰",
+    "Belgium": "比利时",
+    "Switzerland": "瑞士",
+    "Austria": "奥地利",
+    "Portugal": "葡萄牙",
+    "Greece": "希腊",
+    "Turkey": "土耳其",
+    "UAE": "阿联酋",
+    "United Arab Emirates": "阿联酋",
+    "Thailand": "泰国",
+    "Vietnam": "越南",
+    "Indonesia": "印度尼西亚",
+    "Malaysia": "马来西亚",
+    "Philippines": "菲律宾",
+    "Egypt": "埃及",
+    "South Africa": "南非",
+    "Morocco": "摩洛哥",
+    "Argentina": "阿根廷",
+    "Chile": "智利",
+    "Colombia": "哥伦比亚",
+    "Peru": "秘鲁",
+    "New Zealand": "新西兰",
+    "Ireland": "爱尔兰",
+    "Sweden": "瑞典",
+    "Norway": "挪威",
+    "Denmark": "丹麦",
+    "Finland": "芬兰",
+    "Poland": "波兰",
+    "Czech Republic": "捷克",
+    "Hungary": "匈牙利",
+    "Israel": "以色列",
+    "Saudi Arabia": "沙特阿拉伯",
+    "Qatar": "卡塔尔",
+    "Kenya": "肯尼亚",
+    "Nigeria": "尼日利亚",
+    "Pakistan": "巴基斯坦",
+    "Bangladesh": "孟加拉国",
+    "Sri Lanka": "斯里兰卡",
+    "Nepal": "尼泊尔",
+    # Common Cities
+    "New York City": "纽约",
+    "London": "伦敦",
+    "Paris": "巴黎",
+    "Tokyo": "东京",
+    "Guangzhou": "广州",
+    "Shenzhen": "深圳",
+    "Beijing": "北京",
+    "Shanghai": "上海",
+    # Theme Names
+    "Feature-Based Shading": "特征着色",
+    "Japanese Ink": "日式水墨",
+    "Midnight Blue": "午夜蓝",
+    "Terracotta": "陶土色",
+    "Autumn": "秋日",
+    "Blueprint": "蓝图",
+    "Contrast Zones": "高对比度",
+    "Copper Patina": "铜绿",
+    "Forest": "森林",
+    "Gradient Roads": "渐变道路",
+    "Monochrome Blue": "单色蓝",
+    "Neon Cyberpunk": "霓虹赛博",
+    "Noir": "诺尔黑白",
+    "Ocean": "海洋",
+    "Pastel Dream": "蜡笔梦幻",
+    "Sunset": "日落",
+    "Warm Beige": "温暖米色",
+}
+
+# Add inverse mappings to ensure completeness
+for k, v in CN_TO_EN.items():
+    if v not in EN_TO_CN:
+        EN_TO_CN[v] = k
+
+# Expose helpers
+__all__ = [
+    "CITIES",
+    "get_countries",
+    "get_provinces",
+    "get_cities",
+    "get_city_full_name",
+    "translate",
+    "get_country_key",
+    "get_manual_coordinates",
+]
+
+# Manual overrides for city centers to ensure logical centering (e.g. Tiananmen for Beijing)
+CITY_CENTERS = {
+    "北京": (39.9042, 116.4074),
+    "Beijing": (39.9042, 116.4074),
+    "上海": (31.2304, 121.4737),
+    "Shanghai": (31.2304, 121.4737),
+    "广州": (23.1291, 113.2644),
+    "Guangzhou": (23.1291, 113.2644),
+    "深圳": (22.5422, 114.0579),
+    "Shenzhen": (22.5422, 114.0579),
+    "杭州": (30.2741, 120.1551),
+    "Hangzhou": (30.2741, 120.1551),
+    "成都": (30.6570, 104.0660),
+    "Chengdu": (30.6570, 104.0660),
+    "南京": (32.0603, 118.7969),
+    "Nanjing": (32.0603, 118.7969),
+    "武汉": (30.5928, 114.3055),
+    "Wuhan": (30.5928, 114.3055),
+    "西安": (34.3416, 108.9398),
+    "Xi'an": (34.3416, 108.9398),
+    "苏州": (31.2990, 120.5853),
+    "Suzhou": (31.2990, 120.5853),
+    "重庆": (29.5630, 106.5516),
+    "Chongqing": (29.5630, 106.5516),
+    "天津": (39.1255, 117.1901),
+    "Tianjin": (39.1255, 117.1901),
+    "香港": (22.3193, 114.1694),
+    "Hong Kong": (22.3193, 114.1694),
+    "台北": (25.0330, 121.5654),
+    "Taipei": (25.0330, 121.5654),
+    "New York City": (40.7128, -74.0060),
+    "纽约": (40.7128, -74.0060),
+    "London": (51.5074, -0.1278),
+    "伦敦": (51.5074, -0.1278),
+    "Paris": (48.8566, 2.3522),
+    "巴黎": (48.8566, 2.3522),
+    "Tokyo": (35.6895, 139.6917),
+    "东京": (35.6895, 139.6917),
+    "桂林": (25.2736, 110.2902),
+    "Guilin": (25.2736, 110.2902),
+}
+
+
+def get_manual_coordinates(city_name):
+    """Return manual coordinates if available, else None."""
+    if not city_name:
+        return None
+    return CITY_CENTERS.get(city_name)
+
+
+def translate(text, target_lang="en"):
+    """
+    Simple translation helper.
+    target_lang: 'en' or 'cn'
+    """
+    if not text:
+        return text
+
+    if target_lang == "en":
+        # If text is already in CN_TO_EN keys (Chinese), return the English value
+        return CN_TO_EN.get(text, text)
+
+    if target_lang == "cn":
+        # If text is in EN_TO_CN keys (English), return the Chinese value
+        return EN_TO_CN.get(text, text)
+
+    return text
+
+
+def get_countries(lang="en"):
+    """Return list of countries in the target language."""
+    countries = []
+    for country_key in sorted(CITIES.keys()):
+        countries.append(translate(country_key, lang))
+    return sorted(list(set(countries)))
+
+
+def get_country_key(name):
+    """Map a localized name back to the CITIES dictionary key."""
+    # Check if it's already a key
+    if name in CITIES:
+        return name
+    # Check if it's an English name that needs to be Chinese key
+    cn_name = EN_TO_CN.get(name)
+    if cn_name in CITIES:
+        return cn_name
+    # Check if it's a Chinese name that needs to be English key
+    en_name = CN_TO_EN.get(name)
+    if en_name in CITIES:
+        return en_name
+    return name
+
+
+def get_provinces(country_name, lang="en"):
+    """Return sorted list of provinces/states for a given country in target language."""
+    country_key = get_country_key(country_name)
+    if country_key in CITIES:
+        # Translate provinces to target lang
+        provinces = [translate(p, lang) for p in CITIES[country_key].keys()]
+        return sorted(provinces)
+    return []
+
+
+def get_cities(country_name, province_name, lang="en"):
+    """Return sorted list of cities in target language."""
+    country_key = get_country_key(country_name)
+    # To find the province key, we might need to map it back if it was translated
+    # For now, let's assume provincial keys in CITIES are what we search against
+    # If the province_name is translated, we need to find the original key
+    province_key = province_name
+    if country_key in CITIES:
+        # Check if province_name is a direct key
+        if province_name not in CITIES[country_key]:
+            # Try to find the key that translates to province_name
+            for p_key in CITIES[country_key].keys():
+                if translate(p_key, lang) == province_name:
+                    province_key = p_key
+                    break
+
+        if province_key in CITIES[country_key]:
+            cities = [translate(c, lang) for c in CITIES[country_key][province_key]]
+            return sorted(cities)
+    return []
+
+
+def search_cities(query):
+    """
+    Search for cities matching the query (checks both Native and English names).
+    Returns list of tuples: (city, province, country)
+    """
+    if not query or len(query) < 2:
+        return []
+
+    query = query.lower()
+    results = []
+
+    for country, provinces in CITIES.items():
+        country_en = CN_TO_EN.get(country, "").lower()
+        for province, cities in provinces.items():
+            for city in cities:
+                city_en = CN_TO_EN.get(city, "").lower()
+                # Match against native name or English name
+                if query in city.lower() or (city_en and query in city_en):
+                    results.append((city, province, country))
+
+    # Sort by city name
+    return sorted(results, key=lambda x: x[0])[:20]
+
+
+def get_city_full_name(city, province, country, target_lang=None):
+    """
+    Return formatted full name.
+    If target_lang is provided ('en' or 'cn'), translates components.
+    """
+    if target_lang:
+        city = translate(city, target_lang)
+        province = translate(province, target_lang)
+        country = translate(country, target_lang)
+
+    if province == city:  # Direct-controlled municipalities
+        return f"{city}, {country}"
+    return f"{city}, {province}, {country}"

create_map_poster.py

@@ -0,0 +1,822 @@
+import osmnx as ox
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.font_manager import FontProperties
+import matplotlib.colors as mcolors
+import numpy as np
+from geopy.geocoders import Nominatim
+from tqdm import tqdm
+import time
+import json
+import os
+from datetime import datetime
+import argparse
+
+# Explicitly enable caching
+ox.settings.use_cache = True
+
+THEMES_DIR = "themes"
+FONTS_DIR = "fonts"
+POSTERS_DIR = "posters"
+
+
+def load_fonts():
+    """
+    Load fonts for both English (Goudy Old Style) and Chinese (HYWenRunSongYunU).
+    """
+    fonts = {
+        "en_bold": os.path.join(FONTS_DIR, "GoudyOldStyle-Bold.ttf"),
+        "en_regular": os.path.join(FONTS_DIR, "GoudyOldStyle-Regular.ttf"),
+        "cn": os.path.join(FONTS_DIR, "HYWenRunSongYunU.ttf"),
+    }
+
+    # Verify fonts exist
+    available_fonts = {}
+    for key, path in fonts.items():
+        if os.path.exists(path):
+            available_fonts[key] = path
+        else:
+            print(f"⚠ Font not found: {path}")
+
+    return available_fonts if available_fonts else None
+
+
+FONTS = load_fonts()
+
+
+def generate_output_filename(city, theme_name, output_format):
+    """
+    Generate unique output filename with city, theme, and datetime.
+    """
+    if not os.path.exists(POSTERS_DIR):
+        os.makedirs(POSTERS_DIR)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    city_slug = city.lower().replace(" ", "_")
+    ext = output_format.lower()
+    filename = f"{city_slug}_{theme_name}_{timestamp}.{ext}"
+    return os.path.join(POSTERS_DIR, filename)
+
+
+def get_available_themes():
+    """
+    Scans the themes directory and returns a list of available theme names.
+    """
+    if not os.path.exists(THEMES_DIR):
+        os.makedirs(THEMES_DIR)
+        return []
+
+    themes = []
+    for file in sorted(os.listdir(THEMES_DIR)):
+        if file.endswith(".json"):
+            theme_name = file[:-5]  # Remove .json extension
+            themes.append(theme_name)
+    return themes
+
+
+def load_theme(theme_name="feature_based"):
+    """
+    Load theme from JSON file in themes directory.
+    """
+    theme_file = os.path.join(THEMES_DIR, f"{theme_name}.json")
+
+    if not os.path.exists(theme_file):
+        print(
+            f"⚠ Theme file '{theme_file}' not found. Using default feature_based theme."
+        )
+        # Fallback to embedded default theme
+        return {
+            "name": "Feature-Based Shading",
+            "bg": "#FFFFFF",
+            "text": "#000000",
+            "gradient_color": "#FFFFFF",
+            "water": "#C0C0C0",
+            "parks": "#F0F0F0",
+            "road_motorway": "#0A0A0A",
+            "road_primary": "#1A1A1A",
+            "road_secondary": "#2A2A2A",
+            "road_tertiary": "#3A3A3A",
+            "road_residential": "#4A4A4A",
+            "road_default": "#3A3A3A",
+        }
+
+    with open(theme_file, "r") as f:
+        theme = json.load(f)
+        print(f"✓ Loaded theme: {theme.get('name', theme_name)}")
+        if "description" in theme:
+            print(f"  {theme['description']}")
+        return theme
+
+
+# Load theme (can be changed via command line or input)
+THEME = None  # Will be loaded later
+
+
+def create_gradient_fade(ax, color, location="bottom", zorder=10):
+    """
+    Creates a fade effect at the top or bottom of the map.
+    """
+    vals = np.linspace(0, 1, 256).reshape(-1, 1)
+    gradient = np.hstack((vals, vals))
+
+    rgb = mcolors.to_rgb(color)
+    my_colors = np.zeros((256, 4))
+    my_colors[:, 0] = rgb[0]
+    my_colors[:, 1] = rgb[1]
+    my_colors[:, 2] = rgb[2]
+
+    if location == "bottom":
+        my_colors[:, 3] = np.linspace(1, 0, 256)
+        extent_y_start = 0
+        extent_y_end = 0.25
+    else:
+        my_colors[:, 3] = np.linspace(0, 1, 256)
+        extent_y_start = 0.75
+        extent_y_end = 1.0
+
+    custom_cmap = mcolors.ListedColormap(my_colors)
+
+    xlim = ax.get_xlim()
+    ylim = ax.get_ylim()
+    y_range = ylim[1] - ylim[0]
+
+    y_bottom = ylim[0] + y_range * extent_y_start
+    y_top = ylim[0] + y_range * extent_y_end
+
+    ax.imshow(
+        gradient,
+        extent=[xlim[0], xlim[1], y_bottom, y_top],
+        aspect="auto",
+        cmap=custom_cmap,
+        zorder=zorder,
+        origin="lower",
+    )
+
+
+def get_edge_colors_by_type(
+    G, show_motorway=True, show_primary=True, show_secondary=True
+):
+    """
+    Assigns colors to edges based on road type hierarchy.
+    Returns a list of colors corresponding to each edge in the graph.
+    If a layer is hidden, returns 'none' for that edge.
+    """
+    edge_colors = []
+
+    for u, v, data in G.edges(data=True):
+        # Get the highway type (can be a list or string)
+        highway = data.get("highway", "unclassified")
+
+        # Handle list of highway types (take the first one)
+        if isinstance(highway, list):
+            highway = highway[0] if highway else "unclassified"
+
+        # Assign color based on road type
+        if highway in ["motorway", "motorway_link"]:
+            color = THEME["road_motorway"] if show_motorway else "none"
+        elif highway in ["trunk", "trunk_link", "primary", "primary_link"]:
+            color = THEME["road_primary"] if show_primary else "none"
+        elif highway in ["secondary", "secondary_link"]:
+            color = THEME["road_secondary"] if show_secondary else "none"
+        elif highway in ["tertiary", "tertiary_link"]:
+            color = (
+                THEME["road_tertiary"] if show_secondary else "none"
+            )  # Group tertiary with secondary
+        elif highway in [
+            "residential",
+            "living_street",
+            "unclassified",
+            "service",
+            "road",
+        ]:
+            color = THEME["road_residential"]
+        elif highway in ["path", "footway", "track", "cycleway", "pedestrian"]:
+            # Use residential color or a lighter version if defined, for now residential
+            color = THEME["road_residential"]
+        else:
+            color = THEME["road_default"]
+
+        edge_colors.append(color)
+
+    return edge_colors
+
+
+def get_edge_widths_by_type(G):
+    """
+    Assigns line widths to edges based on road type.
+    Major roads get thicker lines.
+    """
+    edge_widths = []
+
+    for u, v, data in G.edges(data=True):
+        highway = data.get("highway", "unclassified")
+
+        if isinstance(highway, list):
+            highway = highway[0] if highway else "unclassified"
+
+        # Assign width based on road importance (increased for visibility)
+        if highway in ["motorway", "motorway_link"]:
+            width = 1.6
+        elif highway in ["trunk", "trunk_link", "primary", "primary_link"]:
+            width = 1.3
+        elif highway in ["secondary", "secondary_link"]:
+            width = 1.0
+        elif highway in ["tertiary", "tertiary_link"]:
+            width = 0.8
+        elif highway in [
+            "residential",
+            "living_street",
+            "unclassified",
+            "service",
+            "road",
+        ]:
+            width = 0.8
+        elif highway in ["path", "footway", "track", "cycleway", "pedestrian"]:
+            width = 0.5
+        else:
+            width = 0.6
+
+        edge_widths.append(width)
+
+    return edge_widths
+
+
+def has_chinese(text):
+    """Check if a string contains any Chinese characters."""
+    if not text:
+        return False
+    for char in text:
+        if "\u4e00" <= char <= "\u9fff":
+            return True
+    return False
+
+
+def get_coordinates(city, country):
+    """
+    Fetches coordinates for a given city and country using OSMnx (which handles caching and retry).
+    First checks for manual overrides in cities_data.
+    """
+    from cities_data import get_manual_coordinates
+
+    # Check for manual override first (e.g. for large cities like Beijing)
+    manual_coords = get_manual_coordinates(city)
+    if manual_coords:
+        print(f"✓ Using manual coordinate override for {city}: {manual_coords}")
+        return manual_coords
+
+    print(f"Looking up coordinates for {city}, {country} via OSMnx...")
+
+    # Configure OSMnx settings for robustness
+    ox.settings.timeout = 30
+    ox.settings.user_agent = "modelscope_map_to_poster/1.0"
+
+    try:
+        # Try City + Country
+        query = f"{city}, {country}"
+        lat, lon = ox.geocode(query)
+        print(f"✓ Found: {lat}, {lon}")
+        return (lat, lon)
+    except Exception as e:
+        print(f"⚠ First attempt failed: {e}")
+        try:
+            # Try just City
+            print(f"Retrying with city name only: {city}")
+            lat, lon = ox.geocode(city)
+            print(f"✓ Found: {lat}, {lon}")
+            return (lat, lon)
+        except Exception as e2:
+            print(f"⚠ Second attempt failed: {e2}")
+            raise ValueError(f"Could not find coordinates for {city}, {country}")
+
+
+def create_poster(
+    city,
+    country,
+    point,
+    dist,
+    output_file,
+    output_format,
+    width=12,
+    height=16,
+    no_crop=False,
+    show_motorway=True,
+    show_primary=True,
+    show_secondary=True,
+    show_water=True,
+    show_parks=True,
+):
+    msg = f"Generating map for {city}, {country}..."
+    print(f"\n{msg}")
+    yield msg
+
+    # Calculate non-square distances to match figure aspect ratio
+    # dist is the vertical (North-South) half-distance
+    dist_ns = dist
+    dist_ew = dist * (width / height)
+
+    # Progress bar for data fetching
+    # Note: tqdm writes to stderr, we will just yield status updates for the UI
+
+    # 1. Fetch Street Network using a bounding box
+    yield "Downloading street network..."
+
+    import math
+
+    lat, lon = point
+    delta_lat = dist_ns / 111320.0
+    delta_lon = dist_ew / (111320.0 * math.cos(math.radians(lat)))
+
+    north, south = lat + delta_lat, lat - delta_lat
+    west, east = lon - delta_lon, lon + delta_lon
+
+    bbox = (west, south, east, north)
+    G = ox.graph_from_bbox(bbox, network_type="all")
+
+    # 2. Fetch Water and Parks in one request
+    yield "Downloading features (water, parks)..."
+    tags = {
+        "natural": ["water", "wood", "scrub"],
+        "waterway": ["riverbank", "dock"],
+        "leisure": ["park", "garden", "nature_reserve"],
+        "landuse": [
+            "forest",
+            "grass",
+            "cemetery",
+            "recreation_ground",
+            "village_green",
+        ],
+    }
+
+    water_polys = None
+    water_lines = None
+    parks = None
+
+    try:
+        features = ox.features_from_bbox(bbox, tags=tags)
+
+        # Separate features and simplify geometries for faster rendering
+        if features is not None and not features.empty:
+            # Safe mask creation for Water
+            water_mask = pd.Series(False, index=features.index)
+            if "natural" in features.columns:
+                water_mask |= features["natural"].isin(["water"])
+            if "waterway" in features.columns:
+                water_mask |= features["waterway"].notna()
+
+            water = features[water_mask]
+
+            if not water.empty:
+                # Water Polygons (Lakes, Wide Rivers)
+                water_polys = water[
+                    water.geometry.type.isin(["Polygon", "MultiPolygon"])
+                ]
+                if not water_polys.empty:
+                    water_polys.geometry = water_polys.geometry.simplify(
+                        tolerance=0.00001, preserve_topology=True
+                    )
+
+                # Water Lines (Rivers, Streams represented as lines)
+                water_lines = water[
+                    water.geometry.type.isin(["LineString", "MultiLineString"])
+                ]
+            else:
+                water_polys, water_lines = None, None  # No water features found
+
+            # Green space/Parks features
+            park_mask = pd.Series(False, index=features.index)
+            if "leisure" in features.columns:
+                park_mask |= features["leisure"].notna()
+            if "landuse" in features.columns:
+                park_mask |= features["landuse"].isin(
+                    [
+                        "forest",
+                        "grass",
+                        "cemetery",
+                        "recreation_ground",
+                        "village_green",
+                    ]
+                )
+            if "natural" in features.columns:
+                park_mask |= features["natural"].isin(["wood", "scrub"])
+
+            parks = features[park_mask]
+            if not parks.empty:
+                parks = parks[parks.geometry.type.isin(["Polygon", "MultiPolygon"])]
+                # Simplify geometries
+                parks.geometry = parks.geometry.simplify(
+                    tolerance=0.00001, preserve_topology=True
+                )
+            else:
+                parks = None  # No park features found
+        else:
+            water_polys, water_lines, parks = None, None, None
+    except Exception as e:
+        print(f"Warning: Could not fetch features: {e}")
+        water_polys, water_lines, parks = None, None, None
+
+    print("✓ All data downloaded successfully!")
+    yield "Data downloaded. Rendering map..."
+
+    # 2. Setup Plot
+    print("Rendering map...")
+    fig, ax = plt.subplots(figsize=(width, height), facecolor=THEME["bg"])
+    ax.set_facecolor(THEME["bg"])
+    ax.set_position([0, 0, 1, 1])
+
+    # 3. Plot Layers
+    # Layer 1: Polygons (filter to only plot polygon/multipolygon geometries, not points)
+    # Layer 1: Water (Polygons and Lines)
+    if show_water:
+        if water_polys is not None and not water_polys.empty:
+            water_polys.plot(
+                ax=ax, facecolor=THEME["water"], edgecolor="none", zorder=1
+            )
+
+        if water_lines is not None and not water_lines.empty:
+            # Plot water lines (rivers) with some thickness
+            water_lines.plot(ax=ax, color=THEME["water"], linewidth=2.0, zorder=1)
+
+    if show_parks and parks is not None and not parks.empty:
+        # Filter to only polygon/multipolygon geometries to avoid point features showing as dots
+        parks_polys = parks[parks.geometry.type.isin(["Polygon", "MultiPolygon"])]
+        if not parks_polys.empty:
+            parks_polys.plot(
+                ax=ax, facecolor=THEME["parks"], edgecolor="none", zorder=2
+            )
+
+    # Layer 2: Roads with hierarchy coloring
+    print("Applying road hierarchy colors...")
+    yield "Applying road styles..."
+    edge_colors = get_edge_colors_by_type(
+        G,
+        show_motorway=show_motorway,
+        show_primary=show_primary,
+        show_secondary=show_secondary,
+    )
+    edge_widths = get_edge_widths_by_type(G)
+
+    ox.plot_graph(
+        G,
+        ax=ax,
+        bgcolor=THEME["bg"],
+        node_size=0,
+        edge_color=edge_colors,
+        edge_linewidth=edge_widths,
+        show=False,
+        close=False,
+    )
+
+    # Layer 3: Gradients (Top and Bottom)
+    create_gradient_fade(ax, THEME["gradient_color"], location="bottom", zorder=10)
+    create_gradient_fade(ax, THEME["gradient_color"], location="top", zorder=10)
+
+    # 4. Typography
+    is_chinese = has_chinese(city)
+
+    if FONTS:
+        if is_chinese:
+            # Chinese styling
+            font_path = FONTS.get("cn") or FONTS.get("en_bold")
+            font_main_base = FontProperties(fname=font_path)
+            font_sub_base = FontProperties(fname=font_path)
+            font_coords = FontProperties(fname=font_path, size=14)
+
+            display_city = city
+            display_country = country
+        else:
+            # English styling (Original)
+            font_path_bold = FONTS.get("en_bold")
+            font_path_reg = FONTS.get("en_regular")
+            font_main_base = FontProperties(fname=font_path_bold)
+            font_sub_base = FontProperties(fname=font_path_reg)
+            font_coords = FontProperties(fname=font_path_reg, size=14)
+
+            # Spaced and uppercase for English
+            display_city = "  ".join(list(city.upper()))
+            display_country = country.upper()
+    else:
+        # Fallback to system fonts
+        font_main_base = FontProperties(family="serif", weight="bold")
+        font_sub_base = FontProperties(family="serif")
+        font_coords = FontProperties(family="monospace", size=14)
+
+        if is_chinese:
+            display_city = city
+            display_country = country
+        else:
+            display_city = "  ".join(list(city.upper()))
+            display_country = country.upper()
+
+    # Dynamically adjust font size
+    base_font_size = 60 if not is_chinese else 54
+    city_char_count = len(city)
+    if not is_chinese and city_char_count > 10:
+        scale_factor = 10 / city_char_count
+        adjusted_font_size = max(base_font_size * scale_factor, 24)
+    elif is_chinese and city_char_count > 6:
+        scale_factor = 6 / city_char_count
+        adjusted_font_size = max(base_font_size * scale_factor, 32)
+    else:
+        adjusted_font_size = base_font_size
+
+    font_main = font_main_base.copy()
+    font_main.set_size(adjusted_font_size)
+
+    font_sub = font_sub_base.copy()
+    font_sub.set_size(22)
+
+    # --- BOTTOM TEXT ---
+    ax.text(
+        0.5,
+        0.14,
+        display_city,
+        transform=ax.transAxes,
+        color=THEME["text"],
+        ha="center",
+        fontproperties=font_main,
+        zorder=11,
+    )
+
+    ax.text(
+        0.5,
+        0.10,
+        display_country,
+        transform=ax.transAxes,
+        color=THEME["text"],
+        ha="center",
+        fontproperties=font_sub,
+        zorder=11,
+    )
+
+    lat, lon = point
+    coords_text = (
+        f"{lat:.4f}° N / {lon:.4f}° E"
+        if lat >= 0
+        else f"{abs(lat):.4f}° S / {lon:.4f}° E"
+    )
+    if lon < 0:
+        coords_text = coords_text.replace("E", "W")
+
+    ax.text(
+        0.5,
+        0.07,
+        coords_text,
+        transform=ax.transAxes,
+        color=THEME["text"],
+        alpha=0.7,
+        ha="center",
+        fontproperties=font_coords,
+        zorder=11,
+    )
+
+    ax.plot(
+        [0.4, 0.6],
+        [0.125, 0.125],
+        transform=ax.transAxes,
+        color=THEME["text"],
+        linewidth=1,
+        zorder=11,
+    )
+
+    # --- ATTRIBUTION (bottom right) ---
+    attr_font = font_sub_base.copy()
+    attr_font.set_size(8)
+
+    ax.text(
+        0.98,
+        0.02,
+        "© OpenStreetMap contributors",
+        transform=ax.transAxes,
+        color=THEME["text"],
+        alpha=0.5,
+        ha="right",
+        va="bottom",
+        fontproperties=attr_font,
+        zorder=11,
+    )
+
+    # 5. Save
+    print(f"Saving to {output_file}...")
+    yield f"Saving to {output_file}..."
+
+    fmt = output_format.lower()
+    save_kwargs = dict(facecolor=THEME["bg"], pad_inches=0.05)
+
+    if not no_crop:
+        save_kwargs["bbox_inches"] = "tight"
+
+    # DPI matters mainly for raster formats
+    if fmt == "png":
+        save_kwargs["dpi"] = 300
+
+    plt.savefig(output_file, format=fmt, **save_kwargs)
+
+    plt.close()
+    print(f"✓ Done! Poster saved as {output_file}")
+    yield "Done!"
+
+
+def print_examples():
+    """Print usage examples."""
+    print("""
+City Map Poster Generator
+=========================
+
+Usage:
+  python create_map_poster.py --city <city> --country <country> [options]
+
+Examples:
+  # Iconic grid patterns
+  python create_map_poster.py -c "New York" -C "USA" -t noir -d 12000           # Manhattan grid
+  python create_map_poster.py -c "Barcelona" -C "Spain" -t warm_beige -d 8000   # Eixample district grid
+  
+  # Waterfront & canals
+  python create_map_poster.py -c "Venice" -C "Italy" -t blueprint -d 4000       # Canal network
+  python create_map_poster.py -c "Amsterdam" -C "Netherlands" -t ocean -d 6000  # Concentric canals
+  python create_map_poster.py -c "Dubai" -C "UAE" -t midnight_blue -d 15000     # Palm & coastline
+  
+  # Radial patterns
+  python create_map_poster.py -c "Paris" -C "France" -t pastel_dream -d 10000   # Haussmann boulevards
+  python create_map_poster.py -c "Moscow" -C "Russia" -t noir -d 12000          # Ring roads
+  
+  # Organic old cities
+  python create_map_poster.py -c "Tokyo" -C "Japan" -t japanese_ink -d 15000    # Dense organic streets
+  python create_map_poster.py -c "Marrakech" -C "Morocco" -t terracotta -d 5000 # Medina maze
+  python create_map_poster.py -c "Rome" -C "Italy" -t warm_beige -d 8000        # Ancient street layout
+  
+  # Coastal cities
+  python create_map_poster.py -c "San Francisco" -C "USA" -t sunset -d 10000    # Peninsula grid
+  python create_map_poster.py -c "Sydney" -C "Australia" -t ocean -d 12000      # Harbor city
+  python create_map_poster.py -c "Mumbai" -C "India" -t contrast_zones -d 18000 # Coastal peninsula
+  
+  # River cities
+  python create_map_poster.py -c "London" -C "UK" -t noir -d 15000              # Thames curves
+  python create_map_poster.py -c "Budapest" -C "Hungary" -t copper_patina -d 8000  # Danube split
+  
+  # List themes
+  python create_map_poster.py --list-themes
+
+Options:
+  --city, -c        City name (required)
+  --country, -C     Country name (required)
+  --theme, -t       Theme name (default: feature_based)
+  --distance, -d    Map radius in meters (default: 29000)
+  --list-themes     List all available themes
+
+Distance guide:
+  4000-6000m   Small/dense cities (Venice, Amsterdam old center)
+  8000-12000m  Medium cities, focused downtown (Paris, Barcelona)
+  15000-20000m Large metros, full city view (Tokyo, Mumbai)
+
+Available themes can be found in the 'themes/' directory.
+Generated posters are saved to 'posters/' directory.
+""")
+
+
+def list_themes():
+    """List all available themes with descriptions."""
+    available_themes = get_available_themes()
+    if not available_themes:
+        print("No themes found in 'themes/' directory.")
+        return
+
+    print("\nAvailable Themes:")
+    print("-" * 60)
+    for theme_name in available_themes:
+        theme_path = os.path.join(THEMES_DIR, f"{theme_name}.json")
+        try:
+            with open(theme_path, "r") as f:
+                theme_data = json.load(f)
+                display_name = theme_data.get("name", theme_name)
+                description = theme_data.get("description", "")
+        except:
+            display_name = theme_name
+            description = ""
+        print(f"  {theme_name}")
+        print(f"    {display_name}")
+        if description:
+            print(f"    {description}")
+        print()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Generate beautiful map posters for any city",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python create_map_poster.py --city "New York" --country "USA"
+  python create_map_poster.py --city Tokyo --country Japan --theme midnight_blue
+  python create_map_poster.py --city Paris --country France --theme noir --distance 15000
+  python create_map_poster.py --list-themes
+        """,
+    )
+
+    parser.add_argument("--city", "-c", type=str, help="City name")
+    parser.add_argument("--country", "-C", type=str, help="Country name")
+    parser.add_argument(
+        "--theme",
+        "-t",
+        type=str,
+        default="feature_based",
+        help="Theme name (default: feature_based)",
+    )
+    parser.add_argument(
+        "--distance",
+        "-d",
+        type=int,
+        default=10000,
+        help="Map radius in meters (default: 10000)",
+    )
+    parser.add_argument(
+        "--width",
+        "-W",
+        type=float,
+        default=12.0,
+        help="Poster width in inches (default: 12.0)",
+    )
+    parser.add_argument(
+        "--height",
+        "-H",
+        type=float,
+        default=16.0,
+        help="Poster height in inches (default: 16.0)",
+    )
+    parser.add_argument(
+        "--no-crop",
+        action="store_true",
+        help="Do not crop the image to the data extent (keeps background)",
+    )
+    parser.add_argument(
+        "--list-themes", action="store_true", help="List all available themes"
+    )
+    parser.add_argument(
+        "--format",
+        "-f",
+        default="png",
+        choices=["png", "svg", "pdf"],
+        help="Output format for the poster (default: png)",
+    )
+
+    args = parser.parse_args()
+
+    # If no arguments provided, show examples
+    if len(os.sys.argv) == 1:
+        print_examples()
+        os.sys.exit(0)
+
+    # List themes if requested
+    if args.list_themes:
+        list_themes()
+        os.sys.exit(0)
+
+    # Validate required arguments
+    if not args.city or not args.country:
+        print("Error: --city and --country are required.\n")
+        print_examples()
+        os.sys.exit(1)
+
+    # Validate theme exists
+    available_themes = get_available_themes()
+    if args.theme not in available_themes:
+        print(f"Error: Theme '{args.theme}' not found.")
+        print(f"Available themes: {', '.join(available_themes)}")
+        os.sys.exit(1)
+
+    print("=" * 50)
+    print("City Map Poster Generator")
+    print("=" * 50)
+
+    # Load theme
+    THEME = load_theme(args.theme)
+
+    # Get coordinates and generate poster
+    try:
+        coords = get_coordinates(args.city, args.country)
+        output_file = generate_output_filename(args.city, args.theme, args.format)
+
+        # Iterate over the generator to execute it
+        for status in create_poster(
+            args.city,
+            args.country,
+            coords,
+            args.distance,
+            output_file,
+            args.format,
+            width=args.width,
+            height=args.height,
+            no_crop=args.no_crop,
+        ):
+            # We already print inside the function, but we act as a consumer here
+            pass
+
+        print("\n" + "=" * 50)
+        print("✓ Poster generation complete!")
+        print("=" * 50)
+
+    except Exception as e:
+        print(f"\n✗ Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        os.sys.exit(1)

fonts/HYWenRunSongYunU.ttf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c0d3409418059e092ddb5e8d71139c76025fd3017d07d4a7440474e9e8477437
+size 49883792

pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "maptoposter"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "IsaacHuo", email = "“2210286979@qq.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "certifi==2026.1.4",
+    "charset-normalizer==3.4.4",
+    "contourpy==1.3.3",
+    "cycler==0.12.1",
+    "fonttools==4.61.1",
+    "geographiclib==2.1",
+    "geopandas==1.1.2",
+    "geopy==2.4.1",
+    "idna==3.11",
+    "kiwisolver==1.4.9",
+    "matplotlib==3.10.8",
+    "networkx==3.6.1",
+    "numpy==2.4.0",
+    "osmnx==2.0.7",
+    "packaging==25.0",
+    "pandas==2.3.3",
+    "pillow==12.1.0",
+    "pyogrio==0.12.1",
+    "pyparsing==3.3.1",
+    "pyproj==3.7.2",
+    "python-dateutil==2.9.0.post0",
+    "pytz==2025.2",
+    "requests==2.32.5",
+    "scipy==1.16.3",
+    "shapely==2.1.2",
+    "six==1.17.0",
+    "tqdm==4.67.1",
+    "tzdata==2025.3",
+    "urllib3==2.6.3",
+    "gradio>=4.0.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.9.24,<0.10.0"]
+build-backend = "uv_build"

requirements.txt

@@ -0,0 +1,29 @@
+certifi==2026.1.4
+charset-normalizer==3.4.4
+contourpy==1.3.3
+cycler==0.12.1
+fonttools==4.61.1
+geographiclib==2.1
+geopandas==1.1.2
+geopy==2.4.1
+idna==3.11
+kiwisolver==1.4.9
+matplotlib==3.10.8
+networkx==3.6.1
+numpy==2.4.0
+osmnx==2.0.7
+packaging==25.0
+pandas==2.3.3
+pillow==12.1.0
+pyogrio==0.12.1
+pyparsing==3.3.1
+pyproj==3.7.2
+python-dateutil==2.9.0.post0
+pytz==2025.2
+requests==2.32.5
+scipy==1.16.3
+shapely==2.1.2
+six==1.17.0
+tqdm==4.67.1
+tzdata==2025.3
+urllib3==2.6.3

restart.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Port to check
+PORT=7860
+
+echo "Checking for processes on port $PORT..."
+
+# Find and kill processes using the port
+PIDS=$(lsof -t -i:$PORT)
+
+if [ -n "$PIDS" ]; then
+    echo "Killing processes on port $PORT: $PIDS"
+    kill -9 $PIDS
+    sleep 1
+else
+    echo "No processes found on port $PORT."
+fi
+
+# Path to python in venv
+VENV_PYTHON="./.venv/bin/python"
+
+if [ -f "$VENV_PYTHON" ]; then
+    echo "Starting application with virtual environment..."
+    $VENV_PYTHON app.py
+else
+    echo "Virtual environment not found, trying system python..."
+    python3 app.py
+fi

src/maptoposter/__init__.py

@@ -0,0 +1,2 @@
+def hello() -> str:
+    return "Hello from maptoposter!"

themes/autumn.json

@@ -0,0 +1,15 @@
+{
+  "name": "Autumn",
+  "description": "Burnt oranges, deep reds, golden yellows - seasonal warmth",
+  "bg": "#FBF7F0",
+  "text": "#8B4513",
+  "gradient_color": "#FBF7F0",
+  "water": "#D8CFC0",
+  "parks": "#E8E0D0",
+  "road_motorway": "#701A00",
+  "road_primary": "#8B2500",
+  "road_secondary": "#B8450A",
+  "road_tertiary": "#CC7A30",
+  "road_residential": "#C9A050",
+  "road_default": "#B8450A"
+}

themes/blueprint.json

@@ -0,0 +1,15 @@
+{
+  "name": "Blueprint",
+  "description": "Classic architectural blueprint - technical drawing aesthetic",
+  "bg": "#1A3A5C",
+  "text": "#E8F4FF",
+  "gradient_color": "#1A3A5C",
+  "water": "#0F2840",
+  "parks": "#1E4570",
+  "road_motorway": "#E8F4FF",
+  "road_primary": "#C5DCF0",
+  "road_secondary": "#9FC5E8",
+  "road_tertiary": "#7BAED4",
+  "road_residential": "#5A96C0",
+  "road_default": "#7BAED4"
+}

themes/contrast_zones.json

@@ -0,0 +1,15 @@
+{
+  "name": "Contrast Zones",
+  "description": "Strong contrast showing urban density - darker in center, lighter at edges",
+  "bg": "#FFFFFF",
+  "text": "#000000",
+  "gradient_color": "#FFFFFF",
+  "water": "#B0B0B0",
+  "parks": "#ECECEC",
+  "road_motorway": "#000000",
+  "road_primary": "#0F0F0F",
+  "road_secondary": "#252525",
+  "road_tertiary": "#404040",
+  "road_residential": "#5A5A5A",
+  "road_default": "#404040"
+}

themes/copper_patina.json

@@ -0,0 +1,15 @@
+{
+  "name": "Copper Patina",
+  "description": "Oxidized copper aesthetic - teal-green patina with copper accents",
+  "bg": "#E8F0F0",
+  "text": "#2A5A5A",
+  "gradient_color": "#E8F0F0",
+  "water": "#C0D8D8",
+  "parks": "#D8E8E0",
+  "road_motorway": "#B87333",
+  "road_primary": "#5A8A8A",
+  "road_secondary": "#6B9E9E",
+  "road_tertiary": "#88B4B4",
+  "road_residential": "#A8CCCC",
+  "road_default": "#88B4B4"
+}

themes/feature_based.json

@@ -0,0 +1,15 @@
+{
+  "name": "Feature-Based Shading",
+  "description": "Different shades for different road types and features with clear hierarchy",
+  "bg": "#FFFFFF",
+  "text": "#000000",
+  "gradient_color": "#FFFFFF",
+  "water": "#C0C0C0",
+  "parks": "#F0F0F0",
+  "road_motorway": "#0A0A0A",
+  "road_primary": "#1A1A1A",
+  "road_secondary": "#2A2A2A",
+  "road_tertiary": "#3A3A3A",
+  "road_residential": "#4A4A4A",
+  "road_default": "#3A3A3A"
+}

themes/forest.json

@@ -0,0 +1,15 @@
+{
+  "name": "Forest",
+  "description": "Deep greens and sage tones - organic botanical aesthetic",
+  "bg": "#F0F4F0",
+  "text": "#2D4A3E",
+  "gradient_color": "#F0F4F0",
+  "water": "#B8D4D4",
+  "parks": "#D4E8D4",
+  "road_motorway": "#2D4A3E",
+  "road_primary": "#3D6B55",
+  "road_secondary": "#5A8A70",
+  "road_tertiary": "#7AAA90",
+  "road_residential": "#A0C8B0",
+  "road_default": "#7AAA90"
+}

themes/gradient_roads.json

@@ -0,0 +1,15 @@
+{
+  "name": "Gradient Roads",
+  "description": "Smooth gradient from dark center to light edges with subtle features",
+  "bg": "#FFFFFF",
+  "text": "#000000",
+  "gradient_color": "#FFFFFF",
+  "water": "#D5D5D5",
+  "parks": "#EFEFEF",
+  "road_motorway": "#050505",
+  "road_primary": "#151515",
+  "road_secondary": "#2A2A2A",
+  "road_tertiary": "#404040",
+  "road_residential": "#555555",
+  "road_default": "#404040"
+}

themes/japanese_ink.json

@@ -0,0 +1,15 @@
+{
+  "name": "Japanese Ink",
+  "description": "Traditional ink wash inspired - minimalist with subtle red accent",
+  "bg": "#FAF8F5",
+  "text": "#2C2C2C",
+  "gradient_color": "#FAF8F5",
+  "water": "#E8E4E0",
+  "parks": "#F0EDE8",
+  "road_motorway": "#701A00",
+  "road_primary": "#1A1A1A",
+  "road_secondary": "#333333",
+  "road_tertiary": "#4D4D4D",
+  "road_residential": "#666666",
+  "road_default": "#4D4D4D"
+}

themes/midnight_blue.json

@@ -0,0 +1,15 @@
+{
+  "name": "Midnight Blue",
+  "description": "Deep navy background with gold/copper roads - luxury atlas aesthetic",
+  "bg": "#0A1628",
+  "text": "#D4AF37",
+  "gradient_color": "#0A1628",
+  "water": "#061020",
+  "parks": "#0F2235",
+  "road_motorway": "#D4AF37",
+  "road_primary": "#C9A227",
+  "road_secondary": "#A8893A",
+  "road_tertiary": "#8B7355",
+  "road_residential": "#6B5B4F",
+  "road_default": "#8B7355"
+}

themes/monochrome_blue.json

@@ -0,0 +1,15 @@
+{
+  "name": "Monochrome Blue",
+  "description": "Single blue color family with varying saturation - clean and cohesive",
+  "bg": "#F5F8FA",
+  "text": "#1A3A5C",
+  "gradient_color": "#F5F8FA",
+  "water": "#D0E0F0",
+  "parks": "#E0EAF2",
+  "road_motorway": "#1A3A5C",
+  "road_primary": "#2A5580",
+  "road_secondary": "#4A7AA8",
+  "road_tertiary": "#7AA0C8",
+  "road_residential": "#A8C4E0",
+  "road_default": "#4A7AA8"
+}

themes/neon_cyberpunk.json

@@ -0,0 +1,15 @@
+{
+  "name": "Neon Cyberpunk",
+  "description": "Dark background with electric pink/cyan - bold night city vibes",
+  "bg": "#0D0D1A",
+  "text": "#00FFFF",
+  "gradient_color": "#0D0D1A",
+  "water": "#0A0A15",
+  "parks": "#151525",
+  "road_motorway": "#FF00FF",
+  "road_primary": "#00FFFF",
+  "road_secondary": "#00C8C8",
+  "road_tertiary": "#0098A0",
+  "road_residential": "#006870",
+  "road_default": "#0098A0"
+}

themes/noir.json

@@ -0,0 +1,15 @@
+{
+  "name": "Noir",
+  "description": "Pure black background with white/gray roads - modern gallery aesthetic",
+  "bg": "#000000",
+  "text": "#FFFFFF",
+  "gradient_color": "#000000",
+  "water": "#0A0A0A",
+  "parks": "#111111",
+  "road_motorway": "#FFFFFF",
+  "road_primary": "#E0E0E0",
+  "road_secondary": "#B0B0B0",
+  "road_tertiary": "#808080",
+  "road_residential": "#505050",
+  "road_default": "#808080"
+}

themes/ocean.json

@@ -0,0 +1,15 @@
+{
+  "name": "Ocean",
+  "description": "Various blues and teals - perfect for coastal cities",
+  "bg": "#F0F8FA",
+  "text": "#1A5F7A",
+  "gradient_color": "#F0F8FA",
+  "water": "#B8D8E8",
+  "parks": "#D8EAE8",
+  "road_motorway": "#1A5F7A",
+  "road_primary": "#2A7A9A",
+  "road_secondary": "#4A9AB8",
+  "road_tertiary": "#70B8D0",
+  "road_residential": "#A0D0E0",
+  "road_default": "#4A9AB8"
+}

themes/pastel_dream.json

@@ -0,0 +1,15 @@
+{
+  "name": "Pastel Dream",
+  "description": "Soft muted pastels with dusty blues and mauves - dreamy artistic aesthetic",
+  "bg": "#FAF7F2",
+  "text": "#5D5A6D",
+  "gradient_color": "#FAF7F2",
+  "water": "#D4E4ED",
+  "parks": "#E8EDE4",
+  "road_motorway": "#7B8794",
+  "road_primary": "#9BA4B0",
+  "road_secondary": "#B5AEBB",
+  "road_tertiary": "#C9C0C9",
+  "road_residential": "#D8D2D8",
+  "road_default": "#C9C0C9"
+}

themes/sunset.json

@@ -0,0 +1,15 @@
+{
+  "name": "Sunset",
+  "description": "Warm oranges and pinks on soft peach - dreamy golden hour aesthetic",
+  "bg": "#FDF5F0",
+  "text": "#C45C3E",
+  "gradient_color": "#FDF5F0",
+  "water": "#F0D8D0",
+  "parks": "#F8E8E0",
+  "road_motorway": "#C45C3E",
+  "road_primary": "#D87A5A",
+  "road_secondary": "#E8A088",
+  "road_tertiary": "#F0B8A8",
+  "road_residential": "#F5D0C8",
+  "road_default": "#E8A088"
+}

themes/terracotta.json

@@ -0,0 +1,15 @@
+{
+  "name": "Terracotta",
+  "description": "Mediterranean warmth - burnt orange and clay tones on cream",
+  "bg": "#F5EDE4",
+  "text": "#8B4513",
+  "gradient_color": "#F5EDE4",
+  "water": "#A8C4C4",
+  "parks": "#E8E0D0",
+  "road_motorway": "#8B3E2F",
+  "road_primary": "#A0522D",
+  "road_secondary": "#B8653A",
+  "road_tertiary": "#C9846A",
+  "road_residential": "#B59A8B",
+  "road_default": "#C9846A"
+}

themes/warm_beige.json

@@ -0,0 +1,15 @@
+{
+  "name": "Warm Beige",
+  "description": "Earthy warm neutrals with sepia tones - vintage map aesthetic",
+  "bg": "#F5F0E8",
+  "text": "#6B5B4F",
+  "gradient_color": "#F5F0E8",
+  "water": "#DDD5C8",
+  "parks": "#E8E4D8",
+  "road_motorway": "#8B7355",
+  "road_primary": "#A08B70",
+  "road_secondary": "#B5A48E",
+  "road_tertiary": "#C9BBAA",
+  "road_residential": "#D9CFC2",
+  "road_default": "#C9BBAA"
+}