Update README.md

README.md

@@ -5,27 +5,47 @@ from matplotlib.patches import Arc
 import numpy as np
 import math
 
-doc = ezdxf.readfile("plan.dxf")
+# ============== 사용자 입력 ==============
+dxf_path = "plan.dxf"
+
+# 하이라이트할 노드 그룹 (원하는 만큼 추가)
+# points: 사용자가 지정한 좌표(대략치여도 스냅됨), label은 옵션
+selected_groups = {
+    "CHECK": {
+        "color": "red",
+        "points": [(100.0, 200.0), (150.2, 80.7)],  # 예시 좌표
+        "labels": ["N1", "N2"],  # 없으면 자동 번호
+    },
+    "MONITOR": {
+        "color": "orange",
+        "points": [(300.0, 210.0)],
+        "labels": None,
+    },
+}
+snap_tol = 1.0      # 스냅 허용오차(도면 단위). 도면 스케일에 맞춰 조정
+marker_size = 8      # 마커 픽셀 크기
+label_fontsize = 6   # 라벨 폰트 크기
+
+# ============== DXF 로드 ==============
+doc = ezdxf.readfile(dxf_path)
 msp = doc.modelspace()
 
-fig, ax = plt.subplots(figsize=(8, 8))
+fig, ax = plt.subplots(figsize=(10, 10))
 
 # ---------------------------
 # 공통 유틸
 # ---------------------------
-def plot_segments(points, closed=False, lw=0.6):
-    """단순 선분 연결(이미 호로 근사된 점열이라는 가정)."""
+def plot_segments(ax, points, closed=False, lw=0.6, color="black"):
     if len(points) < 2:
         return
     xs, ys = zip(*points)
-    ax.plot(xs, ys, linewidth=lw, color="black")
+    ax.plot(xs, ys, linewidth=lw, color=color)
     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")
+                [points[-1][1], points[0][1]], linewidth=lw, color=color)
 
-def plot_lwpolyline(e):
-    """LWPOLYLINE의 bulge를 포함해 호를 근사하여 그립니다."""
-    # get_points("xyb") → (x, y, bulge) 튜플
+def plot_lwpolyline(ax, e):
+    """LWPOLYLINE의 bulge(호)를 근사하여 그림."""
     pts = list(e.get_points("xyb"))
     if not pts:
         return
@@ -36,30 +56,20 @@ def plot_lwpolyline(e):
         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)
+            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:
@@ -69,19 +79,18 @@ def plot_lwpolyline(e):
                     if a_end >= a_start:
                         a_end -= 2*math.pi
                     return np.linspace(a_start, a_end, steps)
-            ccw = (b1 > 0)  # bulge>0이면 반시계
+            ccw = (b1 > 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)
+    plot_segments(ax, cleaned, closed=e.closed, lw=0.6)
 
-def draw_basic_entity(ent):
-    """INSERT로 풀린 가상 엔티티 포함, 개별 엔티티를 현재 축에 그림."""
+def draw_basic_entity(ax, ent):
+    """INSERT 전개된 가상 엔티티 포함, 개별 엔티티를 그림."""
     t = ent.dxftype()
 
     if t == "LINE":
@@ -90,33 +99,28 @@ def draw_basic_entity(ent):
         ax.plot(x, y, linewidth=0.6, color="black")
 
     elif t == "LWPOLYLINE":
-        # bulge 지원
-        plot_lwpolyline(ent)
+        plot_lwpolyline(ax, 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)
+        plot_segments(ax, pts, closed=getattr(ent, "is_closed", False), lw=0.6)
 
     elif t == "ARC":
-        c = ent.dxf.center
-        r = ent.dxf.radius
+        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)
+        c = ent.dxf.center; r = ent.dxf.radius
+        ax.add_patch(plt.Circle((c.x, c.y), r, fill=False, linewidth=0.6, color="black"))
 
     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
+        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)
@@ -131,8 +135,7 @@ def draw_basic_entity(ent):
         ax.plot(xs, ys, linewidth=0.6, color="black")
 
     elif t == "TEXT":
-        ins = ent.dxf.insert
-        text = ent.dxf.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,
@@ -141,9 +144,9 @@ def draw_basic_entity(ent):
     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,
+        rot  = ent.dxf.rotation if ent.dxf.hasattr("rotation") else 0.0
+        h    = getattr(ent.dxf, "char_height", None) or getattr(ent.dxf, "height", None) or 2.5
+        ax.text(ins.x, ins.y, text, fontsize=h, rotation=rot,
                 rotation_mode="anchor", ha="left", va="top", color="black")
 
     elif t == "HATCH":
@@ -155,20 +158,16 @@ def draw_basic_entity(ent):
                     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)
+                        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
+                        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)
+                        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]
@@ -176,45 +175,151 @@ def draw_basic_entity(ent):
                         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")
+                    plot_segments(ax, pts, lw=0.4)
             elif path.PATH_TYPE_POLYLINE:
                 pts = [(v[0], v[1]) for v in path.vertices]
-                plot_segments(pts, lw=0.4)
+                plot_segments(ax, pts, lw=0.4)
 
 # ---------------------------
-# 1) 모델공간 기본 엔티티
+# 1) 기본 엔티티 그리기(INSERT 제외)
 # ---------------------------
 for e in msp:
-    # 블록 참조(INSERT)는 아래에서 따로 처리
     if e.dxftype() == "INSERT":
         continue
-    draw_basic_entity(e)
+    draw_basic_entity(ax, e)
 
 # ---------------------------
-# 2) 블록(INSERT) 전개
+# 2) 블록(INSERT) 전개 + DIMENSION
 # ---------------------------
 for br in msp.query("INSERT"):
-    # MINSERT 포함해 배열/스케일/회전/이동이 적용된 가상 엔티티로 확장
     try:
         for ve in br.virtual_entities():
-            draw_basic_entity(ve)
+            draw_basic_entity(ax, ve)
     except Exception:
-        # 누락된 블록 정의 등 오류는 넘어감
         continue
 
-# (선택) DIMENSION은 virtual_entities()를 쓰려면 보통 render() 필요
 for dim in msp.query("DIMENSION"):
     try:
-        dim.render()  # 치수선→선/텍스트 등으로 실체화 (레거시 DIM에만 필요)
+        dim.render()
         for ve in dim.virtual_entities():
-            draw_basic_entity(ve)
+            draw_basic_entity(ax, ve)
     except Exception:
         continue
 
+# ---------------------------
+# 3) 노드 후보 추출 (끝점/버텍스 중심)
+# ---------------------------
+node_candidates = []
+
+def add_node(p):
+    node_candidates.append((float(p[0]), float(p[1])))
+
+# LINE 끝점
+for e in msp.query("LINE"):
+    add_node((e.dxf.start.x, e.dxf.start.y))
+    add_node((e.dxf.end.x, e.dxf.end.y))
+
+# LWPOLYLINE: 버텍스 좌표(호 중간점까지 다 넣으면 너무 많아져서 버텍스만)
+for e in msp.query("LWPOLYLINE"):
+    for (x, y, *_) in e.get_points("xyb"):
+        add_node((x, y))
+
+# POLYLINE: 버텍스
+for e in msp.query("POLYLINE"):
+    for v in e.vertices:
+        add_node((v.dxf.location.x, v.dxf.location.y))
+
+# ARC/CIRCLE 중심을 노드로 쓰고 싶다면 아래 주석 해제
+# for e in msp.query("ARC"):
+#     add_node((e.dxf.center.x, e.dxf.center.y))
+# for e in msp.query("CIRCLE"):
+#     add_node((e.dxf.center.x, e.dxf.center.y))
+
+# 중복 제거(격자 스냅)
+def snap_key(p, tol=1e-6):
+    return (round(p[0]/tol), round(p[1]/tol))
+uniq = {}
+for p in node_candidates:
+    k = snap_key(p, 1e-6)
+    if k not in uniq:
+        uniq[k] = p
+node_candidates = list(uniq.values())
+
+# ---------------------------
+# 4) 선택 노드 스냅 & 하이라이트
+# ---------------------------
+def find_nearest_node(pt, candidates, tol):
+    """pt에 가장 가까운 후보를 찾고, 거리가 tol보다 크면 None."""
+    px, py = pt
+    best = None; best_d2 = None
+    for cx, cy in candidates:
+        d2 = (cx - px)**2 + (cy - py)**2
+        if (best_d2 is None) or (d2 < best_d2):
+            best_d2 = d2; best = (cx, cy)
+    if best is None:
+        return None
+    dist = math.sqrt(best_d2)
+    return best if dist <= tol else None
+
+def draw_marker(ax, x, y, color="red", size=8, zorder=10):
+    # 화면 픽셀 고정 크기 마커(도면 축척 무관)
+    ax.scatter([x], [y], s=size**2, c=color, marker='o', zorder=zorder, linewidths=0.5, edgecolors="black")
+
+# 그룹별로 스냅/표시
+legend_handles = []
+for gname, cfg in selected_groups.items():
+    color = cfg.get("color", "red")
+    pts   = cfg.get("points", [])
+    labels= cfg.get("labels", None)
+    placed = []
+    for i, pt in enumerate(pts):
+        snapped = find_nearest_node(pt, node_candidates, snap_tol)
+        if snapped is None:
+            # 가까운 노드가 없으면 원래 대략 좌표에 마커(색 다르게 표시)
+            draw_marker(ax, pt[0], pt[1], color="gray", size=marker_size, zorder=12)
+            if labels:
+                ax.text(pt[0], pt[1], labels[i], fontsize=label_fontsize, color="gray",
+                        ha="left", va="bottom", zorder=12)
+            continue
+        x, y = snapped
+        draw_marker(ax, x, y, color=color, size=marker_size, zorder=13)
+        if labels:
+            ax.text(x, y, labels[i], fontsize=label_fontsize, color=color,
+                    ha="left", va="bottom", zorder=13)
+        placed.append((x, y))
+    # 범례용 더미(선택사항)
+    lh = ax.scatter([], [], s=marker_size**2, c=color, marker='o', edgecolors="black", label=gname)
+    legend_handles.append(lh)
+
+if legend_handles:
+    ax.legend(loc="upper right", fontsize=8, frameon=True)
+
+# ---------------------------
+# 5) 보기/저장
+# ---------------------------
 ax.set_aspect("equal")
 ax.axis("off")
-plt.savefig("output.png", dpi=300)
-plt.savefig("output.pdf")
+
+# 도면 전체 extents 자동 크롭(여백 포함)
+try:
+    # ezdxf의 extents 계산을 쓰고 싶다면:
+    # from ezdxf.addons.drawing import layout
+    # ext = layout.Layout(msp).bbox()  # 버전에 따라 다를 수 있음
+    # 여기서는 산포로 추정:
+    xs, ys = [], []
+    for (x, y) in node_candidates:
+        xs.append(x); ys.append(y)
+    if xs and ys:
+        margin = 0.05  # 5% 여백
+        xmin, xmax = min(xs), max(xs)
+        ymin, ymax = min(ys), max(ys)
+        dx = xmax - xmin; dy = ymax - ymin
+        ax.set_xlim(xmin - dx*margin, xmax + dx*margin)
+        ax.set_ylim(ymin - dy*margin, ymax + dy*margin)
+except Exception:
+    pass
+
+plt.savefig("plan_with_nodes.png", dpi=300, bbox_inches="tight", pad_inches=0.02)
+plt.savefig("plan_with_nodes.pdf", bbox_inches="tight", pad_inches=0.02)
 plt.close()
 ```