Update README.md

README.md

@@ -1,281 +1,144 @@
 ```
-import json
-import copy
-from PIL import Image
-from pypdf import PdfReader
-from vllm import LLM, SamplingParams
-from ocrflux.image_utils import get_page_image
-from ocrflux.table_format import table_matrix2html
-from ocrflux.prompts import PageResponse, build_page_to_markdown_prompt, build_element_merge_detect_prompt, build_html_table_merge_prompt
-import requests
-
-import base64
-from io import BytesIO
-from PIL import Image
-import httpx
-
-import asyncio
-
-def pil_to_base64(img: Image.Image, format: str = "PNG") -> str:
-    buffered = BytesIO()
-    img.save(buffered, format=format)
-    img_bytes = buffered.getvalue()
-    img_base64 = base64.b64encode(img_bytes).decode("utf-8")
-    return img_base64
-
-async def get_response(messages, temperature):
-    url = "http://127.0.0.1:8000/v1/chat/completions"
-    headers = {"Content-Type": "application/json"}
-    payload = {
-        "model": "ChatDOC/OCRFlux-3B",
-        "temperature": temperature,
-        "messages": messages,
-        "stream": False,
-        "max_tokens": 4096,
-    }
-
-    timeout = httpx.Timeout(60.0)  # 전체 요청 제한 시간: 60초
-
-    async with httpx.AsyncClient(timeout=timeout) as client:
-        response = await client.post(url, json=payload, headers=headers)
-        response.raise_for_status()
-        return response.json()["choices"][0]['message']['content']
-
-def build_qwen2_5_vl_prompt(question):
-    messages = []
-    messages.append({"role":"system", "content":"You are a helpful assistant."})
-    messages.append({"role":"user", "content":[{"type":"text", "text":f"<|vision_start|><|image_pad|><|vision_end|>{question}"}]})
-
-    return messages
-
-
-def build_page_to_markdown_query(file_path: str, page_number: int, target_longest_image_dim: int = 1024, image_rotation: int = 0) -> dict:
-    assert image_rotation in [0, 90, 180, 270], "Invalid image rotation provided in build_page_query"
-    image = get_page_image(file_path, page_number, target_longest_image_dim=target_longest_image_dim, image_rotation=image_rotation)
-    question = build_page_to_markdown_prompt()
-    prompt = build_qwen2_5_vl_prompt(question)
-    prompt[-1]['content'].append({"type":"image_url","image_url": {"url":f"data:image/png;base64,{pil_to_base64(image)}"}})
-    return prompt
-
-def build_element_merge_detect_query(text_list_1,text_list_2) -> dict:
-    image = Image.new('RGB', (28, 28), color='black')
-    question = build_element_merge_detect_prompt(text_list_1,text_list_2)
-    prompt = build_qwen2_5_vl_prompt(question)
-    prompt[-1]['content'].append({"type":"image_url","image_url": {"url":f"data:image/png;base64,{pil_to_base64(image)}"}})
-    return prompt
-
-def build_html_table_merge_query(text_1,text_2) -> dict:
-    image = Image.new('RGB', (28, 28), color='black')
-    question = build_html_table_merge_prompt(text_1,text_2)
-    prompt = build_qwen2_5_vl_prompt(question)
-    prompt[-1]['content'].append({"type":"image_url","image_url": {"url":f"data:image/png;base64,{pil_to_base64(image)}"}})
-    return prompt
-
-def bulid_document_text(page_to_markdown_result, element_merge_detect_result, html_table_merge_result):
-    page_to_markdown_keys = list(page_to_markdown_result.keys())
-    element_merge_detect_keys = list(element_merge_detect_result.keys())
-    html_table_merge_keys = list(html_table_merge_result.keys())
-
-    for page_1,page_2,elem_idx_1,elem_idx_2 in sorted(html_table_merge_keys,key=lambda x: -x[0]):
-        page_to_markdown_result[page_1][elem_idx_1] = html_table_merge_result[(page_1,page_2,elem_idx_1,elem_idx_2)]
-        page_to_markdown_result[page_2][elem_idx_2] = ''
-
-    for page_1,page_2 in sorted(element_merge_detect_keys,key=lambda x: -x[0]):
-        for elem_idx_1,elem_idx_2 in element_merge_detect_result[(page_1,page_2)]:
-            if len(page_to_markdown_result[page_1][elem_idx_1]) == 0 or page_to_markdown_result[page_1][elem_idx_1][-1] == '-' or ('\u4e00' <= page_to_markdown_result[page_1][elem_idx_1][-1] <= '\u9fff'):
-                page_to_markdown_result[page_1][elem_idx_1] = page_to_markdown_result[page_1][elem_idx_1] + '' + page_to_markdown_result[page_2][elem_idx_2]
-            else:
-                page_to_markdown_result[page_1][elem_idx_1] = page_to_markdown_result[page_1][elem_idx_1] + ' ' + page_to_markdown_result[page_2][elem_idx_2]
-            page_to_markdown_result[page_2][elem_idx_2] = ''
-
-    document_text_list = []
-    for page in page_to_markdown_keys:
-        page_text_list = [s for s in page_to_markdown_result[page] if s]
-        document_text_list += page_text_list
-    return "\n\n".join(document_text_list)
-
-async def parse(file_path,skip_cross_page_merge=False,max_page_retries=0):
-    sampling_params = SamplingParams(temperature=0.0,max_tokens=8192)
-    if file_path.lower().endswith(".pdf"):
-        try:
-            reader = PdfReader(file_path)
-            num_pages = reader.get_num_pages()
-        except:
-            return None
-    else:
-        num_pages = 1
-
-    # try:
-    # Stage 1: Page to Markdown
-    page_to_markdown_query_list = [build_page_to_markdown_query(file_path,page_num) for page_num in range(1, num_pages + 1)]
-    # responses = [get_response(page_to_markdown_query, 0.0) for page_to_markdown_query in page_to_markdown_query_list]
-    tasks = [
-        get_response(query, 0.0)
-        for query in page_to_markdown_query_list
-    ]
-    responses = await asyncio.gather(*tasks)
-    results = [response for response in responses]
-    page_to_markdown_result = {}
-    retry_list = []
-    for i,result in enumerate(results):
-        try:
-            json_data = json.loads(result)
-            page_response = PageResponse(**json_data)
-            natural_text = page_response.natural_text
-            markdown_element_list = []
-            for text in natural_text.split('\n\n'):
-                if text.startswith("<Image>") and text.endswith("</Image>"):
-                    pass
-                elif text.startswith("<table>") and text.endswith("</table>"):
-                    try:
-                        new_text = table_matrix2html(text)
-                    except:
-                        new_text = text.replace("<t>","").replace("<l>","").replace("<lt>","")
-                    markdown_element_list.append(new_text)
-                else:
-                    markdown_element_list.append(text)
-            page_to_markdown_result[i+1] = markdown_element_list
-        except:
-            retry_list.append(i)
-
-    attempt = 0
-    while len(retry_list) > 0 and attempt < max_page_retries:
-        retry_page_to_markdown_query_list = [build_page_to_markdown_query(file_path,page_num) for page_num in retry_list]
-        # retry_sampling_params = SamplingParams(temperature=0.1*attempt, max_tokens=8192)
-        # responses = [get_response(retry_page_to_markdown_query, 0.1*attempt) for retry_page_to_markdown_query in retry_page_to_markdown_query_list]
-        # responses = llm.generate(retry_page_to_markdown_query_list, sampling_params=retry_sampling_params)
-        tasks = [
-            get_response(query, 0.1*attempt)
-            for query in retry_page_to_markdown_query_list
-        ]
-        responses = await asyncio.gather(*tasks)
-        results = [response for response in responses]
-        next_retry_list = []
-        for i,result in zip(retry_list,results):
-            try:
-                json_data = json.loads(result)
-                page_response = PageResponse(**json_data)
-                natural_text = page_response.natural_text
-                markdown_element_list = []
-                for text in natural_text.split('\n\n'):
-                    if text.startswith("<Image>") and text.endswith("</Image>"):
-                        pass
-                    elif text.startswith("<table>") and text.endswith("</table>"):
-                        try:
-                            new_text = table_matrix2html(text)
-                        except:
-                            new_text = text.replace("<t>","").replace("<l>","").replace("<lt>","")
-                        markdown_element_list.append(new_text)
-                    else:
-                        markdown_element_list.append(text)
-                page_to_markdown_result[i+1] = markdown_element_list
-            except:
-                next_retry_list.append(i)
-        retry_list = next_retry_list
-        attempt += 1
-
-    page_texts = {}
-    fallback_pages = []
-    for page_number in range(1, num_pages+1):
-        if page_number not in page_to_markdown_result.keys():
-            fallback_pages.append(page_number-1)
-        else:
-            page_texts[str(page_number-1)] = "\n\n".join(page_to_markdown_result[page_number])
-
-    if skip_cross_page_merge:
-        document_text_list = []
-        for i in range(num_pages):
-            if i not in fallback_pages:
-                document_text_list.append(page_texts[str(i)])
-        document_text = "\n\n".join(document_text_list)
-        return {
-            "orig_path": file_path,
-            "num_pages": num_pages,
-            "document_text": document_text,
-            "page_texts": page_texts,
-            "fallback_pages": fallback_pages,
-        }
-
-    # Stage 2: Element Merge Detect
-    element_merge_detect_keys = []
-    element_merge_detect_query_list = []
-    for page_num in range(1,num_pages):
-        if page_num in page_to_markdown_result.keys() and page_num+1 in page_to_markdown_result.keys():
-            element_merge_detect_query_list.append(build_element_merge_detect_query(page_to_markdown_result[page_num],page_to_markdown_result[page_num+1]))
-            element_merge_detect_keys.append((page_num,page_num+1))
-
-    # responses = [get_response(element_merge_detect_query, 0.0) for element_merge_detect_query in element_merge_detect_query_list]
-    # responses = llm.generate(element_merge_detect_query_list, sampling_params=sampling_params)
-    tasks = [
-        get_response(query, 0.0)
-        for query in element_merge_detect_query_list
-    ]
-    responses = await asyncio.gather(*tasks)
-    results = [response for response in responses]
-    element_merge_detect_result = {}
-    for key,result in zip(element_merge_detect_keys,results):
-        try:
-            element_merge_detect_result[key] = eval(result)
-        except:
-            pass
-
-    # Stage 3: HTML Table Merge
-    html_table_merge_keys = []
-    for key,result in element_merge_detect_result.items():
-        page_1,page_2 = key
-        for elem_idx_1,elem_idx_2 in result:
-            text_1 = page_to_markdown_result[page_1][elem_idx_1]
-            text_2 = page_to_markdown_result[page_2][elem_idx_2]
-            if text_1.startswith("<table>") and text_1.endswith("</table>") and text_2.startswith("<table>") and text_2.endswith("</table>"):
-                html_table_merge_keys.append((page_1,page_2,elem_idx_1,elem_idx_2))
-
-    html_table_merge_keys = sorted(html_table_merge_keys,key=lambda x: -x[0])
-
-    html_table_merge_result = {}
-    page_to_markdown_result_tmp = copy.deepcopy(page_to_markdown_result)
-    i = 0
-    while i < len(html_table_merge_keys):
-        tmp = set()
-        keys = []
-        while i < len(html_table_merge_keys):
-            page_1,page_2,elem_idx_1,elem_idx_2 = html_table_merge_keys[i]
-            if (page_2,elem_idx_2) in tmp:
-                break
-            tmp.add((page_1,elem_idx_1))
-            keys.append((page_1,page_2,elem_idx_1,elem_idx_2))
-            i += 1
-
-        html_table_merge_query_list = [build_html_table_merge_query(page_to_markdown_result_tmp[page_1][elem_idx_1],page_to_markdown_result_tmp[page_2][elem_idx_2]) for page_1,page_2,elem_idx_1,elem_idx_2 in keys]
-        # responses = [get_response(html_table_merge_query, 0.0) for html_table_merge_query in html_table_merge_query_list]
-        # responses = llm.generate(html_table_merge_query_list, sampling_params=sampling_params)
-        tasks = [
-            get_response(query, 0.0)
-            for query in html_table_merge_query_list
-        ]
-        responses = await asyncio.gather(*tasks)
-        results = [response for response in responses]
-        for key,result in zip(keys,results):
-            if result.startswith("<table>") and result.endswith("</table>"):
-                html_table_merge_result[key] = result
-                page_to_markdown_result_tmp[page_1][elem_idx_1] = result
-
-    document_text = bulid_document_text(page_to_markdown_result, element_merge_detect_result, html_table_merge_result)
-    return {
-        "orig_path": file_path,
-        "num_pages": num_pages,
-        "document_text": document_text,
-        "page_texts": page_texts,
-        "fallback_pages": fallback_pages,
-    }
-
-
-file_path = '/content/test.pdf'
-result = await parse(file_path)
-if result != None:
-    document_markdown = result['document_text']
-    print(document_markdown)
-    with open('test.md','w') as f:
-        f.write(document_markdown)
-else:
-    print("Parse failed.")
+import ezdxf
+import matplotlib.pyplot as plt
+from matplotlib.patches import Arc
+import numpy as np
+import math
+
+doc = ezdxf.readfile("plan.dxf")
+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):
+    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")
+
+ax.set_aspect("equal")
+ax.axis("off")
+plt.savefig("output.png", dpi=300)
+plt.savefig("output.pdf")
+plt.close()
 ```