Merge remote-tracking branch 'origin/feat/b03-route-shapefile' into feat/b07-cover-template

# Conflicts: # B03_FileInput/B03_FileInput_Service_Chain.py
2026-09-01 15:34:07 +09:00
parent bc279dd360 892c33c74e
commit e4b859766b
25 changed files with 841 additions and 109 deletions
@@ -177,6 +177,8 @@ export interface UploadOverviewFile {
  file_size_mb: number;
  status: string;
  uploaded_at: string | null;
+  /** 저장 경로 — PRJ 두 장(노선/지형)을 카드에 되돌릴 때 이것으로 가린다. */
+  relative_path: string | null;
 }

 export interface UploadOverviewSession {
@@ -11,6 +11,34 @@ from B03_FileInput.B03_FileInput_Schema import FileUploadDescriptor
 from common_util.common_util_storage import get_project_stage_path
 from config.config_system import CHUNK_TEMP_DIR, UPLOAD_CHUNK_SIZE_BYTES, UPLOAD_MAX_MB

+# shapefile은 형제 파일이 **같은 폴더·같은 basename**이라야 열린다. 확장자별 폴더에
+# 흩어 두면 노선 자체를 못 읽는다. 그래서 세트는 `input/shp/`에 통째로 모은다.
+# 부수 효과가 하나 더 있다 — 노선 PRJ가 이 폴더 안에 남으므로 지형 PRJ(`input/prj/`)와
+# 파일명 정렬 운에 기대지 않고 갈린다 (2026-08-31).
+_SHAPEFILE_FOLDER = "shp"
+_SHAPEFILE_OWNED_EXT = frozenset({"shp", "shx", "dbf", "cpg"})
+
+
+def reconcile_shapefile_members(stage_root: Path) -> list[Path]:
+    """먼저 도착해 다른 폴더에 앉은 shapefile 형제 파일을 `input/shp/`로 모은다.
+
+    파일이 오는 순서를 강제할 수 없다 — PRJ가 SHP보다 먼저 오면 확장자 규칙만으로는
+    `input/prj/`에 앉는다. SHP가 들어온 시점에 같은 basename의 형제를 끌어온다.
+    """
+    input_root = stage_root / "input"
+    shapefile_dir = input_root / _SHAPEFILE_FOLDER
+    if not shapefile_dir.exists():
+        return []
+    moved: list[Path] = []
+    for shape_path in shapefile_dir.glob("*.shp"):
+        for extension in ("shx", "dbf", "cpg", "prj"):
+            stray = input_root / extension / f"{shape_path.stem}.{extension}"
+            target = shapefile_dir / stray.name
+            if stray.exists() and not target.exists():
+                shutil.move(str(stray), str(target))
+                moved.append(target)
+    return moved
+

 def resolve_upload_destination(
    project_root: str | Path,
@@ -18,8 +46,18 @@ def resolve_upload_destination(
 ) -> Path:
    """검증된 파일의 B03 입력 저장 경로를 생성해 반환한다."""
    stage_root = Path(get_project_stage_path(str(project_root), "B03_FileInput")).resolve()
-    file_type = Path(descriptor.original_filename).suffix.lower().lstrip(".")
-    destination = (stage_root / "input" / file_type / descriptor.original_filename).resolve()
+    reconcile_shapefile_members(stage_root)
+
+    source_name = Path(descriptor.original_filename)
+    file_type = source_name.suffix.lower().lstrip(".")
+    folder = file_type
+    if file_type in _SHAPEFILE_OWNED_EXT:
+        folder = _SHAPEFILE_FOLDER
+    elif file_type == "prj":
+        # 노선 shapefile의 짝 PRJ만 세트 폴더로. 지형 PRJ는 `input/prj/`에 남는다.
+        if (stage_root / "input" / _SHAPEFILE_FOLDER / f"{source_name.stem}.shp").exists():
+            folder = _SHAPEFILE_FOLDER
+    destination = (stage_root / "input" / folder / descriptor.original_filename).resolve()

    if os.path.commonpath((stage_root, destination)) != str(stage_root):
        raise ValueError("업로드 저장 경로가 B03 단계 폴더를 벗어났습니다.")
@@ -396,6 +396,10 @@ def analyze_input_metadata(path: str | Path) -> dict[str, Any]:
    extension = source.suffix.lower()
    if extension == ".csv":
        return analyze_planned_route_csv(source)
+    if extension == ".shp":
+        from B03_FileInput.B03_FileInput_Engine_Shapefile import analyze_shapefile_metadata
+
+        return analyze_shapefile_metadata(source)
    if extension in {".las", ".laz"}:
        return analyze_las_metadata(source)
    if extension == ".prj":
@@ -0,0 +1,244 @@
+"""계획노선 shapefile(.shp) 판독 — 기하·속성·좌표계.
+
+GDAL/geopandas를 쓰지 않고 ESRI Shapefile 규격을 직접 읽는다. 업로드 **직후**
+메타데이터를 내야 하는데 그 시점엔 형제 파일(.shx/.dbf/.prj)이 아직 다 도착하지
+않았을 수 있고, GDAL은 한 짝이라도 비면 열기 자체를 실패하기 때문이다. 규격 파싱은
+.shp 하나만으로 기하를 읽어 낸다.
+
+좌표계는 EPSG 코드로 가리지 않는다 — 짝 PRJ 원문을 `crs_input_from_prj()`에 넘겨
+"EPSG:n" 또는 **원문 WKT**를 그대로 변환기 입력으로 쓴다(2026-08-31 사용자 확정).
+"""
+
+import logging
+import struct
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_HEADER_BYTES = 100
+_FILE_CODE = 9994
+
+# 규격상 폴리라인 계열만 계획노선으로 받는다. Z/M 변형도 XY는 같은 자리에 있다.
+_POLYLINE_TYPES = {3: "PolyLine", 13: "PolyLineZ", 23: "PolyLineM"}
+_SHAPE_TYPE_NAMES = {
+    0: "Null",
+    1: "Point",
+    3: "PolyLine",
+    5: "Polygon",
+    8: "MultiPoint",
+    11: "PointZ",
+    13: "PolyLineZ",
+    15: "PolygonZ",
+    18: "MultiPointZ",
+    21: "PointM",
+    23: "PolyLineM",
+    25: "PolygonM",
+    28: "MultiPointM",
+    31: "MultiPatch",
+}
+
+
+def _normalize_codepage(text: str) -> str | None:
+    """.cpg 내용을 파이썬 인코딩 이름으로 바꾼다.
+
+    실물은 `949` 한 줄만 들어 있다(2026-08-31 원청 자료) — `CP949`도 `EUC-KR`도
+    아니라서 그대로 넘기면 LookupError가 난다.
+    """
+    value = (text or "").strip()
+    if not value:
+        return None
+    if value.isdigit():
+        return f"cp{value}"
+    upper = value.upper().replace("-", "").replace("_", "")
+    if upper in {"ANSI", "OEM", "SYSTEM"}:
+        return "cp949"
+    return value
+
+
+def shapefile_encoding(path: Path) -> str:
+    """짝 .cpg에 적힌 인코딩. 없으면 국내 자료 관례대로 CP949."""
+    cpg_path = path.with_suffix(".cpg")
+    if cpg_path.exists():
+        try:
+            encoding = _normalize_codepage(cpg_path.read_text(encoding="ascii", errors="ignore"))
+            if encoding:
+                "".encode(encoding)  # 이름이 실재하는지 확인 — 없으면 LookupError
+                return encoding
+        except (OSError, LookupError):
+            logger.warning("shapefile .cpg 인코딩을 해석하지 못했습니다: %s", cpg_path.name)
+    return "cp949"
+
+
+def shapefile_crs_input(path: Path) -> str | None:
+    """짝 .prj를 `Transformer.from_crs` 입력 문자열로 정규화해 돌려준다."""
+    prj_path = path.with_suffix(".prj")
+    if not prj_path.exists():
+        return None
+    from common_util.common_util_crs import crs_input_from_prj
+
+    return crs_input_from_prj(prj_path.read_text(encoding="utf-8", errors="ignore"))
+
+
+def shapefile_epsg_label(path: Path) -> int | None:
+    """짝 .prj의 EPSG **라벨**. 변환에는 쓰지 않는다 — 메타 표시·로그용."""
+    prj_path = path.with_suffix(".prj")
+    if not prj_path.exists():
+        return None
+    from pyproj import CRS
+
+    from common_util.common_util_crs import identify_epsg
+
+    text = prj_path.read_text(encoding="utf-8", errors="ignore")
+    try:
+        return identify_epsg(CRS.from_wkt(text), text)
+    except Exception:  # pragma: no cover — WKT 불량은 라벨 없음으로 흘린다
+        return None
+
+
+def _read_header(blob: bytes) -> dict[str, Any]:
+    if len(blob) < _HEADER_BYTES:
+        raise ValueError("shapefile 헤더가 100바이트에 못 미칩니다.")
+    file_code = struct.unpack(">i", blob[0:4])[0]
+    if file_code != _FILE_CODE:
+        raise ValueError("shapefile 파일 코드가 규격(9994)과 다릅니다.")
+    declared_bytes = struct.unpack(">i", blob[24:28])[0] * 2
+    shape_type = struct.unpack("<i", blob[32:36])[0]
+    x_min, y_min, x_max, y_max = struct.unpack("<4d", blob[36:68])
+    z_min, z_max = struct.unpack("<2d", blob[68:84])
+    return {
+        "shape_type": shape_type,
+        "shape_type_name": _SHAPE_TYPE_NAMES.get(shape_type, f"Unknown({shape_type})"),
+        "declared_bytes": declared_bytes,
+        "bounds": {
+            "x_min": x_min,
+            "x_max": x_max,
+            "y_min": y_min,
+            "y_max": y_max,
+            "z_min": z_min,
+            "z_max": z_max,
+        },
+    }
+
+
+def _read_polyline_record(blob: bytes, offset: int, content_bytes: int) -> list[list[tuple]]:
+    """폴리라인 레코드 하나를 파트별 정점 목록으로 푼다."""
+    record_type = struct.unpack("<i", blob[offset : offset + 4])[0]
+    if record_type == 0:  # Null shape — 규격상 건너뛴다
+        return []
+    if record_type not in _POLYLINE_TYPES:
+        raise ValueError(f"계획노선은 폴리라인이어야 합니다(받은 형상: {record_type}).")
+
+    cursor = offset + 4 + 32  # 형상종류 + 레코드 bbox
+    part_count, point_count = struct.unpack("<2i", blob[cursor : cursor + 8])
+    cursor += 8
+    parts = list(struct.unpack(f"<{part_count}i", blob[cursor : cursor + part_count * 4]))
+    cursor += part_count * 4
+    flat_xy = struct.unpack(f"<{point_count * 2}d", blob[cursor : cursor + point_count * 16])
+    cursor += point_count * 16
+
+    zs: tuple[float, ...] = ()
+    if record_type == 13:
+        cursor += 16  # Z 범위
+        end = cursor + point_count * 8
+        if end - offset <= content_bytes:
+            zs = struct.unpack(f"<{point_count}d", blob[cursor:end])
+
+    points = [
+        (flat_xy[index * 2], flat_xy[index * 2 + 1], zs[index] if zs else 0.0)
+        for index in range(point_count)
+    ]
+    boundaries = [*parts, point_count]
+    return [points[boundaries[i] : boundaries[i + 1]] for i in range(part_count)]
+
+
+def read_shapefile_parts(path: str | Path) -> list[list[tuple]]:
+    """.shp의 모든 폴리라인 파트를 (x, y, z) 정점 목록으로 읽는다."""
+    source = Path(path)
+    blob = source.read_bytes()
+    header = _read_header(blob)
+    if header["shape_type"] not in _POLYLINE_TYPES and header["shape_type"] != 0:
+        raise ValueError(
+            f"계획노선 shapefile은 폴리라인이어야 합니다(받은 형상: {header['shape_type_name']})."
+        )
+
+    limit = min(len(blob), header["declared_bytes"] or len(blob))
+    parts: list[list[tuple]] = []
+    offset = _HEADER_BYTES
+    while offset + 8 <= limit:
+        content_bytes = struct.unpack(">i", blob[offset + 4 : offset + 8])[0] * 2
+        if content_bytes <= 0:
+            break
+        parts.extend(_read_polyline_record(blob, offset + 8, content_bytes))
+        offset += 8 + content_bytes
+    return [part for part in parts if len(part) >= 2]
+
+
+def read_shapefile_attributes(path: str | Path) -> dict[str, str]:
+    """짝 .dbf 첫 레코드의 속성. 없거나 못 읽으면 빈 dict."""
+    dbf_path = Path(path).with_suffix(".dbf")
+    if not dbf_path.exists():
+        return {}
+    encoding = shapefile_encoding(Path(path))
+    try:
+        blob = dbf_path.read_bytes()
+        header_bytes, record_bytes = struct.unpack("<2H", blob[8:12])
+        fields: list[tuple[str, int]] = []
+        cursor = 32
+        while cursor < header_bytes - 1 and blob[cursor] != 0x0D:
+            descriptor = blob[cursor : cursor + 32]
+            name = descriptor[0:11].split(b"\x00")[0].decode(encoding, errors="replace").strip()
+            fields.append((name, descriptor[16]))
+            cursor += 32
+        record = blob[header_bytes : header_bytes + record_bytes]
+        if not record:
+            return {}
+        values: dict[str, str] = {}
+        position = 1  # 첫 바이트는 삭제 표시
+        for name, width in fields:
+            raw = record[position : position + width]
+            values[name] = raw.decode(encoding, errors="replace").strip()
+            position += width
+        return values
+    except (OSError, struct.error, ValueError):
+        logger.warning("shapefile .dbf 속성을 읽지 못했습니다: %s", dbf_path.name)
+        return {}
+
+
+def _route_name_from_attributes(attributes: dict[str, str], fallback: str) -> str:
+    for key in ("대상지", "노선명", "route_name", "NAME", "name"):
+        value = attributes.get(key)
+        if value:
+            return value
+    return fallback
+
+
+def analyze_shapefile_metadata(path: str | Path) -> dict[str, Any]:
+    """계획노선 shapefile의 B03 메타데이터를 만든다."""
+    source = Path(path)
+    header = _read_header(source.read_bytes()[:_HEADER_BYTES])
+    parts = read_shapefile_parts(source)
+    attributes = read_shapefile_attributes(source)
+    point_count = sum(len(part) for part in parts)
+    missing = [
+        extension for extension in (".shx", ".dbf") if not source.with_suffix(extension).exists()
+    ]
+
+    return {
+        "file": source.name,
+        "extension": "shp",
+        "size_bytes": source.stat().st_size,
+        "purpose": "planned_route",
+        "route_name": _route_name_from_attributes(attributes, source.stem),
+        "shape_type": header["shape_type_name"],
+        "part_count": len(parts),
+        "point_count": point_count,
+        "epsg": shapefile_epsg_label(source),
+        "crs_input": shapefile_crs_input(source),
+        "encoding": shapefile_encoding(source),
+        "attributes": attributes,
+        "missing_members": missing,
+        "bounds": header["bounds"],
+        "start_point": list(parts[0][0]) if parts else None,
+        "end_point": list(parts[-1][-1]) if parts else None,
+    }
@@ -65,11 +65,19 @@ async def get_project_input_readiness(
    connection: aiomysql.Connection,
    project_id: UUID,
 ) -> tuple[set[str], int | None, int | None]:
-    """업로드 파일 유형, 최신 포인트클라우드 입력 ID, 최신 계획노선 CSV 입력 ID를 반환한다."""
+    """업로드 파일 유형, 최신 포인트클라우드 입력 ID, 최신 계획노선 입력 ID를 반환한다.
+
+    계획노선은 CSV 또는 shapefile이다. 둘 다 있으면 shapefile을 고른다 —
+    `find_planned_route_file()`의 우선순위와 같아야 WF1 입력과 실제 판독 대상이 갈리지 않는다.
+
+    PRJ는 노선용·지형용 두 장이 온다. DB `file_type`은 둘 다 `prj`라 그대로 세면 노선
+    PRJ 하나로 필수가 채워진다 — 프로젝트 좌표계를 정하는 것은 **지형 PRJ**이므로,
+    노선 세트 폴더(`input/shp/`)에 있는 PRJ는 `route_prj`로 갈라 센다(2026-08-31).
+    """
    async with connection.cursor(aiomysql.DictCursor) as cursor:
        await cursor.execute(
            """
-            SELECT id, LOWER(file_type) AS file_type
+            SELECT id, LOWER(file_type) AS file_type, raw_file_path
            FROM input_files
            WHERE project_id = %s AND status IN ('UPLOADED', 'PROCESSED')
            ORDER BY id DESC
@@ -78,17 +86,27 @@ async def get_project_input_readiness(
        )
        rows = await cursor.fetchall()

-    file_types = {str(row["file_type"]) for row in rows if row.get("file_type")}
+    file_types: set[str] = set()
+    for row in rows:
+        file_type = str(row.get("file_type") or "")
+        if not file_type:
+            continue
+        if file_type == "prj" and "/input/shp/" in str(row.get("raw_file_path") or ""):
+            file_type = "route_prj"
+        file_types.add(file_type)
    point_cloud_id = next(
        (int(row["id"]) for row in rows if str(row.get("file_type") or "") in {"las", "laz"}),
        None,
    )
-    # LAS 없는 설계(2026-08-30)의 WF1 입력 — 계획노선 CSV가 분석 원천이 된다.
-    route_csv_id = next(
+    # LAS 없는 설계(2026-08-30)의 WF1 입력 — 계획노선 파일이 분석 원천이 된다.
+    route_id = next(
+        (int(row["id"]) for row in rows if str(row.get("file_type") or "") == "shp"),
+        None,
+    ) or next(
        (int(row["id"]) for row in rows if str(row.get("file_type") or "") == "csv"),
        None,
    )
-    return file_types, point_cloud_id, route_csv_id
+    return file_types, point_cloud_id, route_id


 async def get_project_storage_relative_path(
@@ -309,7 +327,7 @@ async def list_project_input_files(
        await cursor.execute(
            """
            SELECT f.id, f.file_type, f.original_filename, f.file_size_mb, f.status,
-                   f.upload_at
+                   f.upload_at, f.raw_file_path
            FROM input_files f
            INNER JOIN (
                SELECT MAX(id) AS id
@@ -12,15 +12,22 @@ import aiomysql
 from config.config_system import TEMP_UPLOAD_RETENTION_DAYS

 # 묶음이 "완료"로 넘어가려면 있어야 하는 파일 종류. B03 필수 슬롯과 같은 기준이다.
-REQUIRED_TEMP_FILE_TYPES = frozenset({"csv", "prj", "tfw"})
+REQUIRED_TEMP_FILE_TYPES = frozenset({"prj", "tfw"})
 POINT_CLOUD_FILE_TYPES = frozenset({"las", "laz"})
+# 계획노선은 CSV 또는 shapefile 중 하나 (2026-08-31).
+ROUTE_FILE_TYPES = frozenset({"csv", "shp"})
+SHAPEFILE_REQUIRED_TYPES = frozenset({"shx", "dbf"})


 def is_batch_required_complete(file_types: set[str]) -> bool:
-    """필수 파일(csv·prj·tfw + las/laz 1종)이 모두 찼는지."""
-    return REQUIRED_TEMP_FILE_TYPES.issubset(file_types) and bool(
-        file_types & POINT_CLOUD_FILE_TYPES
-    )
+    """필수 파일(계획노선 1종 + prj·tfw + las/laz 1종)이 모두 찼는지."""
+    if not REQUIRED_TEMP_FILE_TYPES.issubset(file_types):
+        return False
+    if not file_types & ROUTE_FILE_TYPES:
+        return False
+    if "shp" in file_types and not SHAPEFILE_REQUIRED_TYPES.issubset(file_types):
+        return False
+    return bool(file_types & POINT_CLOUD_FILE_TYPES)


 async def create_temp_batch(
@@ -76,8 +76,13 @@ _ANALYSIS_RUNNING_MESSAGE = "이 프로젝트는 지금 분석 중입니다. 끝
 logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/projects", tags=["B03 File Input"])

-_REQUIRED_FILE_TYPES = frozenset({"csv", "prj", "tfw"})
+_REQUIRED_FILE_TYPES = frozenset({"prj", "tfw"})
 _POINT_CLOUD_FILE_TYPES = frozenset({"las", "laz"})
+# 계획노선은 CSV 또는 shapefile 중 하나면 된다 (2026-08-31 — 원청 정식 노선이 shapefile).
+_ROUTE_FILE_TYPES = frozenset({"csv", "shp"})
+# shapefile은 이것들이 다 있어야 열린다. `.cpg`는 없으면 CP949로 읽으므로 필수가 아니다.
+# `route_prj`는 노선 세트 폴더에 있는 PRJ — 지형 PRJ(`prj`)와 따로 센다.
+_SHAPEFILE_REQUIRED_TYPES = frozenset({"shx", "dbf", "route_prj"})


 def _total_chunks(size_bytes: int, chunk_size_bytes: int) -> int:
@@ -95,6 +100,11 @@ def _is_point_cloud_result(result: UploadedFileResult) -> bool:

 def _missing_required_file_types(file_types: set[str], las_free: bool = False) -> list[str]:
    missing = sorted(_REQUIRED_FILE_TYPES - file_types)
+    if not file_types.intersection(_ROUTE_FILE_TYPES):
+        missing.append("csv/shp")
+    # shapefile로 왔으면 형제 파일이 다 있어야 노선을 읽는다.
+    if "shp" in file_types:
+        missing.extend(sorted(_SHAPEFILE_REQUIRED_TYPES - file_types))
    # LAS 없는 설계(도엽등고선 기반, 2026-08-30)는 LAS 필수를 면제한다.
    if not las_free and not file_types.intersection(_POINT_CLOUD_FILE_TYPES):
        missing.append("las/laz")
@@ -164,7 +174,7 @@ async def _complete_file_input_if_ready(
        if not las_free:
            raise ValueError("LAS 또는 LAZ 입력 파일을 찾을 수 없습니다.")
        if route_csv_input_id is None:
-            raise ValueError("계획 노선 CSV 입력 파일을 찾을 수 없습니다.")
+            raise ValueError("계획 노선 입력 파일(CSV 또는 shapefile)을 찾을 수 없습니다.")
    # 자료가 갈렸으니 옛 계산 결과(파일 + DB)를 지우고 진행 표시도 되돌린다. 남겨 두면
    # 아직 다시 만들어지지 않은 뒷단계 화면이 옛 결과를 새 자료 것인 양 보여준다.
    stored_path = await get_project_storage_relative_path(connection, project_id)
@@ -810,6 +820,7 @@ async def get_project_upload_overview(
                    file_size_mb=float(row["file_size_mb"] or 0.0),
                    status=str(row["status"]),
                    uploaded_at=str(row["upload_at"]) if row.get("upload_at") else None,
+                    relative_path=(str(row["raw_file_path"]) if row.get("raw_file_path") else None),
                )
                for row in files
            ],
@@ -128,6 +128,9 @@ class UploadOverviewFile(BaseModel):
    file_size_mb: float
    status: str
    uploaded_at: str | None = None
+    # PRJ는 노선용·지형용 두 장이 온다. 확장자로는 못 가리므로 저장 폴더로 가린다
+    # (노선 세트는 `B03_FileInput/input/shp/`에 모인다, 2026-08-31).
+    relative_path: str | None = None


 class UploadOverviewSession(BaseModel):
@@ -28,9 +28,9 @@ logger = logging.getLogger(__name__)
 def _planned_route_points_in_project_crs(
    project_root: Path, surface: dict[str, Any] | None = None
 ) -> list[dict[str, float]] | None:
-    """계획노선 CSV를 읽어 프로젝트 좌표계(m) 점 목록으로 돌려준다. 없으면 None.
+    """계획노선 파일(CSV·shapefile)을 읽어 프로젝트 좌표계(m) 점 목록으로 돌려준다.

-    B04 `/planned-route` 조회와 같은 규칙 — CSV가 제 좌표계(crs_epsg)를 적어 두었고
+    B04 `/planned-route` 조회와 같은 규칙 — 파일이 제 좌표계를 싣고 있고
    프로젝트 좌표계와 다르면 한 번 옮긴다.

    `surface`(확정 필터·방식·스무딩)를 받으면 지표면이 덮지 못하는 구간을 잘라 낸다.
@@ -41,7 +41,7 @@ def _planned_route_points_in_project_crs(
    from common_util.common_util_route_geometry import (
        densify_route,
        find_planned_route_file,
-        read_planned_route_csv,
+        read_planned_route,
        trim_route_to_surface,
    )
    from config.config_system import (
@@ -51,12 +51,12 @@ def _planned_route_points_in_project_crs(
    )

    route_file = find_planned_route_file(project_root / "B03_FileInput" / "input")
-    planned = read_planned_route_csv(route_file) if route_file else None
+    planned = read_planned_route(route_file) if route_file else None
    if planned is None or len(planned.vertices) < 2:
        return None
    target_epsg = project_epsg_from_prj(project_root)
    points = [(float(vertex.x), float(vertex.y)) for vertex in planned.vertices]
-    source_epsg = f"EPSG:{planned.epsg}" if planned.epsg else target_epsg
+    source_epsg = planned.crs_input or target_epsg
    if source_epsg.upper() != target_epsg.upper():
        from pyproj import Transformer

@@ -44,6 +44,11 @@ import {
  getExtension,
  initializeSlots,
  makeSessionKey,
+  planSlotAssignments,
+  ROUTE_SLOTS,
+  SHAPEFILE_DEPENDENT_SLOTS,
+  slotConfigs,
+  TERRAIN_SLOTS,
  type FileSlot,
  type FileSlotState,
  type StoredUploadSession,
@@ -193,10 +198,21 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    pageError.textContent = validation ?? "";
  }

+  /** 확장자 줄 — 지금 필수인지에 따라 "· 선택" 꼬리표가 붙고 떨어진다. */
+  function renderExtensionLabel(card: HTMLElement, state: FileSlotState): void {
+    const extLabel = state.extensions.join(", ");
+    const target = card.querySelector(".b03-file__card-ext");
+    if (!target) return;
+    target.textContent = isSlotRequired(state)
+      ? extLabel
+      : `${extLabel} · ${L("B03_File_Card_Optional")}`;
+  }
+
  function renderSlot(slot: FileSlot): void {
    const state = slots.get(slot);
    const card = cardMap.get(slot);
    if (!state || !card) return;
+    renderExtensionLabel(card, state);

    const fileName = card.querySelector<HTMLSpanElement>(
      ".b03-file__file-name",
@@ -290,12 +306,7 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    file: File,
    targetSlot?: FileSlot,
  ): Promise<void> {
-    const extension = getExtension(file.name);
-    const state = targetSlot
-      ? slots.get(targetSlot)
-      : Array.from(slots.values()).find((candidate) =>
-          candidate.extensions.includes(extension),
-        );
+    const state = targetSlot ? slots.get(targetSlot) : undefined;
    if (!state) {
      pageError.textContent = `${L("B03_File_Error_Extension")} ${file.name}`;
      return;
@@ -330,6 +341,13 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    state.etaSeconds = null;
    state.error = undefined;
    renderSlot(state.slot);
+    // 노선 도형이 CSV↔shapefile로 바뀌면 형제 카드의 필수 표시도 따라 바뀐다.
+    if (state.slot === "csv") renderRouteDependentSlots();
+  }
+
+  function renderRouteDependentSlots(): void {
+    for (const slot of SHAPEFILE_DEPENDENT_SLOTS) renderSlot(slot);
+    updateUploadButton();
  }

  function onFileSelected(
@@ -353,14 +371,17 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    // 개수는 "고른 파일 수"가 아니라 **최종적으로 차는 슬롯 수**로 센다.
    // 같은 슬롯을 다시 고르는 것은 교체라 개수가 늘지 않는다 — 더하기로 세면 5개를 고른
    // 뒤 파일 선택 영역으로 하나만 바꾸려 해도 초과로 막힌다(2026-08-08).
+    // 파일 하나에 카드 하나다. `.prj`만 확장자로 안 갈리므로 노선 도형과 basename이
+    // 같은지로 노선/지형 좌표계 카드를 정한다(2026-08-31 사용자 지시).
+    const routeFile = slots.get("csv")?.file?.name;
+    const assignments = planSlotAssignments(
+      files,
+      slotConfigs(),
+      routeFile ? routeFile.replace(/\.[^.]*$/, "") : undefined,
+    );
    const occupied = new Set(selectedStates().map((state) => state.slot));
-    for (const file of files) {
-      const extension = getExtension(file.name);
-      const slot =
-        targetSlot ??
-        Array.from(slots.values()).find((candidate) =>
-          candidate.extensions.includes(extension),
-        )?.slot;
+    for (const item of assignments) {
+      const slot = targetSlot ?? item.slot;
      if (slot) occupied.add(slot);
    }
    if (occupied.size > UPLOAD_MAX_FILES) {
@@ -369,7 +390,14 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    }
    pageError.textContent = blocked ? L("B03_File_Error_LasFreeBlocked") : "";
    void (async () => {
-      for (const file of files) await assignFileToSlot(file, targetSlot);
+      for (const item of assignments) {
+        const slot = targetSlot ?? item.slot;
+        if (!slot) {
+          pageError.textContent = `${L("B03_File_Error_Extension")} ${item.file.name}`;
+          continue;
+        }
+        await assignFileToSlot(item.file, slot);
+      }
      await detectPausedUploads();
    })();
  }
@@ -388,6 +416,27 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    state.etaSeconds = null;
    state.error = undefined;
    renderSlot(slot);
+    if (slot === "csv") renderRouteDependentSlots();
+  }
+
+  /** 노선 도형이 shapefile인가 — 로컬 선택과 서버 정본을 함께 본다. */
+  function routeIsShapefile(): boolean {
+    const state = slots.get("csv");
+    const name = state?.file?.name ?? state?.serverUploaded?.name;
+    return getExtension(name ?? "") === ".shp";
+  }
+
+  /**
+   * 이 카드가 지금 필수인가.
+   *
+   * shapefile 형제 카드(.shx/.dbf/노선 .prj)는 노선 도형이 shapefile일 때만 필수다 —
+   * CSV 한 장으로 넣는 흐름을 막으면 안 된다(2026-08-31).
+   */
+  function isSlotRequired(state: FileSlotState): boolean {
+    if (SHAPEFILE_DEPENDENT_SLOTS.includes(state.slot))
+      return routeIsShapefile();
+    if (state.slot === "las_laz") return !lasFreeDesign;
+    return state.isRequired;
  }

  function validateSlots(): string | null {
@@ -399,11 +448,7 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    // 재접속 후 파일 하나만 교체 업로드하는 흐름을 막지 않는다(2026-08-04 사용자 지시).
    const missingRequired = Array.from(slots.values()).some(
      (state) =>
-        state.isRequired &&
-        !state.file &&
-        !state.serverUploaded &&
-        // LAS 없는 설계면 포인트클라우드 카드는 필수에서 뺀다.
-        !(lasFreeDesign && state.slot === "las_laz"),
+        isSlotRequired(state) && !state.file && !state.serverUploaded,
    );
    if (missingRequired) return L("B03_File_Error_RequiredSlots");
    if (!lasFreeDesign) {
@@ -435,9 +480,20 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
      for (const state of slots.values()) state.serverUploaded = undefined;
      for (const file of overview.files) {
        const extension = `.${file.file_type.toLowerCase()}`;
-        const state = Array.from(slots.values()).find((candidate) =>
-          candidate.extensions.includes(extension),
-        );
+        // PRJ 두 장은 확장자가 같다 — 노선 세트는 `input/shp/`에 모여 있으므로
+        // 저장 경로로 가린다(2026-08-31).
+        const inRouteSet = (file.relative_path ?? "").includes("/input/shp/");
+        const slot: FileSlot | undefined =
+          extension === ".prj"
+            ? inRouteSet
+              ? "route_prj"
+              : "prj"
+            : Array.from(slots.values()).find(
+                (candidate) =>
+                  candidate.slot !== "route_prj" &&
+                  candidate.extensions.includes(extension),
+              )?.slot;
+        const state = slot ? slots.get(slot) : undefined;
        if (state) {
          state.serverUploaded = {
            name: file.original_filename,
@@ -480,11 +536,7 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    card.querySelector(".b03-file__card-label")!.textContent = L(
      state.labelKey,
    );
-    // 지형 래스터만 선택 항목이라 확장자 옆에 표시해 둔다.
-    const extLabel = state.extensions.join(", ");
-    card.querySelector(".b03-file__card-ext")!.textContent = state.isRequired
-      ? extLabel
-      : `${extLabel} · ${L("B03_File_Card_Optional")}`;
+    renderExtensionLabel(card, state);
    const input = card.querySelector<HTMLInputElement>(
      ".b03-file__slot-input",
    )!;
@@ -512,15 +564,24 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
  function createCardGroup(
    title: string,
    groupSlots: readonly FileSlot[],
+    modifier?: string,
+    hint?: string,
  ): HTMLElement {
    const group = document.createElement("section");
    group.className = "b03-file__group";
+    if (modifier) group.classList.add(modifier);
    if (title) {
      const groupTitle = document.createElement("h3");
      groupTitle.className = "b03-file__group-title";
      groupTitle.textContent = title;
      group.append(groupTitle);
    }
+    if (hint) {
+      const groupHint = document.createElement("p");
+      groupHint.className = "b03-file__group-hint";
+      groupHint.textContent = hint;
+      group.append(groupHint);
+    }
    const content = document.createElement("div");
    content.className = "b03-file__group-content";
    for (const slot of groupSlots) {
@@ -768,15 +829,21 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    resultList,
  );

-  // 계획노선과 지형 자료는 지형 래스터(tif)만 빼면 모두 필수라 따로 묶지 않는다
-  // (2026-08-08 사용자 지시).
-  const inputsGroup = createCardGroup(L("B03_File_Group_Inputs"), [
-    "csv",
-    "las_laz",
-    "prj",
-    "tfw",
-    "tif",
-  ]);
+  // 자료의 출처가 둘로 갈린다 — 원청이 준 계획노선, 측량이 준 지형(LAS·래스터).
+  // 좌표계 파일(.prj)도 각각 하나씩 오므로 컨테이너를 나눠야 어느 칸에 무엇을 넣는지
+  // 화면만 보고 안다(2026-08-31 사용자 지시).
+  const routeGroup = createCardGroup(
+    L("B03_File_Group_Route"),
+    ROUTE_SLOTS,
+    "b03-file__group--route",
+    L("B03_File_Group_Route_Hint"),
+  );
+  const terrainGroup = createCardGroup(
+    L("B03_File_Group_Terrain"),
+    TERRAIN_SLOTS,
+    "b03-file__group--terrain",
+    L("B03_File_Group_Terrain_Hint"),
+  );

  // LAS 없는 설계 토글 — 켜면 포인트클라우드 카드를 비활성화하고 필수에서 뺀다.
  const lasFreeRow = document.createElement("label");
@@ -814,10 +881,22 @@ export async function renderB03FileInput(root: HTMLElement): Promise<void> {
    pageError.textContent = "";
  });

-  const cardsContainer = document.createElement("div");
-  cardsContainer.className =
+  // LAS 토글은 지형 컨테이너의 것이다 — 켜면 그 안의 포인트클라우드 카드만 잠긴다.
+  terrainGroup.append(lasFreeRow);
+
+  const routePanel = document.createElement("div");
+  routePanel.className =
    "b03-file__control-panel b03-file__cards-container-panel";
-  cardsContainer.append(lasFreeRow, inputsGroup);
+  routePanel.append(routeGroup);
+
+  const terrainPanel = document.createElement("div");
+  terrainPanel.className =
+    "b03-file__control-panel b03-file__cards-container-panel";
+  terrainPanel.append(terrainGroup);
+
+  const cardsContainer = document.createElement("div");
+  cardsContainer.className = "b03-file__columns";
+  cardsContainer.append(routePanel, terrainPanel);

  const workflowState = activeProjectId
    ? await fetchWorkflowState(activeProjectId).catch(() => undefined)
@@ -180,12 +180,27 @@
  gap: var(--spacing-32);
 }

+/* 계획노선 | 지형(LAS) — 컨테이너를 둘로 나눈다(2026-08-31 사용자 지시).
+   노선은 카드 5장(shapefile 한 벌), 지형은 4장이라 폭을 5:4 비슷하게 준다. */
+.b03-file__columns {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: var(--spacing-24);
+  align-items: start;
+}
+
 .b03-file__group {
  display: flex;
  flex-direction: column;
  gap: var(--spacing-20);
 }

+.b03-file__group-hint {
+  font-size: var(--text-body-sm, 14px);
+  color: var(--color-slate, #615e6e);
+  margin: calc(var(--spacing-8) * -1) 0 0 0;
+}
+
 .b03-file__group-title {
  font-size: var(--text-subheading, 24px);
  color: var(--color-deep-iris, #26114a);
@@ -195,7 +210,7 @@

 .b03-file__group-content {
  display: grid;
-  grid-template-columns: repeat(3, 1fr); /* 3열 구조 */
+  grid-template-columns: repeat(2, minmax(0, 1fr));
  gap: var(--spacing-24);
 }

@@ -260,14 +275,17 @@
  border-color: var(--color-danger, #dc2626);
 }

+/* 카드가 좁아졌다(컨테이너 2열 × 카드 2열, 2026-08-31). 격자로 고정하면 제목이
+   글자 단위로 접히므로, 자리가 모자라면 배지·삭제 버튼이 다음 줄로 내려가게 한다. */
 .b03-file__card-header {
-  display: grid;
-  grid-template-columns: auto 1fr auto auto; /* 아이콘 및 닫기 버튼 주변 확보 */
-  gap: var(--spacing-12);
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--spacing-8);
  align-items: center;
 }

 .b03-file__card-icon {
+  flex: 0 0 auto;
  width: 28px;
  height: 28px;
  border-radius: var(--radius-icons, 8px);
@@ -284,6 +302,7 @@

 .b03-file__card-heading {
  min-width: 0;
+  flex: 1 1 55%;
  display: flex;
  flex-direction: column;
  gap: 2px;
@@ -294,6 +313,11 @@
  color: var(--color-deep-iris, #26114a);
  font-size: var(--text-body-sm, 14px);
  font-weight: var(--font-weight-medium, 500);
+  /* 한글은 글자 단위로 끊기므로 어절을 지켜 준다 — "계획
+노선
+도형" 방지. */
+  word-break: keep-all;
+  overflow-wrap: break-word;
 }

 .b03-file__card-ext,
@@ -306,6 +330,7 @@
 .b03-file__card-badge-container {
  display: flex;
  align-items: center;
+  margin-left: auto;
  margin-right: var(--spacing-4);
 }

@@ -463,9 +488,10 @@
  border-bottom: 0;
 }

-@media (max-width: 1280px) {
-  .b03-file__group-content {
-    grid-template-columns: repeat(2, 1fr); /* 좁은 창에서는 2열 */
+@media (max-width: 1440px) {
+  /* 좁아지면 두 컨테이너를 위아래로 쌓는다 — 카드가 눌려 글자가 접히는 것을 막는다. */
+  .b03-file__columns {
+    grid-template-columns: 1fr;
  }
 }

@@ -1,6 +1,45 @@
 import { ui_locales } from "@ui/ui_template_locale";

-export type FileSlot = "csv" | "las_laz" | "prj" | "tfw" | "tif" | "dxf";
+/**
+ * 카드 한 장 = 파일 한 개. 계획노선 shapefile은 파일이 다섯이므로 카드도 다섯이다
+ * (2026-08-31 사용자 지시) — 어느 파일이 왔고 어느 것이 비었는지 화면에서 바로 보인다.
+ * `route_prj`(노선 좌표계)와 `prj`(지형 좌표계)는 확장자가 같아 basename으로 가른다.
+ */
+export type FileSlot =
+  | "csv"
+  | "shx"
+  | "dbf"
+  | "cpg"
+  | "route_prj"
+  | "las_laz"
+  | "prj"
+  | "tfw"
+  | "tif"
+  | "dxf";
+
+/** 왼쪽(계획노선) 컨테이너에 놓이는 슬롯. */
+export const ROUTE_SLOTS: readonly FileSlot[] = [
+  "csv",
+  "shx",
+  "dbf",
+  "cpg",
+  "route_prj",
+];
+
+/** 오른쪽(지형·LAS) 컨테이너에 놓이는 슬롯. */
+export const TERRAIN_SLOTS: readonly FileSlot[] = [
+  "las_laz",
+  "prj",
+  "tfw",
+  "tif",
+];
+
+/** 노선 도형이 shapefile일 때 함께 있어야 하는 슬롯(.cpg는 없으면 CP949). */
+export const SHAPEFILE_DEPENDENT_SLOTS: readonly FileSlot[] = [
+  "shx",
+  "dbf",
+  "route_prj",
+];
 export type UploadStatus = "pending" | "uploading" | "completed" | "failed";

 export interface SlotConfig {
@@ -45,9 +84,37 @@ const SLOT_CONFIGS: readonly SlotConfig[] = [
    slot: "csv",
    labelKey: "B03_File_Slot_PlannedRoute",
    icon: "⌁",
-    extensions: [".csv"],
+    extensions: [".csv", ".shp"],
    isRequired: true,
  },
+  {
+    slot: "shx",
+    labelKey: "B03_File_Slot_RouteIndex",
+    icon: "⋮",
+    extensions: [".shx"],
+    isRequired: false,
+  },
+  {
+    slot: "dbf",
+    labelKey: "B03_File_Slot_RouteAttribute",
+    icon: "▤",
+    extensions: [".dbf"],
+    isRequired: false,
+  },
+  {
+    slot: "cpg",
+    labelKey: "B03_File_Slot_RouteEncoding",
+    icon: "⌨",
+    extensions: [".cpg"],
+    isRequired: false,
+  },
+  {
+    slot: "route_prj",
+    labelKey: "B03_File_Slot_RouteProjection",
+    icon: "◈",
+    extensions: [".prj"],
+    isRequired: false,
+  },
  {
    slot: "las_laz",
    labelKey: "B03_File_Slot_PointCloud",
@@ -83,6 +150,48 @@ export function getExtension(fileName: string): string {
  return index >= 0 ? fileName.slice(index).toLowerCase() : "";
 }

+export function getBaseName(fileName: string): string {
+  const index = fileName.lastIndexOf(".");
+  return index >= 0 ? fileName.slice(0, index) : fileName;
+}
+
+/**
+ * 고른 파일을 카드(슬롯)에 배정한다.
+ *
+ * `.prj`만 확장자로 갈리지 않는다 — 노선 좌표계와 지형 좌표계가 같은 확장자다.
+ * **노선 도형(.shp)과 basename이 같은 것**만 노선 좌표계 카드로 보내고, 나머지는
+ * 지형 좌표계 카드로 보낸다. `routeStem`은 이미 골라 둔 노선 도형의 basename으로,
+ * 노선 PRJ를 나중에 따로 추가하는 경우를 받아 준다.
+ */
+export function planSlotAssignments(
+  files: readonly File[],
+  slotConfigs: readonly SlotConfig[],
+  routeStem?: string,
+): { file: File; slot?: FileSlot }[] {
+  const batchStem = files
+    .filter((file) => getExtension(file.name) === ".shp")
+    .map((file) => getBaseName(file.name))[0];
+  const stem = batchStem ?? routeStem;
+  return files.map((file) => {
+    const extension = getExtension(file.name);
+    if (extension === ".prj") {
+      const isRoute = stem !== undefined && getBaseName(file.name) === stem;
+      return { file, slot: (isRoute ? "route_prj" : "prj") as FileSlot };
+    }
+    const config = slotConfigs.find(
+      (candidate) =>
+        candidate.slot !== "route_prj" &&
+        candidate.extensions.includes(extension),
+    );
+    return { file, slot: config?.slot };
+  });
+}
+
+/** 슬롯 설정 목록 — 배정 규칙이 카드 정의와 같은 것을 쓰도록 밖으로 연다. */
+export function slotConfigs(): readonly SlotConfig[] {
+  return SLOT_CONFIGS;
+}
+
 export function formatBytes(bytes: number): string {
  const gb = bytes / 1024 / 1024 / 1024;
  if (gb >= 1) return `${gb.toFixed(2)} GB`;