ecode-cutting 0.2.3__py3-none-any.whl

ecode_cutting/exporters.py

@@ -0,0 +1,362 @@
+"""纯标准库布局导出。所有导出先构造完整内容，再写入调用方路径或流。"""
+
+import csv
+from datetime import date
+from html import escape
+import io
+import math
+from pathlib import Path
+import struct
+import zlib
+
+from .models import Options, UnsupportedFeatureError, ValidationError
+from .serialization import _check
+
+
+def _write(target, text):
+    if isinstance(target, (str, bytes, Path)):
+        Path(target).write_text(text, encoding="utf-8", newline="")
+    elif isinstance(target, (io.BufferedIOBase, io.RawIOBase, io.BytesIO)):
+        target.write(text.encode("utf-8"))
+    else:
+        target.write(text)
+
+
+def _csv(rows):
+    output = io.StringIO(newline="")
+    csv.writer(output, lineterminator="\r\n").writerows(rows)
+    return output.getvalue()
+
+
+def _n(value):
+    if not math.isfinite(value):
+        raise ValidationError("导出坐标必须是有限数值")
+    return format(value, ".12g")
+
+
+def _validate(result):
+    from dataclasses import asdict
+    _check(asdict(result))
+
+
+def export_csv(result, target):
+    """与 CutGLib 一致的七列布局 CSV，UTF-8，正确转义引号和换行。"""
+    _validate(result)
+    rows = [[" Sheet", "ID", "X", "Y", "Width", "Height", "Rotated"]]
+    for i, layout in enumerate(result.layouts, 1):
+        for p in layout.parts:
+            rows.append([layout.id or str(i), p.id, _n(p.x), _n(p.y),
+                         _n(p.width), _n(p.height), "yes" if p.rotated else "no"])
+    _write(target, _csv(rows))
+
+
+def _polygon(part):
+    # polygon 中的点是布局绝对坐标。
+    return part.polygon or ((part.x, part.y), (part.x + part.width, part.y),
+                            (part.x + part.width, part.y + part.height),
+                            (part.x, part.y + part.height))
+
+
+def export_dxf(result, target, include_part_ids=True, cuts_only=False,
+               include_cut_number=True, include_stock_panel=True):
+    """输出 ASCII DXF R12，按 Panel_N 分层；中文保留安全 Unicode 转义。"""
+    _validate(result)
+    pairs = []
+    def pair(code, value):
+        pairs.extend((str(code), str(value)))
+    def text_value(value):
+        # 每个非 ASCII UTF-16 单元编码为 DXF \U+XXXX，避免换行注入组码。
+        value = str(value).replace("\\", "\\\\").replace("\r", " ").replace("\n", " ")
+        out = []
+        for c in value:
+            if ord(c) < 128:
+                out.append(c)
+            else:
+                raw = c.encode("utf-16-be")
+                out.extend("\\U+" + raw[i:i+2].hex().upper() for i in range(0, len(raw), 2))
+        return "".join(out)
+    def line(layer, x1, y1, x2, y2):
+        for c, v in ((0,"LINE"),(8,layer),(10,_n(x1)),(20,_n(y1)),(30,0),
+                     (11,_n(x2)),(21,_n(y2)),(31,0)):
+            pair(c,v)
+    def polygon(layer, points):
+        for a, b in zip(points, points[1:] + points[:1]):
+            line(layer,*a,*b)
+    def label(layer,x,y,value,height):
+        for c,v in ((0,"TEXT"),(8,layer),(10,_n(x)),(20,_n(y)),(30,0),
+                    (40,_n(height)),(1,text_value(value))):
+            pair(c,v)
+    for c,v in ((0,"SECTION"),(2,"HEADER"),(9,"$ACADVER"),(1,"AC1009"),
+                (0,"ENDSEC"),(0,"SECTION"),(2,"TABLES"),(0,"TABLE"),
+                (2,"LAYER"),(70,len(result.layouts))):
+        pair(c,v)
+    for i in range(1,len(result.layouts)+1):
+        for c,v in ((0,"LAYER"),(2,f"Panel_{i}"),(70,0),(62,7),(6,"CONTINUOUS")):
+            pair(c,v)
+    for c,v in ((0,"ENDTAB"),(0,"ENDSEC"),(0,"SECTION"),(2,"ENTITIES")):
+        pair(c,v)
+    for i,layout in enumerate(result.layouts,1):
+        layer = f"Panel_{i}"
+        if include_stock_panel:
+            polygon(layer, ((0,0),(layout.width,0),(layout.width,layout.height),(0,layout.height)))
+        if cuts_only:
+            for number,cut in enumerate((*layout.trim_cuts,*layout.cuts),1):
+                line(layer,cut.x1,cut.y1,cut.x2,cut.y2)
+                if include_cut_number:
+                    label(layer,(cut.x1+cut.x2)/2,(cut.y1+cut.y2)/2,number,max(layout.height/100,0.01))
+        else:
+            for p in layout.parts:
+                polygon(layer,_polygon(p))
+                if include_part_ids:
+                    label(layer,p.x+p.width/2,p.y+p.height/2,p.id,max(min(p.width,p.height)/10,0.01))
+    pair(0,"ENDSEC")
+    pair(0,"EOF")
+    _write(target,"\r\n".join(pairs)+"\r\n")
+
+
+def _viewport(layout, max_size, *, png=False, linear=False):
+    if type(max_size) is not int or not 1 <= max_size <= 8192:
+        raise ValidationError("max_size 必须在 1 到 8192 之间")
+    if not all(math.isfinite(v) and v > 0 for v in (layout.width,layout.height)):
+        raise ValidationError("布局宽高必须为正有限数值")
+    from dataclasses import asdict
+    _check(asdict(layout))
+    if png:
+        # 原 DLL 实测：限制值夹在 50..4000，并为边界另留一像素。
+        max_size=min(4000,max(50,max_size))
+        aspect=layout.width/(60*layout.width/max_size if linear else layout.height)
+        if aspect>1:
+            width,height=max_size,math.ceil(max_size/aspect)
+        else:
+            width,height=math.ceil(max_size*aspect),max_size
+        return width+1,height+1,width/layout.width
+    scale = max_size / max(layout.width,layout.height)
+    return max(1,round(layout.width*scale)), max(1,round(layout.height*scale)), scale
+
+
+def render_svg(layout, linear=False, max_size=1000):
+    """返回具有实际斜角多边形及可检索零件 ID 的独立 SVG。"""
+    width,height,scale = _viewport(layout,max_size)
+    items = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {_n(layout.width)} {_n(layout.height)}">',
+             f'<rect width="{_n(layout.width)}" height="{_n(layout.height)}" fill="#f2f2f2" stroke="#333"/>']
+    for p in layout.parts:
+        points=" ".join(f"{_n(x)},{_n(y)}" for x,y in _polygon(p))
+        items.append(f'<polygon points="{points}" fill="#a9d4ed" stroke="#28546c" stroke-width="{_n(1/scale)}"><title>{escape(p.id)}</title></polygon>')
+        items.append(f'<text x="{_n(p.x+p.width/2)}" y="{_n(p.y+p.height/2)}" font-size="{_n(min(p.height/3,12/scale))}" text-anchor="middle">{escape(p.id)}</text>')
+    for c in (*layout.trim_cuts,*layout.cuts):
+        items.append(f'<line x1="{_n(c.x1)}" y1="{_n(c.y1)}" x2="{_n(c.x2)}" y2="{_n(c.y2)}" stroke="#b22" stroke-width="{_n(1/scale)}"/>')
+    return "".join(items)+"</svg>"
+
+
+def render_png(layout, linear=False, max_size=1000):
+    """返回 RGB PNG；扫描线填充实际轮廓，不依赖外部图像库。"""
+    width,height,scale = _viewport(layout,max_size,png=True,linear=linear)
+    yscale=(height-1)/layout.height if linear else scale
+    pixels=bytearray(b"\xf2\xf2\xf2"*(width*height))
+    def pixel(x,y,color):
+        if 0<=x<width and 0<=y<height:
+            at=(y*width+x)*3
+            pixels[at:at+3]=color
+    def draw_line(x1,y1,x2,y2,color):
+        # 先裁剪到画布，极远的有限坐标不能导致逐像素死循环。
+        dx,dy=x2-x1,y2-y1
+        begin,end=0.,1.
+        for p,q in ((-dx,x1),(dx,layout.width-x1),(-dy,y1),(dy,layout.height-y1)):
+            if p==0:
+                if q<0: return
+                continue
+            ratio=q/p
+            if p<0: begin=max(begin,ratio)
+            else: end=min(end,ratio)
+            if begin>end: return
+        x1,y1,x2,y2=x1+begin*dx,y1+begin*dy,x1+end*dx,y1+end*dy
+        x1,y1,x2,y2=(round(x1*scale),round(y1*yscale),round(x2*scale),round(y2*yscale))
+        dx,dy=abs(x2-x1),-abs(y2-y1)
+        sx,sy=(1 if x1<x2 else -1),(1 if y1<y2 else -1)
+        err=dx+dy
+        while True:
+            pixel(x1,y1,color)
+            if x1==x2 and y1==y2: break
+            e2=2*err
+            if e2>=dy: err+=dy; x1+=sx
+            if e2<=dx: err+=dx; y1+=sy
+    for p in layout.parts:
+        points=_polygon(p)
+        scaled=[(x*scale,y*yscale) for x,y in points]
+        for y in range(max(0,math.floor(min(pt[1] for pt in scaled))),min(height,math.ceil(max(pt[1] for pt in scaled)))):
+            scan=y+0.5
+            xs=[]
+            for (x1,y1),(x2,y2) in zip(scaled,scaled[1:]+scaled[:1]):
+                if min(y1,y2)<=scan<max(y1,y2):
+                    xs.append(x1+(scan-y1)*(x2-x1)/(y2-y1))
+            xs.sort()
+            for left,right in zip(xs[::2],xs[1::2]):
+                for x in range(max(0,math.ceil(left-0.5)),min(width,math.ceil(right-0.5))):
+                    pixel(x,y,b"\xa9\xd4\xed")
+        for a,b in zip(points,points[1:]+points[:1]): draw_line(*a,*b,b"\x28\x54\x6c")
+    for c in (*layout.trim_cuts,*layout.cuts): draw_line(c.x1,c.y1,c.x2,c.y2,b"\xbb\x22\x22")
+    def chunk(kind,data):
+        return struct.pack(">I",len(data))+kind+data+struct.pack(">I",zlib.crc32(kind+data)&0xffffffff)
+    raw=b"".join(b"\0"+bytes(pixels[y*width*3:(y+1)*width*3]) for y in range(height))
+    return (b"\x89PNG\r\n\x1a\n"+chunk(b"IHDR",struct.pack(">IIBBBBB",width,height,8,2,0,0,0))+
+            chunk(b"IDAT",zlib.compress(raw))+chunk(b"IEND",b""))
+
+
+def export_ptx(result, target, job_name="", customer="", material="",
+               material_thickness=0, units=0, unit_scale=1,
+               require_all_trim_cuts=False, options=None, materials=()):
+    """输出 PTX 1.08 断头切割记录；拒绝一维及无法断头分割的布局。
+
+    按实际零件几何重建切割树，PATTERNS/CUTS 的尺寸为每级相对尺寸，
+    不是全局坐标。每个布局独立模式，避免合并后丢失实例分配。
+    """
+    _validate(result)
+    if result.linear:
+        raise UnsupportedFeatureError("PTX 仅支持二维矩形断头切割")
+    if not math.isfinite(unit_scale) or unit_scale<=0:
+        raise ValidationError("unit_scale 必须是正有限数值")
+    if type(units) is not int:
+        raise ValidationError("units 必须为整数")
+    _check([job_name,customer,material,material_thickness])
+    opt=options or Options()
+    from dataclasses import asdict
+    _check(asdict(opt))
+    if opt.saw_width<0:
+        raise ValidationError("锯缝必须非负")
+    def dim(v): return _n(round(v*unit_scale,2))
+    part_keys={}
+    part_rows=[]
+    stock_rows=[]
+    offcut_rows=[]
+    patterns=[]
+    sequences=[]
+    remaining_area=0.
+    tol=1e-7
+    for pattern,layout in enumerate(result.layouts,1):
+        if any(p.polygon or p.angle_start or p.angle_end for p in layout.parts):
+            raise UnsupportedFeatureError("PTX 不支持斜角轮廓")
+        if layout.components:
+            raise UnsupportedFeatureError("PTX 不支持组合原料")
+        stock_rows.append(["BOARDS",1,pattern,layout.id,max(1,layout.material+1),dim(layout.width),dim(layout.height),1,1,0,0])
+        items=[]
+        for p in layout.parts:
+            key=(p.id,p.width,p.height,p.material)
+            if key not in part_keys:
+                part_keys[key]=len(part_rows)+1
+                part_rows.append(["PARTS_REQ",1,len(part_rows)+1,p.id,max(1,p.material+1),dim(p.width),dim(p.height),0,0,0,1,0])
+            number=part_keys[key]
+            part_rows[number-1][7]+=1
+            part_rows[number-1][11]+=1
+            items.append((p.x,p.y,p.width,p.height,number))
+        for i,p in enumerate(layout.parts):
+            if p.x < -tol or p.y < -tol or p.x+p.width>layout.width+tol or p.y+p.height>layout.height+tol:
+                raise ValidationError("PTX 零件越出原料")
+            for other in layout.parts[:i]:
+                if min(p.x+p.width,other.x+other.width)>max(p.x,other.x)+tol and min(p.y+p.height,other.y+other.height)>max(p.y,other.y)+tol:
+                    raise ValidationError("PTX 零件重叠")
+        first_axis=1 if opt.cut_direction=="horizontal" else 0
+        if layout.cuts:
+            c=layout.cuts[0]
+            first_axis=0 if abs(c.x1-c.x2)<tol else 1
+        # 对齐 PtxLayoutExporter.ExtendRemnantsToOriginTrims：未要求全部修边时，
+        # 首刀纵向仅将贴上修边的余料延至 y=0，首刀横向则延至 x=0。
+        for r in layout.remnants:
+            x,y,w,h=r.x,r.y,r.width,r.height
+            if not require_all_trim_cuts:
+                if first_axis==0 and abs(y-opt.trim_top)<tol:
+                    h+=y; y=0.
+                elif first_axis==1 and abs(x-opt.trim_left)<tol:
+                    w+=x; x=0.
+            remaining_area+=w*h
+            index=len(offcut_rows)+1
+            offcut_rows.append(["OFFCUTS",1,index,f"X{index}",max(1,layout.material+1),dim(w),dim(h),1])
+            items.append((x,y,w,h,f"X{index}"))
+        # 使用显式任务栈构造树，不受 Python 递归深度或条带数量限制。
+        def split_node(region, members, previous_axis=None, depth=-1):
+            x,y,w,h=region
+            if not members:
+                index=len(offcut_rows)+1
+                offcut_rows.append(["OFFCUTS",1,index,f"X{index}",max(1,layout.material+1),dim(w),dim(h),1])
+                return ("leaf",f"X{index}")
+            if len(members)==1:
+                a,b,c,d,index=members[0]
+                if abs(a-x)<tol and abs(b-y)<tol and abs(c-w)<tol and abs(d-h)<tol:
+                    return ("leaf",index)
+            preferred=first_axis if previous_axis is None else previous_axis
+            axis_order=(preferred,1-preferred)
+            for axis in axis_order:
+                origin=(x,y)[axis]; extent=(w,h)[axis]
+                candidates=sorted({item[axis] for item in members}|{item[axis]+item[axis+2] for item in members})
+                for position in candidates:
+                    if position<=origin+tol or position>=origin+extent-tol: continue
+                    if any(item[axis]+tol<position<item[axis]+item[axis+2]-tol for item in members): continue
+                    before=[a for a in members if a[axis]+a[axis+2]<=position+tol]
+                    after=[a for a in members if a[axis]+a[axis+2]>position+tol]
+                    # 实际相邻零件的空隙至少覆盖指定锯缝。
+                    gap=min((a[axis] for a in after),default=origin+extent)-position
+                    kerf=min(opt.saw_width,max(0,gap))
+                    if after and before and gap+tol<opt.saw_width: continue
+                    left=list(region);right=list(region)
+                    left[axis+2]=position-origin
+                    right[axis]=position+kerf
+                    right[axis+2]=origin+extent-position-kerf
+                    margin_start=(opt.trim_left,opt.trim_top)[axis]
+                    margin_end=(layout.width-opt.trim_right,layout.height-opt.trim_bottom)[axis]
+                    trim_node=((margin_start>0 and abs(position-margin_start)<tol and not before)
+                               or (abs(position-margin_end)<tol and not after
+                                   and (opt.trim_right,opt.trim_bottom)[axis]>0))
+                    # 修边不增加正式加工层级；否则上修边、纵切、横切会被错误
+                    # 算成三阶段，可能超过原始有效布局的 MaxCutLevel。
+                    level=max(depth,0) if trim_node else depth+(axis!=previous_axis)
+                    branches=[(left,before)]
+                    if right[axis+2]>tol: branches.append((right,after))
+                    return ("node",axis,level,[(tuple(r),m) for r,m in branches],trim_node,
+                            previous_axis if trim_node else axis,depth if trim_node else level)
+            raise UnsupportedFeatureError("布局无法重建为合法 PTX 断头切割树")
+        root=[]
+        pending=[((0.,0.,layout.width,layout.height),items,None,-1,root)]
+        while pending:
+            region,members,previous_axis,depth,destination=pending.pop()
+            node=split_node(region,members,previous_axis,depth)
+            if node[0]=="leaf":
+                destination.extend(node)
+                continue
+            _,axis,level,branches,trim_node,next_axis,next_level=node
+            children=[(r[axis+2],[]) for r,m in branches]
+            destination.extend(("node",axis,level,children,trim_node))
+            for (r,m),(size,child) in reversed(list(zip(branches,children))):
+                pending.append((r,m,next_axis,next_level,child))
+        first_axis=root[1] if root[0]=="node" else 0
+        patterns.append(["PATTERNS",1,pattern,pattern,1 if first_axis==0 else 0,1,1,opt.max_layout_size,""])
+        record=1
+        sequence=0
+        sequences.append(["CUTS",1,pattern,record,0,0,0,0,0,0]);record+=1
+        if root[0]=="leaf":
+            # 整张即单件时使用无实际锯切的边界记录。
+            sequences.append(["CUTS",1,pattern,record,0,1,dim(layout.width),0,root[1],1]);record+=1
+        else:
+            pending=[(root[2],i,size,child,len(root[3]),root[4]) for i,(size,child) in reversed(list(enumerate(root[3])))]
+            while pending:
+                level,i,size,child,sibling_count,trim_node=pending.pop()
+                is_leaf=child[0]=="leaf"
+                item=child[1] if is_leaf else 0
+                actual=i<sibling_count-1
+                if actual: sequence+=1
+                operation=91+level if trim_node or (is_leaf and isinstance(item,str)) else level+1
+                sequences.append(["CUTS",1,pattern,record,sequence if actual else 0,operation,dim(size),1 if actual else 0,item,1 if is_leaf else 0]);record+=1
+                if not is_leaf:
+                    pending.extend((child[2],j,s,c,len(child[3]),child[4]) for j,(s,c) in reversed(list(enumerate(child[3]))))
+    mats=list(materials)
+    max_material=max([layout.material for layout in result.layouts]+[p.material for l in result.layouts for p in l.parts]+[-1])
+    count=max(len(mats),max_material+1,1)
+    material_rows=[]
+    for i in range(count):
+        description=mats[i].description if i<len(mats) else material
+        thickness=mats[i].thickness if i<len(mats) else material_thickness
+        # 材料厚度已按所选计量模式给出；原 DLL 只缩放几何和锯缝。
+        material_rows.append(["MATERIALS",1,i+1,description,description,_n(round(thickness,2)),opt.max_layout_size,dim(opt.saw_width),dim(opt.saw_width),0,0,0,0,0,0,0,opt.max_cut_level,0,0,0,description,0])
+    area=sum(l.width*l.height for l in result.layouts)
+    today=date.today().strftime("%d/%m/%Y")
+    rows=[["HEADER","1.08","CutGLib",units,0,0],
+          ["JOBS",1,job_name,job_name,today,today,customer,1,"OPTIONS","SAW",int(result.elapsed),f"{100*remaining_area/area if area else 0:.2f}"]]
+    _write(target,_csv(rows+part_rows+stock_rows+material_rows+offcut_rows+patterns+sequences))