eomsangdonandClaude Opus 5
784d6df801
- DXF -> 도각 JSON 변환 엔진 신설 (ezdxf) — 선·폴리선·원/호/타원/스플라인 평탄화·글자·점 변환, 블록·치수는 분해, 해치 등 미지원 요소는 제외
- DWG 는 ODA File Converter(.env ODA_CONVERTER_PATH) 경유 변환, 미설치 시 DXF 저장 안내로 폴백
- POST /{project_id}/frame-template/import 신설 — 파일을 편집 화면용 도면으로 반환(저장은 기존 [완료] 경로 유지), 20MB·2만 도형 상한
- 도각 편집 띠에 「파일 불러오기」 추가, 자리표 팔레트 신설 (글자 14종·그림 4종을 도면 중앙에 배치 후 이동)
- CAD 텍스트 선택 시 회색 점선 외곽선 표시 (출력물에는 미포함)
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
231 lines
8.7 KiB
Python
231 lines
8.7 KiB
Python
"""B07 외부 도각 파일 불러오기 — DXF(및 변환된 DWG)를 도각 JSON 으로 바꾼다.
|
|
|
|
고객이 내는 도각은 DWG 일 확률이 높지만 DWG 는 비공개 형식이라 파이썬이 바로 못 읽는다.
|
|
`.env` 의 `ODA_CONVERTER_PATH` 에 무료 변환기(ODA File Converter) 경로를 넣어 두면 DWG 를
|
|
DXF 로 바꿔 읽고, 없으면 「DXF 로 저장해 올려 달라」는 안내로 떨어진다 (2026-09-06 사용자 확정).
|
|
|
|
프로그램 값이 들어갈 자리는 여기서 알아맞히지 않는다 — 불러온 뒤 사용자가 자리표를
|
|
직접 놓는다. 좌표는 파일에 있는 그대로 쓴다(도각은 실치수 1:1 mm 로 그린다).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
from math import cos, radians, sin
|
|
from pathlib import Path
|
|
from typing import Any
|
|
from uuid import NAMESPACE_URL, uuid5
|
|
|
|
import ezdxf
|
|
from ezdxf import colors as ezdxf_colors
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
_IMPORT_NS = uuid5(NAMESPACE_URL, "aislo/b07/frame-import")
|
|
_DEFAULT_COLOR = "#f5f7fa"
|
|
# 곡선을 선분으로 풀 때 허용 오차(mm) — 도각 크기(840x594mm)에서 눈에 띄지 않는다.
|
|
_FLATTEN_MM = 0.2
|
|
_MAX_ENTITIES = 20000
|
|
|
|
|
|
def _entity_id(index: int) -> str:
|
|
return str(uuid5(_IMPORT_NS, str(index)))
|
|
|
|
|
|
def _color(entity: Any) -> str:
|
|
"""DXF 색 번호를 화면 색으로. 도면층 색(BYLAYER)이면 기본색을 쓴다."""
|
|
try:
|
|
aci = int(entity.dxf.color)
|
|
if aci in (0, 256): # BYBLOCK · BYLAYER
|
|
return _DEFAULT_COLOR
|
|
red, green, blue = ezdxf_colors.aci2rgb(aci)
|
|
return f"#{red:02x}{green:02x}{blue:02x}"
|
|
except Exception:
|
|
return _DEFAULT_COLOR
|
|
|
|
|
|
def _point(x: float, y: float) -> dict[str, float]:
|
|
return {"x": float(x), "y": float(y)}
|
|
|
|
|
|
def _base(index: int, entity: Any, kind: str) -> dict[str, Any]:
|
|
return {
|
|
"id": _entity_id(index),
|
|
"type": kind,
|
|
"lineColor": _color(entity),
|
|
"lineWidth": 1,
|
|
"layerId": str(getattr(entity.dxf, "layer", "0")),
|
|
}
|
|
|
|
|
|
def _line(index: int, entity: Any, start: Any, end: Any) -> dict[str, Any]:
|
|
return {
|
|
**_base(index, entity, "Line"),
|
|
"shapeData": {
|
|
"startPoint": _point(start[0], start[1]),
|
|
"endPoint": _point(end[0], end[1]),
|
|
},
|
|
}
|
|
|
|
|
|
def _polyline(index: int, entity: Any, points: list[Any], closed: bool) -> dict[str, Any] | None:
|
|
"""점 목록을 선분 묶음(PolyLine)으로 바꾼다. 점이 2개 미만이면 버린다."""
|
|
vertices = [(float(p[0]), float(p[1])) for p in points]
|
|
if closed and len(vertices) > 2:
|
|
vertices.append(vertices[0])
|
|
if len(vertices) < 2:
|
|
return None
|
|
children = [
|
|
{
|
|
**_base(index, entity, "Line"),
|
|
"id": str(uuid5(_IMPORT_NS, f"{index}:{seq}")),
|
|
"shapeData": {
|
|
"startPoint": _point(*vertices[seq]),
|
|
"endPoint": _point(*vertices[seq + 1]),
|
|
},
|
|
}
|
|
for seq in range(len(vertices) - 1)
|
|
]
|
|
return {**_base(index, entity, "PolyLine"), "shapeData": None, "children": children}
|
|
|
|
|
|
def _text(index: int, entity: Any, label: str, insert: Any, height: float) -> dict[str, Any]:
|
|
rotation = float(getattr(entity.dxf, "rotation", 0.0) or 0.0)
|
|
return {
|
|
**_base(index, entity, "Text"),
|
|
"shapeData": {
|
|
"label": label,
|
|
"basePoint": _point(insert[0], insert[1]),
|
|
"options": {
|
|
"textDirection": _point(cos(radians(rotation)), sin(radians(rotation))),
|
|
"textAlign": "left",
|
|
"textColor": _color(entity),
|
|
"fontSize": float(height) or 3.0,
|
|
"fontFamily": "sans-serif",
|
|
},
|
|
},
|
|
}
|
|
|
|
|
|
def _flatten(entity: Any) -> list[Any] | None:
|
|
"""원·호·타원·스플라인을 선분 점열로 편다. 못 펴면 None."""
|
|
try:
|
|
return list(entity.flattening(_FLATTEN_MM))
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def _convert_entity(index: int, entity: Any) -> list[dict[str, Any]]:
|
|
kind = entity.dxftype()
|
|
if kind == "LINE":
|
|
return [_line(index, entity, entity.dxf.start, entity.dxf.end)]
|
|
if kind == "LWPOLYLINE":
|
|
shape = _polyline(index, entity, list(entity.get_points("xy")), bool(entity.closed))
|
|
return [shape] if shape else []
|
|
if kind == "POLYLINE":
|
|
points = [vertex.dxf.location for vertex in entity.vertices]
|
|
shape = _polyline(index, entity, points, bool(entity.is_closed))
|
|
return [shape] if shape else []
|
|
if kind in ("CIRCLE", "ARC", "ELLIPSE", "SPLINE"):
|
|
points = _flatten(entity)
|
|
if not points:
|
|
return []
|
|
shape = _polyline(index, entity, points, kind in ("CIRCLE", "ELLIPSE"))
|
|
return [shape] if shape else []
|
|
if kind == "POINT":
|
|
location = entity.dxf.location
|
|
return [
|
|
{
|
|
**_base(index, entity, "Point"),
|
|
"shapeData": {"point": _point(location[0], location[1])},
|
|
}
|
|
]
|
|
if kind == "TEXT":
|
|
label = str(entity.dxf.text or "").strip()
|
|
if not label:
|
|
return []
|
|
return [_text(index, entity, label, entity.dxf.insert, float(entity.dxf.height or 3.0))]
|
|
if kind == "MTEXT":
|
|
label = str(entity.plain_text() or "").strip()
|
|
if not label:
|
|
return []
|
|
height = float(entity.dxf.char_height or 3.0)
|
|
return [_text(index, entity, label, entity.dxf.insert, height)]
|
|
return []
|
|
|
|
|
|
def _expand(entity: Any) -> list[Any]:
|
|
"""블록·치수처럼 속에 도형을 품은 것은 풀어서 낱개로 만든다. 못 풀면 버린다."""
|
|
if entity.dxftype() in ("INSERT", "DIMENSION", "LEADER", "MULTILEADER"):
|
|
try:
|
|
return list(entity.virtual_entities())
|
|
except Exception:
|
|
logger.info("B07 도각 불러오기 — %s 는 풀지 못해 건너뜀", entity.dxftype())
|
|
return []
|
|
return [entity]
|
|
|
|
|
|
def dxf_to_entities(path: Path) -> list[dict[str, Any]]:
|
|
"""DXF 파일을 도각 엔티티 목록으로. 지원 밖 도형(해치·솔리드 등)은 버린다."""
|
|
document = ezdxf.readfile(str(path))
|
|
entities: list[dict[str, Any]] = []
|
|
index = 0
|
|
for source in document.modelspace():
|
|
for item in _expand(source):
|
|
entities.extend(_convert_entity(index, item))
|
|
index += 1
|
|
if len(entities) > _MAX_ENTITIES:
|
|
raise ValueError(
|
|
f"도형이 너무 많습니다({_MAX_ENTITIES}개 넘음)."
|
|
" 도각만 남겨 다시 저장해 주십시오."
|
|
)
|
|
if not entities:
|
|
raise ValueError("읽을 수 있는 도형이 없습니다. 선·글자가 있는 도각인지 확인해 주십시오.")
|
|
return entities
|
|
|
|
|
|
def _dwg_to_dxf(source: Path, work_dir: Path) -> Path:
|
|
"""ODA File Converter 로 DWG 를 DXF 로 바꾼다. 변환기가 없으면 안내와 함께 실패."""
|
|
converter = os.getenv("ODA_CONVERTER_PATH", "").strip()
|
|
if not converter or not Path(converter).is_file():
|
|
raise ValueError(
|
|
"DWG 는 그대로 읽지 못합니다. 캐드에서 DXF 로 저장해 올려 주십시오."
|
|
" (서버에 ODA File Converter 를 두면 DWG 도 바로 읽습니다)"
|
|
)
|
|
in_dir = work_dir / "in"
|
|
out_dir = work_dir / "out"
|
|
in_dir.mkdir(parents=True, exist_ok=True)
|
|
out_dir.mkdir(parents=True, exist_ok=True)
|
|
shutil.copy(source, in_dir / source.name)
|
|
# ODA 인자: 입력폴더 출력폴더 출력버전 출력형식 재귀 감사
|
|
subprocess.run(
|
|
[converter, str(in_dir), str(out_dir), "ACAD2018", "DXF", "0", "1"],
|
|
check=True,
|
|
timeout=180,
|
|
capture_output=True,
|
|
)
|
|
converted = sorted(out_dir.glob("*.dxf"))
|
|
if not converted:
|
|
raise ValueError("DWG 를 DXF 로 바꾸지 못했습니다. 캐드에서 DXF 로 저장해 올려 주십시오.")
|
|
return converted[0]
|
|
|
|
|
|
def import_frame_file(filename: str, data: bytes) -> list[dict[str, Any]]:
|
|
"""올린 도각 파일(DXF·DWG)을 도각 엔티티 목록으로 바꾼다."""
|
|
suffix = Path(filename).suffix.lower()
|
|
if suffix not in (".dxf", ".dwg"):
|
|
raise ValueError("DXF 또는 DWG 파일만 올릴 수 있습니다.")
|
|
with tempfile.TemporaryDirectory(prefix="aislo-frame-") as temporary:
|
|
work_dir = Path(temporary)
|
|
source = work_dir / f"frame{suffix}"
|
|
source.write_bytes(data)
|
|
target = _dwg_to_dxf(source, work_dir) if suffix == ".dwg" else source
|
|
try:
|
|
return dxf_to_entities(target)
|
|
except ezdxf.DXFError as exc:
|
|
raise ValueError(f"DXF 를 읽지 못했습니다: {exc}") from exc
|