"""Water body monitoring v2 router — SARscape-based pipeline.""" from __future__ import annotations import os import re as _re from datetime import datetime from typing import Any, Dict, List, Optional from fastapi import APIRouter, Depends, HTTPException from pydantic import BaseModel, Field from sqlalchemy import select from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy.orm import selectinload from ..config import settings from ..database import get_db from ..models import AuthUserORM, RadarDataORM, SARSceneGeoORM, FloodDetectionORM, WaterDetectionORM, GF3ProcessingORM from ..services.job_handlers import JOB_TYPE_WATER_GEOCODE, JOB_TYPE_WATER_FLOOD, JOB_TYPE_WATER_DETECT, JOB_TYPE_GF3_PROCESS from ..services.job_queue_service import job_queue_service from ..services.task_service import task_service from .dependencies import _require_admin, _get_current_user router = APIRouter() _WATER_JOB_MAX_ATTEMPTS = 3 # --------------------------------------------------------------------------- # Request models # --------------------------------------------------------------------------- class GeocodeRequest(BaseModel): radar_data_id: int = Field(..., description="RadarDataORM 主键") class FloodDetectRequest(BaseModel): pre_scene_id: int = Field(..., description="灾前 SARSceneGeoORM 主键") post_scene_id: int = Field(..., description="灾后 SARSceneGeoORM 主键") refine: bool = Field(default=False, description="是否启用 MRF 精化") class WaterPairRequest(BaseModel): pre_start: Optional[str] = Field(default=None, description="灾前开始日期 YYYYMMDD") pre_end: Optional[str] = Field(default=None, description="灾前结束日期 YYYYMMDD") post_start: Optional[str] = Field(default=None, description="灾后开始日期 YYYYMMDD") post_end: Optional[str] = Field(default=None, description="灾后结束日期 YYYYMMDD") overlap_threshold: float = Field(default=0.3, ge=0.0, le=1.0, description="最小重叠比例") # --------------------------------------------------------------------------- # Helpers # --------------------------------------------------------------------------- def _overlap_ratio(poly_a, poly_b) -> float: """计算两个 polygon 的重叠比例（相对于较小的那个）。 支持 GeoJSON dict 或原始坐标数组 [[lon,lat], ...] 两种格式。 """ try: from shapely.geometry import shape, Polygon def _to_geom(poly): if isinstance(poly, str): import json poly = json.loads(poly) # 原始坐标数组格式：[[lon, lat], ...] if isinstance(poly, list): return Polygon(poly) # GeoJSON dict 格式 return shape(poly) a = _to_geom(poly_a) b = _to_geom(poly_b) if not a.is_valid or not b.is_valid: return 0.0 inter = a.intersection(b).area smaller = min(a.area, b.area) return inter / smaller if smaller > 0 else 0.0 except Exception: return 0.0 async def _queue_water_job( job_type: str, task_type: str, task_name: str, payload: Dict[str, Any], ) -> Dict[str, Any]: try: task_id = await task_service.create_task( task_type=task_type, task_name=task_name, params=payload, ) job_id = await job_queue_service.create_job( job_type=job_type, payload=payload, task_id=task_id, max_attempts=_WATER_JOB_MAX_ATTEMPTS, ) return {"task_id": task_id, "job_id": job_id, "job_type": job_type, "message": "Job queued."} except ValueError as exc: msg = str(exc) raise HTTPException(status_code=409 if "冲突" in msg else 400, detail=msg) from exc # --------------------------------------------------------------------------- # Endpoints # --------------------------------------------------------------------------- @router.post("/water/geocode", status_code=202) async def submit_geocode( req: GeocodeRequest, db: AsyncSession = Depends(get_db), admin_user: AuthUserORM = Depends(_require_admin), ): """提交单景 SAR 地理编码任务（多视 + 地理编码 + 辐射定标）。""" radar = await db.get(RadarDataORM, req.radar_data_id) if not radar: raise HTTPException(status_code=404, detail=f"RadarData id={req.radar_data_id} 不存在") result = await db.execute( select(SARSceneGeoORM) .where(SARSceneGeoORM.radar_data_id == req.radar_data_id) .with_for_update(skip_locked=True) ) scene = result.scalar_one_or_none() if scene and scene.status in ("PENDING", "RUNNING"): raise HTTPException(status_code=409, detail="该场景已有进行中的地理编码任务") if not scene: scene = SARSceneGeoORM(radar_data_id=req.radar_data_id, status="PENDING") db.add(scene) await db.flush() else: scene.status = "PENDING" scene.error_msg = None await db.flush() scene_id = scene.id await db.commit() try: return await _queue_water_job( job_type=JOB_TYPE_WATER_GEOCODE, task_type=f"WATER_GEOCODE_{scene_id}", task_name=f"水体地理编码 radar_id={req.radar_data_id}", payload={"scene_id": scene_id, "radar_data_id": req.radar_data_id}, ) except HTTPException: # job 入队失败，回滚 scene 状态避免卡在 PENDING async with db.begin(): s = await db.get(SARSceneGeoORM, scene_id) if s and s.status == "PENDING": s.status = "FAILED" s.error_msg = "任务入队失败" raise @router.post("/water/scenes/{scene_id}/reset", status_code=200) async def reset_scene_status( scene_id: int, db: AsyncSession = Depends(get_db), admin_user: AuthUserORM = Depends(_require_admin), ): """将卡住的场景状态重置为 FAILED，允许重新提交。""" scene = await db.get(SARSceneGeoORM, scene_id) if not scene: raise HTTPException(status_code=404, detail=f"场景 id={scene_id} 不存在") if scene.status not in ("PENDING", "RUNNING"): raise HTTPException(status_code=400, detail=f"场景当前状态为 {scene.status}，无需重置") scene.status = "FAILED" scene.error_msg = "手动重置（任务已取消）" await db.commit() return {"id": scene_id, "status": "FAILED", "message": "已重置"} @router.get("/water/scenes/done-ids") async def list_done_scene_radar_ids( db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """返回所有 status=DONE 的场景对应的 radar_data_id 列表，用于前端标注。""" result = await db.execute( select(SARSceneGeoORM.radar_data_id).where(SARSceneGeoORM.status == "DONE") ) return {"ids": [row for (row,) in result.all()]} @router.get("/water/scenes/active-ids") async def list_active_scene_radar_ids( db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """返回所有 status=PENDING/RUNNING 的场景对应的 radar_data_id 列表，用于前端标注。""" result = await db.execute( select(SARSceneGeoORM.radar_data_id).where( SARSceneGeoORM.status.in_(["PENDING", "RUNNING"]) ) ) return {"ids": [row for (row,) in result.all()]} @router.get("/water/scenes") async def list_scenes( limit: int = 20, offset: int = 0, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """列出所有单景地理编码记录（分页）。""" from sqlalchemy import func total_result = await db.execute(select(func.count()).select_from(SARSceneGeoORM)) total = total_result.scalar_one() result = await db.execute( select(SARSceneGeoORM, RadarDataORM) .join(RadarDataORM, SARSceneGeoORM.radar_data_id == RadarDataORM.id) .order_by(SARSceneGeoORM.id.desc()) .limit(limit) .offset(offset) ) rows = result.all() items = [] for scene, radar in rows: items.append({ "id": scene.id, "radar_data_id": scene.radar_data_id, "satellite": radar.satellite, "imaging_date": radar.imaging_date, "geo_path": scene.geo_path, "pixel_size_m": scene.pixel_size_m, "status": scene.status, "error_msg": scene.error_msg, "created_at": scene.created_at.isoformat() if scene.created_at else None, "coverage_polygon": radar.coverage_polygon, "min_lat": radar.min_lat, "max_lat": radar.max_lat, "min_lon": radar.min_lon, "max_lon": radar.max_lon, }) return {"items": items, "total": total} @router.delete("/water/scenes/cleanup", status_code=200) async def cleanup_failed_scenes( db: AsyncSession = Depends(get_db), admin_user: AuthUserORM = Depends(_require_admin), ): """删除所有 FAILED 状态的场景记录。""" from sqlalchemy import delete as sql_delete result = await db.execute( sql_delete(SARSceneGeoORM).where(SARSceneGeoORM.status == "FAILED") ) await db.commit() return {"deleted": result.rowcount} @router.post("/water/flood-detect", status_code=202) async def submit_flood_detect( req: FloodDetectRequest, db: AsyncSession = Depends(get_db), admin_user: AuthUserORM = Depends(_require_admin), ): """提交洪涝检测任务（灾前 + 灾后两景配对）。""" pre = await db.get(SARSceneGeoORM, req.pre_scene_id) post = await db.get(SARSceneGeoORM, req.post_scene_id) if not pre: raise HTTPException(status_code=404, detail=f"灾前场景 id={req.pre_scene_id} 不存在") if not post: raise HTTPException(status_code=404, detail=f"灾后场景 id={req.post_scene_id} 不存在") if pre.status != "DONE": raise HTTPException(status_code=400, detail=f"灾前场景尚未完成地理编码 (status={pre.status})") if post.status != "DONE": raise HTTPException(status_code=400, detail=f"灾后场景尚未完成地理编码 (status={post.status})") result = await db.execute( select(FloodDetectionORM).where( FloodDetectionORM.pre_scene_id == req.pre_scene_id, FloodDetectionORM.post_scene_id == req.post_scene_id, ).with_for_update(skip_locked=True) ) det = result.scalar_one_or_none() if det and det.status in ("PENDING", "RUNNING"): raise HTTPException(status_code=409, detail="该配对已有进行中的洪涝检测任务") if not det: det = FloodDetectionORM( pre_scene_id=req.pre_scene_id, post_scene_id=req.post_scene_id, status="PENDING", ) db.add(det) await db.flush() else: det.status = "PENDING" det.error_msg = None await db.flush() det_id = det.id await db.commit() try: return await _queue_water_job( job_type=JOB_TYPE_WATER_FLOOD, task_type=f"WATER_FLOOD_{det_id}", task_name=f"洪涝检测 pre={req.pre_scene_id} post={req.post_scene_id}", payload={"detection_id": det_id, "refine": req.refine}, ) except HTTPException: async with db.begin(): d = await db.get(FloodDetectionORM, det_id) if d and d.status == "PENDING": d.status = "FAILED" d.error_msg = "任务入队失败" raise @router.get("/water/flood-events") async def list_flood_events( db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """列出所有洪涝检测结果。""" result = await db.execute( select(FloodDetectionORM) .options( selectinload(FloodDetectionORM.pre_scene).selectinload(SARSceneGeoORM.radar_data), selectinload(FloodDetectionORM.post_scene).selectinload(SARSceneGeoORM.radar_data), ) .order_by(FloodDetectionORM.id.desc()) ) dets = result.scalars().all() items = [] for det in dets: pre_rd = det.pre_scene.radar_data if det.pre_scene else None post_rd = det.post_scene.radar_data if det.post_scene else None items.append({ "id": det.id, "pre_scene_id": det.pre_scene_id, "post_scene_id": det.post_scene_id, "pre_imaging_date": pre_rd.imaging_date if pre_rd else None, "post_imaging_date": post_rd.imaging_date if post_rd else None, "pre_satellite": pre_rd.satellite if pre_rd else None, "post_satellite": post_rd.satellite if post_rd else None, "pre_geo_path": det.pre_scene.geo_path if det.pre_scene else None, "post_geo_path": det.post_scene.geo_path if det.post_scene else None, "classified_path": det.classified_path, "flood_area_km2": det.flood_area_km2, "stable_water_area_km2": det.stable_water_area_km2, "status": det.status, "error_msg": det.error_msg, "created_at": det.created_at.isoformat() if det.created_at else None, "updated_at": det.updated_at.isoformat() if det.updated_at else None, }) return {"items": items, "total": len(items)} # --------------------------------------------------------------------------- # Flood event map preview helpers # --------------------------------------------------------------------------- def _open_envi_rasterio(path: str): """打开 ENVI 格式栅格（路径可能无扩展名）。优先尝试裸路径，再尝试加 .bin/.img。""" import rasterio # 统一用正斜杠（Windows rasterio 也接受） path = path.replace("\\", "/") # 如果路径本身可以直接打开（ENVI 无扩展名文件） try: return rasterio.open(path) except Exception: pass # 尝试常见扩展名 for ext in (".bin", ".img", ".tif", ".tiff"): try: return rasterio.open(path + ext) except Exception: pass raise FileNotFoundError(f"无法打开栅格文件: {path}") def _raster_to_png_bytes(path: str, colormap: dict) -> tuple[bytes, list]: """将单波段分类栅格渲染为 RGBA PNG，返回 (png_bytes, [min_lat, min_lon, max_lat, max_lon])。""" import numpy as np from PIL import Image import io with _open_envi_rasterio(path) as ds: data = ds.read(1) bounds = ds.bounds geo_bounds = [bounds.bottom, bounds.left, bounds.top, bounds.right] h, w = data.shape rgba = np.zeros((h, w, 4), dtype=np.uint8) for val, color in colormap.items(): mask = data == val rgba[mask] = color img = Image.fromarray(rgba, "RGBA") buf = io.BytesIO() img.save(buf, format="PNG") return buf.getvalue(), geo_bounds def _geo_raster_to_png_bytes(path: str) -> tuple[bytes, list]: """将地理编码后的 SAR 强度图渲染为灰度 PNG（百分位拉伸）。""" import numpy as np from PIL import Image import io with _open_envi_rasterio(path) as ds: data = ds.read(1).astype(np.float32) nodata = ds.nodata bounds = ds.bounds geo_bounds = [bounds.bottom, bounds.left, bounds.top, bounds.right] # 构建 nodata 掩膜：优先用 ds.nodata，否则用 nan/inf if nodata is not None: nodata_mask = (data == nodata) | ~np.isfinite(data) else: nodata_mask = ~np.isfinite(data) valid = data[~nodata_mask] if valid.size == 0: data_norm = np.zeros_like(data, dtype=np.uint8) else: p2, p98 = np.percentile(valid, 2), np.percentile(valid, 98) clipped = np.clip(data, p2, p98) data_norm = ((clipped - p2) / max(p98 - p2, 1e-9) * 255).astype(np.uint8) # 组装 RGBA：nodata 区域 alpha=0，其余 alpha=200 rgba = np.stack([data_norm, data_norm, data_norm, np.full_like(data_norm, 200)], axis=-1) rgba[nodata_mask, 3] = 0 img = Image.fromarray(rgba, "RGBA") buf = io.BytesIO() img.save(buf, format="PNG") return buf.getvalue(), geo_bounds # 分类结果色表：值 → RGBA _FLOOD_COLORMAP = { 1: (24, 144, 255, 200), # 稳定水体 — 蓝 2: (255, 77, 79, 220), # 洪涝 — 红 3: (250, 173, 20, 180), # 高散射 — 黄 4: (80, 80, 80, 80), # 非水体 — 灰（半透明） } @router.get("/water/flood-events/{event_id}/preview/classified") async def flood_event_classified_preview( event_id: int, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """返回洪涝分类结果的 PNG 预览图 + 地理范围（JSON）。""" from fastapi.responses import JSONResponse import base64 det = await db.get(FloodDetectionORM, event_id) if not det or not det.classified_path: raise HTTPException(status_code=404, detail="分类结果文件不存在") path = det.classified_path.replace("\\", "/") if not os.path.isfile(path): raise HTTPException(status_code=404, detail="请求的文件不存在") try: import asyncio png_bytes, geo_bounds = await asyncio.to_thread( _raster_to_png_bytes, path, _FLOOD_COLORMAP ) except Exception as e: raise HTTPException(status_code=500, detail=f"渲染失败: {e}") return JSONResponse({ "image_b64": base64.b64encode(png_bytes).decode(), "bounds": geo_bounds, # [min_lat, min_lon, max_lat, max_lon] "legend": { "稳定水体": "#1890ff", "洪涝": "#ff4d4f", "高散射": "#faad14", "非水体": "#505050", }, }) @router.get("/water/flood-events/{event_id}/preview/pre") async def flood_event_pre_preview( event_id: int, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """返回灾前地理编码影像的灰度 PNG 预览 + 地理范围。""" from fastapi.responses import JSONResponse import base64 det = await db.get(FloodDetectionORM, event_id) if not det: raise HTTPException(status_code=404, detail="记录不存在") pre = await db.get(SARSceneGeoORM, det.pre_scene_id) if not pre or not pre.geo_path: raise HTTPException(status_code=404, detail="灾前场景路径不存在") path = pre.geo_path.replace("\\", "/") if not os.path.isfile(path): raise HTTPException(status_code=404, detail="请求的文件不存在") try: import asyncio png_bytes, geo_bounds = await asyncio.to_thread(_geo_raster_to_png_bytes, path) except Exception as e: raise HTTPException(status_code=500, detail=f"渲染失败: {e}") return JSONResponse({ "image_b64": base64.b64encode(png_bytes).decode(), "bounds": geo_bounds, }) @router.get("/water/flood-events/{event_id}/preview/post") async def flood_event_post_preview( event_id: int, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """返回灾后地理编码影像的灰度 PNG 预览 + 地理范围。""" from fastapi.responses import JSONResponse import base64 det = await db.get(FloodDetectionORM, event_id) if not det: raise HTTPException(status_code=404, detail="记录不存在") post = await db.get(SARSceneGeoORM, det.post_scene_id) if not post or not post.geo_path: raise HTTPException(status_code=404, detail="灾后场景路径不存在") path = post.geo_path.replace("\\", "/") if not os.path.isfile(path): raise HTTPException(status_code=404, detail="请求的文件不存在") try: import asyncio png_bytes, geo_bounds = await asyncio.to_thread(_geo_raster_to_png_bytes, path) except Exception as e: raise HTTPException(status_code=500, detail=f"渲染失败: {e}") return JSONResponse({ "image_b64": base64.b64encode(png_bytes).decode(), "bounds": geo_bounds, }) @router.post("/water/find-pairs") async def find_water_pairs( req: WaterPairRequest, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """按时间范围查找满足重叠条件的灾前/灾后场景配对。""" # 查询灾前候选（status=DONE，日期在范围内） pre_filters = [SARSceneGeoORM.status == "DONE"] if req.pre_start: pre_filters.append(RadarDataORM.imaging_date >= req.pre_start) if req.pre_end: pre_filters.append(RadarDataORM.imaging_date <= req.pre_end) pre_result = await db.execute( select(SARSceneGeoORM, RadarDataORM) .join(RadarDataORM, SARSceneGeoORM.radar_data_id == RadarDataORM.id) .where(*pre_filters) ) pre_scenes = pre_result.all() # 查询灾后候选 post_filters = [SARSceneGeoORM.status == "DONE"] if req.post_start: post_filters.append(RadarDataORM.imaging_date >= req.post_start) if req.post_end: post_filters.append(RadarDataORM.imaging_date <= req.post_end) post_result = await db.execute( select(SARSceneGeoORM, RadarDataORM) .join(RadarDataORM, SARSceneGeoORM.radar_data_id == RadarDataORM.id) .where(*post_filters) ) post_scenes = post_result.all() # 计算所有候选配对的重叠率 candidates = [] for pre_scene, pre_radar in pre_scenes: for post_scene, post_radar in post_scenes: # 同一景不能自配 if pre_scene.id == post_scene.id: continue ratio = 0.0 if pre_radar.coverage_polygon and post_radar.coverage_polygon: ratio = _overlap_ratio(pre_radar.coverage_polygon, post_radar.coverage_polygon) if ratio < req.overlap_threshold: continue try: pre_date = datetime.strptime(pre_radar.imaging_date, "%Y%m%d") post_date = datetime.strptime(post_radar.imaging_date, "%Y%m%d") time_diff = abs((post_date - pre_date).days) except Exception: time_diff = None candidates.append({ "pre": { "id": pre_scene.id, "imaging_date": pre_radar.imaging_date, "satellite": pre_radar.satellite, "geo_path": pre_scene.geo_path, }, "post": { "id": post_scene.id, "imaging_date": post_radar.imaging_date, "satellite": post_radar.satellite, "geo_path": post_scene.geo_path, }, "overlap_ratio": round(ratio, 4), "time_diff_days": time_diff, }) # 按重叠率降序，贪心去重：每个 pre/post 场景只出现一次 candidates.sort(key=lambda x: x["overlap_ratio"], reverse=True) used_pre, used_post = set(), set() pairs = [] for c in candidates: pid, qid = c["pre"]["id"], c["post"]["id"] if pid in used_pre or qid in used_post: continue used_pre.add(pid) used_post.add(qid) pairs.append(c) pairs.sort(key=lambda x: x["overlap_ratio"], reverse=True) return {"pairs": pairs, "total": len(pairs)} _UID_RE = _re.compile(r"_(\d{7,})$") @router.post("/water/sync-from-disk") async def sync_water_scenes_from_disk( db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_require_admin), ): """扫描 WATER_RESULTS_DIR，把有 geo_db 但未入库的场景补录为 DONE。""" water_dir = settings.WATER_RESULTS_DIR if not os.path.isdir(water_dir): raise HTTPException(status_code=400, detail=f"WATER_RESULTS_DIR 不存在: {water_dir}") # product_unique_id -> radar_data_id uid_rows = await db.execute( select(RadarDataORM.product_unique_id, RadarDataORM.id) .where(RadarDataORM.product_unique_id.isnot(None)) ) uid_to_radar_id: Dict[str, int] = {uid: rid for uid, rid in uid_rows.all() if uid} # 已有 DONE 记录的 radar_data_id done_rows = await db.execute( select(SARSceneGeoORM.radar_data_id).where(SARSceneGeoORM.status == "DONE") ) done_set = {rid for (rid,) in done_rows.all()} inserted = 0 skipped_no_geo_db = 0 skipped_no_match = 0 skipped_already_done = 0 for entry in os.scandir(water_dir): if not entry.is_dir() or not entry.name.startswith("scene_"): continue # 找 *_geo_db 文件 geo_db_path = None for f in os.scandir(entry.path): if f.name.endswith("_geo_db") and not f.name.endswith(".hdr") and not f.name.endswith(".sml"): geo_db_path = f.path break if not geo_db_path: skipped_no_geo_db += 1 continue m = _UID_RE.search(entry.name) if not m: skipped_no_match += 1 continue raw_uid = m.group(1) stripped_uid = raw_uid.lstrip("0") or raw_uid radar_id = uid_to_radar_id.get(raw_uid) or uid_to_radar_id.get(stripped_uid) if not radar_id: skipped_no_match += 1 continue if radar_id in done_set: skipped_already_done += 1 continue # 检查是否已有非 DONE 记录（upsert） existing = await db.execute( select(SARSceneGeoORM).where(SARSceneGeoORM.radar_data_id == radar_id) ) scene = existing.scalar_one_or_none() if scene: scene.status = "DONE" scene.geo_path = geo_db_path else: scene = SARSceneGeoORM( radar_data_id=radar_id, status="DONE", geo_path=geo_db_path, ) db.add(scene) inserted += 1 await db.commit() return { "inserted": inserted, "skipped_no_geo_db": skipped_no_geo_db, "skipped_no_match": skipped_no_match, "skipped_already_done": skipped_already_done, } # --------------------------------------------------------------------------- # Water body detection (Otsu + DEM + morphology) # --------------------------------------------------------------------------- class _WaterDetectReq(BaseModel): scene_id: Optional[int] = Field(default=None, description="SARSceneGeoORM 主键（可选）") input_path: Optional[str] = Field(default=None, description="直接指定 GeoTIFF 路径（可选）") @router.post("/water/detect", status_code=202) async def submit_water_detect( req: _WaterDetectReq, db: AsyncSession = Depends(get_db), admin_user: AuthUserORM = Depends(_require_admin), ): """提交水体检测任务（Otsu 自适应阈值 + DEM/坡度约束 + 形态学 + 连通分量过滤）。""" input_path = req.input_path scene_id = req.scene_id if scene_id: scene = await db.get(SARSceneGeoORM, scene_id) if not scene: raise HTTPException(status_code=404, detail=f"SARSceneGeoORM id={scene_id} 不存在") if not scene.geo_path: raise HTTPException(status_code=400, detail="该场景尚未完成地理编码") # geo_path is ENVI format; try to find a GeoTIFF equivalent or use the path input_path = scene.geo_path if not input_path: raise HTTPException(status_code=400, detail="必须提供 scene_id 或 input_path") det = WaterDetectionORM( scene_id=scene_id, input_path=input_path, status="PENDING", ) db.add(det) await db.flush() detection_id = det.id await db.commit() try: return await _queue_water_job( job_type=JOB_TYPE_WATER_DETECT, task_type=f"WATER_DETECT_{detection_id}", task_name=f"水体检测 id={detection_id}", payload={"detection_id": detection_id}, ) except HTTPException: async with db.begin(): d = await db.get(WaterDetectionORM, detection_id) if d and d.status == "PENDING": d.status = "FAILED" d.error_msg = "任务入队失败" raise @router.get("/water/detections") async def list_water_detections( limit: int = 20, offset: int = 0, status: Optional[str] = None, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """列出水体检测结果（分页）。""" from sqlalchemy import func q = select(func.count()).select_from(WaterDetectionORM) if status: q = q.where(WaterDetectionORM.status == status) total = (await db.execute(q)).scalar_one() q2 = select(WaterDetectionORM).order_by(WaterDetectionORM.id.desc()).limit(limit).offset(offset) if status: q2 = q2.where(WaterDetectionORM.status == status) rows = (await db.execute(q2)).scalars().all() items = [] for det in rows: items.append({ "id": det.id, "scene_id": det.scene_id, "input_path": det.input_path, "output_path": det.output_path, "water_area_km2": det.water_area_km2, "water_pixel_count": det.water_pixel_count, "otsu_threshold_db": det.otsu_threshold_db, "status": det.status, "error_msg": det.error_msg, "created_at": det.created_at.isoformat() if det.created_at else None, "updated_at": det.updated_at.isoformat() if det.updated_at else None, }) return {"items": items, "total": total} @router.get("/water/detections/{detection_id}") async def get_water_detection( detection_id: int, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """获取单个水体检测详情。""" det = await db.get(WaterDetectionORM, detection_id) if not det: raise HTTPException(status_code=404, detail=f"检测记录 id={detection_id} 不存在") return { "id": det.id, "scene_id": det.scene_id, "input_path": det.input_path, "output_path": det.output_path, "water_area_km2": det.water_area_km2, "water_pixel_count": det.water_pixel_count, "otsu_threshold_db": det.otsu_threshold_db, "status": det.status, "error_msg": det.error_msg, "created_at": det.created_at.isoformat() if det.created_at else None, "updated_at": det.updated_at.isoformat() if det.updated_at else None, } # --------------------------------------------------------------------------- # Water detection result preview (binary mask -> PNG) # --------------------------------------------------------------------------- @router.get("/water/detections/{detection_id}/preview") async def get_water_detection_preview( detection_id: int, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """返回水体检测结果的 PNG 预览及地理范围。""" det = await db.get(WaterDetectionORM, detection_id) if not det: raise HTTPException(status_code=404, detail=f"检测记录 id={detection_id} 不存在") if not det.output_path or not os.path.isfile(det.output_path): raise HTTPException(status_code=404, detail="输出文件不存在") import rasterio import io from PIL import Image import numpy as np from fastapi.responses import JSONResponse with rasterio.open(det.output_path) as src: data = src.read(1) transform = src.transform h, w = data.shape min_lon = transform.c max_lon = transform.c + w * transform.a max_lat = transform.f min_lat = transform.f + h * transform.e # Create RGBA image: water=blue semi-transparent, non-water=transparent rgba = np.zeros((data.shape[0], data.shape[1], 4), dtype=np.uint8) water_mask = data > 0 rgba[water_mask] = [24, 144, 255, 160] # #1890ff with alpha img = Image.fromarray(rgba, "RGBA") # Downsample if large max_dim = 1024 if max(w, h) > max_dim: ratio = max_dim / max(w, h) img = img.resize((int(w * ratio), int(h * ratio)), Image.NEAREST) buf = io.BytesIO() img.save(buf, format="PNG") import base64 png_b64 = base64.b64encode(buf.getvalue()).decode() return { "png_base64": png_b64, "bounds": { "min_lon": min_lon, "min_lat": min_lat, "max_lon": max_lon, "max_lat": max_lat, }, } # --------------------------------------------------------------------------- # GF3 L1A -> L2 processing # --------------------------------------------------------------------------- class _GF3ProcessReq(BaseModel): input_dir: str = Field(..., description="GF3 L1A 数据目录路径") resolution: float = Field(default=0.0002, ge=0.00001, le=0.01, description="输出分辨率（度）") @router.post("/water/gf3-process", status_code=202) async def submit_gf3_process( req: _GF3ProcessReq, db: AsyncSession = Depends(get_db), admin_user: AuthUserORM = Depends(_require_admin), ): """提交 GF3 L1A→L2 处理任务（辐射定标 + RPC 几何校正）。""" if not settings.GF3_LEGACY_GDAL_ENABLED: raise HTTPException( status_code=409, detail=( "Legacy GF3 Python/GDAL preprocessing is disabled. " "Use /monitor/gf3-sarscape-produce or /monitor/gf3-sarscape-sync." ), ) if not os.path.exists(req.input_dir): raise HTTPException(status_code=400, detail=f"输入路径不存在: {req.input_dir}") output_dir = os.path.join(settings.GF3_STORAGE_DIRS, f"gf3_{os.path.basename(req.input_dir)}") proc = GF3ProcessingORM( input_dir=req.input_dir, output_dir=output_dir, resolution=req.resolution, status="PENDING", ) db.add(proc) await db.flush() processing_id = proc.id await db.commit() try: return await _queue_water_job( job_type=JOB_TYPE_GF3_PROCESS, task_type=f"GF3_PROCESS_{processing_id}", task_name=f"GF3 处理 id={processing_id}", payload={"processing_id": processing_id}, ) except HTTPException: async with db.begin(): p = await db.get(GF3ProcessingORM, processing_id) if p and p.status == "PENDING": p.status = "FAILED" p.error_msg = "任务入队失败" raise @router.get("/water/gf3-results") async def list_gf3_results( limit: int = 20, offset: int = 0, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """列出 GF3 处理结果（分页）。""" from sqlalchemy import func total = (await db.execute( select(func.count()).select_from(GF3ProcessingORM) )).scalar_one() rows = (await db.execute( select(GF3ProcessingORM).order_by(GF3ProcessingORM.id.desc()).limit(limit).offset(offset) )).scalars().all() items = [] for proc in rows: items.append({ "id": proc.id, "input_dir": proc.input_dir, "output_dir": proc.output_dir, "polarizations": proc.polarizations, "l2_paths": proc.l2_paths, "resolution": proc.resolution, "status": proc.status, "error_msg": proc.error_msg, "created_at": proc.created_at.isoformat() if proc.created_at else None, "updated_at": proc.updated_at.isoformat() if proc.updated_at else None, }) return {"items": items, "total": total} @router.get("/water/gf3-results/{result_id}") async def get_gf3_result( result_id: int, db: AsyncSession = Depends(get_db), current_user: AuthUserORM = Depends(_get_current_user), ): """获取单个 GF3 处理结果详情。""" proc = await db.get(GF3ProcessingORM, result_id) if not proc: raise HTTPException(status_code=404, detail=f"GF3 处理记录 id={result_id} 不存在") return { "id": proc.id, "input_dir": proc.input_dir, "output_dir": proc.output_dir, "polarizations": proc.polarizations, "l2_paths": proc.l2_paths, "resolution": proc.resolution, "status": proc.status, "error_msg": proc.error_msg, "created_at": proc.created_at.isoformat() if proc.created_at else None, "updated_at": proc.updated_at.isoformat() if proc.updated_at else None, }