QGIS完成初步重构

.gitignore

@@ -55,3 +55,7 @@ htmlcov/
 # Ignore dynaconf secret files
 .secrets.*
 /test/
+
+# QGIS 临时模板文件
+app/data/template/*/tmp*.qgz
+tmp*.qgz

app/api/qgis_map_export.py

@@ -17,6 +17,7 @@ from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel, Field
 
 from app.config.paths import get_logger
+from app.config.qgis_mappings import build_static_layers_config, get_gpkg_dir
 from app.repositories import qgis_repository
 from app.schemas.api_schemas import QgisMapExportResponse, QgisMapExportRequest
 from app.utils.api_deps import get_prediction_semaphore
@@ -100,44 +101,77 @@ def _build_map_title(event_type: str, condition: dict, template_name: str) -> st
     return f"{prefix}{template_name}"
 
 
+def _build_info_text(event_type: str, condition: dict, occurred_time) -> str:
+    """
+    构建信息面板文本（左上角橙色矩形区域）。
+
+    暴雨：时间 + 累计降雨量（如有）+ 已持续（如有）
+    地震：时间 + 震级（如有）+ 位置（如有）
+    不显示灾害类型标签（暴雨/地震）。
+    """
+    lines = []
+
+    # 时间
+    if isinstance(occurred_time, datetime):
+        time_str = f"{occurred_time.year}年{occurred_time.month:02d}月{occurred_time.day:02d}日{occurred_time.hour:02d}时{occurred_time.minute:02d}分"
+    elif occurred_time:
+        time_str = str(occurred_time)
+    else:
+        time_str = datetime.now().strftime("%Y年%m月%d日%H时%M分")
+    lines.append(f"时间：{time_str}")
+
+    if event_type == "rainfall":
+        rainfall = condition.get("rainfall")
+        if rainfall is not None and rainfall != "":
+            lines.append(f"累计降雨量：{float(rainfall)}mm")
+
+        duration = condition.get("duration")
+        if duration is not None and duration != "":
+            lines.append(f"已持续：{duration}")
+
+    elif event_type == "earthquake":
+        magnitude = condition.get("magnitude")
+        if magnitude is not None and magnitude != "":
+            lines.append(f"震级：{float(magnitude)}级")
+
+        lon = condition.get("epicenter_lon")
+        lat = condition.get("epicenter_lat")
+        if lon is not None and lat is not None:
+            lines.append(f"位置：经度{float(lon)}°, 纬度{float(lat)}°")
+
+    return "\n".join(lines)
+
+
 def _derive_model_params(
-    inference: dict, batch_folder: str, out_filename: str
+    inference: dict, batch_folder: str, template_path: str
 ) -> dict:
-    """从推理结果 + 配置文件推导专题图生成所需的全部参数。"""
+    """从推理结果 + 模板路径推导专题图生成所需的全部参数。"""
     event_type = inference["event_type"]
     condition = inference["condition"]
     occurred_time = inference["occurred_time"]
 
+    map_unit = getattr(settings, "QGIS_DEFAULTS_MAP_UNIT", "西安市应急管理局")
+
     map_layout = getattr(settings, "QGIS_DEFAULTS_MAP_LAYOUT", "A3")
     zoom_rule = getattr(settings, "QGIS_DEFAULTS_ZOOM_RULE", "11")
     zoom_value = getattr(settings, "QGIS_DEFAULTS_ZOOM_VALUE", "50")
-    map_unit = getattr(settings, "QGIS_DEFAULTS_MAP_UNIT", "西安市应急管理局")
-    template_base = os.path.join(
-        os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
-        "app", "data", "template"
-    )
-
-    template_path = os.path.join(template_base, event_type, f"{map_layout}.qgz")
-
-    template_name_map = {"earthquake": "地震专题图", "rainfall": "降雨专题图"}
-    template_name = template_name_map.get(event_type, f"{event_type}专题图")
 
+    # 从模板文件名推导标题和输出文件名（去掉 .qgz 后缀）
+    template_name = os.path.splitext(os.path.basename(template_path))[0]
     map_title = _build_map_title(event_type, condition, template_name)
 
     safe_name = re.sub(r'[\\/:*?"<>|]', '_', template_name)
     out_file = os.path.join(batch_folder, f"{safe_name}.jpg").replace("\\", "/")
 
-    if occurred_time and isinstance(occurred_time, datetime):
+    # 制图时间统一用当前日期
-        map_time = occurred_time.strftime("%Y-%m-%d %H:%M")
+    map_time = datetime.now().strftime("%Y-%m-%d")
-    elif occurred_time:
-        map_time = str(occurred_time)
-    else:
-        map_time = datetime.now().strftime("%Y-%m-%d %H:%M")
 
     center_x, center_y = _extract_center_from_condition(
         event_type, condition
     )
 
+    info_text = _build_info_text(event_type, condition, occurred_time)
+
     return {
         "name": f"inference_{inference['id']}",
         "path": template_path,
@@ -146,7 +180,7 @@ def _derive_model_params(
         "mapTitle": map_title,
         "mapTime": map_time,
         "mapUint": map_unit,
-        "info": "",
+        "info": info_text,
         "centerX": center_x,
         "centerY": center_y,
         "event": str(inference["id"]),
@@ -172,11 +206,7 @@ def _extract_center_from_condition(event_type: str, condition: dict) -> tuple:
 
 def _build_qgis_config(batch_folder: str) -> dict:
     """构建 QGIS 服务配置（含批次输出目录）"""
-    gpkg_subdir = getattr(settings, "QGIS_GPKG_DIR", "app/data/gpkg")
+    gpkg_dir = get_gpkg_dir()
-    project_root = os.path.dirname(
-        os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    )
-    gpkg_dir = os.path.join(project_root, gpkg_subdir).replace("\\", "/")
 
     return {
         "db": {
@@ -202,41 +232,15 @@ def _build_qgis_config(batch_folder: str) -> dict:
                 "port": getattr(settings, "QGIS_TEMPLATE_OVERRIDE_ACTUAL_PORT", ""),
                 "dbname": getattr(settings, "QGIS_TEMPLATE_OVERRIDE_ACTUAL_DB_NAME", "xian_new"),
                 "schema": getattr(settings, "QGIS_TEMPLATE_OVERRIDE_ACTUAL_SCHEMA", "qgis"),
+                "username": getattr(settings, "DB_USER", "postgres"),
+                "password": getattr(settings, "DB_PASSWORD", ""),
             },
         },
-        "static_layers": _build_static_layers_config(gpkg_dir),
+        "static_layers": build_static_layers_config(gpkg_dir),
         "batch_folder": batch_folder,
     }
 
 
-def _build_static_layers_config(gpkg_dir: str) -> dict:
-    """构建静态底图配置"""
-    layer_defs = {
-        "水库":               ("qgis.rivers",                  "rivers.gpkg"),
-        "市州驻地":           ("qgis.sx_capital",              "sx_capital.gpkg"),
-        "河流":               ("qgis.river",                   "river.gpkg"),
-        "active_fault":       ("qgis.active_fault",            "active_fault.gpkg"),
-        "陕西省":             ("qgis.sx",                      "sx.gpkg"),
-        "乡镇驻地":           ("qgis.sx_street",               "sx_street.gpkg"),
-        "区县驻地":           ("qgis.sx_xa_county",            "sx_xa_county.gpkg"),
-        "县界":               ("qgis.sx_xa_county_boundary",   "sx_xa_county_boundary.gpkg"),
-        "周边区县":           ("qgis.sx_zb_county_boundary",   "sx_zb_county_boundary.gpkg"),
-        "周边市州":           ("qgis.sx_zb_city",              "sx_zb_city.gpkg"),
-        "周边县区":           ("qgis.sx_zb_county",            "sx_zb_county.gpkg"),
-        "traffic_expressway": ("qgis.traffic_expressway",      "traffic_expressway.gpkg"),
-        "traffic_provincial": ("qgis.traffic_provincial",      "traffic_provincial.gpkg"),
-        "traffic_railway":    ("qgis.traffic_railway",         "traffic_railway.gpkg"),
-        "traffic_township":   ("qgis.traffic_township",        "traffic_township.gpkg"),
-        "traffic_trunk_line": ("qgis.traffic_trunk_line",      "traffic_trunk_line.gpkg"),
-    }
-
-    layers = {}
-    for name, (table, gpkg_file) in layer_defs.items():
-        layers[name] = {"file": gpkg_file, "table": table}
-
-    return {"enabled": True, "gpkg_dir": gpkg_dir, "layers": layers}
-
-
 # ============================================================
 # 接口实现
 # ============================================================
@@ -246,29 +250,30 @@ async def export_map(req: QgisMapExportRequest):
     """
     根据模拟ID批量导出专题图。同一 occurred_time 视为同一场灾害，共享文件夹
     """
-    from app.services.qgis.qgis_env import is_qgis_ready
+    from app.services.qgis.qgis_env import is_qgis_available
-    if not is_qgis_ready():
+    if not is_qgis_available():
-        raise HTTPException(status_code=503, detail="QGIS 环境未初始化，专题图功能不可用")
+        raise HTTPException(status_code=503, detail="QGIS 环境不可用（未找到 QGIS Python 3.12 解释器）")
 
     semaphore = get_prediction_semaphore()
 
     async with semaphore:
-        simulation_id = req.simulationId
+        inference_id = req.inferenceId
         loop = asyncio.get_event_loop()
 
         try:
             # 查询推理记录，获取 occurred_time
             inference = await loop.run_in_executor(
-                None, qgis_repository.query_inference_result, simulation_id
+                None, qgis_repository.query_inference_result, inference_id
             )
 
             # 将 occurred_time 格式化为时间戳作为文件夹名
             disaster_time = format_disaster_time(inference["occurred_time"])
+            event_type = inference["event_type"]
 
             # 构建批次文件夹路径
             file_store = getattr(settings, "FILE_STORE_DIR", "G:/files")
-            output_tmpl = getattr(settings, "QGIS_OUTPUT_DIR", "xian/qgis/map/:disasterTime")
+            output_tmpl = getattr(settings, "QGIS_OUTPUT_DIR", "xian/qgis/map/:eventType/:disasterTime")
-            output_dir = output_tmpl.replace(":disasterTime", disaster_time)
+            output_dir = output_tmpl.replace(":eventType", event_type).replace(":disasterTime", disaster_time)
             batch_folder = os.path.join(file_store, output_dir).replace("\\", "/")
 
             # 去重检查：同一 disasterTime 只产图一次
@@ -318,29 +323,41 @@ async def export_map(req: QgisMapExportRequest):
                 # 推导参数 + 构建配置
                 os.makedirs(batch_folder, exist_ok=True)
 
-                event_type = inference["event_type"]
-                template_name_map = {"earthquake": "地震专题图", "rainfall": "降雨专题图"}
-                template_name = template_name_map.get(event_type, f"{event_type}专题图")
-                out_filename = f"{template_name}.jpg"
-
-                model = _derive_model_params(inference, batch_folder, out_filename)
                 config = _build_qgis_config(batch_folder)
 
+                # 扫描模板文件夹下所有 .qgz 文件
+                template_base = os.path.join(
+                    os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+                    "app", "data", "template"
+                )
+                template_dir = os.path.join(template_base, event_type)
+                template_files = sorted([
+                    f for f in os.listdir(template_dir)
+                    if f.endswith(".qgz") and not f.startswith("tmp")
+                ])
+
+                if not template_files:
+                    raise FileNotFoundError(f"模板文件夹为空: {template_dir}")
+
+                # 构建所有模型参数（批量模式）
+                models = []
+                for tpl_file in template_files:
+                    tpl_path = os.path.join(template_dir, tpl_file).replace("\\", "/")
+                    model = _derive_model_params(inference, batch_folder, tpl_path)
                     logger.info(
-                    f"模板路径: {model['path']}, "
+                        f"模板: {tpl_path}, "
                         f"输出: {model['outFile']}, "
                         f"标题: {model['mapTitle']}, "
                         f"中心: ({model['centerX']}, {model['centerY']})"
                     )
+                    models.append(model)
 
-                # 提交到线程池
+                # 一次性提交所有模型到 QGIS 子进程（单次 DLL 加载）
-                _thread_pool.submit(
+                _generate_batch_maps(models, config, disaster_time)
-                    _generate_single_map, model, config, disaster_time
-                )
 
                 return QgisMapExportResponse(
                     code=200,
-                    message="任务已提交",
+                    message=f"任务已完成，共{len(models)}张专题图",
                     data=disaster_time,
                 )
 
@@ -357,22 +374,85 @@ async def export_map(req: QgisMapExportRequest):
             pass
 
 
-def _generate_single_map(model: dict, config: dict, disaster_time: str) -> None:
+def _generate_batch_maps(models: list, config: dict, disaster_time: str) -> None:
-    """线程池工作函数：在工作线程中生成单张专题图"""
+    """通过 QGIS Python 3.12 子进程批量生成专题图（单次 DLL 加载）"""
-    from app.services.qgis.map_service import MapService
+    import json
+    import subprocess
+    import tempfile
+    from app.services.qgis.qgis_env import build_qgis_command
 
     try:
-        logger.info(f"[线程池] 开始产图: {model['mapTitle']} → {model['outFile']}")
+        logger.info(f"[批量产图] 开始: {len(models)} 张专题图, batch={disaster_time}")
-        service = MapService(config)
-        service.generate(model)
 
-        if os.path.exists(model["outFile"]):
+        # 构建子进程请求 JSON —— 批量格式
-            logger.info(f"[线程池] 产图成功: {model['outFile']}")
+        request_data = json.dumps(
+            {"config": config, "models": models},
+            ensure_ascii=False,
+        )
+
+        # 将请求 JSON 写入临时文件（避免 stdin 管道问题）
+        tmp_json = tempfile.NamedTemporaryFile(
+            suffix=".json", delete=False, mode="w", encoding="utf-8"
+        )
+        tmp_json.write(request_data)
+        tmp_json.close()
+
+        try:
+            from config import settings
+            qgis_root = getattr(settings, "QGIS_ROOT", "D:/QGIS")
+            cmd = build_qgis_command(qgis_root)
+            cmd.append(tmp_json.name)
+
+            logger.info(f"[批量产图] 启动 QGIS 子进程: {' '.join(cmd[:3])}...")
+
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                timeout=300,  # 5 分钟超时（批量处理多个模板）
+            )
+        finally:
+            try:
+                os.remove(tmp_json.name)
+            except OSError:
+                pass
+
+        if result.returncode != 0:
+            stderr_text = result.stderr.decode("utf-8", errors="replace").strip()
+            logger.error(f"[批量产图] QGIS 子进程失败 (exit={result.returncode}):")
+            for line in stderr_text.split("\n"):
+                logger.error(f"  {line}")
+            raise RuntimeError(
+                f"QGIS 子进程失败: {stderr_text[:300]}"
+            )
+
+        # 解析子进程输出
+        stdout_text = result.stdout.decode("utf-8", errors="replace").strip()
+        if stdout_text:
+            for line in reversed(stdout_text.split("\n")):
+                line = line.strip()
+                if line.startswith("{"):
+                    output = json.loads(line)
+                    batch_results = output.get("results", [])
+                    success_count = sum(1 for r in batch_results if r.get("success"))
+                    fail_count = len(batch_results) - success_count
+                    logger.info(
+                        f"[批量产图] 完成: 成功={success_count}, 失败={fail_count}"
+                    )
+                    for r in batch_results:
+                        if r.get("success"):
+                            logger.info(f"  ✓ {r.get('output', 'N/A')}")
                         else:
-            logger.error(f"[线程池] 产图后文件不存在: {model['outFile']}")
+                            logger.error(f"  ✗ {r.get('error', 'unknown')}")
+                    break
+            else:
+                logger.warning("[批量产图] 子进程输出中未找到 JSON 结果")
+        else:
+            logger.warning("[批量产图] 子进程无输出，但 exit code = 0")
 
+    except subprocess.TimeoutExpired:
+        logger.error(f"[批量产图] QGIS 子进程超时 (300s)")
     except Exception as e:
-        logger.error(f"[线程池] 产图失败: {model['name']} — {e}", exc_info=True)
+        logger.error(f"[批量产图] 产图失败: {e}", exc_info=True)
 
 
 # ============================================================

app/config/qgis_mappings.py

@@ -0,0 +1,108 @@
+"""
+QGIS 图层映射配置。
+
+所有模板→目标库的表名/图层映射集中管理，避免散落在业务代码中。
+"""
+from pathlib import Path
+import os
+
+# ============================================================
+# 静态底图映射：模板中 PostgreSQL 图层 → 本地 GPKG 文件
+# key: 模板图层名（用于匹配 maplayer/layername）
+# table: 原始数据源表名（schema.table 格式，用于匹配 datasource 替换）
+# gpkg: 本地 GPKG 文件名（相对于 GPKG 目录）
+# ============================================================
+STATIC_LAYERS = {
+    "水库":               {"table": "base.rivers",                     "gpkg": "rivers.gpkg"},
+    "市州驻地":           {"table": "base.sx_capital",                 "gpkg": "sx_capital.gpkg"},
+    "河流":               {"table": "base.river",                      "gpkg": "river.gpkg"},
+    "active_fault":       {"table": "base.active_fault",               "gpkg": "active_fault.gpkg"},
+    "陕西省":             {"table": "base.sx",                         "gpkg": "sx.gpkg"},
+    "乡镇驻地":           {"table": "base.sx_street",                  "gpkg": "sx_street.gpkg"},
+    "区县驻地":           {"table": "base.sx_xa_county",               "gpkg": "sx_xa_county.gpkg"},
+    "县界":               {"table": "base.sx_xa_county_boundary",      "gpkg": "sx_xa_county_boundary.gpkg"},
+    "周边区县":           {"table": "base.sx_zb_county_boundary",      "gpkg": "sx_zb_county_boundary.gpkg"},
+    "周边市州":           {"table": "base.sx_zb_city",                 "gpkg": "sx_zb_city.gpkg"},
+    "周边县区":           {"table": "base.sx_zb_county",               "gpkg": "sx_zb_county.gpkg"},
+    "traffic_expressway": {"table": "base.traffic_expressway",         "gpkg": "traffic_expressway.gpkg"},
+    "traffic_provincial": {"table": "base.traffic_provincial",         "gpkg": "traffic_provincial.gpkg"},
+    "traffic_railway":    {"table": "base.traffic_railway",            "gpkg": "traffic_railway.gpkg"},
+    "traffic_township":   {"table": "base.traffic_township",           "gpkg": "traffic_township.gpkg"},
+    "traffic_trunk_line": {"table": "base.traffic_trunk_line",         "gpkg": "traffic_trunk_line.gpkg"},
+}
+
+# ============================================================
+# OGR 本地图层 → PostgreSQL 转换
+# 设计师用本地 JSON/shp 文件制作模板，数据已迁移到 qgis schema
+# key: layername（模板 datasource 中 |layername=xxx 的值）
+# value: qgis schema 中的目标表名
+# ============================================================
+OGR_TO_POSTGRES = {
+    "公园":   "shelter_park",
+    "学校":   "shelter_school",
+    "文化馆": "shelter_cultural",
+    "人防设施": "shelter_defence",
+    "体育馆": "shelter_gymnasium",
+    "广场":   "shelter_square",
+    "住宿":   "shelter_stay",
+}
+
+# ============================================================
+# 表名映射：模板中引用的表名 → 目标库中实际表名
+# （模板由多个源库的表拼合，迁移后表名可能不同）
+# ============================================================
+TABLE_RENAMES = {
+    "hazard_waterlogging": "hazard_hydrops",  # 积水点
+}
+
+# ============================================================
+# Schema 替换：模板源 schema → 目标 schema
+# ============================================================
+SCHEMA_REPLACEMENTS = ["base", "kspg", "dzxx"]
+
+# ============================================================
+# 图层过滤配置（layer_filter.py 使用）
+# ============================================================
+EVENT_LAYERS = ["eqcenter", "震中"]  # 按 event 字段过滤
+QUEUE_LAYERS = [
+    "intensity", "intensity_mian",
+    "dz_ryss", "dz_jjss", "dz_rysw", "dz_jzph", "dz_xzjl",
+]  # 按 eqqueue_id 字段过滤
+
+# ============================================================
+# GPKG 目录路径（项目根目录相对路径）
+# ============================================================
+GPKG_SUBDIR = "app/data/gpkg"
+
+
+def get_gpkg_dir(project_root: str = None) -> str:
+    """获取 GPKG 目录绝对路径"""
+    if project_root is None:
+        project_root = os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+    gpkg_dir = os.path.join(project_root, GPKG_SUBDIR)
+    return os.path.normpath(gpkg_dir).replace("\\", "/")
+
+
+def build_static_layers_config(gpkg_dir: str = None) -> dict:
+    """
+    构建 template_modifier / qgis_runner 使用的静态底图配置。
+
+    返回格式与原有 template_override 的 static_layers 段兼容。
+    """
+    if gpkg_dir is None:
+        gpkg_dir = get_gpkg_dir()
+
+    layers = {}
+    for name, info in STATIC_LAYERS.items():
+        layers[name] = {
+            "file": info["gpkg"],
+            "table": info["table"],
+        }
+
+    return {
+        "enabled": True,
+        "gpkg_dir": gpkg_dir,
+        "layers": layers,
+    }

app/core/dependency_manager.py

@@ -78,13 +78,13 @@ def check_dependencies(project_root: Path):
                 ],
                 check=True
             )
-            print("✓ 依赖安装完成（虚拟环境）")
+            print("[OK] 依赖安装完成（虚拟环境）")
         else:
-            print("✓ 所有依赖已安装（虚拟环境）")
+            print("[OK] 所有依赖已安装（虚拟环境）")
 
     except subprocess.CalledProcessError as e:
-        print(f"✗ 依赖检查/安装失败: {e}")
+        print(f"[FAIL] 依赖检查/安装失败: {e}")
         sys.exit(1)
     except Exception as e:
-        print(f"✗ 依赖检查出错: {e}")
+        print(f"[FAIL] 依赖检查出错: {e}")
         sys.exit(1)

app/core/env_checker.py

@@ -32,7 +32,7 @@ def check_environment():
     if major == 3 and minor == 10:
         return True
     else:
-        print(f"✗ Python版本不符合要求！")
+        print(f"[FAIL] Python版本不符合要求！")
         print(f"  当前版本: {python_version}")
         print(f"  要求版本: 3.10.x")
         print(f"\n请使用 Python 3.10 版本运行此项目")

app/core/launcher.py

@@ -70,7 +70,7 @@ class AppLauncher:
 
             # 启动应用
             print("\n" + "=" * 50)
-            print("✓ 所有检查通过，准备启动应用...")
+            print("[OK] 所有检查通过，准备启动应用...")
             print("=" * 50)
             # 延迟导入logger
             from app.utils.logger import get_logger
@@ -79,7 +79,10 @@ class AppLauncher:
             start()
 
         except Exception as e:
+            if self.logger:
                 self.logger.error(f"启动失败: {e}")
+            else:
+                print(f"[FAIL] 启动失败: {e}")
             sys.exit(1)
 
 

app/core/server.py

@@ -22,24 +22,24 @@ async def lifespan(app: FastAPI):
     get_earthquake_model()
     logger.info("DBN模型预加载完成")
 
-    # 初始化 QGIS 环境
+    # 检测 QGIS 子进程环境
     qgis_root = getattr(settings, "QGIS_ROOT", None)
     if qgis_root:
         try:
-            from app.services.qgis.qgis_env import init_qgis_env
+            from app.services.qgis.qgis_env import is_qgis_available
-            init_qgis_env(qgis_root)
+            if is_qgis_available(qgis_root):
-            logger.info("QGIS 环境初始化完成")
+                logger.info("QGIS 环境检测通过（子进程模式）")
+            else:
+                logger.warning("QGIS 环境不可用（未找到 Python 3.12 解释器），专题图功能降级")
         except Exception as e:
-            logger.error(f"QGIS 环境初始化失败（专题图功能不可用）: {e}")
+            logger.error(f"QGIS 环境检测失败: {e}")
 
     yield
 
-    # 清理 QGIS 资源
+    # 清理资源
     try:
-        from app.services.qgis.qgis_env import cleanup_qgis_env
+        from app.api.qgis_map_export import shutdown_thread_pool
-        from app.services.qgis.map_service import template_cache
+        shutdown_thread_pool()
-        template_cache.cleanup()
-        cleanup_qgis_env()
     except Exception:
         pass
 

app/core/venv_manager.py

@@ -31,14 +31,14 @@ def check_virtualenv(project_root: Path) -> bool:
         python_exe = venv_path / "bin" / "python3"
     
     if not venv_path.exists():
-        print(f"\n⚠ 虚拟环境不存在，正在创建...")
+        print(f"\n[WARN] 虚拟环境不存在，正在创建...")
         try:
             subprocess.run([sys.executable, "-m", "venv", str(venv_path)], check=True)
-            print("✓ 虚拟环境创建成功")
+            print("[OK] 虚拟环境创建成功")
             return True  # 继续执行后续步骤
         except subprocess.CalledProcessError as e:
-            print(f"✗ 虚拟环境创建失败: {e}")
+            print(f"[FAIL] 虚拟环境创建失败: {e}")
             sys.exit(1)
     else:
-        print(f"✓ 虚拟环境已存在: {venv_path}")
+        print(f"[OK] 虚拟环境已存在: {venv_path}")
         return True

app/repositories/qgis_repository.py

@@ -20,11 +20,11 @@ class QgisRepository:
 
         row = rows[0]
         return {
-            "id": row[0],
+            "id": row["id"],
-            "name": row[1] or "",
+            "name": row["name"] or "",
-            "event_type": row[2] or "",
+            "event_type": row["event_type"] or "",
-            "occurred_time": row[3],
+            "occurred_time": row["occurred_time"],
-            "condition": row[4] if isinstance(row[4], dict) else {},
+            "condition": row["condition"] if isinstance(row["condition"], dict) else {},
         }
 
 

app/script/export_static_layers.py

@@ -1,10 +1,13 @@
 """
 一次性脚本：从 PostgreSQL 导出静态底图为 GeoPackage 文件。
+优先使用 ogr2ogr（QGIS 自带），回退到 geopandas。
+
 运行一次即可，之后服务直接读本地 GPKG。
 
 用法: python -m app.script.export_static_layers
 """
 import os
+import subprocess
 import sys
 import time
 
@@ -13,68 +16,159 @@ project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(_
 if project_root not in sys.path:
     sys.path.insert(0, project_root)
 
+# ============================================================
+# 配置
+# ============================================================
+
+QGIS_ROOT = os.environ.get("QGIS_ROOT", "D:/QGIS")
+ogr2ogr_path = os.path.join(QGIS_ROOT, "bin", "ogr2ogr.exe")
+
+GPKG_DIR = os.path.join(project_root, "app", "data", "gpkg")
+
+# 静态图层定义: {显示名: (schema.table, gpkg文件名)}
+STATIC_LAYERS = [
+    ("水库",               "qgis.rivers",                  "rivers.gpkg"),
+    ("市州驻地",           "qgis.sx_capital",              "sx_capital.gpkg"),
+    ("河流",               "qgis.river",                   "river.gpkg"),
+    ("active_fault",       "qgis.active_fault",            "active_fault.gpkg"),
+    ("陕西省",             "qgis.sx",                      "sx.gpkg"),
+    ("乡镇驻地",           "qgis.sx_street",               "sx_street.gpkg"),
+    ("区县驻地",           "qgis.sx_xa_county",            "sx_xa_county.gpkg"),
+    ("县界",               "qgis.sx_xa_county_boundary",   "sx_xa_county_boundary.gpkg"),
+    ("周边区县",           "qgis.sx_zb_county_boundary",   "sx_zb_county_boundary.gpkg"),
+    ("周边市州",           "qgis.sx_zb_city",              "sx_zb_city.gpkg"),
+    ("周边县区",           "qgis.sx_zb_county",            "sx_zb_county.gpkg"),
+    ("traffic_expressway", "qgis.traffic_expressway",      "traffic_expressway.gpkg"),
+    ("traffic_provincial", "qgis.traffic_provincial",      "traffic_provincial.gpkg"),
+    ("traffic_railway",    "qgis.traffic_railway",         "traffic_railway.gpkg"),
+    ("traffic_township",   "qgis.traffic_township",        "traffic_township.gpkg"),
+    ("traffic_trunk_line", "qgis.traffic_trunk_line",      "traffic_trunk_line.gpkg"),
+]
+
+
+# ============================================================
+# 方法一: ogr2ogr（推荐，QGIS 自带）
+# ============================================================
+
+def _setup_gdal_env():
+    """设置 GDAL/OGR 运行环境"""
+    gdal_data = os.path.join(QGIS_ROOT, "apps", "gdal", "share", "gdal")
+    gdal_lib = os.path.join(QGIS_ROOT, "apps", "gdal", "lib")
+    gdal_bin = os.path.join(QGIS_ROOT, "apps", "gdal", "bin")
+
+    if os.path.isdir(gdal_data):
+        os.environ["GDAL_DATA"] = gdal_data
+    os.environ["GDAL_FILENAME_IS_UTF8"] = "YES"
+
+    paths_to_add = [p for p in [gdal_bin, gdal_lib] if os.path.isdir(p)]
+    os.environ["PATH"] = ";".join(paths_to_add) + ";" + os.environ.get("PATH", "")
+
+
+def _export_with_ogr2ogr(host, port, dbname, user, password, schema, table, gpkg_path):
+    """用 ogr2ogr 导出单个图层"""
+    conn = f"PG:host={host} port={port} dbname={dbname} user={user} password={password}"
+    cmd = [
+        ogr2ogr_path,
+        "-f", "GPKG",
+        gpkg_path,
+        conn,
+        "-sql", f'SELECT * FROM "{schema}"."{table}"',
+        "-nln", table,
+        "-overwrite",
+        "-t_srs", "EPSG:4326",
+    ]
+    result = subprocess.run(cmd, capture_output=True, timeout=120)
+    if result.returncode != 0:
+        stderr = result.stderr.decode("utf-8", errors="replace").strip()
+        raise RuntimeError(stderr[:300])
+    return True
+
+
+# ============================================================
+# 方法二: geopandas（回退）
+# ============================================================
+
+def _export_with_geopandas(host, port, dbname, user, password, schema, table, gpkg_path):
+    """用 geopandas 导出单个图层"""
     import geopandas as gpd
     from sqlalchemy import create_engine
-from config import settings
 
-# GPKG 输出目录（相对于项目根目录）
+    conn_str = f"postgresql://{user}:{password}@{host}:{port}/{dbname}"
-GPKG_DIR = os.path.join(project_root, getattr(settings, "QGIS_GPKG_DIR", "app/data/gpkg"))
-
-# 静态图层定义: {显示名: (schema.table, geom_column, srid)}
-STATIC_LAYERS = {
-    "水库":               ("qgis.rivers",                  "Geometry", 0),
-    "市州驻地":           ("qgis.sx_capital",              "geometry", 0),
-    "河流":               ("qgis.river",                   "Geometry", 0),
-    "active_fault":       ("qgis.active_fault",            "Geometry", 0),
-    "陕西省":             ("qgis.sx",                      "Geometry", 0),
-    "乡镇驻地":           ("qgis.sx_street",               "dgeom",    0),
-    "区县驻地":           ("qgis.sx_xa_county",            "Geometry", 0),
-    "县界":               ("qgis.sx_xa_county_boundary",   "Geometry", 0),
-    "周边区县":           ("qgis.sx_zb_county_boundary",   "Geometry", 0),
-    "周边市州":           ("qgis.sx_zb_city",              "Geometry", 4326),
-    "周边县区":           ("qgis.sx_zb_county",            "Geometry", 0),
-    "traffic_expressway": ("qgis.traffic_expressway",      "Geometry", 0),
-    "traffic_provincial": ("qgis.traffic_provincial",      "Geometry", 0),
-    "traffic_railway":    ("qgis.traffic_railway",         "Geometry", 0),
-    "traffic_township":   ("qgis.traffic_township",        "Geometry", 0),
-    "traffic_trunk_line": ("qgis.traffic_trunk_line",      "Geometry", 0),
-}
-
-
-def export_layers():
-    os.makedirs(GPKG_DIR, exist_ok=True)
-
-    conn_str = (
-        f"postgresql://{settings.DB_USER}:{settings.DB_PASSWORD}"
-        f"@{settings.DB_HOST}:{settings.DB_PORT}/{settings.DB_NAME}"
-    )
     engine = create_engine(conn_str)
 
-    for layer_name, (table_ref, geom_col, srid) in STATIC_LAYERS.items():
+    gdf = gpd.read_postgis(
-        t0 = time.time()
+        f'SELECT * FROM "{schema}"."{table}"',
-        schema, table = table_ref.split(".", 1)
+        engine,
-        print(f"导出 {layer_name} ({table_ref}) ...", end=" ", flush=True)
+        geom_col="Geometry",
-
+    )
-        try:
+    if gdf.crs is None:
-            sql = f'SELECT * FROM "{schema}"."{table}"'
-            gdf = gpd.read_postgis(sql, engine, geom_col=geom_col)
-
-            if srid and srid > 0:
-                gdf = gdf.set_crs(epsg=srid, allow_override=True)
-            elif gdf.crs is None:
         gdf = gdf.set_crs(epsg=4326)
 
-            gpkg_path = os.path.join(GPKG_DIR, f"{table}.gpkg")
     gdf.to_file(gpkg_path, driver="GPKG")
+    engine.dispose()
+    return len(gdf)
 
-            print(f"✓ {len(gdf)} 行, {time.time() - t0:.1f}s")
 
+# ============================================================
+# 主入口
+# ============================================================
+
+def main():
+    # 从 config.settings 读取数据库配置
+    try:
+        from config import settings
+        host = getattr(settings, "QGIS_TEMPLATE_OVERRIDE_ACTUAL_HOST",
+                       getattr(settings, "DB_HOST", "47.92.216.173"))
+        port = str(getattr(settings, "QGIS_TEMPLATE_OVERRIDE_ACTUAL_PORT",
+                           getattr(settings, "DB_PORT", 7654)))
+        dbname = getattr(settings, "QGIS_TEMPLATE_OVERRIDE_ACTUAL_DB_NAME",
+                         getattr(settings, "DB_NAME", "xian_new"))
+        user = getattr(settings, "DB_USER", "postgres")
+        password = getattr(settings, "DB_PASSWORD", "zhangsan")
+    except Exception:
+        host, port, dbname, user, password = "47.92.216.173", "7654", "xian_new", "postgres", "zhangsan"
+
+    os.makedirs(GPKG_DIR, exist_ok=True)
+
+    # 选择导出方法
+    use_ogr2ogr = os.path.isfile(ogr2ogr_path)
+    method = "ogr2ogr" if use_ogr2ogr else "geopandas"
+
+    if use_ogr2ogr:
+        _setup_gdal_env()
+
+    print(f"数据库: {host}:{port}/{dbname}")
+    print(f"输出目录: {GPKG_DIR}")
+    print(f"导出方法: {method}")
+    print(f"共 {len(STATIC_LAYERS)} 个图层\n")
+
+    success = 0
+    failed = 0
+
+    for name, table_ref, gpkg_file in STATIC_LAYERS:
+        schema, table = table_ref.split(".", 1)
+        gpkg_path = os.path.join(GPKG_DIR, gpkg_file)
+
+        print(f"[{success + failed + 1}/{len(STATIC_LAYERS)}] {name} ({table_ref})", end=" ... ", flush=True)
+        t0 = time.time()
+
+        try:
+            if use_ogr2ogr:
+                _export_with_ogr2ogr(host, port, dbname, user, password, schema, table, gpkg_path)
+                size_kb = os.path.getsize(gpkg_path) / 1024
+                print(f"✓ {size_kb:.0f} KB, {time.time() - t0:.1f}s")
+            else:
+                count = _export_with_geopandas(host, port, dbname, user, password, schema, table, gpkg_path)
+                print(f"✓ {count} 行, {time.time() - t0:.1f}s")
+            success += 1
         except Exception as e:
             print(f"✗ 失败: {e}")
+            failed += 1
 
-    engine.dispose()
+    print(f"\n{'='*50}")
-    print(f"\n导出完成！文件目录: {GPKG_DIR}")
+    print(f"完成: 成功={success}, 失败={failed}, 共={len(STATIC_LAYERS)}")
+    print(f"输出目录: {GPKG_DIR}")
 
 
 if __name__ == "__main__":
-    export_layers()
+    main()

app/services/qgis/__init__.py

@@ -1,13 +1,31 @@
-from app.services.qgis.map_service import MapService
+"""
-from app.services.qgis.map_exporter import MapExporter
+QGIS 服务模块。
-from app.services.qgis.template_modifier import TemplateModifier
+
-from app.services.qgis.template_cache import TemplateCache
+注意：此包的核心模块（map_service、template_cache 等）依赖 qgis.core，
-from app.services.qgis.layer_filter import LayerFilter
+仅在 QGIS Python 3.12 子进程中可导入。主进程(Python 3.10)不应直接导入
+这些模块，而应通过 qgis_runner.py 子进程调用。
+
+安全导入（不依赖 qgis.core）：
+  - qgis_env: 环境检测与子进程配置
+  - qgis_runner: 子进程入口脚本路径
+"""
+
+def _lazy_import(module_name: str, attr: str):
+    """延迟导入，仅在子进程中实际使用时才加载"""
+    import importlib
+    mod = importlib.import_module(f".{module_name}", package=__name__)
+    return getattr(mod, attr)
+
 
 __all__ = [
-    'MapService',
+    "MapService",
-    'MapExporter',
+    "MapExporter",
-    'TemplateModifier',
+    "TemplateModifier",
-    'TemplateCache',
+    "TemplateCache",
-    'LayerFilter',
+    "LayerFilter",
 ]
+
+# 不在顶层导入 QGIS 依赖模块，避免主进程崩溃
+# 使用方式：
+#   from app.services.qgis.map_service import MapService  (仅在子进程中)
+#   from app.services.qgis.qgis_env import is_qgis_available  (主进程安全)

app/services/qgis/layer_filter.py

@@ -2,15 +2,10 @@
 图层过滤模块。按 event 和 eqqueue_id 筛选要素。
 """
 from app.config.paths import get_logger
+from app.config.qgis_mappings import EVENT_LAYERS, QUEUE_LAYERS
 
 logger = get_logger("qgis.filter")
 
-EVENT_LAYERS = ["eqcenter", "震中"]
-QUEUE_LAYERS = [
-    "intensity", "intensity_mian",
-    "dz_ryss", "dz_jjss", "dz_rysw", "dz_jzph", "dz_xzjl",
-]
-
 
 class LayerFilter:
     def apply(self, project, model: dict) -> None:

app/services/qgis/map_exporter.py

@@ -15,7 +15,7 @@ class MapExporter:
 
     def update_texts(self, model: dict) -> None:
         """更新布局中的文本标签"""
-        for key in ["mapTitle", "mapTime", "mapUnit", "info"]:
+        for key in ["mapTitle", "mapTime", "mapUint", "info"]:
             label = self.layout.itemById(key)
             if label is not None:
                 label.setText(model[key])

app/services/qgis/map_service.py

@@ -7,6 +7,8 @@ import time
 
 from qgis.core import QgsProject, QgsDataSourceUri
 
+from app.config.paths import get_logger
+from app.config.qgis_mappings import TABLE_RENAMES, SCHEMA_REPLACEMENTS
 from .template_cache import TemplateCache
 from .template_modifier import TemplateModifier
 from .layer_filter import LayerFilter
@@ -115,17 +117,32 @@ class MapService:
                     db_config["username"],
                     db_config["password"],
                 )
-                # 更新 schema（table="base"."xxx" → table="qgis"."xxx"）
+                # 更新 schema
                 old_uri = uri.uri()
                 if f'table="{actual_schema}".' not in old_uri:
-                    new_uri = old_uri.replace('table="base".', f'table="{actual_schema}".')
+                    for old_schema in SCHEMA_REPLACEMENTS:
+                        new_uri = old_uri.replace(
+                            f'table="{old_schema}".',
+                            f'table="{actual_schema}".',
+                        )
                         if new_uri != old_uri:
                             uri = QgsDataSourceUri(new_uri)
+                            break
+
+                # 表名映射（模板表名 ≠ 目标库表名）
+                uri_str = uri.uri()
+                for old_name, new_name in TABLE_RENAMES.items():
+                    full_old = f'table="{actual_schema}"."{old_name}"'
+                    full_new = f'table="{actual_schema}"."{new_name}"'
+                    if full_old in uri_str:
+                        uri_str = uri_str.replace(full_old, full_new)
+                        uri = QgsDataSourceUri(uri_str)
 
                 layer.setDataSource(uri.uri(), layer.name(), "postgres")
 
                 if layer.isValid():
-                    logger.info(f"图层 {layer.name()} 连接更新成功")
+                    fc = layer.featureCount()
+                    logger.info(f"图层 {layer.name()} 连接更新成功 ({fc} features)")
                 else:
                     logger.error(f"图层 {layer.name()} 更新后仍无效")
             except Exception as e:

app/services/qgis/qgis_env.py

@@ -1,266 +1,188 @@
 """
-QGIS 环境初始化模块（跨平台：Windows / Linux）。
+QGIS 环境检测与子进程配置模块。
-在 server.py lifespan 启动阶段调用 init_qgis_env()，
+
-完成共享库注入、环境变量设置、QgsApplication 初始化。
+主进程运行在 Python 3.10，无法直接加载 QGIS 的 Python 3.12 C 扩展。
+所有 QGIS 操作通过 subprocess 调用 QGIS Python 3.12 执行。
+
+本模块提供：
+  - get_qgis_python_path(): 检测 QGIS Python 3.12 解释器路径
+  - build_qgis_command():   构建通过 .bat 启动 QGIS 子进程的命令
+  - is_qgis_available():    检查 QGIS 是否可用
+  - get_runner_script():    获取 qgis_runner.py 的路径
 """
 import os
-import sys
+import tempfile
-import platform
 from pathlib import Path
 
 from app.config.paths import get_logger
 
 logger = get_logger("qgis.env")
 
-_qgs_app = None
-_initialized = False
-_IS_WINDOWS = platform.system() == "Windows"
 
-
+def get_qgis_python_path(qgis_root: str = None) -> str | None:
-def init_qgis_env(qgis_root: str) -> None:
     """
-    初始化 QGIS 运行环境。整个应用生命周期只需调用一次。
+    检测 QGIS 自带的 Python 3.12 解释器路径。
 
-    Args:
+    Windows: {QGIS_ROOT}/apps/Python312/python3.exe
-        qgis_root: QGIS 安装根目录
+
-                   Windows: "D:/QGIS"
+    Returns:
-                   Linux:   "/usr" 或 "/opt/QGIS"
+        解释器绝对路径，不存在则返回 None
     """
-    global _qgs_app, _initialized
+    if qgis_root is None:
-    if _initialized:
+        qgis_root = _detect_qgis_root()
-        return
+    if qgis_root is None:
+        return None
 
-    qgis_app_dir = _find_qgis_app_dir(qgis_root)
+    import platform
-
+    if platform.system() == "Windows":
-    # 共享库搜索路径（平台相关）
+        for name in ("python3.exe", "python.exe"):
-    #    Windows: os.add_dll_directory() 显式注册 DLL 目录
+            candidate = os.path.join(qgis_root, "apps", "Python312", name)
-    #    Linux:   LD_LIBRARY_PATH 追加 .so 搜索目录
+            if os.path.isfile(candidate):
-    _add_library_paths(qgis_root, qgis_app_dir)
+                logger.info(f"检测到 QGIS Python: {candidate}")
-
+                return candidate
-    # 环境变量
+        logger.warning(f"未找到 QGIS Python 3.12")
-    _set_environment(qgis_root, qgis_app_dir)
+        return None
-
-    # Python 模块路径
-    _add_python_paths(qgis_root, qgis_app_dir)
-
-    # 初始化 QgsApplication
-    _init_qgs_application(qgis_app_dir)
-
-    _initialized = True
-    logger.info(f"QGIS 环境初始化完成 ({platform.system()})")
-
-
-def cleanup_qgis_env() -> None:
-    """清理 QGIS 资源（应用退出时调用）"""
-    global _qgs_app, _initialized
-    if _qgs_app is not None:
-        _qgs_app.exitQgis()
-        _qgs_app = None
-        _initialized = False
-        logger.info("QGIS 资源已清理")
-
-
-def is_qgis_ready() -> bool:
-    """检查 QGIS 是否已初始化"""
-    return _initialized
-
-
-# ─────────────────────────────────────────────────────────────
-#  平台检测
-# ─────────────────────────────────────────────────────────────
-
-def _find_qgis_app_dir(root: str) -> str:
-    """
-    自动检测 QGIS 应用目录。
-
-    Windows（OSGeo4W 安装）: {root}/apps/qgis-ltr/
-    Linux（包管理器安装）:     {root}/share/qgis/（Python 在 {root}/share/qgis/python）
-    """
-    if _IS_WINDOWS:
-        return _find_qgis_app_dir_windows(root)
     else:
-        return _find_qgis_app_dir_linux(root)
+        import shutil
 
+        # 优先检查环境变量
+        env_python = os.environ.get("QGIS_PYTHON_PATH")
+        if env_python and os.path.isfile(env_python):
+            logger.info(f"QGIS_PYTHON_PATH 指定: {env_python}")
+            return env_python
 
-def _find_qgis_app_dir_windows(root: str) -> str:
+        # 搜索标准 Linux QGIS 安装路径
-    """Windows: 在 {root}/apps/ 下查找 qgis* 目录"""
+        linux_paths = [
-    apps_dir = Path(root) / "apps"
+            "/usr/bin/qgis",  # Ubuntu/Debian apt 安装
-    if apps_dir.is_dir():
+            "/usr/bin/qgis.bin",
-        for name in sorted(apps_dir.iterdir()):
+            "/opt/QGIS/apps/Python312/bin/python3",  # 独立安装器
-            if name.name.startswith("qgis") and name.is_dir():
+            "/opt/QGIS/apps/Python3/bin/python3",
-                logger.info(f"检测到 QGIS 应用目录: {name}")
+            "/usr/libexec/qgis/python3",  # Fedora/RHEL
-                return str(name)
-    fallback = str(apps_dir / "qgis")
-    logger.warning(f"未检测到 qgis* 目录，使用默认路径: {fallback}")
-    return fallback
-
-
-def _find_qgis_app_dir_linux(root: str) -> str:
-    """
-    Linux: 返回 QGIS_PREFIX_PATH。
-    包管理器安装的标准路径：
-      Debian/Ubuntu:  /usr （qgis-core 在 /usr/lib/qgis/）
-      RHEL/CentOS:    /usr
-      QGIS.org 官方:  /usr 或 /opt/QGIS
-    """
-    candidates = [
-        Path(root) / "share" / "qgis",        # /usr/share/qgis
-        Path(root) / "lib" / "qgis",           # /usr/lib/qgis
-        Path(root) / "share" / "qgis-ltr",     # qgis-ltr 变体
         ]
-    for c in candidates:
+        for candidate in linux_paths:
-        if c.is_dir():
+            if os.path.isfile(candidate):
-            logger.info(f"检测到 QGIS 应用目录: {c}")
+                logger.info(f"检测到 QGIS 可执行文件: {candidate}")
-            return str(c)
+                return candidate
 
-    # 回退：用 root 本身（/usr），由 QgsApplication 自行探测
+        # 回退到系统 Python（如果 qgis.core 可导入）
-    logger.warning(f"未找到 QGIS 标准目录，使用 root: {root}")
+        sys_python = shutil.which("python3") or shutil.which("python")
-    return str(root)
+        if sys_python:
+            logger.info(f"Linux 环境，使用系统 Python: {sys_python}")
+            return sys_python
+        return None
 
 
-# ─────────────────────────────────────────────────────────────
+def build_qgis_command(qgis_root: str = None) -> list[str]:
-#  共享库注入
-# ─────────────────────────────────────────────────────────────
-
-def _add_library_paths(root: str, qgis_app: str) -> None:
     """
-    注入共享库搜索路径。
+    构建通过 .bat 包装器启动 QGIS 子进程的命令列表。
 
-    Windows: 调用 os.add_dll_directory() 显式注册每个 DLL 目录，
+    .bat 文件设置环境变量并启动 QGIS Python 3.12。
-             Python 3.8+ 不再自动搜索 PATH 中的 DLL。
+    DLL 加载由 qgis_runner.py 中的 ctypes 预加载机制处理。
-    Linux:   追加 LD_LIBRARY_PATH，让动态链接器 (ld-linux) 找到 .so。
+
+    Returns:
+        可直接传给 subprocess.run() 的命令列表
     """
-    if _IS_WINDOWS:
+    import platform
-        _add_dll_directories_windows(root, qgis_app)
+    if platform.system() != "Windows":
+        # Linux: 直接用 Python，不需要 .bat 包装
+        python_path = get_qgis_python_path(qgis_root)
+        if not python_path:
+            raise RuntimeError("未找到 QGIS Python 解释器")
+        return [python_path, get_runner_script()]
+
+    if qgis_root is None:
+        qgis_root = _detect_qgis_root() or "D:/QGIS"
+
+    python_path = get_qgis_python_path(qgis_root)
+    if not python_path:
+        raise RuntimeError("未找到 QGIS Python 3.12 解释器")
+
+    runner_script = get_runner_script()
+    if not os.path.isfile(runner_script):
+        raise RuntimeError(f"QGIS Runner 脚本不存在: {runner_script}")
+
+    # 生成 .bat 包装脚本
+    bat_path = _generate_bat_wrapper(qgis_root, python_path, runner_script)
+    return ["cmd.exe", "/c", bat_path]
+
+
+def is_qgis_available(qgis_root: str = None) -> bool:
+    """检查 QGIS 环境是否可用"""
+    return get_qgis_python_path(qgis_root) is not None
+
+
+def get_runner_script() -> str:
+    """获取 qgis_runner.py 的绝对路径"""
+    return str(Path(__file__).parent / "qgis_runner.py")
+
+
+def _generate_bat_wrapper(qgis_root: str, python_path: str, runner_script: str) -> str:
+    """
+    生成 .bat 包装脚本，设置 QGIS 环境变量并启动 runner。
+
+    .bat 文件通过 cmd.exe 执行，设置必要的环境变量。
+    DLL 加载由 qgis_runner.py 的 ctypes 预加载处理。
+    """
+    qgis_app_dir = os.path.join(qgis_root, "apps", "qgis-ltr").replace("/", "\\")
+    python_dir = os.path.join(qgis_root, "apps", "Python312").replace("/", "\\")
+    qt5_plugins = os.path.join(qgis_root, "apps", "Qt5", "plugins").replace("/", "\\")
+    qtplugins = os.path.join(qgis_app_dir, "qtplugins").replace("/", "\\")
+    gdal_data = os.path.join(qgis_root, "apps", "gdal", "share", "gdal").replace("/", "\\")
+    qgis_python_dir = os.path.join(qgis_app_dir, "python").replace("/", "\\")
+    qgis_bin = os.path.join(qgis_app_dir, "bin").replace("/", "\\")
+    qt5_bin = os.path.join(qgis_root, "apps", "Qt5", "bin").replace("/", "\\")
+    gdal_lib = os.path.join(qgis_root, "apps", "gdal", "lib").replace("/", "\\")
+
+    bat_content = f"""@echo off
+set "PYTHONHOME={python_dir}"
+set "PYTHONPATH={qgis_python_dir}"
+set "QGIS_PREFIX_PATH={qgis_app_dir}"
+set "QT_PLUGIN_PATH={qtplugins};{qt5_plugins}"
+set "GDAL_DATA={gdal_data}"
+set "PYTHONUTF8=1"
+set "GDAL_FILENAME_IS_UTF8=YES"
+set "VSI_CACHE=TRUE"
+set "VSI_CACHE_SIZE=1000000"
+set "PATH={qgis_bin};{qt5_bin};{gdal_lib};%PATH%"
+"{python_path}" "{runner_script}" %*
+"""
+
+    # 写入临时 .bat 文件
+    bat_dir = os.path.join(tempfile.gettempdir(), "qgis_runner")
+    os.makedirs(bat_dir, exist_ok=True)
+    bat_path = os.path.join(bat_dir, "run_qgis.bat")
+
+    with open(bat_path, "w", encoding="utf-8") as f:
+        f.write(bat_content)
+
+    logger.debug(f"生成 QGIS 包装脚本: {bat_path}")
+    return bat_path
+
+
+def _detect_qgis_root() -> str | None:
+    """
+    自动检测 QGIS 安装根目录。
+
+    优先级：
+    1. 环境变量 QGIS_ROOT
+    2. Windows 默认路径 D:/QGIS
+    3. Linux 常见路径
+    """
+    env_root = os.environ.get("QGIS_ROOT")
+    if env_root and os.path.isdir(env_root):
+        return env_root
+
+    import platform
+    if platform.system() == "Windows":
+        for candidate in ["D:/QGIS", "C:/OSGeo4W", "C:/QGIS"]:
+            if os.path.isdir(candidate):
+                logger.info(f"检测到 QGIS 根目录: {candidate}")
+                return candidate
     else:
-        _add_ld_library_path_linux(root, qgis_app)
+        for candidate in ["/usr", "/opt/QGIS", "/home/QGIS"]:
+            if os.path.isdir(candidate):
+                logger.info(f"检测到 QGIS 根目录: {candidate}")
+                return candidate
 
-
+    logger.warning("未检测到 QGIS 安装目录")
-def _add_dll_directories_windows(root: str, qgis_app: str) -> None:
+    return None
-    """Windows: 显式注册 DLL 搜索目录"""
-    if not hasattr(os, "add_dll_directory"):
-        return  # Python < 3.8
-
-    dll_dirs = [
-        os.path.join(root, "apps", "Qt5", "bin"),
-        os.path.join(qgis_app, "bin"),
-        os.path.join(root, "bin"),
-        os.path.join(root, "apps", "gdal", "bin"),
-        os.path.join(root, "apps", "gdal", "lib"),
-    ]
-    for d in dll_dirs:
-        if os.path.isdir(d):
-            os.add_dll_directory(d)
-            logger.debug(f"注册 DLL 目录: {d}")
-
-
-def _add_ld_library_path_linux(root: str, qgis_app: str) -> None:
-    """
-    Linux: 追加 LD_LIBRARY_PATH，使动态链接器找到 QGIS/GDAL 的 .so。
-
-    QGIS 包管理器安装时的标准 .so 路径：
-      /usr/lib/                    — libqgis_core.so, libqgis_analysis.so
-      /usr/lib/qgis/               — 插件 .so
-      /usr/lib/qgis/plugins/       — provider .so
-      /usr/share/qgis/python/      — Python 模块
-    """
-    ld_dirs = [
-        os.path.join(root, "lib"),                     # /usr/lib
-        os.path.join(root, "lib", "qgis"),             # /usr/lib/qgis
-        os.path.join(root, "lib", "qgis", "plugins"),  # /usr/lib/qgis/plugins
-        os.path.join(root, "share", "qgis", "lib"),    # 某些安装方式
-        os.path.join(root, "apps", "gdal", "lib"),     # OSGeo4W 风格
-    ]
-    existing = os.environ.get("LD_LIBRARY_PATH", "")
-    new_dirs = [d for d in ld_dirs if os.path.isdir(d) and d not in existing]
-    if new_dirs:
-        joined = ":".join(new_dirs)
-        os.environ["LD_LIBRARY_PATH"] = f"{joined}:{existing}" if existing else joined
-        logger.info(f"LD_LIBRARY_PATH 追加: {new_dirs}")
-
-
-# ─────────────────────────────────────────────────────────────
-#  环境变量
-# ─────────────────────────────────────────────────────────────
-
-def _set_environment(root: str, qgis_app: str) -> None:
-    """设置 QGIS 和 GDAL 相关环境变量（平台自适应）"""
-    env_vars = {
-        "QGIS_PREFIX_PATH": qgis_app,
-        "PYTHONUTF8": "1",
-        "GDAL_FILENAME_IS_UTF8": "YES",
-        "VSI_CACHE": "TRUE",
-        "VSI_CACHE_SIZE": "1000000",
-    }
-
-    if _IS_WINDOWS:
-        env_vars["QT_PLUGIN_PATH"] = (
-            f"{os.path.join(qgis_app, 'qtplugins')};"
-            f"{os.path.join(root, 'apps', 'Qt5', 'plugins')}"
-        )
-        env_vars["GDAL_DATA"] = os.path.join(root, "apps", "gdal", "share", "gdal")
-    else:
-        # Linux: GDAL 数据通常在系统路径 /usr/share/gdal/ 下
-        gdal_candidates = [
-            os.path.join(root, "share", "gdal"),
-            os.path.join(root, "share", "qgis", "resources"),
-        ]
-        for p in gdal_candidates:
-            if os.path.isdir(p):
-                env_vars["GDAL_DATA"] = p
-                break
-
-        # QGIS 插件路径（Linux 标准）
-        qt_plugin = os.path.join(root, "lib", "qt", "plugins")
-        if os.path.isdir(qt_plugin):
-            env_vars["QT_PLUGIN_PATH"] = qt_plugin
-
-    for key, value in env_vars.items():
-        os.environ[key] = value
-        logger.debug(f"环境变量: {key}={value}")
-
-
-# ─────────────────────────────────────────────────────────────
-#  Python 模块路径
-# ─────────────────────────────────────────────────────────────
-
-def _add_python_paths(root: str, qgis_app: str) -> None:
-    """将 QGIS Python 模块路径加入 sys.path（平台自适应）"""
-    if _IS_WINDOWS:
-        python_paths = [
-            os.path.join(qgis_app, "python"),
-            os.path.join(root, "apps", "Python312", "Lib", "site-packages"),
-        ]
-    else:
-        python_paths = [
-            os.path.join(qgis_app, "python"),                          # /usr/share/qgis/python
-            os.path.join(root, "lib", "python3", "dist-packages"),     # Debian/Ubuntu
-            os.path.join(root, "lib", "python3.10", "site-packages"),  # 通用
-        ]
-
-    for p in python_paths:
-        if os.path.isdir(p) and p not in sys.path:
-            sys.path.insert(0, p)
-            logger.info(f"添加 Python 路径: {p}")
-
-
-# ─────────────────────────────────────────────────────────────
-#  QgsApplication 初始化
-# ─────────────────────────────────────────────────────────────
-
-def _init_qgs_application(qgis_app: str) -> None:
-    """创建并初始化 QgsApplication 实例"""
-    global _qgs_app
-
-    from qgis.core import QgsApplication, QgsSettings
-
-    QgsApplication.setPrefixPath(qgis_app, True)
-    _qgs_app = QgsApplication([], False)  # False = 不启动 GUI
-
-    settings = QgsSettings()
-    settings.setValue("/qgis/render_decorations", False)
-    settings.setValue("/qgis/parallel_rendering", True)
-    settings.setValue("/qgis/use_spatial_index", True)
-
-    _qgs_app.initQgis()
-    logger.info("QgsApplication 初始化完成")

app/services/qgis/qgis_runner.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+QGIS 专题图生成子进程入口。
+
+由主进程 (Python 3.10) 通过 subprocess 调用，
+运行在 QGIS 自带的 Python 3.12 环境中。
+
+支持两种模式：
+  - 批量模式（推荐）：单次启动 QgsApplication，顺序处理多个模板
+    输入: { "config": {...}, "models": [{...}, {...}, ...] }
+  - 单任务模式（兼容）：
+    输入: { "config": {...}, "model": {...} }
+
+输出 JSON (stdout):
+  批量: { "results": [{"name": "...", "output": "..."}, ...] }
+  单任务: { "name": "...", "output": "..." }
+
+错误: stderr + exit code 1
+"""
+import json
+import os
+import sys
+import time
+
+# ============================================================
+# 1. 环境初始化（必须在任何 QGIS/Qt import 之前）
+# ============================================================
+
+QGIS_ROOT = os.environ.get("QGIS_ROOT", "D:/QGIS")
+
+
+def _setup_python_path():
+    """将项目根目录和 QGIS Python 路径加入 sys.path"""
+    project_root = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    )
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+
+    qgis_python = os.path.join(QGIS_ROOT, "apps", "qgis-ltr", "python")
+    if os.path.isdir(qgis_python) and qgis_python not in sys.path:
+        sys.path.insert(0, qgis_python)
+
+
+def _setup_environment():
+    """设置 QGIS 运行所需的环境变量"""
+    qgis_app_dir = os.path.join(QGIS_ROOT, "apps", "qgis-ltr")
+    os.environ["QGIS_PREFIX_PATH"] = qgis_app_dir
+    os.environ["PYTHONUTF8"] = "1"
+    os.environ["GDAL_FILENAME_IS_UTF8"] = "YES"
+    os.environ["VSI_CACHE"] = "TRUE"
+    os.environ["VSI_CACHE_SIZE"] = "1000000"
+
+    if sys.platform == "win32":
+        os.environ["QT_PLUGIN_PATH"] = (
+            f"{os.path.join(qgis_app_dir, 'qtplugins')};"
+            f"{os.path.join(QGIS_ROOT, 'apps', 'Qt5', 'plugins')}"
+        )
+        gdal_data = os.path.join(QGIS_ROOT, "apps", "gdal", "share", "gdal")
+        if os.path.isdir(gdal_data):
+            os.environ["GDAL_DATA"] = gdal_data
+
+        import ctypes
+        _dll_dirs = [
+            os.path.join(qgis_app_dir, "bin"),
+            os.path.join(QGIS_ROOT, "apps", "Qt5", "bin"),
+            os.path.join(QGIS_ROOT, "apps", "gdal", "lib"),
+        ]
+        _preload_dlls = [
+            "qgis_core.dll", "qgispython.dll",
+            "Qt5Core.dll", "Qt5Gui.dll", "Qt5Widgets.dll",
+            "Qt5Network.dll", "Qt5Svg.dll", "Qt5Xml.dll",
+            "Qt5Concurrent.dll", "Qt5PrintSupport.dll",
+        ]
+        for dll_dir in _dll_dirs:
+            if not os.path.isdir(dll_dir):
+                continue
+            os.add_dll_directory(dll_dir)
+            for dll_name in _preload_dlls:
+                dll_path = os.path.join(dll_dir, dll_name)
+                if os.path.isfile(dll_path):
+                    try:
+                        ctypes.WinDLL(dll_path)
+                    except OSError:
+                        pass
+
+
+# ============================================================
+# 2. 主逻辑
+# ============================================================
+
+def _init_qgis():
+    """初始化 QgsApplication（只做一次）"""
+    from qgis.core import QgsApplication
+
+    qgis_app_dir = os.path.join(QGIS_ROOT, "apps", "qgis-ltr")
+    QgsApplication.setPrefixPath(qgis_app_dir, True)
+    qgs_app = QgsApplication([], False)
+    qgs_app.initQgis()
+    return qgs_app
+
+
+def _process_single(service, model):
+    """处理单个模板，返回结果 dict"""
+    name = service.generate(model)
+    return {"name": name, "output": model["outFile"]}
+
+
+def main():
+    t_start = time.time()
+
+    # 环境初始化
+    _setup_environment()
+    _setup_python_path()
+
+    # 读取请求 JSON
+    if len(sys.argv) > 1 and os.path.isfile(sys.argv[1]):
+        with open(sys.argv[1], "r", encoding="utf-8") as f:
+            request = json.load(f)
+    else:
+        request = json.load(sys.stdin)
+
+    config = request["config"]
+
+    # 兼容批量和单任务模式
+    models = request.get("models") or [request["model"]]
+
+    # 初始化 QgsApplication（只做一次）
+    qgs_app = _init_qgis()
+
+    try:
+        from app.services.qgis.map_service import MapService
+
+        service = MapService(config)
+        results = []
+
+        for i, model in enumerate(models):
+            t_model = time.time()
+            try:
+                result = _process_single(service, model)
+                results.append(result)
+                elapsed = time.time() - t_model
+                print(
+                    f"[qgis_runner] [{i+1}/{len(models)}] 完成: {result['name']}, "
+                    f"耗时 {elapsed:.1f}s",
+                    file=sys.stderr,
+                )
+            except Exception as e:
+                elapsed = time.time() - t_model
+                error_msg = f"{e}"
+                print(
+                    f"[qgis_runner] [{i+1}/{len(models)}] 失败: {model.get('name', '?')}, "
+                    f"耗时 {elapsed:.1f}s — {error_msg}",
+                    file=sys.stderr,
+                )
+                results.append({"name": model.get("name", ""), "output": "", "error": error_msg})
+
+        # 输出结果
+        if len(models) == 1 and not request.get("models"):
+            # 单任务模式兼容
+            json.dump(results[0], sys.stdout, ensure_ascii=False)
+        else:
+            json.dump({"results": results}, sys.stdout, ensure_ascii=False)
+        sys.stdout.flush()
+
+        total = time.time() - t_start
+        ok = sum(1 for r in results if not r.get("error"))
+        fail = len(results) - ok
+        print(
+            f"\n[qgis_runner] 批量完成: {ok}成功/{fail}失败, 总耗时 {total:.1f}s",
+            file=sys.stderr,
+        )
+    except Exception as e:
+        elapsed = time.time() - t_start
+        print(f"[qgis_runner] 致命错误 ({elapsed:.1f}s): {e}", file=sys.stderr)
+        sys.exit(1)
+    finally:
+        qgs_app.exitQgis()
+
+
+if __name__ == "__main__":
+    main()

app/services/qgis/template_cache.py

@@ -51,7 +51,7 @@ class TemplateCache:
         extent = None
         layout = project.layoutManager().layoutByName(layout_name)
         if layout:
-            for item_id in ["mapTitle", "mapTime", "mapUnit", "info"]:
+            for item_id in ["mapTitle", "mapTime", "mapUint", "info"]:
                 item = layout.itemById(item_id)
                 if item:
                     texts[item_id] = item.text()

app/services/qgis/template_modifier.py

@@ -9,6 +9,7 @@ import zipfile
 import tempfile
 
 from app.config.paths import get_logger
+from app.config.qgis_mappings import OGR_TO_POSTGRES, TABLE_RENAMES, SCHEMA_REPLACEMENTS
 
 logger = get_logger("qgis.modifier")
 
@@ -33,6 +34,26 @@ class TemplateModifier:
             mapping[xml_key] = gpkg_path
         return mapping
 
+    @staticmethod
+    def _fix_provider_tags(content: str) -> str:
+        """
+        将 GPKG 文件路径对应的 <provider ...>postgres</provider> 改为 ogr。
+
+        策略：按 <maplayer> 块处理，若块内 datasource 是文件路径（盘符开头），
+        则该块内的 provider 改为 ogr。避免跨层误改。
+        """
+        maplayer_re = re.compile(r'(<maplayer[^>]*>.*?</maplayer>)', re.DOTALL)
+        provider_re = re.compile(r'(<provider[^>]*>)postgres(</provider>)')
+        file_ds_re = re.compile(r'<datasource>([A-Za-z]:/[^<]+)</datasource>')
+
+        def _fix_layer(m):
+            layer_xml = m.group(1)
+            if file_ds_re.search(layer_xml):
+                layer_xml = provider_re.sub(r'\1ogr\2', layer_xml)
+            return layer_xml
+
+        return maplayer_re.sub(_fix_layer, content)
+
     def modify(self, template_path: str) -> str:
         """修改模板文件，返回修改后的临时 .qgz 路径"""
         override = self.config.get("template_override")
@@ -65,29 +86,8 @@ class TemplateModifier:
                     if item.filename.endswith(".qgs"):
                         content = data.decode("utf-8")
 
-                        # 替换 host/port/dbname/schema
+                        # ★ 先替换静态底图 datasource（在 schema 替换之前）
-                        if orig and actual:
+                        # 否则 table="base"."xxx" 会被改为 table="qgis"."xxx"，导致匹配失败
-                            content = re.sub(
-                                rf"(host\s*=\s*['\"])({re.escape(orig['host'])})(['\"])",
-                                rf"\g<1>{actual['host']}\3",
-                                content,
-                            )
-                            content = re.sub(
-                                rf"(port\s*=\s*['\"])({re.escape(str(orig['port']))})(['\"])",
-                                rf"\g<1>{actual['port']}\3",
-                                content,
-                            )
-                            content = re.sub(
-                                rf"(dbname\s*=\s*['\"])({re.escape(orig['dbname'])})(['\"])",
-                                rf"\g<1>{actual['dbname']}\3",
-                                content,
-                            )
-                            content = content.replace(
-                                f'table="{orig["schema"]}".',
-                                f'table="{actual["schema"]}".',
-                            )
-
-                        # 替换静态底图 datasource
                         if self._static_map:
                             def _replace(m):
                                 tbl = table_re.search(m.group(2))
@@ -99,6 +99,74 @@ class TemplateModifier:
 
                             content = datasource_re.sub(_replace, content)
 
+                        # ★ 转换避难场所 OGR 图层为 PostgreSQL（模板引用本地 JSON 文件）
+                        _target_schema = (actual or {}).get("schema") or "qgis"
+                        _db = self.config.get("db", {})
+                        content = self._convert_ogr_to_postgres(content, _db, _target_schema)
+
+                        # 替换所有 PostgreSQL 连接参数（统一指向目标库）
+                        db = self.config.get("db", {})
+
+                        # host: 模板中 host=localhost 无引号，匹配带/不带引号
+                        if db.get("host"):
+                            content = re.sub(
+                                r"(host\s*=\s*)(?:['\"])?(?:localhost|127\.0\.0\.1)(?:['\"])?(?=\s|$)",
+                                rf"\g<1>{db['host']}",
+                                content,
+                            )
+                        # port: 模板中 port=5432 无引号，匹配带/不带引号
+                        if db.get("port"):
+                            content = re.sub(
+                                r"(port\s*=\s*)(?:['\"])?5432(?:['\"])?(?=\s|$)",
+                                rf"\g<1>{str(db['port'])}",
+                                content,
+                            )
+                        if db.get("database"):
+                            content = re.sub(
+                                r"(dbname\s*=\s*['\"])([^'\"]+)(['\"])",
+                                rf"\g<1>{db['database']}\3",
+                                content,
+                            )
+                        # 移除 authcfg（QGIS 本地认证配置，子进程环境无效）
+                        content = re.sub(r'\s*authcfg\s*=\s*\S+', '', content)
+                        # 移除可能残留的 user=/password=（防止重复注入）
+                        if db.get("username"):
+                            content = re.sub(r"\s*user\s*=\s*'[^']*'", '', content)
+                        if db.get("password"):
+                            content = re.sub(r"\s*password\s*=\s*'[^']*'", '', content)
+                        # 在 port 后注入显式 user + password
+                        if db.get("username") and db.get("password"):
+                            content = re.sub(
+                                r'(port\s*=\s*\d+)',
+                                rf"\1 user='{db['username']}' password='{db['password']}'",
+                                content,
+                            )
+                        # schema 替换：统一指向目标 schema
+                        target_schema = (actual or {}).get("schema") or "qgis"
+                        for old_schema in SCHEMA_REPLACEMENTS:
+                            content = content.replace(
+                                f'table="{old_schema}".',
+                                f'table="{target_schema}".',
+                            )
+
+                        # 表名映射（模板表名 ≠ 目标库表名）
+                        for old_name, new_name in TABLE_RENAMES.items():
+                            content = content.replace(
+                                f'table="{target_schema}"."{old_name}"',
+                                f'table="{target_schema}"."{new_name}"',
+                            )
+
+                        # tid 列已通过 add_tid_column.py 添加到所有 qgis 动态表中
+                        # 模板中的 key='tid' 可正常工作，无需移除
+
+                        # 修正 srid=0 → srid=4326（QGIS 无法从 srid=0 自动检测 SRID）
+                        content = content.replace(" srid=0 ", " srid=4326 ")
+
+                        # ★ 修复 provider 标签：GPKG 文件路径的图层必须用 ogr provider
+                        # 否则 QGIS 会将 .gpkg 路径当作 PostgreSQL 连接字符串解析，导致图层无效
+                        if self._static_map:
+                            content = self._fix_provider_tags(content)
+
                         data = content.encode("utf-8")
 
                     zout.writestr(item, data)
@@ -109,3 +177,47 @@ class TemplateModifier:
         except Exception as e:
             logger.error(f"模板修改失败，将使用原始模板: {e}")
             return template_path
+
+    @staticmethod
+    def _convert_ogr_to_postgres(content: str, db: dict, schema: str) -> str:
+        """
+        将模板中引用本地文件的避难场所 OGR 图层转换为 PostgreSQL 图层。
+
+        设计师在本地用 JSON 文件制作了避难场所图层（公园/学校/文化馆等），
+        这些数据已迁移到目标库 qgis schema 中。
+        """
+        _ogr_shelter_map = OGR_TO_POSTGRES
+
+        maplayer_re = re.compile(r'(<maplayer[^>]*>.*?</maplayer>)', re.DOTALL)
+        provider_re = re.compile(r'(<provider[^>]*>)ogr(</provider>)')
+        datasource_re = re.compile(r'(<datasource>).*?(</datasource>)', re.DOTALL)
+        file_ds_re = re.compile(r'<datasource>.*?\|layername=([^<]+)</datasource>', re.DOTALL)
+
+        def _convert_layer(m):
+            layer_xml = m.group(1)
+            ds_match = file_ds_re.search(layer_xml)
+            if not ds_match:
+                return layer_xml
+            layer_name = ds_match.group(1)
+            table = _ogr_shelter_map.get(layer_name)
+            if not table:
+                return layer_xml
+
+            # 构建 PostgreSQL URI
+            pg_uri = (
+                f"dbname='{db.get('database', 'xian_new')}' "
+                f"host={db.get('host', '47.92.216.173')} "
+                f"port={db.get('port', 7654)} "
+                f"user='{db.get('username', 'postgres')}' "
+                f"password='{db.get('password', '')}' "
+                f"key='tid' srid=4326 type=Point "
+                f"table=\"{schema}\".\"{table}\" (geometry)"
+            )
+            new_ds = f"<datasource>{pg_uri}</datasource>"
+
+            layer_xml = datasource_re.sub(new_ds, layer_xml)
+            layer_xml = provider_re.sub(r'\1postgres\2', layer_xml)
+            logger.info(f"避难场所图层已转换: {layer_name} → qgis.{table}")
+            return layer_xml
+
+        return maplayer_re.sub(_convert_layer, content)

requirements.txt

@@ -10,3 +10,4 @@ fastapi == 0.136.3
 uvicorn[standard] == 0.48.0
 loguru == 0.7.3
 geopandas == 0.14.4
+sqlalchemy == 2.0.51

settings.toml

@@ -11,12 +11,12 @@ PREDICT_PROBABILITY_THRESHOLD = 50
 # 静态底图 GeoPackage 目录（相对于项目根目录）
 QGIS_GPKG_DIR = "app/data/gpkg"
 # 专题图输出子目录（相对于 FILE_STORE_DIR）
-QGIS_OUTPUT_DIR = "xian/qgis/map/:disasterTime"
+QGIS_OUTPUT_DIR = "xian/qgis/map/:eventType/:disasterTime"
 # 专题图默认参数
 QGIS_DEFAULTS_MAP_LAYOUT = "A3"
 QGIS_DEFAULTS_ZOOM_RULE = "11"
 QGIS_DEFAULTS_ZOOM_VALUE = "50"
-QGIS_DEFAULTS_MAP_UNIT = "西安市应急管理局"
+QGIS_DEFAULTS_MAP_UNIT = "制图单位：西安市应急管理局"
 # 专题图DPI
 QGIS_EXPORT_DPI = 300
 # 批量产图线程池
@@ -80,6 +80,9 @@ FILE_STORE_DIR = "G:/files"
 # QGIS 配置
 # ============================================================
 QGIS_ROOT = "D:/QGIS"
+# 专题图输出子目录
+QGIS_OUTPUT_DIR = "xian/qgis/map/:eventType/:disasterTime"
+QGIS_DEFAULTS_MAP_UNIT = "制图单位：西安市应急管理局"
 # 模板数据库覆盖：将模板中硬编码的连接替换为实际环境连接
 QGIS_TEMPLATE_OVERRIDE_ENABLED = true
 QGIS_TEMPLATE_OVERRIDE_ORIGINAL_HOST = "localhost"

tools/add_tid_column.py

@@ -0,0 +1,42 @@
+"""
+在所有 qgis 动态表中添加 tid 自增主键列
+QGIS 的 datasource key='tid' 需要此列
+"""
+import psycopg2
+
+TABLES = [
+    'hazard_hydrops',
+    'lifeline_outfall', 
+    'lifeline_pipe',
+    'risk_census_population',
+    'sx_xa_towns',
+]
+
+c = psycopg2.connect(
+    host='47.92.216.173', port=7654,
+    user='postgres', password='zhangsan',
+    database='xian_new'
+)
+c.autocommit = True
+cur = c.cursor()
+
+for t in TABLES:
+    try:
+        # 检查 tid 列是否存在
+        cur.execute(f"""
+            SELECT EXISTS (
+                SELECT FROM information_schema.columns 
+                WHERE table_schema='qgis' AND table_name='{t}' AND column_name='tid'
+            )
+        """)
+        exists = cur.fetchone()[0]
+        
+        if exists:
+            print(f"qgis.{t}: tid 列已存在, 跳过")
+        else:
+            cur.execute(f'ALTER TABLE qgis."{t}" ADD COLUMN tid SERIAL')
+            print(f"qgis.{t}: tid 列添加成功")
+    except Exception as e:
+        print(f"qgis.{t}: 失败 - {e}")
+
+c.close()

tools/check_dynamic_layers.py

@@ -0,0 +1,72 @@
+"""
+批量检查所有 rainfall 模板的图层，看哪些动态图层需要显示、表是否存在
+"""
+import zipfile, re, os, psycopg2
+
+TEMPLATE_DIR = r"F:\project\xian\xian_algorithm_new\app\data\template\rainfall"
+
+# 收集所有非GPKG动态图层的表名
+all_dynamic = set()
+for fname in sorted(os.listdir(TEMPLATE_DIR)):
+    if not fname.endswith('.qgz') or fname.startswith('tmp'):
+        continue
+    path = os.path.join(TEMPLATE_DIR, fname)
+    z = zipfile.ZipFile(path)
+    qgs_name = [n for n in z.namelist() if n.endswith('.qgs')][0]
+    content = z.read(qgs_name).decode('utf-8')
+    
+    maplayer_re = re.compile(r'<maplayer[^>]*>(.*?)</maplayer>', re.DOTALL)
+    for m in maplayer_re.finditer(content):
+        block = m.group(1)
+        name_m = re.search(r'<layername>([^<]+)</layername>', block)
+        provider_m = re.search(r'<provider[^>]*>(\w+)</provider>', block)
+        ds_m = re.search(r'<datasource>(.*?)</datasource>', block, re.DOTALL)
+        
+        provider = provider_m.group(1) if provider_m else '?'
+        if provider != 'postgres':
+            continue
+        
+        ds = ds_m.group(1).strip() if ds_m else ''
+        table_m = re.search(r'table="(\w+)"\."(\w+)"', ds)
+        layer_name = name_m.group(1) if name_m else '?'
+        
+        if table_m:
+            schema = table_m.group(1)
+            table = table_m.group(2)
+            key = f"{schema}.{table}"
+            all_dynamic.add((layer_name, key))
+
+# 已知的GPKG静态层（会被替换为ogr）
+static_tables = {
+    'base.rivers', 'base.river', 'base.sx', 'base.sx_capital',
+    'base.sx_street', 'base.sx_xa_county', 'base.sx_xa_county_boundary',
+    'base.sx_zb_county_boundary', 'base.sx_zb_city', 'base.sx_zb_county',
+    'base.active_fault', 'base.traffic_expressway', 'base.traffic_provincial',
+    'base.traffic_railway', 'base.traffic_township', 'base.traffic_trunk_line',
+}
+
+# DB检查
+c = psycopg2.connect(host='47.92.216.173', port=7654, user='postgres', password='zhangsan', database='xian_new')
+c.autocommit = True
+cur = c.cursor()
+
+print(f"{'图层名':20s} {'原表':35s} {'qgis中存在':12s} {'行数':>8s}")
+print("-" * 80)
+
+for layer_name, table_key in sorted(all_dynamic):
+    if table_key in static_tables:
+        continue  # 会被GPKG替换，跳过
+    
+    schema, table = table_key.split('.', 1)
+    try:
+        cur.execute(f'SELECT count(*) FROM qgis.{table}')
+        count = cur.fetchone()[0]
+        exists = "YES"
+    except:
+        exists = "NO"
+        count = 0
+    
+    marker = " !!!" if exists == "NO" else ""
+    print(f"{layer_name:20s} {table_key:35s} {exists:12s} {count:>8,d}{marker}")
+
+c.close()

tools/check_layer_order.py

@@ -0,0 +1,54 @@
+"""检查模板中所有图层的渲染顺序（z-order）"""
+import zipfile, re, os
+
+TEMPLATE_DIR = r"F:\project\xian\xian_algorithm_new\app\data\template\rainfall"
+fname = "暴雨内涝潜在隐患点及人口分布图.qgz"
+path = os.path.join(TEMPLATE_DIR, fname)
+
+z = zipfile.ZipFile(path)
+qgs_name = [n for n in z.namelist() if n.endswith('.qgs')][0]
+content = z.read(qgs_name).decode('utf-8')
+
+# 提取所有 maplayer 块（保持顺序 — 这就是渲染顺序）
+maplayer_re = re.compile(r'<maplayer[^>]*>(.*?)</maplayer>', re.DOTALL)
+
+print(f"模板: {fname}")
+print(f"{'#':>3s} {'图层名':20s} {'类型':10s} {'可见':4s} {'表名'}")
+print("-" * 80)
+
+for i, m in enumerate(maplayer_re.finditer(content)):
+    block = m.group(1)
+    
+    # 图层名
+    name_m = re.search(r'<layername>([^<]+)</layername>', block)
+    name = name_m.group(1) if name_m else '?'
+    
+    # provider
+    provider_m = re.search(r'<provider[^>]*>(\w+)</provider>', block)
+    provider = provider_m.group(1) if provider_m else '?'
+    
+    # datasource table
+    ds_m = re.search(r'<datasource>(.*?)</datasource>', block, re.DOTALL)
+    ds = ds_m.group(1).strip() if ds_m else ''
+    table_m = re.search(r'table="(\w+)"\."(\w+)"', ds)
+    table = f"{table_m.group(1)}.{table_m.group(2)}" if table_m else '?'
+    
+    # 可见性
+    visible = 'Y' if 'visible="1"' in m.group(0) or 'visible="1"' in block else 'N'
+    
+    # 判断图层类型
+    is_static = table in [
+        'base.rivers', 'base.river', 'base.sx', 'base.sx_capital',
+        'base.sx_street', 'base.sx_xa_county', 'base.sx_xa_county_boundary',
+        'base.sx_zb_county_boundary', 'base.sx_zb_city', 'base.sx_zb_county',
+        'base.active_fault', 'base.traffic_expressway', 'base.traffic_provincial',
+        'base.traffic_railway', 'base.traffic_township', 'base.traffic_trunk_line',
+    ]
+    layer_type = "底图" if is_static else "动态"
+    
+    marker = " <<<" if not is_static and provider == 'postgres' else ""
+    print(f"{i+1:>3d} {name:20s} {provider:10s} {visible:4s} {table:35s} [{layer_type}]{marker}")
+
+print()
+print("提示: 图层按从上到下的顺序渲染（序号小的在底层，序号大的在顶层）")
+print("动态图层如果在底图下方，会被底图完全遮盖")

tools/check_layout.py

@@ -0,0 +1,65 @@
+"""检查布局 Map 项的图层配置"""
+import zipfile, re, os
+
+TEMPLATE_DIR = r"F:\project\xian\xian_algorithm_new\app\data\template\rainfall"
+fname = "暴雨内涝潜在隐患点及人口分布图.qgz"
+path = os.path.join(TEMPLATE_DIR, fname)
+
+z = zipfile.ZipFile(path)
+qgs_name = [n for n in z.namelist() if n.endswith('.qgs')][0]
+content = z.read(qgs_name).decode('utf-8')
+
+# 提取 Layout 元素（找 Map 项）
+# QGIS 有两种布局格式：<Composer> (QGIS 2.x style) 和 <Layout> (QGIS 3.x style)
+layout_re = re.compile(r'<(?:Composer|Layout)[^>]*name="([^"]*)"[^>]*>(.*?)</(?:Composer|Layout)>', re.DOTALL)
+
+for m in layout_re.finditer(content):
+    layout_name = m.group(1)
+    layout_content = m.group(2)
+    print(f"=== 布局: {layout_name} ===")
+    
+    # 检查 Map 项
+    map_item_re = re.compile(r'<ComposerMap[^>]*>(.*?)</ComposerMap>', re.DOTALL)
+    for mm in map_item_re.finditer(layout_content):
+        map_content = mm.group(1)
+        
+        # 检查是否有 lockedLayers
+        locked = re.findall(r'<lockedLayers>(.*?)</lockedLayers>', map_content, re.DOTALL)
+        if locked:
+            print(f"  lockedLayers: {locked[0][:500]}")
+        
+        # 检查 keepLayerSet
+        keep_set = re.findall(r'keepLayerSet="([^"]*)"', mm.group(0))
+        if keep_set:
+            print(f"  keepLayerSet: {keep_set[0]}")
+        
+        # 检查 followPreset
+        preset = re.findall(r'followPreset="([^"]*)"', mm.group(0))
+        if preset:
+            print(f"  followPreset: {preset[0]}")
+        
+        # 检查 followPresetName
+        preset_name = re.findall(r'followPresetName="([^"]*)"', mm.group(0))
+        if preset_name:
+            print(f"  followPresetName: {preset_name[0]}")
+        
+        # 检查 <layerSet>
+        layer_set = re.findall(r'<layerSet>(.*?)</layerSet>', map_content, re.DOTALL)
+        if layer_set:
+            print(f"  layerSet: {layer_set[0][:500]}")
+        
+        # 检查 <ComposerMapGrid>
+        grids = re.findall(r'<ComposerMapGrid[^>]*/>', map_content)
+        print(f"  grids: {len(grids)}")
+
+    # 也检查 <Layout> 格式 (QGIS 3.x)
+    map_item2_re = re.compile(r'<LayoutItem[^>]*type="[^"]*map[^"]*"[^>]*>(.*?)</LayoutItem>', re.DOTALL | re.IGNORECASE)
+    for mm in map_item2_re.finditer(layout_content):
+        map_content = mm.group(1)
+        print(f"  [LayoutItem Map] attributes: {mm.group(0)[:300]}")
+
+# 打印模板中所有的 map theme / visibility preset
+presets = re.findall(r'<(?:visibility-presets|map-theme-collection).*?</(?:visibility-presets|map-theme-collection)>', content, re.DOTALL)
+if presets:
+    print("\n=== 可见性预设 ===")
+    print(presets[0][:500])

tools/check_shelter.py

@@ -0,0 +1,71 @@
+"""检查暴雨避难场所分布图的所有动态图层是否有数据"""
+import zipfile, re, os, psycopg2
+
+TEMPLATE_PATH = r"F:\project\xian\xian_algorithm_new\app\data\template\rainfall\暴雨避难场所分布图.qgz"
+
+z = zipfile.ZipFile(TEMPLATE_PATH)
+qgs_name = [n for n in z.namelist() if n.endswith('.qgs')][0]
+content = z.read(qgs_name).decode('utf-8')
+
+maplayer_re = re.compile(r'<maplayer[^>]*>(.*?)</maplayer>', re.DOTALL)
+
+# 收集所有 PostgreSQL 动态图层
+layers = []
+for m in maplayer_re.finditer(content):
+    block = m.group(1)
+    name_m = re.search(r'<layername>([^<]+)</layername>', block)
+    provider_m = re.search(r'<provider[^>]*>(\w+)</provider>', block)
+    ds_m = re.search(r'<datasource>(.*?)</datasource>', block, re.DOTALL)
+    
+    provider = provider_m.group(1) if provider_m else '?'
+    if provider != 'postgres':
+        continue
+    
+    name = name_m.group(1) if name_m else '?'
+    ds = ds_m.group(1).strip() if ds_m else ''
+    table_m = re.search(r'table="(\w+)"\."(\w+)"', ds)
+    table_key = f"{table_m.group(1)}.{table_m.group(2)}" if table_m else '?'
+
+    layers.append((name, table_key))
+
+# 已知 GPKG 静态层
+static_tables = {
+    'base.rivers', 'base.river', 'base.sx', 'base.sx_capital',
+    'base.sx_street', 'base.sx_xa_county', 'base.sx_xa_county_boundary',
+    'base.sx_zb_county_boundary', 'base.sx_zb_city', 'base.sx_zb_county',
+    'base.active_fault', 'base.traffic_expressway', 'base.traffic_provincial',
+    'base.traffic_railway', 'base.traffic_township', 'base.traffic_trunk_line',
+}
+
+c = psycopg2.connect(host='47.92.216.173', port=7654, user='postgres', password='zhangsan', database='xian_new')
+c.autocommit = True
+cur = c.cursor()
+
+print(f"模板: 暴雨避难场所分布图")
+print(f"{'图层名':20s} {'原表':40s} {'qgis有数据':10s} {'行数':>6s}")
+print("-" * 85)
+
+for name, table_key in layers:
+    if table_key in static_tables:
+        continue
+    
+    schema, table = table_key.split('.', 1)
+    mapped_table = 'hazard_hydrops' if table == 'hazard_waterlogging' else table
+    
+    try:
+        cur.execute(f'SELECT count(*) FROM qgis.{mapped_table}')
+        count = cur.fetchone()[0]
+        exists = "YES" if count > 0 else "EMPTY"
+    except:
+        try:
+            cur.execute(f'SELECT count(*) FROM {schema}.{table}')
+            count = cur.fetchone()[0]
+            exists = f"在{schema}"
+        except:
+            exists = "NO"
+            count = 0
+    
+    marker = " <-- 无数据!" if count == 0 else ""
+    print(f"{name:20s} {table_key:40s} {exists:10s} {count:>6,d}{marker}")
+
+c.close()

tools/check_tables.py

@@ -0,0 +1,38 @@
+import psycopg2
+c = psycopg2.connect(host='47.92.216.173', port=7654, user='postgres', password='zhangsan', database='xian_new')
+cur = c.cursor()
+
+tables = ['lifeline_outfall', 'lifeline_pipe', 'risk_census_population', 'hazard_waterlogging', 'sx_street', 'sx_xa_county']
+
+print("=== qgis schema ===")
+for t in tables:
+    try:
+        cur.execute(f'SELECT COUNT(*) FROM qgis."{t}"')
+        count = cur.fetchone()[0]
+        cur.execute(f"SELECT GeometryType(geom) FROM qgis.\"{t}\" LIMIT 1")
+        g = cur.fetchone()
+        print(f"  qgis.{t}: {count} 行, geom={g[0] if g else 'N/A'}")
+    except Exception as e:
+        print(f"  qgis.{t}: 不存在")
+
+print("\n=== base schema (检查积水点原始表) ===")
+for t in ['hazard_waterlogging']:
+    try:
+        cur.execute(f'SELECT COUNT(*) FROM base."{t}"')
+        print(f"  base.{t}: {cur.fetchone()[0]} 行")
+    except:
+        print(f"  base.{t}: 不存在")
+
+# 查找所有含 water 或 hazard 的表
+print("\n=== 搜索含 water/hazard 的表 ===")
+cur.execute("""
+    SELECT table_schema, table_name 
+    FROM information_schema.tables 
+    WHERE (table_name LIKE '%water%' OR table_name LIKE '%hazard%')
+    AND table_schema IN ('qgis', 'base', 'public')
+    ORDER BY table_schema, table_name
+""")
+for r in cur.fetchall():
+    print(f"  {r[0]}.{r[1]}")
+
+c.close()

tools/inspect_layers.py

@@ -0,0 +1,42 @@
+"""提取模板 .qgs 中所有图层名称、类型、数据源"""
+import zipfile, re, os, sys
+
+template_dir = r"F:\project\xian\xian_algorithm_new\app\data\template\rainfall"
+for fname in sorted(os.listdir(template_dir)):
+    if not fname.endswith('.qgz') or fname.startswith('tmp'):
+        continue
+    path = os.path.join(template_dir, fname)
+    z = zipfile.ZipFile(path)
+    # 找到 .qgs 文件
+    qgs_name = [n for n in z.namelist() if n.endswith('.qgs')][0]
+    content = z.read(qgs_name).decode('utf-8')
+    
+    # 提取 maplayer 块
+    maplayer_re = re.compile(r'<maplayer[^>]*>(.*?)</maplayer>', re.DOTALL)
+    layers = []
+    for m in maplayer_re.finditer(content):
+        block = m.group(1)
+        # 图层名
+        name_m = re.search(r'<layername>([^<]+)</layername>', block)
+        # provider
+        provider_m = re.search(r'<provider[^>]*>(\w+)</provider>', block)
+        # datasource (截取前120字符)
+        ds_m = re.search(r'<datasource>(.*?)</datasource>', block, re.DOTALL)
+        
+        name = name_m.group(1) if name_m else '?'
+        provider = provider_m.group(1) if provider_m else '?'
+        ds = ds_m.group(1).strip()[:120] if ds_m else '?'
+        
+        layers.append((name, provider, ds))
+    
+    print(f"\n{'='*60}")
+    print(f"模板: {fname}")
+    print(f"{'='*60}")
+    for name, provider, ds in layers:
+        print(f"  [{provider:10s}] {name}")
+        if ds:
+            print(f"              ds: {ds}")
+    
+    # 只分析第一个模板（所有 rainfall 模板结构相同）
+    if fname == '暴雨内涝潜在隐患点及人口分布图.qgz':
+        break

tools/list_shelter_layers.py

@@ -0,0 +1,16 @@
+import zipfile, re
+
+z = zipfile.ZipFile(r"F:\project\xian\xian_algorithm_new\app\data\template\rainfall\暴雨避难场所分布图.qgz")
+c = z.read([n for n in z.namelist() if n.endswith('.qgs')][0]).decode()
+layers = re.findall(r'<maplayer[^>]*>(.*?)</maplayer>', c, re.DOTALL)
+
+for i, l in enumerate(layers):
+    nm = re.search(r'<layername>([^<]+)</layername>', l)
+    pv = re.search(r'<provider[^>]*>(\w+)</provider>', l)
+    ds = re.search(r'<datasource>(.*?)</datasource>', l, re.DOTALL)
+    name = nm.group(1) if nm else '?'
+    prov = pv.group(1) if pv else '?'
+    ds_text = ds.group(1).strip()[:120] if ds else ''
+    print(f"{i:2d}. [{prov:10s}] {name}")
+    if ds_text:
+        print(f"    ds: {ds_text}")

tools/test_single_map.py

@@ -0,0 +1,295 @@
+"""
+单张专题图测试脚本 - 独立版
+直接构建 model/config 并通过 subprocess 调用 qgis_runner.py
+"""
+import json, os, sys, tempfile, subprocess, re
+from datetime import datetime
+
+# ============================================================
+# 配置（和 settings.toml 一致）
+# ============================================================
+DB_CONFIG = {
+    "host": "47.92.216.173",
+    "port": 7654,
+    "username": "postgres",
+    "password": "zhangsan",
+    "database": "xian_new",
+}
+QGIS_ROOT = "D:/QGIS"
+XIAN_CENTER = [108.948024, 34.263161]
+GPKG_DIR = r"F:\project\xian\xian_algorithm_new\app\data\gpkg".replace("\\", "/")
+TEMPLATE_BASE = r"F:\project\xian\xian_algorithm_new\app\data\template"
+
+# ============================================================
+# 模拟推理结果（inference_id=50）
+# ============================================================
+# 从实际数据库查询得知:
+# event_type='rainfall', condition={'region_code':'610116','rainfall':'120'},
+# occurred_time='2025-09-16 20:00:00'
+inference = {
+    "id": 50,
+    "event_type": "rainfall",
+    "condition": {"region_code": "610116", "rainfall": "120"},
+    "occurred_time": datetime(2025, 9, 16, 20, 0, 0),
+}
+
+# ============================================================
+# 区域映射（从 settings.toml）
+# ============================================================
+AREA_MAP = {
+    "610102": "新城区", "610103": "碑林区", "610104": "莲湖区",
+    "610111": "灞桥区", "610112": "未央区", "610113": "雁塔区",
+    "610114": "阎良区", "610115": "临潼区", "610116": "长安区",
+    "610117": "高陵区", "610118": "鄠邑区", "610122": "蓝田县",
+    "610124": "周至县",
+}
+
+STATIC_LAYERS = {
+    "水库": ("base.rivers", "rivers.gpkg"),
+    "市州驻地": ("base.sx_capital", "sx_capital.gpkg"),
+    "河流": ("base.river", "river.gpkg"),
+    "active_fault": ("base.active_fault", "active_fault.gpkg"),
+    "陕西省": ("base.sx", "sx.gpkg"),
+    "乡镇驻地": ("base.sx_street", "sx_street.gpkg"),
+    "区县驻地": ("base.sx_xa_county", "sx_xa_county.gpkg"),
+    "县界": ("base.sx_xa_county_boundary", "sx_xa_county_boundary.gpkg"),
+    "周边区县": ("base.sx_zb_county_boundary", "sx_zb_county_boundary.gpkg"),
+    "周边市州": ("base.sx_zb_city", "sx_zb_city.gpkg"),
+    "周边县区": ("base.sx_zb_county", "sx_zb_county.gpkg"),
+    "traffic_expressway": ("base.traffic_expressway", "traffic_expressway.gpkg"),
+    "traffic_provincial": ("base.traffic_provincial", "traffic_provincial.gpkg"),
+    "traffic_railway": ("base.traffic_railway", "traffic_railway.gpkg"),
+    "traffic_township": ("base.traffic_township", "traffic_township.gpkg"),
+    "traffic_trunk_line": ("base.traffic_trunk_line", "traffic_trunk_line.gpkg"),
+}
+
+# ============================================================
+# 辅助函数（从 qgis_map_export.py 直接复制）
+# ============================================================
+def format_disaster_time(occurred_time):
+    if isinstance(occurred_time, datetime):
+        return occurred_time.strftime("%Y%m%d%H%M%S")
+    return str(occurred_time).replace("-", "").replace(":", "").replace(" ", "")[:14]
+
+def resolve_district(condition):
+    code = condition.get("region_code")
+    if code and str(code) in AREA_MAP:
+        return AREA_MAP[str(code)]
+    return ""
+
+def build_map_title(event_type, condition, template_name):
+    district = resolve_district(condition)
+    prefix = f"陕西西安{district}" if district else "陕西西安"
+    if event_type == "rainfall":
+        rainfall = condition.get("rainfall")
+        if rainfall is not None and rainfall != "":
+            return f"{prefix}{float(rainfall)}mm{template_name}"
+        return f"{prefix}{template_name}"
+    return f"{prefix}{template_name}"
+
+def build_info_text(event_type, condition, occurred_time):
+    """构建信息面板文本（不显示灾害类型标签）"""
+    lines = []
+    if isinstance(occurred_time, datetime):
+        time_str = f"{occurred_time.year}年{occurred_time.month:02d}月{occurred_time.day:02d}日{occurred_time.hour:02d}时{occurred_time.minute:02d}分"
+    elif occurred_time:
+        time_str = str(occurred_time)
+    else:
+        time_str = ""
+    lines.append(f"时间：{time_str}")
+    
+    if event_type == "rainfall":
+        rainfall = condition.get("rainfall")
+        if rainfall is not None and rainfall != "":
+            lines.append(f"累计降雨量：{float(rainfall)}mm")
+        duration = condition.get("duration")
+        if duration is not None and duration != "":
+            lines.append(f"已持续：{duration}")
+    elif event_type == "earthquake":
+        magnitude = condition.get("magnitude")
+        if magnitude is not None and magnitude != "":
+            lines.append(f"震级：{float(magnitude)}级")
+        lon = condition.get("epicenter_lon")
+        lat = condition.get("epicenter_lat")
+        if lon is not None and lat is not None:
+            lines.append(f"位置：经度{float(lon)}°, 纬度{float(lat)}°")
+    
+    return "\n".join(lines)
+
+def derive_model_params(inference, batch_folder, template_path):
+    event_type = inference["event_type"]
+    condition = inference["condition"]
+    occurred_time = inference["occurred_time"]
+    
+    template_name = os.path.splitext(os.path.basename(template_path))[0]
+    map_title = build_map_title(event_type, condition, template_name)
+    safe_name = re.sub(r'[\\/:*?"<>|]', '_', template_name)
+    out_file = os.path.join(batch_folder, f"{safe_name}.jpg").replace("\\", "/")
+    
+    if isinstance(occurred_time, datetime):
+        map_time = occurred_time.strftime("%Y-%m-%d %H:%M")
+    else:
+        map_time = str(occurred_time)
+    
+    info_text = build_info_text(event_type, condition, occurred_time)
+    
+    center_x, center_y = XIAN_CENTER
+    if event_type == "earthquake":
+        lon = condition.get("epicenter_lon", XIAN_CENTER[0])
+        lat = condition.get("epicenter_lat", XIAN_CENTER[1])
+        center_x, center_y = float(lon), float(lat)
+    
+    return {
+        "name": f"test_{inference['id']}_{safe_name}",
+        "path": template_path,
+        "outFile": out_file,
+        "mapLayout": "A3",
+        "mapTitle": map_title,
+        "mapTime": map_time,
+        "mapUnit": "西安市应急管理局",
+        "info": info_text,
+        "centerX": center_x,
+        "centerY": center_y,
+        "event": str(inference["id"]),
+        "queueId": str(inference["id"]),
+        "zoomRule": "11",
+        "zoomValue": "50",
+    }
+
+def build_qgis_config(batch_folder):
+    static_layers_config = {}
+    for name, (table, gpkg_file) in STATIC_LAYERS.items():
+        static_layers_config[name] = {"file": gpkg_file, "table": table}
+    
+    return {
+        "db": DB_CONFIG,
+        "qgis": {"exportDpi": 300},
+        "template_override": {
+            "enabled": True,
+            "original": {
+                "host": "localhost",
+                "port": 5432,
+                "dbname": "yjzyk_xian",
+                "schema": "base",
+            },
+            "actual": {
+                "host": DB_CONFIG["host"],
+                "port": DB_CONFIG["port"],
+                "dbname": DB_CONFIG["database"],
+                "schema": "qgis",
+                "username": DB_CONFIG["username"],
+                "password": DB_CONFIG["password"],
+            },
+        },
+        "static_layers": {
+            "enabled": True,
+            "gpkg_dir": GPKG_DIR,
+            "layers": static_layers_config,
+        },
+        "batch_folder": batch_folder,
+    }
+
+# ============================================================
+# 主逻辑
+# ============================================================
+event_type = inference["event_type"]
+disaster_time = format_disaster_time(inference["occurred_time"])
+batch_folder = os.path.join("G:/files", "xian/qgis/map", disaster_time).replace("\\", "/")
+os.makedirs(batch_folder, exist_ok=True)
+
+template_dir = os.path.join(TEMPLATE_BASE, event_type)
+template_path = os.path.join(template_dir, "暴雨内涝潜在隐患点及人口分布图.qgz").replace("\\", "/")
+
+model = derive_model_params(inference, batch_folder, template_path)
+config = build_qgis_config(batch_folder)
+
+print("=" * 60)
+print(f"模板: {template_path}")
+print(f"输出: {model['outFile']}")
+print(f"标题: {model['mapTitle']}")
+print(f"时间: {model['mapTime']}")
+print(f"单位: {model['mapUnit']}")
+print(f"info:\n{model['info']}")
+print(f"中心: ({model['centerX']}, {model['centerY']})")
+print(f"event: {model['event']}, queueId: {model['queueId']}")
+print("=" * 60)
+
+request_data = json.dumps(
+    {"config": config, "model": model},
+    ensure_ascii=False,
+)
+
+tmp_json = tempfile.NamedTemporaryFile(
+    suffix=".json", delete=False, mode="w", encoding="utf-8"
+)
+tmp_json.write(request_data)
+tmp_json.close()
+
+runner_script = os.path.join(
+    os.path.dirname(__file__),
+    r"F:\project\xian\xian_algorithm_new\app\services\qgis\qgis_runner.py"
+).replace("\\", "/")
+# Fix: use absolute path
+runner_script = r"F:\project\xian\xian_algorithm_new\app\services\qgis\qgis_runner.py"
+
+bat_dir = os.path.join(tempfile.gettempdir(), "qgis_runner")
+os.makedirs(bat_dir, exist_ok=True)
+bat_path = os.path.join(bat_dir, "run_qgis_test.bat")
+
+qgis_app_dir = os.path.join(QGIS_ROOT, "apps", "qgis-ltr").replace("/", "\\")
+python_dir = os.path.join(QGIS_ROOT, "apps", "Python312").replace("/", "\\")
+qt5_plugins = os.path.join(QGIS_ROOT, "apps", "Qt5", "plugins").replace("/", "\\")
+qtplugins = os.path.join(qgis_app_dir, "qtplugins").replace("/", "\\")
+gdal_data = os.path.join(QGIS_ROOT, "apps", "gdal", "share", "gdal").replace("/", "\\")
+qgis_python_dir = os.path.join(qgis_app_dir, "python").replace("/", "\\")
+qgis_bin = os.path.join(qgis_app_dir, "bin").replace("/", "\\")
+qt5_bin = os.path.join(QGIS_ROOT, "apps", "Qt5", "bin").replace("/", "\\")
+gdal_lib = os.path.join(QGIS_ROOT, "apps", "gdal", "lib").replace("/", "\\")
+python_exe = os.path.join(python_dir, "python3.exe").replace("/", "\\")
+
+bat_content = f"""@echo off
+set "PYTHONHOME={python_dir}"
+set "PYTHONPATH={qgis_python_dir}"
+set "QGIS_PREFIX_PATH={qgis_app_dir}"
+set "QT_PLUGIN_PATH={qtplugins};{qt5_plugins}"
+set "GDAL_DATA={gdal_data}"
+set "PYTHONUTF8=1"
+set "GDAL_FILENAME_IS_UTF8=YES"
+set "VSI_CACHE=TRUE"
+set "VSI_CACHE_SIZE=1000000"
+set "PATH={qgis_bin};{qt5_bin};{gdal_lib};%PATH%"
+"{python_exe}" "{runner_script}" "{tmp_json.name}"
+"""
+
+with open(bat_path, "w", encoding="utf-8") as f:
+    f.write(bat_content)
+
+cmd = ["cmd.exe", "/c", bat_path]
+print(f"执行: {' '.join(cmd[:3])} ...")
+print()
+
+try:
+    result = subprocess.run(cmd, capture_output=True, timeout=300)
+    stderr_text = result.stderr.decode("utf-8", errors="replace")
+    stdout_text = result.stdout.decode("utf-8", errors="replace")
+
+    print("=== stderr ===")
+    for line in stderr_text.split("\n"):
+        print(f"  {line}")
+    print()
+    print("=== stdout ===")
+    print(stdout_text[:500] if stdout_text else "(empty)")
+
+    if result.returncode != 0:
+        print(f"\n!!! FAIL: exit={result.returncode}")
+    else:
+        print(f"\n=== SUCCESS ===")
+        if os.path.isfile(model["outFile"]):
+            print(f"文件: {model['outFile']} ({os.path.getsize(model['outFile'])/1024:.1f} KB)")
+        else:
+            print(f"文件不存在: {model['outFile']}")
+finally:
+    try:
+        os.remove(tmp_json.name)
+    except OSError:
+        pass