diff --git a/B07_DesignDetail/B07_DesignDetail_Engine_Frame_Import.py b/B07_DesignDetail/B07_DesignDetail_Engine_Frame_Import.py index 8472d92fd..673df9a21 100644 --- a/B07_DesignDetail/B07_DesignDetail_Engine_Frame_Import.py +++ b/B07_DesignDetail/B07_DesignDetail_Engine_Frame_Import.py @@ -29,6 +29,8 @@ from uuid import NAMESPACE_URL, uuid5 import ezdxf from ezdxf import colors as ezdxf_colors +from ezdxf import path as ezdxf_path +from ezdxf.enums import TextEntityAlignment from ezdxf.lldxf.encoding import decode_dxf_unicode, has_dxf_unicode logger = logging.getLogger(__name__) @@ -38,6 +40,8 @@ _DEFAULT_COLOR = "#f5f7fa" # 곡선을 선분으로 풀 때 허용 오차(mm) — 도각 크기(840x594mm)에서 눈에 띄지 않는다. _FLATTEN_MM = 0.2 _MAX_ENTITIES = 20000 +# 블록 속 블록을 풀 깊이 — 자기를 품는 깨진 블록에서 끝없이 돌지 않게. +_MAX_BLOCK_DEPTH = 16 # 프로그램에 함께 담은 LibreDWG 자리 — `B07_DesignDetail/openwebcad/tools/libredwg/`. @@ -117,16 +121,26 @@ def _plain(label: str) -> str: return decode_dxf_unicode(label) if has_dxf_unicode(label) else label -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) +def _text( + index: int, + entity: Any, + label: str, + insert: Any, + height: float, + direction: Any = None, + align: str = "left", +) -> dict[str, Any]: + if direction is None: + rotation = float(getattr(entity.dxf, "rotation", 0.0) or 0.0) + direction = (cos(radians(rotation)), sin(radians(rotation))) return { **_base(index, entity, "Text"), "shapeData": { "label": _plain(label), "basePoint": _point(insert[0], insert[1]), "options": { - "textDirection": _point(cos(radians(rotation)), sin(radians(rotation))), - "textAlign": "left", + "textDirection": _point(direction[0], direction[1]), + "textAlign": align, "textColor": _color(entity), "fontSize": float(height) or 3.0, "fontFamily": "sans-serif", @@ -143,16 +157,50 @@ def _flatten(entity: Any) -> list[Any] | None: return None +def _polyline_points(entity: Any) -> tuple[list[Any], bool]: + """폴리선 → WCS 점열. bulge(호 마디)는 펴고 OCS(압출 −Z 거울 블록)는 WCS 로. + + `make_path` 가 닫힌 폴리선의 닫는 마디까지 넣으므로 닫힘 표시는 False. + 면 · 메시 POLYLINE 처럼 경로로 못 바꾸면 꼭짓점을 그대로 잇는다. + """ + try: + return list(ezdxf_path.make_path(entity).flattening(_FLATTEN_MM)), False + except Exception: + if entity.dxftype() == "LWPOLYLINE": + return list(entity.get_points("xy")), bool(entity.closed) + return [vertex.dxf.location for vertex in entity.vertices], bool(entity.is_closed) + + +# DXF 가로 정렬 → CAD 글 정렬. 맞춤(ALIGNED · FIT)은 첫 점에서 왼쪽. +_TEXT_ALIGN = { + TextEntityAlignment.CENTER: "center", + TextEntityAlignment.MIDDLE: "center", + TextEntityAlignment.TOP_CENTER: "center", + TextEntityAlignment.MIDDLE_CENTER: "center", + TextEntityAlignment.BOTTOM_CENTER: "center", + TextEntityAlignment.RIGHT: "right", + TextEntityAlignment.TOP_RIGHT: "right", + TextEntityAlignment.MIDDLE_RIGHT: "right", + TextEntityAlignment.BOTTOM_RIGHT: "right", +} + + +def _text_placement(entity: Any) -> tuple[Any, Any, str]: + """TEXT 의 (WCS 기준점, WCS 방향, 가로 정렬). 정렬점 · OCS(압출 −Z)를 따른다.""" + align, first, _second = entity.get_placement() + ocs = entity.ocs() + rotation = radians(float(entity.dxf.rotation or 0.0)) + direction = ocs.to_wcs((cos(rotation), sin(rotation), 0.0)) + return ocs.to_wcs(first), direction, _TEXT_ALIGN.get(align, "left") + + 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)) + if kind in ("LWPOLYLINE", "POLYLINE"): + points, closed = _polyline_points(entity) + shape = _polyline(index, entity, points, closed) return [shape] if shape else [] if kind in ("CIRCLE", "ARC", "ELLIPSE", "SPLINE"): points = _flatten(entity) @@ -172,24 +220,32 @@ def _convert_entity(index: int, entity: Any) -> list[dict[str, Any]]: 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))] + insert, direction, align = _text_placement(entity) + height = float(entity.dxf.height or 3.0) + return [_text(index, entity, label, insert, height, direction, align)] 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)] + # 붙임점 1~9 = 위 · 가운데 · 아래 줄의 왼 · 가운데 · 오른. + align = ("left", "center", "right")[(int(entity.dxf.attachment_point or 1) - 1) % 3] + return [_text(index, entity, label, entity.dxf.insert, height, align=align)] return [] -def _expand(entity: Any) -> list[Any]: - """블록·치수처럼 속에 도형을 품은 것은 풀어서 낱개로 만든다. 못 풀면 버린다.""" +def _expand(entity: Any, depth: int = 0) -> list[Any]: + """블록·치수처럼 속에 도형을 품은 것은 풀어서 낱개로 — 블록 속 블록까지. 못 풀면 버린다.""" if entity.dxftype() in ("INSERT", "DIMENSION", "LEADER", "MULTILEADER"): + if depth >= _MAX_BLOCK_DEPTH: + logger.info("B07 도각 불러오기 — 블록이 %d 겹 넘게 겹쳐 건너뜀", _MAX_BLOCK_DEPTH) + return [] try: - return list(entity.virtual_entities()) + inner = list(entity.virtual_entities()) except Exception: logger.info("B07 도각 불러오기 — %s 는 풀지 못해 건너뜀", entity.dxftype()) return [] + return [item for child in inner for item in _expand(child, depth + 1)] return [entity] diff --git a/resources/tester/test_b07_frame_import_shapes.py b/resources/tester/test_b07_frame_import_shapes.py new file mode 100644 index 000000000..a93942d27 --- /dev/null +++ b/resources/tester/test_b07_frame_import_shapes.py @@ -0,0 +1,135 @@ +"""B07 도면 불러오기 — 호 · bulge 폴리선 · 거울 블록 · 겹 블록 견본 DXF(84-2) · 내보내기 시계방향 호(84-3). + +견본은 ezdxf 로 그 자리에서 만들어 끌어다 놓기 길(`drawing_file_to_entities`)로 읽는다. +""" + +from __future__ import annotations + +import io +import math + +import ezdxf +from ezdxf.enums import TextEntityAlignment + +from B07_DesignDetail import B07_DesignDetail_Engine_Frame_Export as export +from B07_DesignDetail.B07_DesignDetail_Engine_Frame_Import import drawing_file_to_entities + + +def _read(doc: ezdxf.document.Drawing) -> list[dict]: + stream = io.StringIO() + doc.write(stream) + entities, _layers = drawing_file_to_entities("견본.dxf", stream.getvalue().encode("utf-8")) + return entities + + +def _points(polyline: dict) -> list[tuple[float, float]]: + children = polyline["children"] + points = [ + (c["shapeData"]["startPoint"]["x"], c["shapeData"]["startPoint"]["y"]) for c in children + ] + last = children[-1]["shapeData"]["endPoint"] + return [*points, (last["x"], last["y"])] + + +def _on_circle(points, cx: float, cy: float, r: float) -> bool: + return all(abs(math.hypot(x - cx, y - cy) - r) < 0.21 for x, y in points) + + +def test_호는_1사분면_작은_호(): + doc = ezdxf.new() + doc.modelspace().add_arc((0, 0), 10, 0, 90) + (arc,) = _read(doc) + points = _points(arc) + assert _on_circle(points, 0, 0, 10) + assert points[0] == (10.0, 0.0) and math.isclose(points[-1][0], 0, abs_tol=1e-9) + assert all(x >= -1e-9 and y >= -1e-9 for x, y in points) # 큰 호(270°)로 뒤집히지 않음 + + +def test_bulge_폴리선은_호로_펴짐(): + doc = ezdxf.new() + space = doc.modelspace() + # 반원(bulge 1 · 반시계 → 아래로) · 작은 호(bulge −0.2 · 시계 → 위로 1) + space.add_lwpolyline([(0, 0, 0, 0, 1), (10, 0)], format="xyseb") + space.add_lwpolyline([(0, 20, 0, 0, -0.2), (10, 20)], format="xyseb") + half, small = _read(doc) + half_points = _points(half) + assert len(half_points) > 3 and _on_circle(half_points, 5, 0, 5) + assert min(y for _x, y in half_points) < -4.9 + small_points = _points(small) + assert len(small_points) > 3 + assert math.isclose(max(y for _x, y in small_points), 21.0, abs_tol=0.01) # 처짐 = 0.2 × 10 / 2 + assert min(y for _x, y in small_points) >= 20 - 1e-9 + + +def test_거울_블록은_WCS_자리(): + doc = ezdxf.new() + block = doc.blocks.new("거울") + block.add_lwpolyline([(0, 0, 0, 0, -0.2), (10, 0)], format="xyseb") + block.add_arc((20, 0), 2, 0, 90) + block.add_text("가", dxfattribs={"height": 2.5}).set_placement((2, 3)) + doc.modelspace().add_blockref("거울", (100, 0), dxfattribs={"xscale": -1}) + by_type: dict[str, list[dict]] = {} + for entity in _read(doc): + by_type.setdefault(entity["type"], []).append(entity) + bulge, arc = by_type["PolyLine"] + bulge_points = _points(bulge) + assert ( + min(x for x, _y in bulge_points) >= 90 - 1e-9 + and max(x for x, _y in bulge_points) <= 100 + 1e-9 + ) + assert math.isclose(max(y for _x, y in bulge_points), 1.0, abs_tol=0.01) # 위로 그대로 + arc_points = _points(arc) + assert _on_circle(arc_points, 80, 0, 2) + assert all(x <= 80 + 1e-9 and y >= -1e-9 for x, y in arc_points) # 2사분면으로 대칭 + (text,) = by_type["Text"] + assert text["shapeData"]["basePoint"] == {"x": 98.0, "y": 3.0} + + +def test_겹_블록도_풀림(): + doc = ezdxf.new() + doc.blocks.new("속").add_line((0, 0), (1, 0)) + doc.blocks.new("겉").add_blockref("속", (5, 0)) + doc.modelspace().add_blockref("겉", (10, 0)) + (line,) = _read(doc) + assert line["type"] == "Line" + assert line["shapeData"] == { + "startPoint": {"x": 15.0, "y": 0.0}, + "endPoint": {"x": 16.0, "y": 0.0}, + } + + +def test_TEXT_정렬점_자리(): + doc = ezdxf.new() + space = doc.modelspace() + space.add_text("가운데", dxfattribs={"height": 2}).set_placement( + (50, 5), align=TextEntityAlignment.MIDDLE_CENTER + ) + space.add_text("오른", dxfattribs={"height": 2}).set_placement( + (80, 5), align=TextEntityAlignment.BOTTOM_RIGHT + ) + center, right = _read(doc) + assert center["shapeData"]["basePoint"] == {"x": 50.0, "y": 5.0} + assert center["shapeData"]["options"]["textAlign"] == "center" + assert right["shapeData"]["basePoint"] == {"x": 80.0, "y": 5.0} + assert right["shapeData"]["options"]["textAlign"] == "right" + + +def test_내보내기_시계방향_작은_호(tmp_path): + arc = { + "type": "Arc", + "layerId": "기본", + "shapeData": { + "center": {"x": 0, "y": 0}, + "radius": 1, + "startAngle": math.pi / 2, + "endAngle": 0, + "counterClockwise": False, + }, + } + raw, skipped = export.drawing_to_dxf({"entities": [arc], "layers": []}) + assert skipped == {} + path = tmp_path / "out.dxf" + path.write_bytes(raw) + (out,) = ezdxf.readfile(path).modelspace().query("ARC") + span = (out.dxf.end_angle - out.dxf.start_angle) % 360 + assert math.isclose(span, 90) and math.isclose(out.dxf.start_angle % 360, 0, abs_tol=1e-9)