Update README.md

README.md

@@ -10,131 +10,207 @@ msp = doc.modelspace()
 
 fig, ax = plt.subplots(figsize=(8, 8))
 
-# 1) LINE
-for e in msp.query("LINE"):
-    x = [e.dxf.start.x, e.dxf.end.x]
-    y = [e.dxf.start.y, e.dxf.end.y]
-    ax.plot(x, y, linewidth=0.6, color="black")
-
-# 2) LWPOLYLINE / POLYLINE
-def plot_poly(points, closed, lw=0.6):
+# ---------------------------
+# 공통 유틸
+# ---------------------------
+def plot_segments(points, closed=False, lw=0.6):
+    """단순 선분 연결(이미 호로 근사된 점열이라는 가정)."""
+    if len(points) < 2:
+        return
     xs, ys = zip(*points)
     ax.plot(xs, ys, linewidth=lw, color="black")
     if closed and (points[0] != points[-1]):
         ax.plot([points[-1][0], points[0][0]],
                 [points[-1][1], points[0][1]], linewidth=lw, color="black")
 
-for e in msp.query("LWPOLYLINE"):
-    pts = [(p[0], p[1]) for p in e.get_points()]  # (x, y, [bulge...])
-    plot_poly(pts, e.closed)
-
-for e in msp.query("POLYLINE"):
-    pts = [(v.dxf.location.x, v.dxf.location.y) for v in e.vertices]
-    plot_poly(pts, e.is_closed)
-
-# 3) ARC (중심, 반경, 시작각, 끝각)
-for e in msp.query("ARC"):
-    c = e.dxf.center
-    r = e.dxf.radius
-    start = e.dxf.start_angle
-    end = e.dxf.end_angle
-    # matplotlib Arc는 도(deg) 기준
-    arc = Arc((c.x, c.y), width=2*r, height=2*r, angle=0,
-              theta1=start, theta2=end, linewidth=0.6, color="black")
-    ax.add_patch(arc)
-
-# 4) CIRCLE
-for e in msp.query("CIRCLE"):
-    c = e.dxf.center
-    r = e.dxf.radius
-    circle = plt.Circle((c.x, c.y), r, fill=False, linewidth=0.6, color="black")
-    ax.add_patch(circle)
-
-# 5) ELLIPSE (파라메트릭 샘플링)
-for e in msp.query("ELLIPSE"):
-    # 중심, 주축 벡터, 종축비, 시작/끝 파라미터(t in [0, 2π))
-    center = np.array([e.dxf.center.x, e.dxf.center.y])
-    major = np.array([e.dxf.major_axis.x, e.dxf.major_axis.y])
-    ratio = e.dxf.ratio  # minor_len / major_len
-    t0 = e.dxf.start_param
-    t1 = e.dxf.end_param
-
-    # 주축/종축 벡터
-    u = major
-    v = np.array([-major[1], major[0]])  # 직교 벡터
-    v = v / (np.linalg.norm(v) + 1e-12) * (np.linalg.norm(major) * ratio)
-
-    ts = np.linspace(t0, t1, 200)
-    xs = center[0] + u[0]*np.cos(ts) + v[0]*np.sin(ts)
-    ys = center[1] + u[1]*np.cos(ts) + v[1]*np.sin(ts)
-    ax.plot(xs, ys, linewidth=0.6, color="black")
-
-# 6) SPLINE (근사)
-for e in msp.query("SPLINE"):
-    pts = e.approximate(segments=200)  # 복잡하면 세그먼트 수 증가
-    xs, ys = zip(*[(p[0], p[1]) for p in pts])
-    ax.plot(xs, ys, linewidth=0.6, color="black")
-
-# 7) TEXT
-for e in msp.query("TEXT"):
-    ins = e.dxf.insert
-    text = e.dxf.text
-    height = e.dxf.height if e.dxf.height else 2.5  # 기본값
-    rot = e.dxf.rotation if e.dxf.hasattr("rotation") else 0.0
-    # Matplotlib 텍스트: 폰트/정렬은 완벽히 CAD와 동일하진 않음
-    ax.text(ins.x, ins.y, text,
-            fontsize=height, rotation=rot, rotation_mode="anchor",
-            ha="left", va="baseline", color="black")
-
-# 8) MTEXT
-for e in msp.query("MTEXT"):
-    ins = e.dxf.insert
-    text = e.plain_text()  # 포맷 태그 제거된 순수 텍스트
-    # MTEXT는 폭/높이/줄바꿈/정렬 등 복잡: 간단히만 표시
-    rot = e.dxf.rotation if e.dxf.hasattr("rotation") else 0.0
-    char_height = e.dxf.char_height if e.dxf.hasattr("char_height") else 2.5
-    ax.text(ins.x, ins.y, text,
-            fontsize=char_height, rotation=rot, rotation_mode="anchor",
-            ha="left", va="top", color="black")
-
-# (선택) HATCH: 경계만 외곽선으로 스케치 (간단 버전)
-for e in msp.query("HATCH"):
-    for path in e.paths:
-        if path.PATH_TYPE_EDGE:  # EDGE path
-            # EDGE는 Line/Arc/Ellipse/Spline 세그먼트, 여기선 샘플링하여 폴리라인화
-            pts = []
-            for edge in path.edges:
-                typ = edge.EDGE_TYPE
-                if typ == "LineEdge":
-                    pts += [(edge.start[0], edge.start[1]), (edge.end[0], edge.end[1])]
-                elif typ == "ArcEdge":
-                    cx, cy = edge.center
-                    r = edge.radius
-                    a0 = math.radians(edge.start_angle)
-                    a1 = math.radians(edge.end_angle)
-                    ts = np.linspace(a0, a1, 50)
-                    pts += [(cx + r*np.cos(t), cy + r*np.sin(t)) for t in ts]
-                elif typ == "EllipseEdge":
-                    (cx, cy) = edge.center
-                    major = np.array(edge.major_axis)
-                    ratio = edge.ratio
-                    t0, t1 = edge.start_param, edge.end_param
-                    u = major
-                    v = np.array([-major[1], major[0]])
-                    v = v / (np.linalg.norm(v) + 1e-12) * (np.linalg.norm(major) * ratio)
-                    ts = np.linspace(t0, t1, 100)
-                    pts += [(cx + u[0]*np.cos(t) + v[0]*np.sin(t),
-                             cy + u[1]*np.cos(t) + v[1]*np.sin(t)) for t in ts]
-                elif typ == "SplineEdge":
-                    ap = edge.spline.approximate(segments=100)
-                    pts += [(p[0], p[1]) for p in ap]
-            if len(pts) >= 2:
-                xs, ys = zip(*pts)
-                ax.plot(xs, ys, linewidth=0.4, color="black")
-        elif path.PATH_TYPE_POLYLINE:
-            pts = [(v[0], v[1]) for v in path.vertices]
-            xs, ys = zip(*pts)
-            ax.plot(xs, ys, linewidth=0.4, color="black")
+def plot_lwpolyline(e):
+    """LWPOLYLINE의 bulge를 포함해 호를 근사하여 그립니다."""
+    # get_points("xyb") → (x, y, bulge) 튜플
+    pts = list(e.get_points("xyb"))
+    if not pts:
+        return
+    approx = []
+    for i in range(len(pts) - 1 + int(e.closed)):
+        x1, y1, b1 = pts[i % len(pts)]
+        x2, y2, _  = pts[(i+1) % len(pts)]
+        p1 = np.array([x1, y1])
+        p2 = np.array([x2, y2])
+        if abs(b1) < 1e-12:
+            # 직선 세그먼트
+            approx += [tuple(p1), tuple(p2)]
+        else:
+            # bulge → 호 근사
+            # bulge = tan(delta/4), delta: 중심각
+            delta = 4 * math.atan(b1)
+            chord = p2 - p1
+            L = np.linalg.norm(chord)
+            if L < 1e-12:
+                continue
+            # 호 반지름
+            R = (L/2) / abs(math.sin(delta/2))
+            # chord 중점
+            mid = (p1 + p2) / 2
+            # chord 법선 단위벡터
+            n = np.array([-(chord[1]), chord[0]]) / (L + 1e-12)
+            # 중점에서 원 중심까지 거리
+            h = R * math.cos(delta/2)
+            # bulge의 부호로 중심 방향 결정
+            center = mid + np.sign(b1) * h * n
+            # p1, p2 각도
+            a1 = math.atan2(p1[1]-center[1], p1[0]-center[0])
+            a2 = math.atan2(p2[1]-center[1], p2[0]-center[0])
+            # 진행 방향: bulge 부호에 따라 시계/반시계
+            def angle_range(a_start, a_end, ccw=True, steps=32):
+                if ccw:
+                    if a_end <= a_start:
+                        a_end += 2*math.pi
+                    return np.linspace(a_start, a_end, steps)
+                else:
+                    if a_end >= a_start:
+                        a_end -= 2*math.pi
+                    return np.linspace(a_start, a_end, steps)
+            ccw = (b1 > 0)  # bulge>0이면 반시계
+            angles = angle_range(a1, a2, ccw=ccw, steps=max(16, int(abs(delta)*16)))
+            for t in angles:
+                approx.append((center[0] + R*math.cos(t), center[1] + R*math.sin(t)))
+    # 중복점 정리
+    cleaned = []
+    for p in approx:
+        if not cleaned or (abs(cleaned[-1][0]-p[0])>1e-9 or abs(cleaned[-1][1]-p[1])>1e-9):
+            cleaned.append(p)
+    plot_segments(cleaned, closed=e.closed, lw=0.6)
+
+def draw_basic_entity(ent):
+    """INSERT로 풀린 가상 엔티티 포함, 개별 엔티티를 현재 축에 그림."""
+    t = ent.dxftype()
+
+    if t == "LINE":
+        x = [ent.dxf.start.x, ent.dxf.end.x]
+        y = [ent.dxf.start.y, ent.dxf.end.y]
+        ax.plot(x, y, linewidth=0.6, color="black")
+
+    elif t == "LWPOLYLINE":
+        # bulge 지원
+        plot_lwpolyline(ent)
+
+    elif t == "POLYLINE":
+        pts = [(v.dxf.location.x, v.dxf.location.y) for v in ent.vertices]
+        plot_segments(pts, closed=getattr(ent, "is_closed", False), lw=0.6)
+
+    elif t == "ARC":
+        c = ent.dxf.center
+        r = ent.dxf.radius
+        arc = Arc((c.x, c.y), width=2*r, height=2*r, angle=0,
+                  theta1=ent.dxf.start_angle, theta2=ent.dxf.end_angle,
+                  linewidth=0.6, color="black")
+        ax.add_patch(arc)
+
+    elif t == "CIRCLE":
+        c = ent.dxf.center
+        r = ent.dxf.radius
+        circle = plt.Circle((c.x, c.y), r, fill=False, linewidth=0.6, color="black")
+        ax.add_patch(circle)
+
+    elif t == "ELLIPSE":
+        center = np.array([ent.dxf.center.x, ent.dxf.center.y])
+        major = np.array([ent.dxf.major_axis.x, ent.dxf.major_axis.y])
+        ratio = ent.dxf.ratio
+        t0 = ent.dxf.start_param
+        t1 = ent.dxf.end_param
+        u = major
+        v = np.array([-major[1], major[0]])
+        v = v / (np.linalg.norm(v) + 1e-12) * (np.linalg.norm(major) * ratio)
+        ts = np.linspace(t0, t1, 200)
+        xs = center[0] + u[0]*np.cos(ts) + v[0]*np.sin(ts)
+        ys = center[1] + u[1]*np.cos(ts) + v[1]*np.sin(ts)
+        ax.plot(xs, ys, linewidth=0.6, color="black")
+
+    elif t == "SPLINE":
+        pts = ent.approximate(segments=200)
+        xs, ys = zip(*[(p[0], p[1]) for p in pts])
+        ax.plot(xs, ys, linewidth=0.6, color="black")
+
+    elif t == "TEXT":
+        ins = ent.dxf.insert
+        text = ent.dxf.text
+        height = ent.dxf.height if ent.dxf.height else 2.5
+        rot = ent.dxf.rotation if ent.dxf.hasattr("rotation") else 0.0
+        ax.text(ins.x, ins.y, text, fontsize=height, rotation=rot,
+                rotation_mode="anchor", ha="left", va="baseline", color="black")
+
+    elif t in ("MTEXT", "ATTRIB"):
+        ins = ent.dxf.insert
+        text = ent.plain_text() if t == "MTEXT" else ent.dxf.text
+        rot = ent.dxf.rotation if ent.dxf.hasattr("rotation") else 0.0
+        char_height = getattr(ent.dxf, "char_height", None) or getattr(ent.dxf, "height", None) or 2.5
+        ax.text(ins.x, ins.y, text, fontsize=char_height, rotation=rot,
+                rotation_mode="anchor", ha="left", va="top", color="black")
+
+    elif t == "HATCH":
+        for path in ent.paths:
+            if path.PATH_TYPE_EDGE:
+                pts = []
+                for edge in path.edges:
+                    typ = edge.EDGE_TYPE
+                    if typ == "LineEdge":
+                        pts += [(edge.start[0], edge.start[1]), (edge.end[0], edge.end[1])]
+                    elif typ == "ArcEdge":
+                        cx, cy = edge.center
+                        r = edge.radius
+                        a0 = math.radians(edge.start_angle)
+                        a1 = math.radians(edge.end_angle)
+                        ts = np.linspace(a0, a1, 50)
+                        pts += [(cx + r*np.cos(t), cy + r*np.sin(t)) for t in ts]
+                    elif typ == "EllipseEdge":
+                        (cx, cy) = edge.center
+                        major = np.array(edge.major_axis)
+                        ratio = edge.ratio
+                        t0, t1 = edge.start_param, edge.end_param
+                        u = major
+                        v = np.array([-major[1], major[0]])
+                        v = v / (np.linalg.norm(v) + 1e-12) * (np.linalg.norm(major) * ratio)
+                        ts = np.linspace(t0, t1, 100)
+                        pts += [(cx + u[0]*np.cos(t) + v[0]*np.sin(t),
+                                 cy + u[1]*np.cos(t) + v[1]*np.sin(t)) for t in ts]
+                    elif typ == "SplineEdge":
+                        ap = edge.spline.approximate(segments=100)
+                        pts += [(p[0], p[1]) for p in ap]
+                if len(pts) >= 2:
+                    xs, ys = zip(*pts)
+                    ax.plot(xs, ys, linewidth=0.4, color="black")
+            elif path.PATH_TYPE_POLYLINE:
+                pts = [(v[0], v[1]) for v in path.vertices]
+                plot_segments(pts, lw=0.4)
+
+# ---------------------------
+# 1) 모델공간 기본 엔티티
+# ---------------------------
+for e in msp:
+    # 블록 참조(INSERT)는 아래에서 따로 처리
+    if e.dxftype() == "INSERT":
+        continue
+    draw_basic_entity(e)
+
+# ---------------------------
+# 2) 블록(INSERT) 전개
+# ---------------------------
+for br in msp.query("INSERT"):
+    # MINSERT 포함해 배열/스케일/회전/이동이 적용된 가상 엔티티로 확장
+    try:
+        for ve in br.virtual_entities():
+            draw_basic_entity(ve)
+    except Exception:
+        # 누락된 블록 정의 등 오류는 넘어감
+        continue
+
+# (선택) DIMENSION은 virtual_entities()를 쓰려면 보통 render() 필요
+for dim in msp.query("DIMENSION"):
+    try:
+        dim.render()  # 치수선→선/텍스트 등으로 실체화 (레거시 DIM에만 필요)
+        for ve in dim.virtual_entities():
+            draw_basic_entity(ve)
+    except Exception:
+        continue
 
 ax.set_aspect("equal")
 ax.axis("off")